在這篇文章裡，我們將提供Java8 Stream distinct（）示例。

distinct（）返回由該流的不同元素組成的流。distinct（）是Stream介面的方法。

distinct（）使用hashCode（）和equals（）方法來獲取不同的元素。因此，我們的類必須實現hashCode（）和equals（）方法。

如果distinct（）正在處理有序流，那麼對於重複元素，將保留以遭遇順序首先出現的元素，並且以這種方式選擇不同元素是穩定的。在無序流的情況下，不同元素的選擇不一定是穩定的，是可以改變的。distinct（）執行有狀態的中間操作。在有序流的並行流的情況下，保持distinct（）的穩定性是需要很高的代價的，因為它需要大量的緩衝開銷。如果我們不需要保持遭遇順序的一致性，那麼我們應該可以使用通過BaseStream.unordered（）方法實現的無序流。

Stream.distinct()

distinct()方法的宣告如下：

Stream<T> distinct()

它是Stream介面的方法。在此示例中，我們有一個包含重複元素的字串資料型別列表

DistinctSimpleDemo.java

package com.concretepage;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class DistinctSimpleDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("AA", "BB", "CC", "BB", "CC", "AA", "AA");
        long l = list.stream().distinct().count();
        System.out.println("No. of distinct elements:"+l);
        String output = list.stream().distinct().collect(Collectors.joining(","));
        System.out.println(output);
    }
} 
 

Output

No. of distinct elements:3
AA,BB,CC 

Stream.distinct() with List of Objects

在此示例中，我們有一個Book物件列表。 為了對列表進行去重，該類將重寫hashCode（）和equals（）。

Book.java

package com.concretepage;
public class Book {
    private String name;
    private int price;
    public Book(String name, int price) {
	this.name = name;
	this.price = price;
    }
    public String getName() {
	return name;
    }
    public int getPrice() {
	return price;
    }
    @Override
    public boolean equals(final Object obj) {
      if (obj == null) {
         return false;
      }
      final Book book = (Book) obj;
      if (this == book) {
         return true;
      } else {
         return (this.name.equals(book.name) && this.price == book.price);
      }
    }
    @Override
    public int hashCode() {
      int hashno = 7;
      hashno = 13 * hashno + (name == null ? 0 : name.hashCode());
      return hashno;
    }
} 
 

DistinctWithUserObjects.java

package com.concretepage;
import java.util.ArrayList;
import java.util.List;
public class DistinctWithUserObjects {
    public static void main(String[] args) {
        List<Book> list = new ArrayList<>();
        {
           list.add(new Book("Core Java", 200));
           list.add(new Book("Core Java", 200));
           list.add(new Book("Learning Freemarker", 150));        	
           list.add(new Book("Spring MVC", 300));
           list.add(new Book("Spring MVC", 300));
        }
        long l = list.stream().distinct().count();
        System.out.println("No. of distinct books:"+l);
        list.stream().distinct().forEach(b -> System.out.println(b.getName()+ "," + b.getPrice()));
    }
}

Output

No. of distinct books:3
Core Java,200
Learning Freemarker,150
Spring MVC,300 

Distinct by Property

distinct（）不提供按照屬性對物件列表進行去重的直接實現。它是基於hashCode（）和equals（）工作的。如果我們想要按照物件的屬性，對物件列表進行去重，我們可以通過其它方法來實現。如下程式碼段所示：

static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
} 

上面的方法可以被Stream介面的 filter()接收為引數，如下所示：

list.stream().filter(distinctByKey(b -> b.getName())); 

distinctByKey()方法返回一個使用ConcurrentHashMap 來維護先前所見狀態的 Predicate 例項，如下是一個完整的使用物件屬性來進行去重的示例。

DistinctByProperty.java

package com.concretepage;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
public class DistinctByProperty {
    public static void main(String[] args) {
        List<Book> list = new ArrayList<>();
        {
        	list.add(new Book("Core Java", 200));
        	list.add(new Book("Core Java", 300));
        	list.add(new Book("Learning Freemarker", 150));
        	list.add(new Book("Spring MVC", 200));
        	list.add(new Book("Hibernate", 300));
        }
        list.stream().filter(distinctByKey(b -> b.getName()))
              .forEach(b -> System.out.println(b.getName()+ "," + b.getPrice()));   
    }
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
} 

Output

Core Java,200
Learning Freemarker,150
Spring MVC,200
Hibernate,300 

from : https://www.concretepage.com/java/jdk-8/java-8-distinct-example