package com.huongdanjava.javaexample;

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

public class Example {

	public static void main(String[] args) {
		List<String> names = new ArrayList<>();
		names.add("Thanh");
		names.add("Khanh");
		names.add("Tan");

		Collections.sort(names, new Comparator<String>() {
		    @Override
		    public int compare(String s1, String s2) {
		        return s1.compareTo(s2);
		    }
		});

		for (String s : names) {
			System.out.println(s);
		}
	}
}

Kết quả:

Từ Java 8 trở đi, chúng ta có thêm một cách khác để sort các phần tử trong một đối tượng List đó là sử dụng phương thức sort() của đối tượng List này với Lambda Expression.

Bây giờ nếu mình sửa lại ví dụ ở trên để sử dụng phương thức sort() của đối tượng List và Lambda Expression:

package com.huongdanjava.javaexample;

import java.util.ArrayList;
import java.util.List;

public class Example {

	public static void main(String[] args) {
		List<String> names = new ArrayList<>();
		names.add("Thanh");
		names.add("Khanh");
		names.add("Tan");

		names.sort((s1, s2) -> s1.compareTo(s2));

		names.forEach(System.out::println);
	}
}

thì kết quả sẽ tương tự như trên:

Tham số của phương thức sort() là interface Comparator và bởi vì interface Comparator chỉ có một phương thức, nghĩa là nó còn có thể gọi là Functional Interface nên chúng ta có thể áp dụng Lambda Expression cho nó.

The post Sử dụng Lambda Expression để sort một List trong Java appeared first on Hướng Dẫn Java.

Ví dụ như:

package com.huongdanjava.javaexample;

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

public class Example {

	public static void main(String[] args) {
		List<String> names = new ArrayList<>();
		names.add("Thanh");
		names.add("Khanh");
		names.add("Tan");

		Collections.sort(names, new Comparator<String>() {
		    @Override
		    public int compare(String s1, String s2) {
		        return s1.compareTo(s2);
		    }
		});

		for (String s : names) {
			System.out.println(s);
		}
	}
}

Kết quả:

Từ Java 8 trở đi, chúng ta có một cách khác để làm điều này. Đó chính là sử dụng phương thức sort() của đối tượng List với Lambda Expression.

Giờ mình có thể viết lại ví dụ trên với phương thức sort() và Lambda Expression như sau:

package com.huongdanjava.javaexample;

import java.util.ArrayList;
import java.util.List;

public class Example {

	public static void main(String[] args) {
		List<String> names = new ArrayList<>();
		names.add("Thanh");
		names.add("Khanh");
		names.add("Tan");

		names.sort((s1, s2) -> s1.compareTo(s2));

		names.forEach(System.out::println);
	}
}

Tham số của phương thức sort() là một Comparator interface. Comparator interface là một Functional Interface nên chúng ta có thể sử dụng Lambda Expression cho nó.

Kết quả vẫn như vậy:

The post Sử dụng Lambda Expression để sắp xếp các phần tử của một List trong Java appeared first on Hướng Dẫn Java.

Ví dụ, mình có một đối tượng Map như sau:

Map<String, Integer> studentMap = new HashMap<>();
studentMap.put("Khanh", 31);
studentMap.put("Thanh", 25);
studentMap.put("Dung", 35);

Trước Java 8, để filter đối tượng Map này và lấy tuổi của sinh viên Khanh, chúng ta có thể viết code như sau:

int age = 0;
for (Map.Entry<String, Integer> entry : studentMap.entrySet()) {
    if ("Khanh".equals(entry.getKey())) {
        age = entry.getValue();
    }
}

Kết quả:

Từ Java 8, chúng ta có thể viết lại đoạn code trên như sau sử dụng Stream và Lambda Expression:

Integer age = studentMap.entrySet().stream()
    .filter(map -> "Khanh".equals(map.getKey()))
    .map(map -> map.getValue())
    .findFirst()
    .get();

