java stream 对某字段求和 java stream 匹配

定义了一个实体类，Apple.java

public class Apple {
private Integer id;
private String name;
private Double money;
private Integer num;
/**状态： 1： 正常 2： 非正常**/
private String status;
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Apple(Integer id, String name, Double money, Integer num, String status) {
this.id = id;
 = name;
this.money = money;
this.num = num;
this.status = status;
}
@Override
public String toString() {
return "Apple{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
", num=" + num +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
 = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
public Integer getNum() {
return num;
}
public void setNum(Integer num) {
this.num = num;
}
}
Java新特性操作部分
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import static java.util.Comparator.comparingLong;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;
/**
*
* @author 王立朝
* @date 2020-8-30
* @description:
*/
public class Java8Test {
/**
* 使用java7进行排序
*
* @param names
*/
public void sortUsingJava7(List names) {
Collections.sort(names, new Comparator() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
for (String s : names) {
System.out.println("java7排序后的结果为： " + s);
}
}
/**
* 使用java8进行排序
*
* @param names
*/
public void sortUsingJava8(List names) {
Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
System.out.println("java 8 的语法");
for (String s : names) {
System.out.println("java7排序后的结果为： " + s);
}
}
/**
* 测试java7 和 java 8 的 排序
*/
public void testJava7And8Sort() {
List nameList = new ArrayList<>();
nameList.add("Java");
nameList.add("Phyton");
nameList.add("JavaScript");
nameList.add("VUE");
nameList.add("BootStrap");
System.out.println("遍历之前的数据顺序为： ");
Java8Test java8Test1 = new Java8Test();
nameList.forEach(e -> System.out.println(e));
java8Test1.sortUsingJava7(nameList);
java8Test1.sortUsingJava8(nameList);
}
/**
* java 1.8 创建对象
*
* @param supplier
* @return
*/
public static Java8Test create(final Supplier supplier) {
return supplier.get();
}
/**
* java8 对数据的处理
*/
public ArrayList getData() {
ArrayList apples = new ArrayList<>();
Apple apple1 = new Apple(1, "苹果1", 1.2, 10, "true");
Apple apple12 = new Apple(1, "苹果2", 1.1, 20, "false");
Apple apple2 = new Apple(2, "香蕉", 6.2, 5, "falseMe");
Apple apple4 = new Apple(4, "香蕉", 2.2, 10, "true");
Apple apple3 = new Apple(3, "荔枝", 0.5, 5, "false");
apples.add(apple1);
apples.add(apple12);
apples.add(apple2);
apples.add(apple3);
apples.add(apple4);
return apples;
}
/**
* 根据ID 进行分组，ID 相同的放到一起
*
* @param apples
*/
public void groupById(ArrayList apples) {
// List以ID 分组，然后放到Map 中
Map> groupby = apples.stream().collect(Collectors.groupingBy(Apple::getId));
System.out.println(groupby);
}
/**
* list　转换为Ｍap,
* 注意： Collectors.toMap() 方法中，如果key有重复，会报错Duplicate key
* apple1,apple12的id都为1。可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
*
* @param apples
*/
public void listToMap(ArrayList apples) {
Map map = apples.stream().collect(Collectors.toMap(Apple::getId, a -> a, (k1, k2) -> k1));
for (Object key : map.keySet()) {
System.out.println("key= " + key + " and value= " + map.get(key));
}
}
/**
* 对数据进行过滤
*
* @param apples
*/
public void filterData(ArrayList apples) {
List list = apples.stream().filter(a -> a.getName().equals("香蕉")).collect(Collectors.toList());
Apple apple = null;
for (int i = 0; i < list.size(); i++) {
apple = list.get(i);
System.out.println("过滤香蕉的数据为： " + apple);
}
}
/**
* 按照某一个属性进行求和
*
* @param apples
*/
public void getSumByProperty(ArrayList apples) {
int sum = apples.stream().mapToInt(Apple::getId).sum();
System.out.println("统计的结果为： " + sum);
}
/**
* 计算流中的最大值和最小值
* TODO 暂时还不确定这个方法到底是怎么用
*/
public void getMaxAndMinVal() {
/*Optional maxDish = Dish.menu.stream().
collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
maxDish.ifPresent(System.out::println);
Optional minDish = Dish.menu.stream().
collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
minDish.ifPresent(System.out::println);*/
}
/**
* 对数据进行去重
*
* @param apples
*/
public void distinic(ArrayList apples) {
// 根据id去重
List unique = apples.stream().collect(
collectingAndThen(
toCollection(() -> new TreeSet<>(comparingLong(Apple::getId))), ArrayList::new)
);
System.out.println("去重前数据遍历结果为： ");
apples.forEach(s -> {
System.out.println("去重前遍历的结果为： " + s);
});
System.out.println("去重后数据遍历结果");
unique.forEach(s -> {
System.out.println("去重后遍历的结果为： " + s);
});
}
/**
* TODO: 对数据进行操作
* TODO: 查找与匹配数据
* TODO: 1、检查是否匹配所有元素 allMatch
* TODO: 2、检查是否至少匹配一个元素 anyMatch
* TODO: 3、检查是否没有匹配的元素 noneMatch
* TODO: 4、返回第一个元素 findFirst
* TODO: 5、返回当前流中的任意一个元素 findAny
* TODO: 6、返回流中元素的总个数 count
* TODO: 7、返回流中的最大值 max
* TODO: 8、返回流中的最小值 min
**/
public void testStreamApi(ArrayList apples) {
// 判断 列表里面的值是否都是true allMatch
boolean aTrue = apples.stream().allMatch((e) -> e.getStatus().equals("true"));
System.out.println("判断 列表里面的值是否都是true-->" + aTrue);
boolean anyMatch = apples.stream().anyMatch((e) -> e.getStatus().equals("false"));
System.out.println("判断列表里面的值是否至少匹配一个元素->" + anyMatch);
boolean noneMatch = apples.stream().noneMatch((e) -> e.getStatus().equals("false"));
System.out.println("判断列表里面的值是否一个都没有匹配到->" + noneMatch);
Optional first = apples.stream().sorted(Comparator.comparing(Apple::getMoney)).findFirst();
System.out.println("获取列表中的第一个元素(先根据 money进行排序，然后)->" + first);
Optional findAny = apples.stream().filter((e) -> e.getStatus().equals("false")).findAny();
System.out.println("获取列表中任意一个元素->" + findAny);
long listCount = apples.stream().count();
System.out.println("获取列表的数量->" + listCount);
long falseCount = apples.stream().filter((e) -> e.getStatus().equals("false")).count();
System.out.println("查询列表中 状态是false 的总共有几个 ->" + falseCount);
Optional max = apples.stream().map(Apple::getMoney).max(Double::compareTo);
System.out.println("查询money最大的 ->" + max);
Optional min = apples.stream().sorted(Comparator.comparingDouble(Apple::getMoney))
.min(Comparator.comparingInt(Apple::getNum));
System.out.println("查询 num 最小的值-> " + min);
}
public static void main(String[] args) {
//　使用java8　来创建一个对象
Java8Test java8Test = Java8Test.create(Java8Test::new);
java8Test.testJava7And8Sort();
// 使用java8 对数据进行处理
// 1.对数据进行分组
java8Test.groupById(java8Test.getData());
// 2.对list 类型的数据转换为Map类型
java8Test.listToMap(java8Test.getData());
// 3.读数据进行过滤
java8Test.filterData(java8Test.getData());
// 4、对数据按照某一个属性进行求和
java8Test.getSumByProperty(java8Test.getData());
//5、对数据去重
java8Test.distinic(java8Test.getData());
// 6、检查list集合中status的值是否都是true
java8Test.testStreamApi(java8Test.getData());
}
}

标签：Apple,Stream,System,特性,Java8,apples,println,public,out