首先创建个实体类
package com.example.demo.entity;
/**
* hlvy
*
* @author heng
**/
public class hlvy {
/**
* 姓名
*/
private String name;
/**
* 年龄
*/
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
接着:
package com.example.demo;
import com.example.demo.entity.hlvy;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* HlvyTest
*
* @author heng
**/
public class HlvyTest {
public static void main(String[] args) {
/**
* java8新特征 stream map
* 拿到集合里实体类的某个字段
*/
List<hlvy> list = new ArrayList<hlvy>();
hlvy h = new hlvy();
hlvy h1 = new hlvy();
h.setName("yanyan");
h.setAge(18);
h1.setName("heng");
h1.setAge(18);
list.add(h);
list.add(h1);
List<String> name = list.stream().map(hlvy::getName).collect(Collectors.toList());
/*
for (String s : name) {
System.out.println(s);
}*/
/**
* java8新特征 stream
* %2==0就添加到集合 filter 让符合条件的通过，不符合的过滤掉
*/
List <Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
List<Integer> listTwo = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
/* for (Integer integer : listTwo) {
System.out.println(integer);
}*/
/**
* java8新特征 stream distinct 对数据进行去重
* %2==0就添加到集合 并且不重复
*/
List <Integer> numsOne = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
List<Integer> listThree = numsOne.stream().filter(num -> num % 2 == 0).distinct().collect(Collectors.toList());
/* for (Integer integer : listThree) {
System.out.println(integer);
}*/
/**
* java8新特征 stream limit 限制数据出现的条数 limit返回包含前n个元素的流，当集合大小小于n时，则返回实际长度
* 两个是 10的数字
*/
List <Integer> numsTwo = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
List<Integer> listFour = numsTwo.stream().filter(num -> num == 10).limit(2).collect(Collectors.toList());
/*for (Integer integer : listFour) {
System.out.println(integer);
}*/
/**
* java8新特征 stream skip 与limit操作相反 跳过前n个元素
* 跳过前两个，从第三个开始
*/
List <Integer> numsFive = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
List<Integer> listFive = numsFive.stream().filter(num -> num > 1).skip(2).collect(Collectors.toList());
/*for (Integer integer : listFive) {
System.out.println(integer);
}*/
/**
* java8新特征 stream
* 计算和
*/
/**
* java8新特征 stream map
* 拿到集合里实体类的某个字段
*/
List<hlvy> list2 = new ArrayList<hlvy>();
hlvy h2 = new hlvy();
hlvy h3 = new hlvy();
h2.setName("yanyan");
h2.setAge(18);
h3.setName("heng");
h3.setAge(18);
list2.add(h2);
list2.add(h3);
Integer ages = list2.stream().filter(list3 -> list3.getAge() > 1).mapToInt(hlvy::getAge).sum();
// System.out.println(ages);
/**
* 使用这些数值流的好处还在于可以避免jvm装箱操作所带来的性能消耗
* flatMap 用于合并用
*/
List<Integer> collected0 = new ArrayList<>();
collected0.add(1);
collected0.add(3);
collected0.add(5);
List<Integer> collected1 = new ArrayList<>();
collected1.add(2);
collected1.add(4);
collected1 = Stream.of(collected0, collected1)
.flatMap(num -> num.stream()).collect(Collectors.toList());
// System.out.println(collected1);// 1,3,5,2,4
/**
* java8新特征 allMatch 用于检测是否全部都满足指定的参数行为，如果全部满足则返回true
* 如果数组的数字全部大于7则返回true否则false
*/
List <Integer> allMatchs = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
boolean listallMatchs = allMatchs.stream().allMatch(mas -> mas > 7);
// System.out.println(listallMatchs);
/**
* java8新特征 anyMatch 检测是否存在一个或多个满足指定的参数行为，如果满足则返回true
* 如果数组的数字y有等于7的返回true
*/
List <Integer> allMatchs2 = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
boolean listallMatchs2 = allMatchs2.stream().anyMatch(numt -> numt==7);
// System.out.println(listallMatchs2);
/**
* java8新特征 noneMathch 检测是否不存在满足指定行为的元素
*不存在返回true
*/
List <Integer> allMatchs3 = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);
boolean listallMatchs3 = allMatchs3.stream().noneMatch(numt -> numt==17);
// System.out.println(listallMatchs3);
/**
* java8新特征 findFirst 返回满足条件的第一条元素
*/
List <Integer> allMatchs4 = Arrays.asList(1,2,3,4,5,6,6,7,8,9,10,10);
Optional<Integer> listallMatchs4 = allMatchs4.stream().filter(numt -> numt>1).findFirst();
if(listallMatchs4.isPresent()){//如果里面存有值
//System.out.println(listallMatchs4.get());
}
// 前面例子中的方法
int totalAge = list.stream()
.filter(hlvy -> "yanyan".equals(hlvy.getName()))
.mapToInt(hlvy::getAge).sum();
// System.out.println(totalAge);
// 归约操作
int totalAge11 = list.stream()
.filter(hlvy -> "yanyan".equals(hlvy.getName()))
.map(hlvy::getAge)
.reduce(0, (a, b) -> a + b);
// System.out.println(totalAge11);
// 进一步简化
int totalAge2 = list.stream()
.filter(hlvy -> "yanyan".equals(hlvy.getName()))
.map(hlvy::getAge)
.reduce(0, Integer::sum);
//System.out.println(totalAge2);
// 采用无初始值的重载版本，需要注意返回Optional
Optional<Integer> totalAge22 = list.stream()
.filter(hlvy -> "yanyan".equals(hlvy.getName()))
.map(hlvy::getAge)
.reduce(Integer::sum); // 去掉初始值
// if (totalAge22.isPresent()) System.out.println(totalAge22.get());
/**
* 收集 前面利用collect(Collectors.toList())是一个简单的收集操作，是对处理结果的封装
*来自于java.util.stream.Collectors，我们可以称之为收集器。
*/
long count = list.stream().collect(Collectors.counting());
long count1 = list.stream().count();
//System.out.println(count+"-------"+count1);
/**
* 求年龄的最大值和最小值
*/
// 求最大年龄
Optional<hlvy> olderStudent = list.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
// System.out.println(olderStudent.get().getAge());
// 进一步简化
Optional<hlvy> olderStudent2 = list.stream().collect(Collectors.maxBy(Comparator.comparing(hlvy::getAge)));
// System.out.println(olderStudent2.get().getAge());
// 求最小年龄
Optional<hlvy> olderStudent3 = list.stream().collect(Collectors.minBy(Comparator.comparing(hlvy::getAge)));
// System.out.println(olderStudent3.get().getAge());
/**
* 求年龄总和
*/
int totalAge4 = list.stream().collect(Collectors.summingInt(hlvy::getAge));
// System.out.println(totalAge4);
/**
* 求年龄的平均值
*/
double avgAge = list.stream().collect(Collectors.averagingInt(hlvy::getAge));
// System.out.println(avgAge);
/**
* 一次性得到元素个数、总和、均值、最大值、最小值
*/
IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(hlvy::getAge));
// System.out.println(statistics.toString());
/**
* 字符串拼接
*/
String names = list.stream().map(hlvy::getName).collect(Collectors.joining());
String names2 = list.stream().map(hlvy::getName).collect(Collectors.joining(", "));
// System.out.println(names); //yanyanheng
// System.out.println(names2); //yanyan, heng
/**
* 分组
* 在数据库操作中，我们可以通过GROUP BY关键字对查询到的数据进行分组，
* java8的流式处理也为我们提供了这样的功能Collectors.groupingBy来操作集合。
*/
Map<String, List<hlvy>> groups = list.stream().collect(Collectors.groupingBy(hlvy::getName));
// System.out.println(groups.get("yanyan").get(0).getName()); //yanyan
/**
* groupingBy接收一个分类器Function<? super T, ? extends K> classifier，我们可以自定义分类器来实现需要的分类效果。
*上面演示的是一级分组，我们还可以定义多个分类器实现 多级分组，比如我们希望在按学校分组的基础之上再按照专业进行分组，实现如下：
*/
Map<String, Map<String, List<hlvy>>> groups2 = list.stream().collect(
Collectors.groupingBy(hlvy::getName, // 一级分组，按学校
Collectors.groupingBy(hlvy::getName))); // 二级分组，按专业
// System.out.println(groups2.get("yanyan").get("yanyan").get(0).getAge());
/**
* 实际上在groupingBy的第二个参数不是只能传递groupingBy，
* 还可以传递任意Collector类型，比如我们可以传递一个Collector.counting，用以统计每个组的个数：
* 如果我们不添加第二个参数，则编译器会默认帮我们添加一个Collectors.toList()。
*/
Map<String, Long> groups3 = list.stream().collect(Collectors.groupingBy(
hlvy::getName, Collectors.counting()));
System.out.println(groups3.toString());
}
}