Kết quả:

Chúng ta cũng có thể filter một Map và trả về một Map như sau:

package com.huongdanjava.javaexample;

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Example {

	public static void main(String[] args) {
		Map<String, Integer> studentMap = new HashMap<>();
		studentMap.put("Khanh", 31);
		studentMap.put("Thanh", 25);
		studentMap.put("Dung", 35);

		Map<String, Integer> age = studentMap.entrySet().stream()
		    .filter(map -> "Khanh".equals(map.getKey()))
		    .collect(Collectors.toMap(m -> m.getKey(), m -> m.getValue()));

		System.out.println(age);
	}

}

Kết quả:

The post Filter một Map sử dụng Stream và Lambda Expression trong Java appeared first on Hướng Dẫn Java.

Ví dụ mình có một List chứa thông tin tên sinh viên như sau:

List<String> names = new ArrayList<>();
names.add("Thanh");
names.add("Khanh");
names.add("Tan");

Bây giờ, mình muốn filter List trên để có một List khác chỉ chứa những sinh viên có tên bắt đầu với ký tự “T”, mình sẽ code như sau:

List<String> namesStartWithT = new ArrayList<>();
for (String s : names) {
    if (s.startsWith("T")) {
        namesStartWithT.add(s);
    }
}

System.out.println(namesStartWithT);

Kết quả:

Kể từ Java 8, chúng ta có một cách tốt hơn để làm điều này đó chính là sử dụng Lambda Expression với Stream. Cụ thể là chúng ta sẽ tạo mới đối tượng Stream từ đối tượng List, sau đó sử dụng phương thức filter() của đối tượng Stream để filter.

Stream stream = names.stream().filter(s -> s.startsWith("T"));

Tham số của phương thức filter() là một đối tượng của interface Predicate, một Functional Interface. Các bạn có thể xem thêm về interface Predicate ở đây. Và còn một điều nữa là phương thức filter() đóng vai trò là một intermediate operation trong Stream pipeline, do đó chúng ta cần phải thêm một method nữa đóng vai trò là terminal operation.

Ở đây, sau khi filter xong, mình sẽ collect tất cả các phần tử thoả điều kiện vào một List sử dụng phương thức collect() của đối tượng Stream. Phương thức này là teminal operation của Stream pipeline đó các bạn.

List<String> list = names.stream()
    .filter(s -> s.startsWith("T"))
    .collect(Collectors.toList());

list.stream().forEach(System.out::println);

Khi đó, kết quả vẫn như vậy:

The post Filter một List sử dụng Lambda Expression và Stream trong Java appeared first on Hướng Dẫn Java.

Trước tiên, các bạn cần biết là, phương thức map() là một intermediate operation nên chúng ta sẽ cần thêm phương thức đóng vai trò là terminal operation để hoàn thành Stream pipeline. Các bạn xem thêm về đối tượng Stream ở đây để hiểu rõ hơn nhé.

Ví dụ đầu tiên, chúng ta sẽ chuyển đổi một List của String dưới dạng chữ thường sang List của String dưới dạng viết hoa sử dụng phương thức map().

Trước Java 8, chúng ta có thể chuyển đổi như sau:

List<String> names = new ArrayList<>();
names.add("Thanh");
names.add("Khanh");
names.add("Tan");

List<String> namesUpper = new ArrayList<>();
for (String s : names) {
    namesUpper.add(s.toUpperCase());
}

System.out.println(namesUpper.toString());

Kết quả:

Nếu bây giờ, các bạn viết lại đoạn code trên sử dụng phương thức map() của đối tượng Stream với Lambda Expression từ Java 8:

List<String> names = new ArrayList<>();
names.add("Thanh");
names.add("Khanh");
names.add("Tan");

List<String> namesUppper = names.stream()
    .map(x -> x.toUpperCase())
    .collect(Collectors.toList());
