Java on Hello World

Java Note - 1: Enum

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites#

Java 1.5+

New type: Enum#

Enum was a great improvement in Java 1.5. From that more and more developer abandom the interface or abstract class as constant variable container.

Before Java 5#

Before Java 1.5 you will following coding in many Java program.

 // Use interface or abstract class as constant variable container
 public interface Country {
 public static final String AU = "Australian";
 public static final String UK = "United Kingdom"; 
 public static final String US = "United State"; 
 }
 
 public class Util {
 
 public static String getLanguageCode(String country) {
 
 String languageCode = "en";
 switch (country) {
 case Country.AU:
 languageCode = "en-au";
 break;
 case Country.UK:
 languageCode = "en-uk";
 break;
 case Country.US:
 languageCode = "en-us";
 break;
 }
 return languageCode;
 }
 }

Above program looks very good. Please take a close look and check it carefully. You will find the program will never return en-au, since there is a typo in the constant AU. It should be Australia instead of Australian. I believe many developers have short sight problem like me, and it happened again and again. Using string as constant flag is not a good option, but there is no other better solution before Java 1.5.

Java Note - 2: Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Thread#

Join#

The join method allows one thread to wait for the completion of another. join responds to an interrupt by exiting with an InterruptedException.
Demo code of thread join

public class JoinDemo implements Runnable {
 private Random rand = new Random(System.currentTimeMillis());

 public void run() {
 //simulate some CPU expensive task
 for (int i = 0; i < 100000000; i++) {
 rand.nextInt();
 }
 System.out.println("[" + Thread.currentThread().getName() + "] finished .");
 }

 public static void main(String[] args) throws InterruptedException {
 Thread[] threads = new Thread[5];
 for (int i = 0; i < threads.length; i++) {
 threads[i] = new Thread(new JoinDemo(), "joinThread " + i);
 threads[i].start();
 }
 for (int i = 0; i < threads.length; i++) {
 threads[i].join();
 }
 System.out.println("[" 
 + Thread.currentThread().getName() 
 + "] All -threads have finished.");
 }
}

Common problem of multithred program#

When there are many threads running, the exact sequence in which all running threads are executed depends next to the thread configuration like priority also on the available CPU resources and the way the scheduler chooses the next thread to execute. Although the behavior of the scheduler is completely deterministic, it is hard to predict which threads execute in which moment at a given point in time. This makes access to shared resources critical as it is hard to predict which thread will be the first thread that tries to access it.

Java Note - 3: Path and Files

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites#

Java 7+

Good stuff from not shiny Java 7#

If you are planning to refactor your code, please give a second thought. It is time to dump to try these new features. When the Java 7 was released, I was kind of disappointed without lambda, jigsaw as most developers, but when I tried new Path, Files API, I found that is great improvement. The enhancement of this new IO is really useful. It save so much effort for Java developer.

Java Note - 4: Date Time

Mon, 01 Jan 0001 00:00:00 +0000

Date-Time API#

Through the java.time packages, Java 8 provides a comprehensive Date-Time API to work with date, time, and datetime. By default, most of the classes are based on the ISO-8601 standards. The main classes are

Instant
- represents an instant on the timeline and it is suitable for machines, for example, as timestamps for event
LocalDate, LocalTime, LocalDateTime
- represents human readable date, time, and datetime without a time zone.
OffsetTime, OffsetDateTime

Java Note - 5: Lambda

Mon, 01 Jan 0001 00:00:00 +0000

Lamda#

Lambda Best Practices#

Use Interfaces#

The most common misstep taken by an over-eager functional programmer is the use of functional interfaces in type signatures. In general, you should avoid using the functional interface types directly and instead provide single-method interfaces as arguments to your methods. These interfaces become a way to create self-documenting code and to provide meaningful type information, as well as leaving open the opportunity for your user to provide an actual Java type.

Java Note - 7: Stream API

Mon, 01 Jan 0001 00:00:00 +0000

Stream#

Iterations#

Collections and Maps#

Filtering#

Mapping#

LambdaCollectionDemo#

Lambda Collection Map Demo#



public class LambdaCollectionMapDemo {

 public static void main(String[] args) {

 // FunctionalInterface 
 System.out.println("x + y:" + engine((x, y) -> x + y));// w w w .j av a 2s. c om
 System.out.println("x - y:" + engine((x, y) -> x * y));
 System.out.println("x * y:" + engine((x, y) -> x / y));
 System.out.println("x / y:" + engine((x, y) -> x % y));

 String[] strArray = new String[] { "abc", "klm", "xyz", "pqr" };
 List list = Arrays.asList(strArray);

 // Default Methods
 list.forEach(System.out::println);

 Arrays.sort(strArray, (first, second) -> first.compareToIgnoreCase(second));
 list = Arrays.asList(strArray);

 System.out.println("After sorting ... ");
 list.forEach(System.out::println);



 // Common Functional Interfaces
 // Runnable
 repeat(5, () -> System.out.println("Hello")) ;

 // UnaryOperator
 UnaryOperator<String> upperCase = str -> str.toUpperCase();
 // BiUnaryOperator
 BinaryOperator<String> concat = (left,right) -> left + right;

 System.out.println( " UnaryOperator upperCase "+upperCase.apply( "hello") );
 System.out.println( " BinaryOperator<String> concat "+ concat.apply("hello","world"));
 

 }

 private static int engine(Calculator calculator) {
 int x = 2, y = 4;
 return calculator.calculate(x, y);
 }

 public static void repeat(int n, Runnable action) {
 for (int i = 0; i < n; i++)
 action.run();
 }
}

@FunctionalInterface
interface Calculator {
 int calculate(int x, int y);
}

Java Note - Part 6: Lambda & Collection

Mon, 01 Jan 0001 00:00:00 +0000

Lambda and Collection#

Iterations#

Collections and Maps#

Filtering#

Mapping#

LambdaCollectionDemo#

Lambda Collection Map Demo#

public class LambdaCollectionMapDemo {

 public static void main(String[] args) {

 // FunctionalInterface 
 System.out.println("x + y:" + engine((x, y) -> x + y));// w w w .j av a 2s. c om
 System.out.println("x - y:" + engine((x, y) -> x * y));
 System.out.println("x * y:" + engine((x, y) -> x / y));
 System.out.println("x / y:" + engine((x, y) -> x % y));

 String[] strArray = new String[] { "abc", "klm", "xyz", "pqr" };
 List list = Arrays.asList(strArray);

 // Default Methods
 list.forEach(System.out::println);

 Arrays.sort(strArray, (first, second) -> first.compareToIgnoreCase(second));
 list = Arrays.asList(strArray);

 System.out.println("After sorting ... ");
 list.forEach(System.out::println);



 // Common Functional Interfaces
 // Runnable
 repeat(5, () -> System.out.println("Hello")) ;

 // UnaryOperator
 UnaryOperator<String> upperCase = str -> str.toUpperCase();
 // BiUnaryOperator
 BinaryOperator<String> concat = (left,right) -> left + right;

 System.out.println( " UnaryOperator upperCase "+upperCase.apply( "hello") );
 System.out.println( " BinaryOperator<String> concat "+ concat.apply("hello","world"));
 

 }

 private static int engine(Calculator calculator) {
 int x = 2, y = 4;
 return calculator.calculate(x, y);
 }

 public static void repeat(int n, Runnable action) {
 for (int i = 0; i < n; i++)
 action.run();
 }
}

@FunctionalInterface
interface Calculator {
 int calculate(int x, int y);
}