Binary Search

public class BinarySearchTest {
   
    public static void main(String[] args){
        int[] iarr = {1,3,5,7};
        int key = 5;
        int index = binarySearch(iarr,key);
        System.out.print(key+" is at index "+index);
    }

    private static int binarySearch(int[] iarr, int key) {
        int start = 0;
        int end = iarr.length-1;
        int mid = 0;
       
        while (start<=end){
            mid = (start+end)/2;
            if (key==iarr[mid]) {
                return mid;
            }
            else if (key<iarr[mid]){
                end = mid -1;
            }
            else if (key>iarr[mid]){
                start = mid+1;
            }
        }
        return -1;
    }

}
OUTPUT
5 is at index 2

SortCollectionByComparator

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortCollectionByComparator {
   
   
public static void main(String[] args){
        List<Employee> empList = new ArrayList<Employee>();
        empList.add(new Employee("John",10));
        empList.add(new Employee("Alex",20));
        empList.add(new Employee("Mark",30));
       
        Collections.sort(empList,new SortEmpByNameComparator());
        for (Employee emp: empList){
            System.out.println(emp.getEmpName()+" "+emp.getEmpId());
        }
    }

}




public class Employee {
    private String empName;
    private Integer empId;

    public Employee() {
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }
   
    public Employee(String empName, Integer empId){
        super();
        this.setEmpName(empName);
        this.setEmpId(empId);
       
    }
}



import java.util.Comparator;

public class SortEmpByNameComparator implements Comparator<Employee> {

    @Override
    public int compare(Employee emp1, Employee emp2) {
        return emp1.getEmpName().compareTo(emp2.getEmpName());
    }

}

OUTPUT
Alex 20
John 10
Mark 30

Sort HashMap on Value

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class MapSortByValue {
   
    public static void main(String[] args){
       
        Map map = new HashMap();
        map.put("a", 1);
        map.put("c", 3);
        map.put("b", 2);
       
        Set set = map.entrySet();
        List list = new ArrayList(set); // convert set to list
       
        // before sorting
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
       
        Collections.sort(list, new Comparator(){

            @Override
            public int compare(Object o1, Object o2) {
                Map.Entry<String, Integer> entry1 = (Map.Entry<String, Integer>) o1;
                Map.Entry<String, Integer> entry2 = (Map.Entry<String, Integer>) o2;
                return (entry1.getValue()).compareTo(entry2.getValue());
            }
        });
       
        // after sorting
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

Arrays.sort(fruits, Fruit.FruitNameComparator) - Fruit static object FruitNameComparator

import java.util.Arrays;

public class ComparatorTest {
   
    public static void main(String[] args){
        Fruit fruit1 = new Fruit("banana",1);
        Fruit fruit2 = new Fruit("apple",2);
        Fruit fruit3 = new Fruit("orange",3);
        Fruit[] fruits = {fruit1, fruit2, fruit3};
        
        // we can write comparator based on properties
        Arrays.sort(fruits,Fruit.FruitNameComparator);
       
        for (Fruit fruit: fruits){
            System.out.println(fruit.getName());
        }
    }

}


import java.util.Comparator;

public class Fruit implements Comparable{
    public static final Comparator<Fruit> FruitNameComparator = new Comparator<Fruit>(){

        @Override
        public int compare(Fruit fruit1, Fruit fruit2) {
            // fruit1.getName() is String, String.compareTo
            // String, Integer, Double all have compareTo()
            return fruit1.getName().compareTo(fruit2.getName());
        }
       
       
    };
    public Fruit(String name, int quantity) {
        super();
        this.name = name;
        this.quantity = quantity;
    }
   
    String name;
    int quantity;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getQuantity() {
        return quantity;
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
   
    // comparable means this object is comparable so it can compareTo other object
    @Override
    public int compareTo(Object compareFruit) {
        int compareFruitQuantity = ((Fruit)compareFruit).getQuantity();
        //ascending order
        return this.getQuantity() - compareFruitQuantity;
    }
   

}

OUTPUT
apple
banana
orange

Arrays.sort(Fruit) - Fruit needs to implement Comparable

Comparable is java.lang.Comparable
Comparator is java.util.Comparator

Comparable means this object is Comparable, it can compareTo other object
Comparator means tool can compare two objects, so it has method compare(object1, object2)

Comparable compare based on single property 
Comparator could compare based on multiple properties


import java.util.Arrays;

public class ComparableTest {
   
    public static void main(String[] args){
        Fruit fruit1 = new Fruit("banana",1);
        Fruit fruit2 = new Fruit("apple",2);
        Fruit fruit3 = new Fruit("orange",3);
        Fruit[] fruits = {fruit1,fruit2,fruit3};
       
        Arrays.sort(fruits);
       
        for (Fruit fruit:fruits){
            System.out.println(fruit.getName());
        }
    }

}

public class Fruit implements Comparable{
    public Fruit(String name, int quantity) {
        super();
        this.name = name;
        this.quantity = quantity;
    }
   
    String name;
    int quantity;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getQuantity() {
        return quantity;
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
   
    // comparable means this object is comparable so it can compareTo other object
    @Override
    public int compareTo(Object compareFruit) {
        int compareFruitQuantity = ((Fruit)compareFruit).getQuantity();
        //ascending order
        return this.getQuantity() - compareFruitQuantity;
    }
   

}

OUTPUT
banana
apple
orange

Sort ArrayList using Collections.sort

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class SortArrayListTest {
   
    public static void main(String[] args){
        List list = new ArrayList();
        list.add("banana");
        list.add("apple");
        list.add("orange");
       
        Collections.sort(list);
       
        Iterator it = list.listIterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

OUTPUT
apple
banana
orange

Sort Array using Arrays.sort

import java.util.Arrays;

public class SortArrayTest {
    public static void main(String[] args){
        String[] sa = {"banana","apple","orange"};
        Arrays.sort(sa);
       
        for (String s:sa){
            System.out.println(s);
        }
    }

}
OUTPUT
apple
banana
orange