System.out.println(namesUppper);

thì kết quả vẫn như vậy.

Ví dụ thứ 2 mà mình muốn đề cập ở đây đó là chúng ta có thể extract một số thông tin từ đối tượng này tới đối tượng khác sử dụng phương thức map().

Ví dụ, mình có class Student như sau:

package com.huongdanjava.javaexample;

import java.util.Date;

public class Student {

    private String name;
    private Date dateOfBirth;


    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getDateOfBirth() {
        return dateOfBirth;
    }

    public void setDateOfBirth(Date dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }
}

Bây giờ, mình có thể extract thông tin tên của tất cả sinh viên thành danh sách tên như sau:

List<Student> students = Arrays.asList(
    new Student("Khanh"),
    new Student("Thanh"),
    new Student("Tan"));
List<String> names = students.stream()
    .map(s -> s.getName())
    .collect(Collectors.toList());

System.out.println(names);

Trong ví dụ trên, biến s đại diện cho mỗi đối tượng Student trong danh sách sinh viên, do đó, các bạn có thể lấy được tên sinh viên để put vào danh sách tên sinh viên.

Kết quả:

The post Chuyển đổi đối tượng sang kiểu dữ liệu khác sử dụng Lambda Expression và Stream trong Java appeared first on Hướng Dẫn Java.

OK, bắt đầu nào các bạn!

Giống như List object, phương thức forEach() cũng được thêm vào đối tượng Map từ Java 8, giúp cho chúng ta có thể nhiều cách khác để in ra các phần tử trong đối tượng này.

Ví dụ, mình có đối tượng Map như sau:

Map<String, String> students = new HashMap<>();
students.put("name", "Khanh");
students.put("age", "20");
students.put("dateofBirth", "24-06-1997");

Thông thường, mình sẽ viết code như sau:

