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

Bertha 。 2022-12-23 15:21 86阅读 0赞

## 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()));