java stream使用方法

1.filter

 //见名知意过滤出想要的东西会返回一个新的steam()，如果想要2个以上的过滤条件 用&& || !
 
//获得所有的车辆   以下demo都是对cars进行处理，添加了一个重复的Car对象以便后续的demo的使用
List<Car> cars = getCars();
cars.forEach(System.out::println);
	
//cars list打印
Car{id=1, name='第1辆车', price=5.0}
Car{id=2, name='第2辆车', price=10.0}
Car{id=3, name='第3辆车', price=15.0}
Car{id=4, name='第4辆车', price=20.0}
Car{id=5, name='第5辆车', price=25.0}
Car{id=1, name='第1辆车', price=5.0}

	
List<Car> filter =
            cars.stream().filter(car -> car.getPrice() < 20 && car.getId()>1).collect(Collectors.toList());
filter.forEach(System.out::println);

--------------------过滤出价格小于20的并且id大于1的----------------------------
Car{id=2, name='第2辆车', price=10.0}
Car{id=3, name='第3辆车', price=15.0}
	

2.limit

		
//limit取前两个
List<Car> limit = cars.stream().limit(2).collect(Collectors.toList());
limit .forEach(System.out::println);

//打印
---------------------limit指定前两个---------------------------
Car{id=1, name='第1辆车', price=5.0}
Car{id=2, name='第2辆车', price=10.0}

3.skip 跳过前N个

//跳过前两个
List<Car> skip = cars.stream().skip(2).collect(Collectors.toList());
skip .forEach(System.out::println);

//打印
----------------------skip--------------------------
Car{id=3, name='第3辆车', price=15.0}
Car{id=4, name='第4辆车', price=20.0}
Car{id=5, name='第5辆车', price=25.0}
Car{id=1, name='第1辆车', price=5.0}

4.distinct 去重 对象去重的话得重写equals和hashCode

 List<Car> distinct = cars.stream().distinct().collect(Collectors.toList());
 distinct.forEach(System.out::println);

//打印
Car{id=1, name='第1辆车', price=5.0}
Car{id=2, name='第2辆车', price=10.0}
Car{id=3, name='第3辆车', price=15.0}
Car{id=4, name='第4辆车', price=20.0}
Car{id=5, name='第5辆车', price=25.0}

5 sorted排序 有2个重载的方法一个是无参的默认为正序排列，另一个得实现Comparator<? super T> comparator

//排序                                  
//Comparator.comparing(Car::getPrice).reversed()是逆序

List<Car> sorted = cars.stream().sorted(Comparator.comparing(Car::getPrice)).collect(Collectors.toList());
sorted.forEach(System.out::println);

//打印
------------------排序------------------------------
Car{id=1, name='第1辆车', price=5.0}
Car{id=1, name='第1辆车', price=5.0}
Car{id=2, name='第2辆车', price=10.0}
Car{id=3, name='第3辆车', price=15.0}
Car{id=4, name='第4辆车', price=20.0}
Car{id=5, name='第5辆车', price=25.0}

6 map 可以理解能够转换成其他的数据

//把Car对象转成NewCar对象
List<NewCar> newCars = cars.stream().map(car -> {

    NewCar newCar = new NewCar();

    newCar.setId(car.getId());
    newCar.setName("我是新的---" + car.getName());
    newCar.setPrice(car.getPrice());

    return newCar;

}).collect(Collectors.toList());

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

//打印
NewCar{id=1, name='我是新的---第1辆车', price=5.0}
NewCar{id=2, name='我是新的---第2辆车', price=10.0}
NewCar{id=3, name='我是新的---第3辆车', price=15.0}
NewCar{id=4, name='我是新的---第4辆车', price=20.0}
NewCar{id=5, name='我是新的---第5辆车', price=25.0}
NewCar{id=1, name='我是新的---第1辆车', price=5.0}

7 reduce 根据指定的计算模型进行计算也可以理解成聚合

//使用map使其变成BigDecimal，再对其价格进行相加
BigDecimal reduce = cars.stream().map(car -> new BigDecimal(car.getPrice())).reduce(BigDecimal.ZERO, BigDecimal::add);

//打印
80

8 Collectors.groupingBy 根据条件进行分组

//按照id一样的进行合并
Map<Integer, List<Car>> groupingBy = cars.stream().collect(Collectors.groupingBy(car -> car.getId()));

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

//打印
1:[Car{id=1, name='第1辆车', price=5.0}, Car{id=1, name='第1辆车', price=5.0}]
2:[Car{id=2, name='第2辆车', price=10.0}]
3:[Car{id=3, name='第3辆车', price=15.0}]
4:[Car{id=4, name='第4辆车', price=20.0}]
5:[Car{id=5, name='第5辆车', price=25.0}]

9.把以上demo合起来使用

找出cars里价格大于5.0 转成NewCar对象并把id一样的进行分组 最终的效果就是[{id:"",list:[{},{}]},{id:"",list:[{},{}]}]

//先把过滤后的car对象再转成NewCar对象
Map<Integer, List<NewCar>> collect = cars.stream()
                                        .filter(car -> car.getPrice() > 5.0)
                                        .map(car -> {
                                            NewCar newCar = new NewCar();
                                            newCar.setId(car.getId());
                                            newCar.setName("我是新的---" + car.getName());
                                            newCar.setPrice(car.getPrice());
                                            return newCar;
                                        }).collect(Collectors.groupingBy(NewCar::getId));
//打印
2<---->[NewCar{id=2, name='我是新的---第2辆车', price=10.0}]
3<---->[NewCar{id=3, name='我是新的---第3辆车', price=15.0}]
4<---->[NewCar{id=4, name='我是新的---第4辆车', price=20.0}]
5<---->[NewCar{id=5, name='我是新的---第5辆车', price=25.0}]


//再把上面的map里的Key取出来，collect.get(key)就是NewCarList
List<Map<String, Object>> list = collect.keySet().stream().map(k -> {
            Map<String, Object> result = new HashMap<>(2);
            result.put("id", k);
            List<NewCar> newCarsList = collect.get(k);
            result.put("list", newCarsList);
            return result;
        }).collect(Collectors.toList());
//打印
{list=[NewCar{id=2, name='我是新的---第2辆车', price=10.0}], id=2}
{list=[NewCar{id=3, name='我是新的---第3辆车', price=15.0}], id=3}
{list=[NewCar{id=4, name='我是新的---第4辆车', price=20.0}], id=4}
{list=[NewCar{id=5, name='我是新的---第5辆车', price=25.0}], id=5}