中间操作2之filter、distinct、limit、skip、sorted

1.filter

	Collection<Person> collection = new ArrayList();
	collection.add(new Person("张三", 22, "男"));
	collection.add(new Person("李四", 19, "女"));
	collection.add(new Person("王五", 34, "男"));
	collection.add(new Person("赵六", 30, "男"));
	collection.add(new Person("田七", 25, "女"));
	
	Stream<Person> personStream = collection.stream().filter(
	        person -> "男".equals(person.getGender())//只保留男性
	);
	
	collection = personStream.collect(Collectors.toList());//将Stream转化为List
	System.out.println(collection.toString());//查看结果

2.distinct

• 返回由该流的不同元素组成的流

• distinct() 使用hashCode() 和equals() 方法来获取不同的元素。因此，我们的类必须实现hashCode() 和equals() 方法

• 在处理有序流，那么对于重复元素，将保留以遭遇顺序首先出现的元素，并且以这种方式选择不同元素是稳定的

• 在无序流的情况下，不同元素的选择不一定是稳定的，是可以改变的

• distinct() 执行有状态的中间操作。在有序流的并行流的情况下，保持distinct()的稳定性是需要很高的代价的，因为它需要大量的缓冲开销。如果我们不需要保持遭遇顺序的一致性，那么我们应该可以使用通过BaseStream.unordered()方法实现的无序流

  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);
      }
  
  //输出：
  No. of distinct elements:3
  AA,BB,CC  
  
  //在此示例中，我们有一个Book对象列表。 为了对列表进行去重，该类将重写hashCode()和equals()。
  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;
      }
  } 
  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()));
      }
  }
  
  //输出：
  No. of distinct books:3
  Core Java,200
  Learning Freemarker,150
  Spring MVC,300    
  
  //distinct()不提供按照属性对对象列表进行去重的直接实现。它是基于hashCode()和equals()工作的。
  //如果我们想要按照对象的属性，对对象列表进行去重，我们可以通过其它方法来实现。如下代码段所示：
  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;
      }
  } 
  

3.limit

截断流使其最多只包含指定数量的元素。

4.skip

返回一个新的流，并跳过原始流中的前 N 个元素。

5.sorted

对流进行排序。

//按自然升序对集合进行排序
list.stream().sorted();

//自然序降序使用Comparator提供reverseOrder()方法
list.stream().sorted(Comparator.reverseOrder());

//sorted(Comparator<? super T> comparator)
list.stream().sorted(Comparator.comparing(Student::getAge)); 
list.stream().sorted(Comparator.comparing(Student::getAge).reversed()); 

map.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getValue))
						.forEach(e -> System.out.println("Key: "+ e.getKey() +", Value: "+ e.getValue()));

map.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey))
						.forEach(e -> System.out.println("Key: "+ e.getKey() +", Value: "+ e.getValue()));