java 8 常用总结

//筛选出条件为....的数据
List<Apple> greenList  = list.stream().filter(apple -> apple.getColor().equals("green")).collect(Collectors.toList());

//根据条件进行分组的三种写法

1	private static Map<String,List<Apple>> groupByNormal(List<Apple> apples){ Map<String,List<Apple>> map = new HashMap<>(); for (Apple apple: apples){ List<Apple> list = map.get(apple.getColor()); if (null == list){ list = new ArrayList<>(); map.put(apple.getColor(),list); } list.add(apple); } return map; }
2	private static Map<String,List<Apple>> groupByFunction(List<Apple> apples){ Map<String,List<Apple>> map = new HashMap<>(); apples.parallelStream().forEach(apple -> { List<Apple> colorList = Optional.ofNullable( map.get(apple.getColor())).orElseGet(() ->{ List<Apple> list = new ArrayList<>(); map.put(apple.getColor(),list); return list; }); colorList.add(apple); }); return map; }
3	private static Map<String,List<Apple>> groupByCollector(List<Apple> apples){ return apples.parallelStream().collect(groupingBy(Apple::getColor)); }

//根据条件筛选出想要的数据
private static List<Apple> findGreenApples(String color,List<Apple> apples){
    List<Apple> list = new ArrayList<>();
    apples.forEach(apple -> {
        if (color.equals(apple.getColor())){
            list.add(apple);
        }
    });
    return list;
}

//多个条件筛选[List<Apple> result2 = filterByBiPredicate(list, (s, w) -> s.equals("green") && w > 100);]
private static List<Apple> filterByBiPredicate(List<Apple> apples, BiPredicate<String,Long> predicate){
    List<Apple> list = new ArrayList<>();
    apples.forEach(apple -> {
        if (predicate.test(apple.getColor(),apple.getWeight())){
            list.add(apple);
        }
    });
    return list;
}

//正序，倒序
apples.sort((o1, o2) -> o1.getColor().compareTo(o2.getColor()));
apples.sort(Comparator.comparing(Apple::getWeight).reversed());

//得到一个字符串里的第几个字符
BiFunction<String,Integer,Character> f2 = String::charAt;
Character c =  f2.apply("hello",2);

//计算平均值
private static Double testCollectingAndThen(){
    Double collect = dishes.stream().collect(Collectors.collectingAndThen(
            Collectors.averagingInt(Dish::getCalories),
            avg -> +avg
    ));
    return collect;
}
//计算一共有多少条数据
private static long testCounting(List<Dish> dishes){
    return  dishes.stream().collect(Collectors.counting());
}
//分组
private static Map<Dish.Type, List<Dish>> testGroupingByFunction(List<Dish> dishes){
   return dishes.parallelStream().collect(groupingBy(Dish::getType));
}
//分组
private static ConcurrentMap<Dish.Type, List<Dish>> testGroupingByConcurrentWithFunction(List<Dish> dishs){
    return dishs.stream().collect(Collectors.groupingByConcurrent(Dish::getType));
}
//分组，并计算各组的值
private static Map<Dish.Type, Double> testGroupingByFunctionAndCollector(List<Dish> dishes){
  return dishes.stream().collect(Collectors.groupingBy(Dish::getType,
            Collectors.averagingInt(Dish::getCalories)));
}
//分组，利用树排序，计算平均值
private static Map<Dish.Type,Double> testGroupingByFunctionAndSupplierAndCollector(List<Dish> dishes){
  Map<Dish.Type,Double> dish = dishes.stream().collect(Collectors.groupingBy(
     Dish::getType, TreeMap::new,Collectors.averagingInt(Dish::getCalories)
  ));
  return dish;
}
//得到数据中各种聚合函数
private static IntSummaryStatistics testSummarizingInt(List<Dish> dishes){
    return dishes.stream().collect(Collectors.summarizingInt(Dish::getCalories));
}

//使流里面是指定字段拼接起来
private static String testJoining(List<Dish> dishes) {
   return dishes.stream().map(Dish::getName).collect(Collectors.joining());
}
//使流里面是指定字段拼接起来，以逗号分隔
private static String testJoiningWithDelimiter(List<Dish> dishes) {
    return  dishes.stream().map(Dish::getName).collect(Collectors.joining(","));
}
//拼接指定字段，加前后缀
private static String testJoiningWithDelimiterAndPrefixAndSuffix(List<Dish> dishes) {
     return dishes.stream().map(Dish::getName).collect(Collectors.joining(",", "Names[", "]"));
}
//取一组数据中最大、最小的数据
private static Optional<Dish> testMaxBy(List<Dish> dishes) {
    return dishes.stream().collect(Collectors.maxBy(Comparator.comparingInt(Dish::getCalories)));
}
private static Optional<Dish> testMinBy(List<Dish> dishes) {
    return dishes.stream().collect(Collectors.minBy(Comparator.comparingInt(Dish::getCalories)));
}
//去掉重复的数据
private static Stream  stream(List<Dish> dishes){
   return dishes.stream().distinct();
}
//找出符合条件的数据且排序
private static List<Transaction> transactionList (List<Transaction> transactions,int year){
    return transactions.stream().filter(transaction -> transaction.getYear() == year)
            .sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList());
}
private static List<Trader> traderList (List<Transaction> transactions,String city){
    return transactions.stream().map(Transaction::getTrader)
            .filter(transaction -> transaction.getCity().equals(city))
            .distinct().sorted(Comparator.comparing(Trader::getName))
            .collect(Collectors.toList());
}

//判断集合中是否有重复值
List<Roles> rolesList = createData();
long count = rolesList.stream().distinct().count();
boolean isRepeat = count < rolesList.size();
System.out.println(count);//输出2

List<Integer> integers = rolesList.stream().map(Roles::getId).collect(Collectors.toList());
long idCount = integers.stream().distinct().count();
boolean repeat = idCount < integers.size();
System.out.println(idCount);
if(repeat){
   System.out.println(true);//输出true 拥有重复值
}else{
   System.out.println(false);//输出true  没有重复值
}

if(isRepeat){
   System.out.println(true);//输出true 拥有重复值
}else{
   System.out.println(false);//输出true  没有重复值
}

Map<String, List<Roles>> map = rolesList.stream().collect(Collectors.groupingBy(o -> o.getRoleName().concat(String.valueOf(o.getId()))));

map.forEach((k,v)->{
   if (v.size()>1){
      System.out.println("存在重复值："+k);
   }else{
      System.out.println("不存在重复值");
   }
});

call Method: this.listToString(list,',');
//list 转string 
public String listToString(List list, char separator) {
    return org.apache.commons.lang3.StringUtils.join(list.toArray(), separator);
}