Java 8 là gì

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 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() { @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 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 { 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 converter = new Converter() { @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 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 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 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 { // 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 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 list = Arrays.asList("a", "b", "c", "a1", "a2"); list.forEach(new Consumer() { @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 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 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 { // Đá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) 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 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 stream = list.stream(); // Stream mới chỉ chứa các số lẻ. Stream stream2 = stream.filter(new Predicate() { @Override public boolean test(Integer t) { return t % 2 == 1; } }); } // Sử dụng phương thức Stream.filter(Predicate) 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 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 stream = list.stream(); // Một Stream mới chỉ chứa các số lẻ. Stream stream2 = stream.filter(t -> { return t % 2 == 1; }); // Stream.forEach(Consumer) stream2.forEach(t -> System.out.println(t)); } // Đơn giản và ngắn gọn hơn nữa. public static void java8ConsumerMoreSimple() { List 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 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 { // 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 list = Arrays.asList("a", "c", "B", "e", "g"); // Stream chứa các phần tử của danh sách. Stream stream = list.stream(); // Stream.map(Function): // Stream map(Function mapper); // Trả về một Stream mới, với các phần tử đã được thay đổi. Stream streamUpper = stream.map(new Function() { @Override public String apply(String t) { return t == null ? null : t.toUpperCase(); } }); streamUpper.forEach(t -> System.out.println(t)); } public static void java8Function() { List list = Arrays.asList("a", "c", "B", "e", "g"); // Một Stream chứa các phần tử của danh sách. Stream 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 apply(int value); } @FunctionalInterface public interface LongFunction { R apply(long value); } @FunctionalInterface public interface DoubleFunction { R apply(double value); }

package java.util.function; @FunctionalInterface public interface Supplier { // 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. public static void display(Supplier supp) { System.out.println(supp.get()); } // Không sử dụng biểu thức Lambda. public static void beforeJ8() { display(new Supplier() { @Override public String get() { return "Hello"; } }); display(new Supplier() { @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); } }