# java8之Stream筛选与切片

**Repository Path**: fpfgitmy_admin/java8-stream-select-cut

## Basic Information

- **Project Name**: java8之Stream筛选与切片
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-04-28
- **Last Updated**: 2021-04-28

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

### Stream的筛选与切片
+ 多个**中间操作**可以连接起来形成一个流水线，除非流水线上出发终止操作，否则**中间操作不会执行任何处理，而在终止操作时一次性全部处理，称为'惰性求值'**

#### 筛选与切片

| 方法 |描述 |扩展|
| --- | --- | --- |
| filter(Predicate p) | 接受Lambda,从流中排除某些元素 | [函数式接口Predicate]() |
| distinct() | 筛选，通过流锁生成元素的hashCode()和equals()去除重复元素 | - |
| limit(long maxSize) | 截断流，使其元素不超过给定数量 | - |
| skip(long n) | 跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补 | - |

#### 代码示例
+ 使用的model

```
public class Goods implements Comparable {

    private String name;
    private Double price;

    public static List<Goods> getGoods() {
        ArrayList<Goods> list = new ArrayList<>();
        list.add(new Goods("小米", 3999.0));
        list.add(new Goods("苹果", 9999.0));
        list.add(new Goods("华为", 5999.0));
        return list;
    }

    public Goods() {
    }

    public Goods(Double price) {
        this.price = price;
    }

    public Goods(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}
```

+ 进行操作

```
    @Test
    public void test1() {
        // 传入一个参数并进行操作,返回boolean
        Predicate<String> p = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("a");
            }
        };
        boolean b = p.test("b");
        System.out.println(b);
        System.out.println("------------使用filter过滤操作-----------");
        List<Goods> list = Goods.getGoods();
        Stream<Goods> stream = list.stream();
        stream.filter(g -> g.getPrice() > 3444.0).forEach(System.out::println);
        System.out.println("-------------使用了limit操作-----------");
        // 上一步的stream已经使用了终止操作符，被关闭，需要重新声明
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("-------------使用了skip操作(跳过前两个)-----------");
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("-------------使用了distinct操作,使用hashcode()和equals()去除重复元素-----------");
        list.add(new Goods("小米", 3999.0));
        list.add(new Goods("小米", 3999.0));
        list.add(new Goods("小米", 3999.0));
        list.stream().distinct().forEach(System.out::println);
    }
```