Cú pháp và các tính năng mới trong Java 8

package org.o7planning.tutorial.j8.itf;

public interface Formula {

	// Khai báo một phương thức trừu tượng.
	double calculate(int a);

	// Khai báo một phương thức không trừu tượng.
	// Sử dụng từ khóa default.
	// (Hàm tính căn bậc 2 của một số).
	default double sqrt(int a) {
		return Math.sqrt(a);
	}

}

package org.o7planning.tutorial.j8.itf;

// Một lớp thi hành interface Formula.
public class FormulaImpl implements Formula {

	// Chỉ cần thực hiện phương thức trừu tượng của Formula.
	@Override
	public double calculate(int a) {
		return a * a - a;
	}

}

package org.o7planning.tutorial.j8.itf;

public class FormulaTest {

   public static void main(String[] args) {
       Formula formula = new FormulaImpl();

       // ==> 5
       double value1 = formula.sqrt(25);
       System.out.println("Value1 = " + value1);

       // ==> 600
       double value2 = formula.calculate(25);
       System.out.println("Value2 = " + value2);

   }

}

package org.o7planning.tutorial.j8.funcitf;

@FunctionalInterface
public interface Foo {

  void something();

  default void defaultMethod() {
      System.out.println("..");
  }
}

package org.o7planning.tutorial.j8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortBefore8Example {

	public static void main(String[] args) {

		// Một danh sách các loại quả.
		List<String> fruits = Arrays.asList("Grapefruit", "Apple", "Durian", "Cherry");

		// Sử dụng phương thức tiện ích của Collections 
		// để sắp xếp lại danh sách trên.
		// Cung cấp một Comparator (Bộ so sách).
		Collections.sort(fruits, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}

		});

		for (String fruit : fruits) {
			System.out.println(fruit);
		}

	}
}

package org.o7planning.tutorial.j8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class SortJava8Example {

	public static void main(String[] args) {

		// Một danh sách các loại quả.
		List<String> fruits = Arrays.asList("Grapefruit", "Apple", "Durian", "Cherry");

		// Sử dụng phương thức tiện ích của Collections để sắp xếp lại danh sách trên.
		// Cung cấp một Comparator (bộ so sánh) cho tham số thứ 2 của phương thức.
		// Vì Comparator là interface có duy nhất 1 phương thức.
		// ==> Có thể viết ngắn gọn với biểu thức Lambda.
		// Không cần viết tên interface,
		// Không cần viết tên phương thức.
		Collections.sort(fruits, (String o1, String o2) -> {
			return o1.compareTo(o2);
		});

		for (String fruit : fruits) {
			System.out.println(fruit);
		}

	}
}

Collections.sort(fruits, (String o1, String o2) -> o1.compareTo(o2)  );

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

package org.o7planning.tutorial.j8.lambda;

@FunctionalInterface
public interface Converter<F, T> {
   
   T convert(F from);
   
}

package org.o7planning.tutorial.j8.lambda;

public class ConverterBefore8Example {

	public static void main(String[] args) {

		// Khởi tạo một đối tượng Converter.
		Converter<String, Integer> converter = new Converter<String, Integer>() {

			@Override
			public Integer convert(String from) {
				return Integer.parseInt(from);
			}

		};

		// ==> 100
		Integer value = converter.convert("0100");

		System.out.println("Value = " + value);
	}
}

package org.o7planning.tutorial.j8.lambda;

public class ConveterJava8Example {

	public static void main(String[] args) {

		// Converter là một FunctionalInterface
		// Sử dụng cú pháp của Java 8 (Lambda)
		// Trong trường hợp: Tạo đối tượng trực tiếp từ FunctionalInterface.
		Converter<String, Integer> converter1 = (String from) -> {
			return Integer.parseInt(from);
		};

		// ==> 100
		Integer value1 = converter1.convert("0100");

		System.out.println("Value1 = " + value1);

		// Hoặc đơn giản hơn:
		Converter<String, Integer> converter2 = (from) -> Integer
				.parseInt(from);

		// ==> 200
		Integer value2 = converter2.convert("00200");

		System.out.println("Value2 = " + value2);
		
		// Nếu phương thức chỉ có một tham số, có thể bỏ qua ().
		Converter<String, Integer> converter3 = from -> Integer
				.parseInt(from);

		// ==> 300
		Integer value3 = converter3.convert("00300");

		System.out.println("Value3 = " + value3);
		
	}

}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer<T> {
	
	// Phương thức chấp nhận một tham số đầu vào
	// và không trả về gì cả.
	void accept(T t);

}

