InShortView

Parameter

STACK

HEAP

Basic

Memory is allocated in a contiguous block.

Memory is allocated in any random order.

Allocation and De-allocation

Automatic by compiler instructions.

Manual by the programmer.

Cost

Less

More

Implementation

Easy

Hard

Access time

Faster

Slower

Main Issue

Shortage of memory

Memory fragmentation

Locality of reference

Excellent

Adequate

Safety

Thread safe, data stored can only be accessed by owner

Not Thread safe, data stored visible to all threads

Flexibility

Fixed-size

Resizing is possible

Data type structure

Linear

Hierarchical

Preferred

Static memory allocation is preferred in array.

Heap memory allocation is preferred in the linked list.

Size

Small than heap memory.

Larger than stack memory.

package play1;

import java.util.HashSet;

import java.util.Set;

public class Player1 {

    private Integer id;

    private String name;

    private Integer age;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    @Override

    public int hashCode() {

        int hash = 3;

        hash = 7 * hash + this.name.hashCode();

        hash = 7 * hash + this.age.hashCode();

        hash = 7 * hash + this.id.hashCode();

        return hash;

    }

    public String toString() {

        return "Alpha : " + id;

    }

    @Override

    public boolean equals(Object object) {

        boolean result = false;

        if (object == null || object.getClass() != getClass()) {

            result = false;

        } else {

            Player1 tiger = (Player1) object;

            if (this.id == tiger.getId()) {

                result = true;

            }

        }

        return result;

    }

    public Player1(Integer color, String stripePattern, Integer height) {

        this.id = color;

        this.name = stripePattern;

        this.age = height;

    }

    public static void main(String[] args) {

        Set s = new HashSet();

        Player1 a1 = new Player1(1, "John", 24);

        Player1 a2 = new Player1(2, "jack", 25);

        Player1 a3 = new Player1(3, "John", 24);

        s.add(a1);

        s.add(a2);

        s.add(a3);

        System.out.println(s.size());

        for (Player1 val: s) {

            System.out.println(val.getName());

        }

    }

}

// An immutable class

public final class Student

{

    final String name;

    final int regNo;

    public Student(String name, int regNo)

    {

        this.name = name;

        this.regNo = regNo;

    }

    public String getName()

    {

        return name;

    }

    public int getRegNo()

    {

        return regNo;

    }

}

// Driver class

class Test

{

    public static void main(String args[])

    {

        Student s = new Student("ABC", 101);

        System.out.println(s.getName());

        System.out.println(s.getRegNo());

        // Uncommenting below line causes error

        // s.regNo = 102;

    }

}

Output:

ABC

101

/ A Class that represents use-defined expception

class MyException extends Exception

{

    public MyException(String s)

    {

        // Call constructor of parent Exception

        super(s);

    }

}

// A Class that uses above MyException

public class Main

{

    // Driver Program

    public static void main(String args[])

    {

        try

        {

            // Throw an object of user defined exception

            throw new MyException("GeeksGeeks");

        }

        catch (MyException ex)

        {

            System.out.println("Caught");

            // Print the message from MyException object

            System.out.println(ex.getMessage());

        }

    }

}

import java.util.Arrays;

import java.util.Comparator;

public class GFG

{

    // Method to sort a mixed string

    public static String sortString(String inputString)

    {

        // convert input string to Character array

        Character tempArray[] = new Character[inputString.length()];

        for (int i = 0; i < inputString.length(); i++) {

            tempArray[i] = inputString.charAt(i);

        }

        // Sort, ignoring case during sorting

        Arrays.sort(tempArray, new Comparator(){

            @Override

            public int compare(Character c1, Character c2)

            {

                // ignoring case

                return Character.compare(Character.toLowerCase(c1),

                                        Character.toLowerCase(c2));

            }

        });

        // using StringBuilder to convert Character array to String

        StringBuilder sb = new StringBuilder(tempArray.length);

        for (Character c : tempArray)

            sb.append(c.charValue());

        return sb.toString();

    }

    // Driver method

    public static void main(String[] args)

    {

        String inputString = "GeeksforGeeks";

        String outputString = sortString(inputString);

        System.out.println("Input String : " + inputString);

        System.out.println("Output String : " + outputString);

    }

}

// A Java program to demonstrate use of Comparable

import java.io.*;

import java.util.*;

// A class 'Movie' that implements Comparable

class Movie implements Comparable

{

    private double rating;

    private String name;

    private int year;

    // Used to sort movies by year

    public int compareTo(Movie m)

    {

        return this.year - m.year;

    }

    // Constructor

    public Movie(String nm, double rt, int yr)

    {

        this.name = nm;

        this.rating = rt;

        this.year = yr;

    }

