java8提供了对集合数据进行处理一系列数据的方法,今天就全面解析一下其用法,也是自己对其的一个总结性文章的结束了,后面就不再写这样的文章了。
关于Stream的用法,记住原点,中间操作,终端操作这三个知识点就可以了。
整个代码的示例程序已经包含了整个用法的详细解释,这里就不一一用文字进行描述了。
package com.wpw.springbootjuc.java8;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 使用最新的Stream流数据api进行数据处理
*
* @author wpw
*/
@Slf4j
public class CollectionTest {
private static final List<Person> personList = new ArrayList<>();
static {
personList.add(Person.builder().build().setId(1L).setName("张三").setAge(15).setAddress("浙江"));
personList.add(Person.builder().build().setId(2L).setName("李四").setAge(15).setAddress("河南"));
personList.add(Person.builder().build().setId(3L).setName("王五").setAge(16).setAddress("北京"));
personList.add(Person.builder().build().setId(4L).setName("赵六").setAge(16).setAddress("上海"));
personList.add(Person.builder().build().setId(5L).setName("孙七").setAge(17).setAddress("浙江"));
}
/**
* 数据过滤的测试
*/
private static List<Person> DataFilter(List<Person> personList) {
/**
* 这里我们过滤年龄是15&地址是浙江的数据
*/
return personList.stream().filter(x -> x.getAge() == 15 && x.getAddress().equals("浙江")).collect(Collectors.toList());
}
/***
* 数据的输出print
*/
public static void acceptDataAndPrint(List<Person> personList) {
personList.forEach(x -> System.out.println("x = " + x));
}
/**
* 数据的转换或者可以说是处理map
*
* @return
*/
public static List<Integer> mapHandler(List<Person> personList) {
/***
* 只获取年纪这个字段的数据,进行数据的收集
* 其它字段的数据收集类推
*/
return personList.stream().map(Person::getAge).collect(Collectors.toList());
}
/**
* 数据集合的去重distinct
*
* @return
*/
public static List<String> distinctHandler(List<Person> personList) {
/**
* 处理数据集合地址重复的数据,然后进行收集
*/
return personList.stream().map(Person::getAddress).distinct().collect(Collectors.toList());
}
/**
* 数据集合的自然排序
*
* @return
*/
public static List<Person> sortHandler(List<Person> personList) {
return personList.stream().sorted().collect(Collectors.toList());
}
/***
*数据集合的自定义排序
* @return
*/
public static List<Person> sortHandlerWithComparator(List<Person> personList) {
/**
* 按照年级进行排序,你可以根据自己的需求进行排序
*/
return personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
}
/**
* 数据集合的limit,想到mysql这样的db用法了
*
* @return
*/
public static List<Person> limitHandler(List<Person> personList) {
/**
* 只会过滤出前两条数据
*/
return personList.stream().limit(2).collect(Collectors.toList());
}
/**
* 数据集合skip方法的使用
*
* @return
*/
public static List<Person> skipHandler(List<Person> personList) {
/**
* 跳过前两个数据,然后进行数据的收集
*/
return personList.stream().skip(2).collect(Collectors.toList());
}
/**
* 数据的收集聚合操作reduce
*
* @return
*/
public static String reduceHandler(List<Person> personList) {
return personList.stream().map(Person::getAddress).reduce("地址集合", (x, y) -> x + y);
}
/**
* 返回数据集合中年纪最大的数据max
*
* @return
*/
public static Person maxHandler(List<Person> personList) {
return personList.stream().max(Comparator.comparing(Person::getAge)).orElse(null);
}
/**
* 返回数据集合中年纪最小的数据min
*
* @return
*/
public static Person minHandler(List<Person> personList) {
return personList.stream().min(Comparator.comparing(Person::getAge)).orElse(null);
}
/**
* 判断数据集合是否全部满足某一规则
*
* @return
*/
public static boolean allMatchHandler(List<Person> personList) {
return personList.stream().map(Person::getAddress).allMatch("浙江"::equals);
}
/**
* 判断数据集合是否任意满足某一规则
*
* @return true/false
*/
public static boolean anyMatchHandler(List<Person> personList) {
return personList.stream().map(Person::getAddress).anyMatch("浙江"::equals);
}
/**
* 判断数据集合是否全部不满足某一规则
*
* @return true/false
*/
public static boolean noneMatchHandler(List<Person> personList) {
return personList.stream().map(Person::getAddress).noneMatch("郑州"::equals);
}
/**
* 统计数据集合的数据count
*
* @return count汇总数据的个数
*/
public static long countHandler(List<Person> personList) {
return personList.stream().count();
}
/**
* 处理数据集合中,满足执行条件的第一个数据findFirst
*
* @return
*/
public static Person findFirstHandler(List<Person> personList) {
return personList.stream().filter(x -> x.getAddress().equals("浙江")).findFirst().orElse(null);
}
/**
* 数据转集合,集合转数据的介绍toArray
*
* @return
*/
public static Object[] toArrayHandler(List<Person> personList) {
return personList.stream().map(Person::getAddress).toArray();
}
/**
* 数据集合转为map
*
* @return
*/
public static Map<Object, Object> listToMapHandler(List<Person> personList) {
/**
* 按照地址进行map的转换
*/
return personList.stream().collect(Collectors.toMap(Function.identity(), Person::getAddress));
}
/**
* 处理map的数据信息
*/
public static void mapDataHandler(Map<Object, Object> map) {
map.forEach((key, value) -> {
System.out.println(String.format("键%s--值:%s", key, value));
});
}
/**
* map转集合数据
*
* @return
*/
public static List<Object> mapToListHandler(Map<Object, Object> map) {
return map.values().stream().collect(Collectors.toList());
}
/**
* 数据集合转换流
*
* @return
*/
public static Stream<Object> listToStreamHandler(List<Person> personList) {
return Stream.of(personList.toArray());
}
public static void main(String[] args) {
log.debug("数据集合的filter操作");
acceptDataAndPrint(DataFilter(personList));
log.debug("数据集合的map操作");
List<Integer> integerList = mapHandler(personList);
integerList.stream().forEachOrdered(x -> System.out.print(x + "\t"));
log.debug("数据集合的去重操作");
List<String> stringList = distinctHandler(personList);
stringList.forEach(x -> System.out.print(x + "\t"));
log.debug("数据集合的自然排序操作");
acceptDataAndPrint(sortHandler(personList));
log.debug("数据集合的自定义排序");
acceptDataAndPrint(sortHandlerWithComparator(personList));
log.debug("数据集合的limit限制数据的返回");
acceptDataAndPrint(limitHandler(personList));
log.debug("数据集合的skip跳过指定数据的处理");
acceptDataAndPrint(skipHandler(personList));
log.debug("数据集合的聚合操作");
String handler = reduceHandler(personList);
System.out.println("handler = " + handler);
log.debug("返回数据的最大值数据");
Person person = maxHandler(personList);
System.out.println("person = " + person);
log.debug("返回数据的最小值数据");
Person p = minHandler(personList);
System.out.println("p = " + p);
log.debug("数据直接的allMatch操作");
boolean matchHandler = allMatchHandler(personList);
System.out.println("matchHandler = " + matchHandler);
log.debug("数据直接的anyMatch操作");
boolean anyMatchHandler = anyMatchHandler(personList);
System.out.println("anyMatchHandler = " + anyMatchHandler);
log.debug("数据直接的noneMatch操作");
boolean noneMatchHandler = noneMatchHandler(personList);
System.out.println("noneMatchHandler = " + noneMatchHandler);
log.debug("数据集合的统计操作");
long count = countHandler(personList);
System.out.println("count = " + count);
log.debug("数据集合的findFirst操作");
Person firstHandler = findFirstHandler(personList);
System.out.println("firstHandler = " + firstHandler);
log.debug("数据集合转为数组的操作");
Object[] objects = toArrayHandler(personList);
Arrays.stream(objects).forEachOrdered(System.out::println);
log.debug("数据集合转为map操作");
Map<Object, Object> map = listToMapHandler(personList);
mapDataHandler(map);
Map<String,String> hashMap = new HashMap<>(16,0.75f);
hashMap.put("key","value");
hashMap.put("key2","value2");
hashMap.put("key3","value3");
log.debug("map转为集合的操作");
List<Object> objectList = mapToListHandler(map);
objectList.stream().forEach(System.out::println);
log.debug("转为数据流Stream的操作");
Stream<Object> stream = listToStreamHandler(personList);
List<Object> collect = stream.collect(Collectors.toList());
collect.forEach(System.out::println);
}
}
关于集合的Stream操作就到这里结束了,还是喜欢那简单而有用的示例程序,java基础性的文章终于告一段落了。文中的实体类person主要包含id,name,age,address字段用于测试,自己在用时新建一个就可以了。