// java.util.List extends java.util.Collection  (extends Iterable)

// Interface java.util.Iterable:
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
   for (T t : this) {
       action.accept(t);
   }
}

package org.o7planning.tutorial.j8.api;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample {

	// Sử dụng phương thức List.forEach(Consumer) với cú pháp của Java < 8.
	// In ra danh sách các phân tử của List.
	public static void beforeJ8() {
		List<String> list = Arrays.asList("a", "b", "c", "a1", "a2");

		list.forEach(new Consumer<String>() {

			@Override
			public void accept(String t) {
				System.out.println(t);
			}

		});
	}

	// Sử dụng phương thức List.forEach(Consumer) với cú pháp của Java 8.
	// Với việc sử dụng biểu thức Lambda.
	public static void java8Consumer() {
		List<String> list = Arrays.asList("a", "b", "c", "a1", "a2");

		list.forEach((String t) -> {
			System.out.println(t);
		});
	}

	// Sử dụng phương thức List.forEach(Consumer) theo cú pháp của Java 8.
	// Với việc sử dụng biểu thức Lambda.
	// (Đơn giản hơn)
	public static void java8ConsumerMoreSimple() {
		List<String> list = Arrays.asList("a", "b", "c", "a1", "a2");

		list.forEach((String t) -> System.out.println(t));
	}
	
}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {

	// Đánh giá một tham số đầu vào và trả về true hoặc false.
	boolean test(T t);

}

package org.o7planning.tutorial.j8.api;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class PredicateExample {

	// Sử dụng phương thức Stream.filter(Predicate<T>) theo cú pháp của Java < 8.
	// Lọc một danh sách các số nguyên và in ra các số lẻ.
	public static void beforeJ8() {
		List<Integer> list = Arrays.asList(1, 4, 5, 1, 7, 8);

		// Stream chứa các phần tử của danh sách trên.
		Stream<Integer> stream = list.stream();

		// Stream mới chỉ chứa các số lẻ.
		Stream<Integer> stream2 = stream.filter(new Predicate<Integer>() {

			@Override
			public boolean test(Integer t) {
				return t % 2 == 1;
			}
		});
	}

	// Sử dụng phương thức Stream.filter(Predicate<T>) theo cú pháp của Java >= 8.
	// Lọc một danh sách các số nguyên và in ra các số lẻ.
	// Với việc sử dụng biểu thức Lambda.
	public static void java8Predicate() {
		List<Integer> list = Arrays.asList(1, 4, 5, 1, 7, 8);

		// Một Stream chứa các phần tử của danh sách trên.
		Stream<Integer> stream = list.stream();

		// Một Stream mới chỉ chứa các số lẻ.
		Stream<Integer> stream2 = stream.filter(t -> {
			return t % 2 == 1;
		});

		// Stream.forEach(Consumer<T>)
		stream2.forEach(t -> System.out.println(t));
	}

	// Đơn giản và ngắn gọn hơn nữa.
	public static void java8ConsumerMoreSimple() {
		List<Integer> list = Arrays.asList(1, 4, 5, 1, 7, 8);

		// Một Stream chứa các phần tử của danh sách trên.
		Stream<Integer> stream = list.stream();

		stream.filter(t -> t % 2 == 1).forEach(t -> System.out.println(t));
	}

}

package java.util.function;

import java.util.Objects;


@FunctionalInterface
public interface Function<T, R> {

	// Phương thức này chấp nhận một tham số.
	// Và trả về một giá trị.
	R apply(T t);

}

package org.o7planning.tutorial.j8.api;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;

public class FunctionExample {