    // Getter methods for accessing private data

    public double getRating() { return rating; }

    public String getName()   {  return name; }

    public int getYear()      {  return year;  }

}

// Driver class

class Main

{

    public static void main(String[] args)

    {

        ArrayList list = new ArrayList();

        list.add(new Movie("Force Awakens", 8.3, 2015));

        list.add(new Movie("Star Wars", 8.7, 1977));

        list.add(new Movie("Empire Strikes Back", 8.8, 1980));

        list.add(new Movie("Return of the Jedi", 8.4, 1983));

        Collections.sort(list);

        System.out.println("Movies after sorting : ");

        for (Movie movie: list)

        {

            System.out.println(movie.getName() + " " +

                               movie.getRating() + " " +

                               movie.getYear());

        }

    }

}

Output:

Movies after sorting :

Star Wars 8.7 1977

Empire Strikes Back 8.8 1980

Return of the Jedi 8.4 1983

Force Awakens 8.3 2015

//A Java program to demonstrate Comparator interface

import java.io.*;

import java.util.*;

// A class 'Movie' that implements Comparable

class Movie implements Comparable

{

    private double rating;

    private String name;

    private int year;

    // Used to sort movies by year

    public int compareTo(Movie m)

    {

        return this.year - m.year;

    }

    // Constructor

    public Movie(String nm, double rt, int yr)

    {

        this.name = nm;

        this.rating = rt;

        this.year = yr;

    }

    // Getter methods for accessing private data

    public double getRating() { return rating; }

    public String getName()   {  return name; }

    public int getYear()      {  return year;  }

}

// Class to compare Movies by ratings

class RatingCompare implements Comparator

{

    public int compare(Movie m1, Movie m2)

    {

        if (m1.getRating() < m2.getRating()) return -1;

        if (m1.getRating() > m2.getRating()) return 1;

        else return 0;

    }

}

// Class to compare Movies by name

class NameCompare implements Comparator

{

    public int compare(Movie m1, Movie m2)

    {

        return m1.getName().compareTo(m2.getName());

    }

}

// Driver class

class Main

{

    public static void main(String[] args)

    {

        ArrayList list = new ArrayList();

        list.add(new Movie("Force Awakens", 8.3, 2015));

        list.add(new Movie("Star Wars", 8.7, 1977));

        list.add(new Movie("Empire Strikes Back", 8.8, 1980));

        list.add(new Movie("Return of the Jedi", 8.4, 1983));

        // Sort by rating : (1) Create an object of ratingCompare

        //                  (2) Call Collections.sort

        //                  (3) Print Sorted list

        System.out.println("Sorted by rating");

        RatingCompare ratingCompare = new RatingCompare();

        Collections.sort(list, ratingCompare);

        for (Movie movie: list)

            System.out.println(movie.getRating() + " " +

                               movie.getName() + " " +

                               movie.getYear());

        // Call overloaded sort method with RatingCompare

        // (Same three steps as above)

        System.out.println("\nSorted by name");

        NameCompare nameCompare = new NameCompare();

        Collections.sort(list, nameCompare);

        for (Movie movie: list)

            System.out.println(movie.getName() + " " +

                               movie.getRating() + " " +

                               movie.getYear());

        // Uses Comparable to sort by year

        System.out.println("\nSorted by year");

        Collections.sort(list);

        for (Movie movie: list)

            System.out.println(movie.getYear() + " " +

                               movie.getRating() + " " +

                               movie.getName()+" ");

    }

} 

Output :
Sorted by rating
8.3 Force Awakens 2015
8.4 Return of the Jedi 1983
8.7 Star Wars 1977
8.8 Empire Strikes Back 1980

Sorted by name
Empire Strikes Back 8.8 1980
Force Awakens 8.3 2015
Return of the Jedi 8.4 1983
Star Wars 8.7 1977

Sorted by year
1977 8.7 Star Wars
1980 8.8 Empire Strikes Back
1983 8.4 Return of the Jedi
2015 8.3 Force Awakens

public static void main(String[] args) {

    Scanner reader = new Scanner(System.in);
    String tempStr;
    System.out.print("Enter the strings > ");
    String s1 = new String(reader.nextLine());
    String[] t1 = s1.split(", ");

    for (int t = 0; t < t1.length - 1; t++) {
        for (int i= 0; i < t1.length - t -1; i++) {
            if (t1[i+1].compareTo(t1[i])<0) {
                tempStr = t1[i];
                t1[i] = t1[i + 1];
                t1[i + 1] = tempStr;
            }
        }
    }
    for (int i = 0; i < t1.length; i++) {
        System.out.println(t1[i]);
    }
}