for (Map.Entry<String, String> entry : students.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

Với phương thức forEach() và Lambda Expression thì lúc này code của mình sẽ đơn giản như sau:

students.forEach((k, v) -> System.out.println(k + " : " + v));

Tham số của phương thức forEach() trong đối tượng Map là BiConsumer, một Functional Interface.

Kết quả:

dateofBirth : 24-06-1987
name : Khanh
age : 20

The post Sử dụng Lambda Expression để foreach Map object trong Java appeared first on Hướng Dẫn Java.

OK, bắt đầu nào các bạn!

Thông thường từ Java 7 trở về trước, mỗi khi muốn in ra các phần tử trong một List object nào đó, ví dụ như:

List<String> names = new ArrayList<>();
names.add("Khanh");
names.add("Tan");
names.add("Thanh");

chúng ta thường code như sau:

for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

hoặc:

for (String s : names) {
    System.out.println(s);
}

Từ Java 8 trở đi, chúng ta còn có một số cách khác để làm điều này: đó chính là sử dụng phương thức forEach() trong đối tượng List cùng với Lambda Expression, cụ thể như sau:

names.forEach(s -> System.out.println(s));

Hoặc với Method reference:

names.forEach(System.out::println);

Tham số của phương thức forEach() trong đối tượng List là Consumer, một Functional Interface.

Kết quả:

Khanh
Tan
Thanh

The post Sử dụng Lambda Expression để foreach List object trong Java appeared first on Hướng Dẫn Java.

Đầu tiên, hãy cũng mình xem xét ví dụ sau:

package com.huongdanjava.example;

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

public class Example {

	public static void main(String[] args) {
		List<String> names = Arrays.asList("Khanh", "Thanh", "Dung");

		names.stream()
			.filter(s -> s.startsWith("K"))
			.forEach(System.out::println);
	}
}

Trong ví dụ này, mình có một List của đối tượng String. Từ đối tượng List này, mình chuyển nó qua đối tượng của Stream, sau đó dùng đối tượng Stream này để lọc lấy những String bắt đầu bằng ký tự “K”, cuối cùng là in những đối tượng String bắt đầu bằng chữ “K” ra màn hình.

Kết quả:

Rõ ràng, như các bạn thấy việc sử dụng Stream cùng với Lambda Expression làm cho việc code của chúng ta dễ hiểu và dễ đọc hơn rất nhiều.

Ở đoạn code trên, chúng ta lấy đối tượng Stream từ đối tượng Collection, các bạn sẽ có cảm giác có vẻ như Stream là một Collection phải không? Không phải vậy đâu các bạn, Stream không phải là một Collection.

Định nghĩa đơn giản thì Stream là một wrapper của collection và array. Nó wrap một collection sẵn có và các data source khác để hỗ trợ việc thao tác trên các collection, datasource đó sử dụng Lambda Expression. Vì thế, bạn chỉ cần chỉ định cái bạn muốn làm, còn việc làm như thế nào, Stream sẽ lo cái đó.

Các đặc điểm của Stream bao gồm:

• Stream hỗ trợ hoàn hảo cho Lambda Expression.
• Stream không chứa các element của collection hay array.
• Stream là immutable object.
• Stream không dùng lại được, nghĩa là một khi đã sử dụng nó xong, chúng ta không thể gọi nó lại để sử dụng lần nữa.
• Chúng ta không thể dùng index để access các element trong Stream.
• Stream hỗ trợ thao tác song song các element trong collection hay array.
• Stream hỗ trợ thao tác lazy, khi cần thì thao tác mới được thực hiện. Để làm được điều này, hầu hết các thao tác với Stream đều return lại một Stream mới, giúp tạo một mắc xích bao gồm một loạt các thao tác nhằm thực thi các thao tác đó một cách tối ưu nhất. Mắc xích này còn được gọi là pipeline.

Có 3 công đoạn chính để tạo nên một pipeline cho Stream, đó là:

Tạo mới một Stream.

Interface Stream trong package java.util.stream là interface đại diện cho một Stream. Interface này chỉ làm việc với kiểu dữ liệu là object.

Với các kiểu primitive thì các bạn có thể sử dụng các đối tượng Stream dành cho những kiểu primitive đó, ví dụ như IntStream, LongStream hay DoubleStream.

Chúng ta có nhiều cách để tạo mới một Stream:

Tạo mới Stream từ một collection

Ví dụ như:

List<String> names = Arrays.asList("Khanh", "Thanh", "Dung");
Stream<String> stream = names.stream();

Tạo mới Stream từ các giá trị nào đó sử dụng interface Stream.

Ví dụ như:

Stream<String> stream = Stream.of("Khanh", "Thanh", "Dung");

Tạo mới Stream từ một array.

Ví dụ như:

String[] names = { "Khanh", "Thanh", "Dung" };
Stream<String> stream = Stream.of(names);

Sử dụng 0 hoặc nhiều intermediate operations để chuyển đổi Stream ban đầu thành những Stream mới.

Stream có nhiều intermediate operations để thao tác với Stream, như ví dụ ở đầu bài viết mà mình đã sử dụng:

Stream<String> stream = Stream.of("Khanh", "Thanh", "Dung");
stream.filter(s -> s.startsWith("K")).distinct();

Hầu hết các intermediate operation đều return về một đối tượng Stream mới.

Điều quan trọng mà các bạn cần biết là: mặc dù chúng ta định nghĩa nhiều intermediate operation như thế nhưng chúng không thực thi các thao tác đó liền. Chỉ khi terminal operation được gọi thì toàn bộ các thao tác đó mới được thực thi nhé các bạn!

Sử dụng terminal operation lấy về kết quả hoặc một side-effect từ những intermediate operations đã định nghĩa.

Các bạn có thể dễ dàng xác định đâu là intermediate operation, đâu là terminal operation bởi vì terminal operation sẽ trả về void hoặc non-Stream object.

Sau khi terminal operation được gọi, Stream sẽ không sử dụng được nữa nhé các bạn. Muốn sử dụng lại thì các bạn phải tạo mới Stream từ những collection hay array mà các bạn muốn.

The post Giới thiệu về Stream trong Java appeared first on Hướng Dẫn Java.

Giả sử các bạn đang làm việc với một Lambda Expression có dạng như sau:

(args) -> new ClassName(args)

Trong biểu thức Lambda Expression này, phần body chúng ta chỉ có một đoạn code khởi tạo mới một đối tượng với constructor có hoặc không sử dụng các tham số argument.

Để ngắn gọn hơn, chúng ta có thể sử dụng constructor reference như sau:

ClassName::new

Để lấy ví dụ cho khái niệm constructor reference này, mình sẽ sử dụng một số interface nằm trong package java.util.function.

• Với constructor không có tham số, mình sẽ sử dụng interface Supplier với biểu thức Lambda Expression như sau:

Supplier<List<String>> s = () -> new ArrayList<>();

Viết lại với constructor reference:

Supplier<List<String>> s = ArrayList::new;

• Với constructor có một tham số, mình sẽ sử dụng interface Function với biểu thức Lambda Expression như sau:

Function<String, Integer> f = s -> new Integer(s);

Viết lại với constructor reference:

Function<String, Integer> f = Integer::new;

The post Constructor reference trong Java appeared first on Hướng Dẫn Java.

OK, bắt đầu nào các bạn …

Điều đầu tiên, các bạn cần phải biết là method reference là cách code ngắn gọn hơn cho những Lambda Expression mà trong phần body của nó chỉ có duy nhất một phương thức được gọi.

Cú pháp chung của method reference là:

Object::methodName

Trong đó Object là tên class có chứa phương thức đang được gọi (methodName) trong phần body của Lambda Expression.

Ví dụ giả sử mình có một Lambda Expression như sau:

SayHello sayHello = s -> System.out.println(s);

Trong Lambda Expression này, phần body chúng ta chỉ gọi phương thức println() của đối tượng System.out (PrintStream). Do đó, chúng ta có thể viết lại đoạn code trên sử dụng method reference như sau:

System.out::println;

Kết quả:

Ở đây, chúng ta cho tất cả 3 loại method reference.

• Loại thứ nhất là method reference cho một phương thức static:

Giả sử mình có Lambda Expression sau:

(args) -> ClassName.staticMethod(args)

thì khi chuyển qua method reference, mình có thể viết lại như sau:

ClassName::staticMethod

• Loại thứ hai là method reference cho một instance method của một đối tượng với kiểu dữ liệu cụ thể.

Loại này chúng ta có thể áp dụng cho những Lambda Expression có dạng giống giống như sau:

(obj, args) -> obj.instanceMethod(args)

trong đó, obj là instance của một object nào đó và obj này gọi một instance method có sử dụng các args còn lại trong biểu thức Lambda Expression.

Ví dụ mình có Lambda Expression như sau:

(String s, int i) -> s.substring(i);

Trong biểu thức này, chúng ta có s là một argument với kiểu dữ liệu String và trong phần body, chúng ta sử dụng s để gọi một phương thức có sử dụng argument i. Trong trường hợp này, chúng ta có thể sử dụng method reference như sau:

String::substring

• Loại cuối cùng là method reference cho một existing object.

Với loại này, chúng ta apply cho những Lambda Expression có dạng như sau:

(args) -> obj.instanceMethod(args);

Với dạng này, obj là môt instance của một đối tượng đã được khai báo ở đâu đó, obj này gọi một phương thức có sử dụng argument trong biểu thức Lambda Expression.

Trong ví dụ ở đầu bài viết:

s -> System.out.println(s);

println() là một instance method của class PrintStream. Do đó chúng ta có thể code gọn lại như sau:

System.out::println

The post Method reference trong Java appeared first on Hướng Dẫn Java.