Chapter 1 , Core Java by Cay Horstmann

An Introduction To Java

Java is not just a programming language, but an entire platform of libraries, execution environment - security, portability, automatic garbage collection.

Brief history:

1991 : Java founders at Sun Microsystems want to create a language suitable for consumer devices(cable) - so it has to be small and also platform neutral.

1994 : Mosaic browser - need for a language like java. Sun creates HotJava browser to show off java and the craze begins.

1996: Java 1.0 - no print

1997: 1.1 - refelection, GUI event model, inner classes

1998: 1.2 - SE, ME(embedded devices), EE

2000-2002: 1.3-1.4 - libraries, performance

2004: 1.5-> 5 - for each, loops, autoboxing, annotations, enums, static import

2006: 6 - libraries, performance

2009: Oracle buys Sun

2011: 7 - switch string, diamond op

2014: 8 - functional style prog, lambda expressions, streams, interfaces with default methods

2017: 9 - modules

2018: 11- var

2021: 17-records

Buzz words:

Simple : cleaned up C++, small(embedded devices)

Object oriented : data=objects, interfaces to objects

Distributed: access objects across net(HTTP/FTP)

Robust: compile time and run time checks, memory cant be overwritten and corrupted

Secure: secure over a network

Architecture neutral : code compiled to bytecode that can run anywhere

Portable: No implementation dependency, datatypes size doesnt vary as in C++

Interpreted : executes bytecode - fast

High performance: frequently executed bytecode to machine code - hotspots - Just In Time Compiler

Multithreaded: fast and real time

Dynamic: changing libraries without impacting dependent code, adding code to running programs

~

Comparable and Comparator

Java supports sorting on collection in two ways - through Comparable and Comparator(both are functional interfaces with one single abstract method).

Comparable:

To sort collection based on Comparable:

• Elements of the collection must implement Comparable interface and implement it's method "int compareTo(Object o1)".
• Then sorting can be done using Collections.sort(List)

Cons:

• Can't support multiple types of sorting, as one compareTo method can have only one implementation.
• May not have access to the element class, in which case, subclassing the element and implementing compareTo would be the only option.

Code:

public class Dog implements Comparable<Dog>{

      String name;

      String breed;

      public Dog(String name,String breed){

            this.name = name;

            this.breed = breed;

      }

        @Override

public int compareTo(Dog o) {

return name.compareTo(o.name);

}

}

...

List<Dog> dogList = new ArrayList<Dog>();

Collections.sort(dogList);

...

Comparator:

To sort collection based on Comparator:

• A class/anonymous class implements Comparator interface and implements it's method "int compare(Object o1, Object o2). 
• Then sorting can be done by passing the object of the above implmented Comparator - using Collection.sort(List, Comparator).

Pros:

• Can support multiple sorting implementations.
• Don't need to have access to elements of the collection.

Code:

public class DogBreedComparator implements Comparator<Dog> {

@Override

public int compare(Dog o1, Dog o2) {

return o1.breed.compareTo(o2.breed);

}

}

..

Collections.sort(dogList, new DogBreedComparator());

..

Lambda expression:

Collections.sort(dogList, (o1,o2)->o1.breed.compareTo(o2.breed));

..

Both compareTo and compare methods return integer - 

1  : if passed in object is greater than current object

-1: if passed in object is lesser than current object

0: if both are equal

~