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);
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值