	// Sử dụng phương thức Stream.map(Function) với cú pháp của Java < 8.
	// In ra danh sách các phần tử của List.
	public static void beforeJ8() {
		List<String> list = Arrays.asList("a", "c", "B", "e", "g");

		// Stream chứa các phần tử của danh sách.
		Stream<String> stream = list.stream();

		// Stream.map(Function):
		// <R> Stream<R> map(Function<? super T, ? extends R> mapper);
		// Trả về một Stream mới, với các phần tử đã được thay đổi.
		Stream<String> streamUpper = stream.map(new Function<String, String>() {

			@Override
			public String apply(String t) {
				return t == null ? null : t.toUpperCase();
			}

		});

		streamUpper.forEach(t -> System.out.println(t));
	}

	public static void java8Function() {
		List<String> list = Arrays.asList("a", "c", "B", "e", "g");

		// Một Stream chứa các phần tử của danh sách.
		Stream<String> stream = list.stream();

		stream.map(t -> t == null ? null : t.toUpperCase()).forEach(t -> System.out.println(t));
	}

	public static void main(String[] args) {

		beforeJ8();

		java8Function();
	}

}

@FunctionalInterface
public interface IntFunction<R> {
 
    R apply(int value);
}


@FunctionalInterface
public interface LongFunction<R> {
 
    R apply(long value);
}


@FunctionalInterface
public interface DoubleFunction<R> {
 
    R apply(double value);
}

package java.util.function;

@FunctionalInterface
public interface Supplier<T> {

	// Phương thức này không có tham số.
	// Nhưng trả về một kết quả.
	T get();

}

package org.o7planning.tutorial.j8.api;

import java.util.function.Supplier;

public class SupplierExample {

	// Một phương thức với tham số là Supplier<String>.
	public static void display(Supplier<String> supp) {
		System.out.println(supp.get());
	}

	// Không sử dụng biểu thức Lambda.
	public static void beforeJ8() {
		display(new Supplier<String>() {

			@Override
			public String get() {
				return "Hello";
			}
		});
		display(new Supplier<String>() {

			@Override
			public String get() {
				return "World";
			}
		});
	}

	// Sử dụng biểu thức Lambda.
	public static void java8Supplier() {
		display(() -> {
			return "Hello";
		});

		display(() -> {
			return "World";
		});
	}

	// Sử dụng biểu thức Lambda.
	// (Ngắn gọn hơn nữa).
	public static void java8SupplierShortest() {
		display(() -> "Hello");

		display(() -> "World");
	}

	public static void main(String[] args) {

		beforeJ8();
		System.out.println("-----------");
		java8SupplierShortest();
	}

}

package org.o7planning.tutorial.j8.mref;

@FunctionalInterface
public interface MyFunction {

	// Phương thức này có 2 tham số a, b và trả về kiểu int.
	public int doSomething(int a, int b);

}

package org.o7planning.tutorial.j8.mref;

public class MyMathUtils {

	// Phương thức này có 2 tham số a, b và trả về kiểu int.
	// Phương thức này khác tên,
	// nhưng có cấu trúc giống với MyFunction.doSomething(int,int).
	public static int sum(int a, int b) {
		return a + b;
	}

	public static int minus(int a, int b) {
		return a - b;
	}

}

package org.o7planning.tutorial.j8.mref;

public class MethodReferenceExample {

	// Tham số thứ 3 của phương thức này là MyFunction (Functional Interface).
	// Khi sử dụng phương thức này:
	// Bạn có thể truyền tham chiếu của một phương thức cho tham số thứ 3.
	// (Các phương thức phải cùng kiểu với MyFunction).
	public static int action(int a, int b, MyFunction func) {
		return func.doSomething(a, b);
	}

	public static void main(String[] args) {
		int a = 100;
		int b = 30;

		// Truyền vào tham chiếu của phương thức MyMathUtils.sum.
		int c = action(a, b, MyMathUtils::sum);// ==> 130.

		System.out.println("c = " + c);

		// Truyền vào tham chiếu của phương thức MyMathUtils.minus.
		int d = action(a, b, MyMathUtils::minus);// ==> 70

		System.out.println("d = " + d);

		// Truyền vào tham chiếu của phương thức Math.subtractExact.
		int e = action(a, b, Math::subtractExact);// ==> 70

		System.out.println("e = " + e);

		// Truyền vào tham chiếu của phương thức Math.min.
		// Pass the reference of Math.min method.
		int f = action(a, b, Math::min);// ==> 30

		System.out.println("f = " + f);
	}
}