- Test new java 8 feature

Author: hyao

Java8/src/com/hong/dev/practice/java8/Main.java

@@ -1,9 +1,64 @@
 package com.hong.dev.practice.java8;
 
+import com.hong.dev.practice.java8.capi.functionalInterface.IConverter;
+import com.hong.dev.practice.java8.capi.functionalInterface.ISomethingFactory;
+import com.hong.dev.practice.java8.internal.Calculator;
+import com.hong.dev.practice.java8.internal.lambda.Lambda;
+
+/**
+ * {@link http://winterbe.com/posts/2014/03/16/java-8-tutorial/}
+ * 
+ * @author HYao
+ *
+ */
 public class Main {
 
 	public static void main(String[] args) {
 		System.out.println("Hello, World!");
-	}
 
+		// default method
+		Calculator calculator = new Calculator();
+		double res = calculator.calculate(20);
+		System.out.println(res);
+
+		// lambda
+		Lambda lambda = new Lambda();
+		lambda.sort(lambda.names);
+
+		// functional interface
+		IConverter<String, String> converter = (from) -> "new " + from;
+		System.out.println(converter.convert("world"));
+
+		// method reference
+		// the class must be located in the same package?
+		IConverter<String, String> converter2 = Something2::startWith;
+		System.out.println(converter2.convert("Hi"));
+
+		IConverter<String, Integer> converter3 = String::valueOf;
+		System.out.println(converter3.convert(1234));
+
+		// constructor reference
+		ISomethingFactory<Something> factory = Something::new;
+		factory.create("yoo", "hoo").printThings();
+
+		// lambda could read the final or implicitly final local variable which
+		// is out of the scope of the expression. For instance or static field
+		// there is no limit.
+		// The default methods of interface can not be accessed in lambda
+		// expression.
+		int i1 = 1;
+		final int i2 = 2;
+		IConverter<String, Integer> converter4 = (i) -> i1 + i + "";
+		System.out.println(converter4.convert(23));
+		// i1 = 20; // Compile error.
+		IConverter<String, Integer> converter5 = (i) -> i2 + i * 2 + "";
+		System.out.println(converter5.convert(89));
+
+	}
 }
+
+class Something2 {
+	static String startWith(String pStr) {
+		return String.valueOf(pStr.charAt(0));
+	}
+}

Java8/src/com/hong/dev/practice/java8/Something.java

@@ -0,0 +1,36 @@
+package com.hong.dev.practice.java8;
+
+public class Something {
+	
+	private String thing1;
+	private String thing2;
+	
+	Something(String theThing, String thatThing) {
+		this.thing1 = theThing;
+		this.thing2 = thatThing;
+	}
+	
+	public void printThings(){
+		System.out.println(getThing1() + " - " + getThing2());
+	}
+	
+	static String startWith(String pStr) {
+		return String.valueOf(pStr.charAt(0));
+	}
+
+	public String getThing1() {
+		return thing1;
+	}
+
+	public void setThing1(String thing1) {
+		this.thing1 = thing1;
+	}
+
+	public String getThing2() {
+		return thing2;
+	}
+
+	public void setThing2(String thing2) {
+		this.thing2 = thing2;
+	}
+}

Java8/src/com/hong/dev/practice/java8/capi/defaultMethod/IFormula.java

@@ -0,0 +1,15 @@
+package com.hong.dev.practice.java8.capi.defaultMethod;
+
+/**
+ * 
+ * @author HYao
+ *
+ */
+public interface IFormula {
+	double calculate(int a);
+	
+	// default method
+	default double sqrt(int a) {
+		return Math.sqrt(a);
+	}
+}

Java8/src/com/hong/dev/practice/java8/capi/functionalInterface/IConverter.java

@@ -0,0 +1,9 @@
+package com.hong.dev.practice.java8.capi.functionalInterface;
+
+@FunctionalInterface
+public interface IConverter<T, F> {
+	T convert(F from);
+	default void printType() {
+		System.out.println(this.getClass().getName());
+	}
+}

Java8/src/com/hong/dev/practice/java8/capi/functionalInterface/ISomethingFactory.java

@@ -0,0 +1,8 @@
+package com.hong.dev.practice.java8.capi.functionalInterface;
+
+import com.hong.dev.practice.java8.Something;
+
+@FunctionalInterface
+public interface ISomethingFactory<P extends Something> {
+	P create(String str1, String str2);
+}

Java8/src/com/hong/dev/practice/java8/internal/Calculator.java

@@ -0,0 +1,12 @@
+package com.hong.dev.practice.java8.internal;
+
+import com.hong.dev.practice.java8.capi.defaultMethod.IFormula;
+
+public class Calculator implements IFormula {
+
+	@Override
+	public double calculate(int a) {		
+		return sqrt(a);
+	}
+
+}

Java8/src/com/hong/dev/practice/java8/internal/lambda/Lambda.java

@@ -0,0 +1,18 @@
+package com.hong.dev.practice.java8.internal.lambda;
+
+import java.net.Socket;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class Lambda {
+	
+	public List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
+	
+	public void sort(List<String> pList) {
+		System.out.println(pList);
+		Collections.sort(pList, (a, b) -> a.compareTo(b));
+		System.out.println(pList);		
+	}
+	
+}