Java
All the code can be found at: javaTutorial
Install
With apt
sudo apt-add-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java8-installer
Also ensure your JAVA_HOME variable has been set to:
/usr/lib/jvm/java-8-oracle
From Source
wget --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u5-b13/jdk-8u5-linux-x64.tar.gz sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/oracle_jdk8/jre/bin/java 2000 sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/oracle_jdk8/bin/javac 2000 update-alternatives --display java update-alternatives --display javac
hello world
public class aplication {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
Numeric variables
public class variables {
public static void main(String[] args) {
int myInt = 88; //Integer 32 bit
short myShort; //Short 16 bit
long myLong; //Long 64 bit
byte myByte; //Byte 8 bit
double myDouble; //Double
float myFloat = 325.25f //Float
char myChar = 'y'; //Char
boolean myBoolean = true; //Boolean
}
}
Data types
byte b; byte (8 bits)
short s; short (16 bits)
int i; Integer (32 bits)
long lo; long (64 bits)
float f=4.0f; (32 bits) Not precise use big decimal instead
double d; (64 bits) Not precise use big decimal instead
char c; (16 bits)
String st; String
boolean isTrue; true/false
Todo: Arrays etc...
Strings
public class stringstuto {
public static void main(String[] args) {
int myInt = 7;
String myString1 = "Hello ";
String myString2 = "Rafa";
String myString3 = myString1 + myString2;
System.out.println(myString3);
System.out.println("My integer is: " + myInt);
}
}
Enum type
See code example:
EnumTypes.java
Animal.java
Operators
Asignment
= Asignment
Arithmetic
+ Additive
- Substraction
* Multiplication
/ Division
% Remainder
Increment / Decrement
++ Increment
-- Decrement
+= 1 Increment by one
-= 1 Decrement by one
/=2 Divide by 2
*= 2 multiplied by 2
Logic
== Equal to (*)
!= Not Equal to
> Greater than
>= Greater than or equal to
< Less than
<= Less than or equal to
&& Conditional-AND
|| Conditional-OR
?: Ternary (shorthand for if-then-else statement: CONDITION? VALUE_IF_TRUE : VALUE_IF_FALSE)
int number = 2;
boolean isEven = ( number % 2 == 0 ? true : false)
(*) Check .equals()
Bitwise and Bit Shift Operators
~ Unary bitwise complement
<< Signed left shift
>> Signed right shift
>>> Unsigned right shift
& Bitwise AND
^ Bitwise exclusive OR
| Bitwise inclusive OR
Type comparison operator
instanceof
Loops
While
int myInt = 0;
while(myInt < 10){
System.out.println("Hello");
myInt = myInt++;
}
For
for(int i=0; i<5;i++){
System.out.printf("The value of i is %d\n", i);
}
Do While
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
int value = 0;
do{
System.out.println("Enter a number: ");
value = myScanner.nextInt();
}
while(value != 5);
System.out.println("5!");
}
Conditional
if
int value = 20;
if(value < 10){
System.out.println("Value < 10");
}
else if(value >= 10 && value < 20){
System.out.println("value >=10 and value < 20");
}
else {
System.out.println("value >= 20");
}
switch case
switch(VariableIntOrString){
case "start":
System.out.println("Machine started!");
break;
case "stop":
System.out.println("Machine stopped");
break;
default:
System.out.println("Command not recognized");
}
User Input
import java.util.Scanner;
public class UserInput {
public static void main(String[] args) {
Scanner myInput = new Scanner(System.in);
System.out.println("Enter a line of text: ");
String line = myInput.nextLine();
System.out.println("You entered: " + line);
System.out.println("Enter a number: ");
int value = myInput.nextInt();
System.out.println("You entered: " + value);
System.out.println("Enter a number: ");
double dvalue = myInput.nextDouble();
System.out.println("You entered: " + dvalue);
}
}
- Note: Ctrl + Shift + O in eclipse adds all the imports you need.
Arrays
int[] values;
values = new int[3];
int[] values2 = {5, 24, 12};
values[0] = 10;
values.length; → returns the array lenght
Iterating trough an array
String[] fruits = {"apple", "banana", "pear", "kiwi"};
for(String fruit: fruits){
System.out.println(fruit);
}
Fill array
int[] marks = new int[5]
Arrays.fill(marks, 100)
Other
Arrays.equals(array1, array2) // Compare 2 arrays
Arrays.sort(array1) // Sort array
Array of arguments
void print(int... values) {
System.out.print(Arrays.toString(values));
}
Multidimensional arrays
int[][] grid = {
{3, 5, 12},
{2, 4},
{25, 12, 0}
};
System.out.println(grid[1][1];
String[][] = new String[2][3];
Collections
List: Can't add elements.
ArrayList: Access very slow, efficient insert and delete
LinkedList: Iteration very slow faster insertion and deletion
Vector: Thread safe (syncronized)
List
List<String> words = List.of("Apple", "Bat", "Cat");
words.size();
words.isEmpty();
words.get(0);
words.contains("Dog");
words.indexOf("Cat");
ArrayList
List<String> words = List.of("Eagle", "Dog", "Pear");
List<String> wordsArrayList = new ArrayList<String>(words)
ArrayList<String> items = new ArrayList<String>()
items.add("Apple")
items.add("Bat")
items.add(2, "Cat")
items.remove("Pear")
items.remove(0)
items.size()
Colections.max(items)
List<String> newList= List.of("Table", "Pencil", "Hole");
wordsArrayList.addAll(newList)
wordsArrayList.set(6, "Fish") // Modify element on position 6
Different ways to loop lists
for (String word:words){
System.out.println(word);
}
for (int i=0; i<words.size(); i++){
System.out.println(words.get(i));
}
// Use this one when modifiying list
Iterator wordsIterator = words.iterator();
while (wordsIterator.hasNext()){
if (wordsIterator.next().endsWith("at")){
wordsIterator.remove();
}
}
Collections.sort(<array_list_var>) Requires implementation of Comparable interface. ej:
public class Student implements Comparable<Student> {
private int id;
private String name;
public Student(int id, String name){
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
@override
public int compareTo(Student that){
return Integer.compare(this.id, that.id);
}
}
with comparators
class DescendingStudentComparator implements Comparator<Student> {
@Override
public int compare(Student student1, Student student2){
return Integer.compare(student1.getId(), student2.getId());
}
}
Collections.sort(studentsArrayList, new DescendingStudentComparator());
Set Interface (unique values)
Set<String> set = Set("Apple", "Banana", "Cat");
Set<String> hashset = new HashSet<>(set);
hashset.add("Dog");
Hashing (Fast searches)
LinkedHashSet: keeps the order in which elements are inserted
Set<Integer> numbers = new LinkedHashSet<>();
numbers.add(4185);
numbers.add(545);
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.LinkedHashSet;
import java.util.HashSet;
public class SetRunner{
public static void main(String[] args){
List<Character> characters = List.of('A', 'Z', 'A', 'B', 'Z', 'F');
// print unique characters in sorted order
Set<Character> treeSet = new TreeSet<>(characters);
System.out.println("treeSet" + treeSet);
//print unique characters in insertion order
Set<Character> linkedHashSet = new LinkedHashSet<>(characters);
System.out.println("linkedHashSet" + linkedHashSet);
// hashset, sometimes sorted some not
Set<Character> HashSet = new HashSet<>(characters);
System.out.println("linkedHashSet" + linkedHashSet);
}
}
Tree (Reduces cost of search, insert and delete)
TreeSet<Integer> numbers = new TreeSet<>(Set.of(65, 54, 34, 12, 99));
numbers.floor(40); // lower or equal to 40 in set
numbers.lower(34); //lower than 34
numbers.ceiling(34); //>=
numbers.higher(34); //>
numbers.subSet(20, 80); // Returns numbers between 20 and 80 in set
Queue
Queue <String> queue = new PriorityQueue<>();
queue.poll() // pull things out of queue
queue.offer("Apple") // put things on queue
queue.addAll(List.of("Zebra", "Monkeky")) // put lists on queue
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
class StringLenghtComparator implements Comparator<String> {
@Override
public int compare(String value1, String value2){
return Integer.compare(value1.lenght(), value2.length());
}
}
public class QueueRunner{
public void main(String[]; args){
// Queue<String> queue = new PriorityQueue<>(new StringLenghtComparator ());
Queue<String> queue = new PriorityQueue<>();
queue.addAll(List.of("Zebra", "Monkey", "Cat"));
System.out.println(queue.poll());
}
}
Map
Key - Value Pair
HashMap --> Not syncronized
HashTable -> synchronized (thread safe)
LinkedHashMap -> Insertion order is mainained, slower deletion and insertion, faster iteration
TreeMap -> Data stored in sorted order
Map<String, Integer> map = Map.of("A", 3, "B", 5, "Z", 10);
map.get("Z");
map.size();
map.isEmpty();
map.containsKey("A");
map.cointainsValue(4);
map.keySet();
map.values();
Map<String, Integer> hashmap = new HashMap(map);
hashmap.put("F", 5);
HashMap<String, Integer> hashmap = new HashMap<>();
hashmap.put("Z", 5);
hashmap.put("A", 7);
//keeps insertion order
LinkedhashMap<String, Integer> linkedHashMap = new LinkkedHashMap<>();
linkedHashMap.put("F", 25);
linkedHashMap.put("A", 15);
// sorts on keys
TreeMap<String, Integer> treemap = new TreeMap<>();
treemap.put("Z", 5);
treemap.put("A", 7);
import java.util.HashMap;
import java.util.Map;
public class MapRunner {
public static void main(String[] args){
String str = "Text to count words and letters";
Map<Character, Integer> occurances = new HashMap<>();
char[] chars = str.toCharArray();
for (char character:characters){
Integer integer = occurances.get(character);
if (integer == null) {
occurances.put(character, 1);
} else {
occurrances.put(character, integer + 1);
}
System.out.println(occurrances);
}
Map<String, Integer> stringOccurances = new HashMap<>();
String[] words = str.split(" ");
for (String word:words){
Integer integer = stringOccurances .get(word);
if (integer == null) {
stringOccurances .put(word, 1);
} else {
stringOccurances .put(word, integer + 1);
}
System.out.println(stringOccurances );
}
}
}
TreeMap
TreeMap<String, Integer> treemap = new TreeMap();
treemap.put("F", 25);
treemap.put("Z", 5);
treemap.put("L", 250);
treemap.put("A", 15);
treemap.put("B", 25);
treemap.put("G", 25);
treemap.higherKey("B");
--> F
treemap.higherKey("C"); // >
--> F
treemap.ceilingKey("B"); //>=
--> B
tremap.lowerKey("B");
tremap.floorKey("B");
treemap.lastEntry();
treemap.firtstEntry();
treemap.subMap("C", "Y");
treemap.subMap("B", true, "Z", true); // to include last element
Streams
List<Integers> numbers = List.of(3, 5, 8, 213, 45, 4, 7)
numbers.stream().sorted().forEach(element -> System.out.println(element));
numbers.stream().distinct().map(e -> e * e).forEach(e -> System.out.println(e));
IntStream.range(1, 11).map(e -> e * e).forEach(e -> System.out.println(e));
List.of("Apel", "Ant", "Bat").stream().map(s -> s.tolowercase()).forEach(p -> System.out.println(p));
IntStream.range(1, 11).reduce(0, (n1, n2) -> n1+n2)
List.of(23, 12, 34, 53).stream().min((n1, n2) -> Integer.compare(n1, n2)).get()
List.of(23, 12, 34, 53).stream().max((n1, n2) -> Integer.compare(n1, n2)).get()
List.of(23, 12, 34, 53).stream().filter(e -> e%2==1).collect(Collectors.toList());
List.of(23, 45, 67, 53).stream().filter(e -> e%2==0).max((n1, n2)->Integer.compare(n1, n2)).orElse(0);
// with method reference
public static class MethodReferencesRunner {
public static boolean isEven(Integer number){
return number%2==0;
}
}
Integer max = List.of(23, 45, 67, 34).stream().filter(MethodReferencesRunner::isEven).max(Integer::compare).orElse(0);
Classes and Objects
class Person {
String name;
int age;
void speak(String text) {
System.out.println(text + name + " and i am " + age + " years old.");
}
int yearsToRetire () {
int yearsLeft = 67 - age;
return yearsLeft;
}
publick String toString(){
return name + ' (' + age + ')'
}
}
class Student extends Person {
String college;
}
public class Classes {
public static void main(String[] args){
Person person1 = new Person();
person1.name = "Joe Doe";
person1.age = 37;
person1.speak("My name is: ");
System.out.println("Years to retirement= " + person1.yearsToRetire());
System.out.println(person1 instanceof Person); // true
System.out.println(person1 instanceof Object); // true
System.out.println(person1 instanceof Student); // false
}
}
Setters and 'this'
package tutorial1;
class Frog {
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public void setAge(int newAge){
age = newAge;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
public class setters {
public static void main(String[] args) {
Frog frog1 = new Frog();
frog1.setName("Steven");
frog1.setAge(1);
System.out.println(frog1.getName()+ " " + frog1.getAge());
}
}
Constructors
Methods that are executed at the instantiation of a class.
There can be more than one, diferentiated on the number of parameters that are passed at the instantiation of a class.
example code
static
static is used to define class variables and methods.
static objects are referenced by the class, not the instance.
example code
final
final is used to declare constants. The asignment of value must be at the declaration
example code
StringBuilder / formatting
StringBuilder is more efficient for strings appending than using += example code
Inheritance & abstract
Use key word extends at the class declaration
private variables and methods are not inherited.
protected would be the appropiated declaration to be able to inherit variables without being public.
public abstract class Machine {
abstract public void move();
}
public class Car extends Machine {
public void move() {
System.out.println("Moving...")
}
}
sample code files:
inheritance.java
Machine.java
Car.java
Packages
Packages allow to have classes with the same name as long as they are in diferent packages.
In orther to be able to use the classes from a package it must be imported.
Each package classes will be on a package folder.
The first line of the .java file for the classes of one package must be: package package_name
Example:
import tutorial1.ocean.fish
Example files:
tutorial1.ocean package
packageexample.java
Interfaces
If you whant to define a method for more than one class, you should use an interface (rigt click on project > new > interface)
Interfaces file names should start with upper case.
public interface GamingConsole {
public void up();
public void down();
public void left();
public void right();
default void start() {
System.out.println("Start");
}
}
public class MarioGame implements GamingConsole {
@Override
public void up() {
System.out.println("Jump");
}
@Override
public void down() {
System.out.println("Goes into a hole");
}
@Override
public void left() {
System.out.println("Go back");
}
@Override
public void right() {
System.out.println("Go forward");
}
}
Example files:
interfaces.java
PersonInterface.java
Machine.java
Info.java
public/private/protected variables
public → can be accesed from anywhere.
public final static → constant.
private → can only be accesed from the class where it was declared.
protected → can only be by the class where it was declarated, subclasses and from it's package.
no access specifier → only accesible from the same package.
Polymorphism
You can point a variable of a parent type to a child type, it will have the methods from it's type but overriden by the subclass.
You wont be able to call methods from the subclass that are not implemented on the variable type.
Example files:
Polymorphism.java
Plant.java
Tree.java
Encapsulation and the API
Variables whithin a class should be private and if you need to change them use getters and setters.
Java 8 API
Casting Numerical Values
See examples
Upcasting and Downcasting
Code examples:
UpcastingDowncasting.java
Camara.java
Machine.java
Generic class
Can work with other objects specified at the class instantiation.
Generic.java
import java.util.ArrayList;
import java.util.HashMap;
public class Generic {
public static void main(String[] args) {
//////////// Before Java 5 //////////
ArrayList list1 = new ArrayList();
list1.add("Banana");
list1.add("Apple");
list1.add("Orange");
String fruit = (String)list1.get(1);
System.out.println(fruit);
///////// After Java 5 /////////////
ArrayList<String> strings = new ArrayList<String>();
strings.add("cat");
strings.add("dog");
strings.add("fish");
String animal = strings.get(2);
System.out.println(animal);
///////// There can be more than one type argument //////
HashMap<Integer, String> map= new HashMap<Integer, String>();
//////// Java 7 //////////////////////
ArrayList<Integer> someList = new ArrayList<>();
}
}
Generics and Wildcards
See: Generic.java
Files
Reading text files
See: ReadTextFile.java
Reading files (Try-With-Resources)
This requires at least Java 7
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FilesTryWithResources {
public static void main(String[] args) {
File file = new File("./src/tutorialJava/textFile.txt");
try (BufferedReader br = new BufferedReader(new FileReader(file))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (FileNotFoundException e) {
System.out.println("File not found: " + file.toString());
} catch (IOException e) {
System.out.println("Unable to read the file: " + file.toString());
}
}
}
Reading files with FileReader
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class ReadingFiles {
public static void main(String[] args) {
File file = new File("./src/tutorialJava/textFile.txt");
BufferedReader br = null;
try {
FileReader fr = new FileReader(file);
br = new BufferedReader(fr);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (FileNotFoundException e) {
System.out.println("File not found" + file.toString());
} catch (IOException e) {
System.out.println("Unable to read the file: " + file.toString());
} finally {
try {
br.close();
} catch (IOException e) {
System.out.println("Can't close the file.");
}
}
}
}
Writing files
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
public class WritingFiles {
public static void main(String[] args) {
File file = new File("./src/tutorialJava/textFile2.txt");
try (BufferedWriter br = new BufferedWriter(new FileWriter(file))) {
br.write("This is line 1");
br.newLine();
br.write("This is line 2");
br.newLine();
br.write("Last line");
br.newLine();
} catch (IOException e) {
System.out.println("Unable to read the file: " + file.toString());
}
}
}
Anonymous class
see: AnonymousClass.java
Exceptions
trows
package tutorialJava;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class HandlingExceptions {
public static void main(String[] args) trows FileNotFoundException {
File file = new File("test.txt");
FileReader fr = new FileReader(file);
throw new RuntimeException("Example exception throwing");
}
}
// To throw Exception instead of RuntimeException you need to do like this:
public class HandlingExceptions throws Exception {
public static void main(String[] args) trows FileNotFoundException {
File file = new File("test.txt");
FileReader fr = new FileReader(file);
throw new Exception("Example exception throwing");
}
}
// Custom exception
class CustomException extends Exception {
}
class CustomException1 extends Exception {
public CustomException1()
}
public class CustomExceptionRunner {
public void static main(String[], args) throws CustomException {
throw new CustomException("Some text");
}
}
try/catch
import java.io.IOException;
import java.text.ParseException;
public class MultipleExceptions {
public static void main(String[] args) {
Test test = new Test();
//Option 1
try {
test.run();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("File not found.");
} catch (ParseException e) {
// e.printStackTrace();
System.out.println("Parse error.");
}
//Option 2
try {
test.run();
} catch (IOException | ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Option 3
try {
test.run();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// Do something
}
//Option 4
// add throws to main declaration...
}
}
Runtime exceptions
The compiler does not force you to handle them.
package tutorialJava;
public class RuntimeExceptions {
public static void main(String[] args) {
int value = 7;
String[] texts = {"cero", "one", "two"};
//runtime exceptions
//// division by 0(ArithmeticException)
try {
value = value/0;
} catch (Exception e){
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
}
//// ArrayIndexOutOfBoundsException
System.out.println(texts[3]);
// NoPointerException
}
}
Abstract Class
Classes that can't be instantiated, only inherited.
See example files:
AbstractClasses.java
AbstractClassChild2.java
AbstractClassChild1.java
.equals() Method
It's used to compare if two objects of the same class are equal. In order to be able to use it you must override this method by:
Right click on the class > source > Generate hashCode() and Equals()...
Select the fields you whant to compare.
See code examples:
EqualsMethod.java
Persona.java
Inner Classes
Clases declared inside other classes.
Code examples:
InnerClasses.java
Robot.java
Recursion
See code example:
Recursion.java
Serialization
Turning an object into binary data, deserialization is the opposite.
Code examples:
WriteObjects.java
ReadObjects.java
Persona.java
Multiple Objects
WriteMultipleObjects.java
ReadMultipleObjects.java
Transient Keyword
To prevent the serialization of some variable in a class you can declare it as:
private transient int variableName;
Static fields aren't serialized too.
Threading
class Task1 extends Thread {
public void run() {
System.out.print("\nTask1 Started");
// Do something
Thread.yield(); // let other thread take over
System.out.print("\nTask1 Done");
}
}
class Task2 implements Runnable {
public void run() {
System.out.print("\nTask2 Started");
// Do something
System.out.print("\nTask2 Done");
}
}
public class ThreadBasicsRunner {
public static void main(String[] args) throws InterruptedException {
Task1 task1 = new Task1();
task1.setPriority(10); // min = 1 max = 10
task1.start();
Task2 task2 = new Task2();
Thread task2thread = new Thread(task2);
task2thread.start();
// wait for task1 to end
task1.join();
// task3
System.out.print("\nTask3 Started");
// Do something
System.out.print("\nTask3 Done");
}
}
Executor service
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Task extends Thread{
public Task(int number){
this.number = number;
}
public void run() {
System.out.print("\nTask" + number + " Started");
for (i=number*100; i<=number*100+99; i++){
System.out.print(i + " ");
}
System.out.print("\nTask" + number + " Done");
}
}
public class ExecutorServiceRunner {
public static void main(String[] args){
// ExecutorService executorService = Executors.newSingleThreadExecutor();
ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.execute(new Task(1));
executorService.execute(new Task(2));
executorService.execute(new Task(3));
executorService.execute(new Task(4));
executorService.shutdown()
}
}
Return values from threads
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
class CallableTask implements Callable<String> {
public CallableTask(String name){
this.name = name;
}
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "Hello " + name;
}
}
public class CallableRunner throws InterruptedException, ExecutionException {
public static void main(String[] args){
ExecutorService executorService = Executors.newFixedThreadPoool(1);
Future<String> welcomeFuture = executorService.submit(new CallableTask("Manolo"));
System.out.print("\ncallable executed")
String welcomeMessage = welcomeFuture.get();
System.out.print("\nMain completed")
executorService.shutdown();
}
}
Multiple callable runner
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
class CallableTask implements Callable<String> {
public CallableTask(String name){
this.name = name;
}
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "Hello " + name;
}
}
public class MultipleCallableRunner throws InterruptedException, ExecutionException {
public static void main(String[] args){
ExecutorService executorService = Executors.newFixedThreadPoool(3);
List<CallableTask> tasks = List.of(new CallableTask("Manolo"), new CallableTask("Pedro"));
List<Future<String>> results = executorService.invokeAll(tasks);
// String result = executorService.invokeAny(tasks); // returns only 1 the fastest
for (Future<String> result:results){
System.out.println(result.get());
}
System.out.print("\nMain completed")
executorService.shutdown();
}
}
Eclipse shortcuts
Ctrl + Space → Autocomplete.
Ctrl + d → Delete Line
Ctrl + o → Automatically add imports
Ctrl + Shift + f → Indent
Ctrl + m → Toogle fulscreen
Notes
Hibernate → Java ORM framework for web design