Java8使用Lambda表达式案例_arraytodelimitedstring

作者：AllinToyou | 2024-06-16 13:17:49
踩
arraytodelimitedstring
一、Lambda 表达式简介

1、什么是 Lambda 表达式
Lambda 表达式是在 JDK 8 中引入的一个新特性，可用于取代大部分的匿名内部类。使用 Lambda 表达式可以完成用少量的代码实现复杂的功能，极大的简化代码代码量和代码结构。同时，JDK 中也增加了大量的内置函数式接口供我们使用，使得在使用 Lambda 表达式时更加简单、高效。
为什么需要 Lambda 表达式
谈起为什么需要 Lambda 表达式，那得从函数式编程开始说起。函数式编程可以简单说是一种编程规范，也就是如何编写程序的方法论。它属于结构化编程的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。函数式编程有很多优点，其中包括：
易于并发编程；
代码的热升级；
更方便的代码管理；
代码简洁，开发快速；
接近自然语言，易于理解；
函数式编程在 C#、Python、JavaScript中都得到充分体现，在 Java 8 版本中也得到了支持。最明显的就是对 Lambda 表达式的支持。很多种迹象表明未来编程语言将是逐渐融合各自的特性，而不是单纯的声明式语言函数编程语言。将来声明式编程语言借鉴函数编程思想，函数编程语言融合声明式编程特性，这几乎是一种必然趋势。
在 Java 中主要引入 Lambda 表达式的作用是对现有编码语义的优化，减少语法冗余。轻量级的将代码封装为数据，使代码简洁，易于理解。
二、Lambda表达式使用案例


 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.Test;
import org.springframework.util.StringUtils;
 
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
/**
 * java8使用lamda表达式
 */
public class JavaLambdaTest {
 
 
    /**
     * 字符串转数组,以分隔符
     */
    @Test
    public void stringToArray() {
 
        //java8以前字符串转数组
        String str = "0,1,2,3,4,5";
        String[] arr = str.split(","); // 用,分割
        System.out.println("java8以前字符串转数组 " + Arrays.toString(arr));
    }
 
    /**
     * 数组转字符串,以分隔符
     */
    @Test
    public void arrayToString() {
 
        String[] arr = {"0", "1", "2", "3", "4", "5"};
 
        //方法一: 遍历
        StringBuffer strBuffer = new StringBuffer();
        for (String s : arr) {
            strBuffer.append(s);
        }
        System.out.println("java8以前数组转字符串: " + strBuffer.toString());
 
        //方法二: 使用StringUtils的join方法
        String str2 = org.apache.commons.lang3.StringUtils.join(arr, ",");
        System.out.println("使用StringUtils的join方法: " + str2);
 
        //方法三: 使用org.apache.commons.lang3.ArrayUtils的toString方法
        String str3 = ArrayUtils.toString(arr, ",");
        System.out.println("使用ArrayUtils的toString方法: " + str2);
 
 
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + "");
        }
 
        //方法四: 使用org.springframework.util.StringUtils的arrayToDelimitedString方法
        String str4 = StringUtils.arrayToDelimitedString(list.toArray(new String[list.size()]), ",");
        System.out.println("使用StringUtils的arrayToDelimitedString方法: " + str2);
    }
 
 
    /**
     * String转List
     */
    @Test
    public void stringToList() {
        String str = "11111,你好,是是是";
 
        //方法一: 先使用split方法转成数组，然后再用Arrays.asList方法把数组转成list
        //List<String> list1 = Arrays.asList(str.split(","));
 
        List<String> list1 = new ArrayList<String>(Arrays.asList(str.split(",")));
        System.out.println("先使用split方法转成数组，然后再用Arrays.asList方法把数组转成list : " + list1);
 
        List<String> list2 = Stream.of(str.split(",")).collect(Collectors.toList());
        System.out.println("String字符串转成List<Long>数据格式 : " + list2);
 
        //String字符串转成List<Long>数据格式
        String str1 = "1,2,3,4,5,6";
        List<Long> list3 = Arrays.stream(str1.split(",")).map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());
        System.out.println("String字符串转成List<Long>数据格式 : " + list3);
    }
 
    /**
     * List转字符串,以分隔符
     */
    @Test
    public void collectionToString() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + 100 + "");
        }
        //使用for循环遍历方式
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            if (i != 0) {
                sb.append(",");
            }
            sb.append(list.get(i));
        }
        System.out.println("使用for循环遍历方式: " + sb.toString());
 
        String newStr = String.join(",", list);
        System.out.println("String.join: " + newStr);
 
        //list转字符串,以 , 分割
        String str1 = StringUtils.collectionToDelimitedString(list, ",");
        System.out.println("StringUtils.collectionToDelimitedString : " + str1);
 
        //方法三：StringUtils.join方法,以,分割
        String str2 = org.apache.commons.lang3.StringUtils.join(list, ",");
        System.out.println("StringUtils.join方法 : " + str2);
 
        //方法三：使用流的方式
        String str3 = list.stream().collect(Collectors.joining(","));
        System.out.println("使用流的方式 : " + str3);
 
 
        //使用流的方式，在连接之前操作字符串
        String str = list.stream().map(String::valueOf).collect(Collectors.joining(","));
        System.out.println("collectionToString : " + str);
 
        //高级用法 ：从list获取某个字段
        //String nameStr = list.stream().map(s::getName).collect(Collectors.joining(","));
    }
 
 
    /**
     * 数组转成list
     */
    @Test
    public void arrayToList() {
 
        String[] array = {"Java", "Scala", "C++", "Haskell", "Lisp"};
 
        //方法一：Arrays.asList方法
        List<String> arrayTolist = new ArrayList<String>(Arrays.asList(array));
        System.out.println("Arrays.asList方法 : " + arrayTolist);
 
        //方法二：Collections.addAll方法
        ArrayList<String> arrayList = new ArrayList<String>(array.length);
        Collections.addAll(arrayList, array);
        System.out.println("Collections.addAll方法 : " + arrayList);
 
        //方法三：String数组Stream.of方法
        List<String> arrayTolist2 = Stream.of(array).collect(Collectors.toList());
        System.out.println("Stream.of方法  : " + arrayTolist2);
 
        //基本类型用法
        long[] array2 = {23, 33, 21};
        List<Long> longList = Arrays.stream(array2).boxed().collect(Collectors.toList());
        System.out.println("基本类型用法: " + longList);
    }
 
    /**
     * Java8 List转为数组
     */
    @Test
    public void listToArray() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + 100 + "");
        }
 
        //方法一：list.toArray方法
        String[] array = list.toArray(new String[list.size()]);
        System.out.println("list.toArray方法: " + Arrays.toString(array));
 
        //方法二：list.stream方法
        String[] array2 = list.stream().toArray(String[]::new);
        System.out.println("list.stream方法: " + Arrays.toString(array2));
 
        //Arrays.stream(array).forEach(str -> System.err.println("listToArray " + str));
    }
 
    /**
     * collect 提取某个元素组成新List
     */
    @Test
    public void streamToList() {
        // List<Long> userIds = userList.stream().map(u -> u.getId()).collect(Collectors.toList());
    }
 
    /**
     * java8遍历List
     */
    @Test
    public void forEachList() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + 100 + "");
        }
 
        //Java8 lambda遍历list(简化写法)
        list.forEach(s -> System.out.println(s));
 
        //Java8 lambda遍历list使用 equals
        list.forEach(item -> {
            if ("C".equals(item)) {
                System.out.println(item);
            }
        });
        //contains 过滤
        list.stream().filter(s -> s.contains("100")).forEach(s -> System.out.print(s));
    }
 
 
    /**
     * Java8 List转换Map
     */
    @Test
    public void listToMap() {
 
        List<User> list2 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setName("张三" + i);
            user.setAge(i);
            list2.add(user);
        }
 
        //List转换Map
        Map<Object, Object> map = list2.stream().collect(Collectors.toMap((key -> key), (value -> value)));
        map.forEach((key, value) -> System.out.println("key:" + key + " value:" + value));
 
        System.out.println("—————— List转换Map组合使用 ——————");
        //提取list里面age属性,组成一个新map
        Map<Integer, User> map1 = list2.stream().collect(Collectors.toMap(User::getAge, user -> user));
        Map<Integer, User> map2 = list2.stream().collect(Collectors.toMap(user -> user.getAge(), Function.identity()));
        System.out.println("提取list里面age属性,组成一个新map: " + map1);
        System.out.println("提取list里面age属性,组成一个新map: " + map2);
 
        //将集合中(name, age提取)转换成map
        Map map3 = list2.stream().collect(Collectors.toMap(User::getName, User::getAge));
        System.out.println("将集合中(name, age提取)转换成map: " + map3);
 
        // List转为Map按Name分组
        Map<String, List<User>> map4 = list2.stream().collect(Collectors.groupingBy(User::getName));
        System.out.println("List转为Map按Name重复分组: " + map4);
 
        // List转为Map年龄排序后，再根据ID分组
        Collections.sort(list2, Comparator.comparing(User::getName).thenComparing(User::getAge));
    }
 
 
    /**
     * java8遍历Map
     */
    @Test
    public void forEachMap() {
        Map<String, Object> map = new HashMap<>(16);
        map.put("A", 10);
        map.put("B", 20);
        map.put("C", 30);
 
        //Java8之前遍历是这样遍历map
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("Java8之前遍历 " + "key:" + entry.getKey() + " value:" + entry.getValue());
        }
 
        //Java8遍历map
        map.forEach((key, value) -> System.out.println("Java8遍历map " + "key:" + key + " value:" + value));
 
        //Java8遍历map使用equals
        map.forEach((k, v) -> {
            System.out.println("Item : " + k + " Count : " + v);
            if ("C".equals(k)) {
                System.out.println("Java8遍历map使用equals " + "C : " + k);
            }
        });
    }
 
    /**
     * Java8 Map使用Filter->String
     */
    @Test
    public void Filter() {
        Map<String, String> map = new HashMap<>(16);
        map.put("A", "11");
        map.put("B", "11");
 
        //获取map里面 value="11"的字段
        String str = map.entrySet().stream().filter(m -> "11".equals(m.getValue()))
                .map(m -> m.getValue()).collect(Collectors.joining());
        System.out.println("str : " + str);
 
        //获取map里面某个字符串
        String str2 = map.entrySet().stream().filter(m -> m.getKey().equals("B"))
                .map(m -> m.getValue()).collect(Collectors.joining());
        System.out.println("获取map里面某个字符串 : " + str2);
 
 
        // Filter过滤某个值，形成新的map
        Map<String, String> newMap = map.entrySet().stream().filter(m -> m.getKey().equals("A"))
                .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));
        System.out.println("Filter过滤某个值，形成新的map : " + newMap);
    }
 
 
    /**
     * List转换Set
     */
    @Test
    public void listToSet() {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setName("张三" + i);
            list.add(user);
        }
        //方法一: 使用distinct方法把List转换Set
        Set<String> set = list.stream().map(s -> s.getName()).distinct().collect(Collectors.toSet());
        System.out.println("listToSet : " + set);
    }
 
 
    /**
     * Java8 distinct 获取某个属性并去重
     */
    @Test
    public void distinct() {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三");
        System.out.println("去重前数据: " + list.toString());
 
 
        //方法一: 去除list里面所有重复的数据
        List<String> distinct1 = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去除list里面所有重复的数据 : " + distinct1);
 
        //方法二: 去除list里面重复的数据
        List<String> distinct2 = list.stream().map(String::valueOf).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());
        System.out.println("distinct2 : " + distinct2);
 
        //方法三: 根据某个字段去重
        //List<String> distinct2 = list.stream().map(String::getName).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());
 
        long count = list.stream().distinct().count();
        System.out.println("去重后统计数量 ：" + count);
 
        //去重后以,分割成字符串
        String str = list.stream().distinct().collect(Collectors.joining(","));
        System.out.println("去重后以,分割成字符串: " + str);
 
    }
 
    /**
     * 使用lamda sort排序
     */
    @Test
    public void sort() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(String.valueOf(i));
        }
 
        // 1、传递代码，函数式编程
//        list.sort(new AppleComparator());
//        System.out.println("函数式编程 :  " + list.toString());
 
 
        // 2、匿名内部类排序
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.parseInt(o1) - Integer.parseInt(o2);
            }
        });
        System.out.println("匿名内部类排序 升序 :  " + list.toString());
        //匿名内部类排序简化写法
        Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
        System.out.println("匿名内部类排序 升序 :  " + list.toString());
 
 
        //3、使用Lambda表达式
        //list.sort((a, b) -> a.getWeight() - b.getWeight());
 
        //对象排序
        list.sort((a, b) -> a.compareTo(b));
        System.out.println("Lambda表达式 升序 :  " + list.toString());
        list.sort((b, a) -> a.compareTo(b));
        System.out.println("Lambda表达式 降序 :  " + list.toString());
 
 
        //等价于3
        list.sort((a, b) -> Integer.parseInt(a) - Integer.parseInt(b));
        System.out.println("用法3  ——》升序 :  " + list.toString());
        list.sort((a, b) -> Integer.parseInt(b) - Integer.parseInt(a));
        System.out.println("用法3  ——》降序 :  " + list.toString());
 
 
        //4、使用Comparator的comparing
        list.sort(Comparator.comparing(a -> a));
        System.out.println("comparing 升序 :  " + list.toString());
        Collections.sort(list, Comparator.comparing(String::valueOf).reversed());
        System.out.println("comparing 降序 :  " + list.toString());
 
 
        //5对象集合操作
        List<User> list1 = new ArrayList<User>();
        User user = new User("张三", 15, "男");
        User user1 = new User("李四", 10, "男");
        list1.add(user);
        list1.add(user1);
 
        //在Comparator.comparing中定义排序反转
        list1.sort(Comparator.comparing(User::getName, Comparator.reverseOrder()));
        System.out.println("在Comparator.comparing中定义排序反转 :  " + list.toString());
 
        //在Stream中定义排序反转
        list1.stream().sorted(Comparator.comparing(User::getName, Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println("在Stream中定义排序反转 :  " + list.toString());
 
 
        //1、年龄升序
        list1.sort((a, b) -> String.valueOf(a.getAge()).compareTo(String.valueOf(b.getAge())));
 
        //2、姓名降序排列
        list1.sort(Comparator.comparing(User::getName).reversed());
        //等价于 2
        list1.sort(Comparator.comparing(a -> ((User) a).getAge()).reversed());
 
        //3、先按性别排，如果年龄相同，再按年龄排序
        list1.sort(Comparator.comparing(User::getSex).reversed().thenComparing(User::getAge));
 
        //6.对JSONArray 排序
        JSONArray resultArray = new JSONArray();
        JSONObject result = new JSONObject();
        result.put("name", "张三");
        result.put("age", "15");
        result.put("data", "201812130451");
        resultArray.add(result);
        //根据姓名的倒序排序
        resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getString("name")).reversed());
        System.out.println("根据姓名的倒序排序 :----->" + resultArray.toString());
        //根据时间倒序排序
        resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getDate("data")).reversed());
        System.out.println("根据时间倒序排序 :----->" + resultArray.toString());
        //根据年龄升序排序
        resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getInteger("age")));
        System.out.println("根据年龄升序排序 :----->" + resultArray.toString());
    }
 
 
    /**
     * Java8 groupingBy 分租
     */
    @Test
    public void groupingBy() {
        List<User> list = new ArrayList<User>();
        User user = new User("张三", 15, "男", "shanghai");
        User user1 = new User("李四", 14, "男", "wuhan");
        list.add(user);
        list.add(user1);
 
        Map<String, List<User>> listGroupingBy1 = list.stream().collect(Collectors.groupingBy(c -> c.getAddress()));
        System.out.println("listGroupingBy1: " + listGroupingBy1);
 
        Map<String, List<User>> listGroupingBy2 = list.stream().collect(Collectors.groupingBy(User::getName));
        System.out.println("listGroupingBy2: " + listGroupingBy2);
    }
 
 
    /**
     * java8使用 equals
     */
    @Test
    public void equals() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + "");
        }
        System.out.println("list的值: " + list);
 
        //Java8 lambda遍历list使用 equals
        list.forEach(item -> {
            if ("1".equals(item)) {
                System.out.println("item的值: " + item);
            }
        });
 
 
    }
 
    /**
     * Java8 基本操作  equals contains filter groupingBy sum max min count average  anyMatch allMatch limit
     */
    @Test
    public void basicOperation() {
        List<User> list = new ArrayList<User>();
        User user = new User("张三", 15, "男", "shanghai");
        User user1 = new User("李四", 15, "男", "wuhan");
        list.add(user);
        list.add(user1);
 
        //求和
        int sum = list.stream().collect(Collectors.summingInt(User::getAge));
        System.out.println("sum : " + sum);
 
 
        //Java8使用equals 匿名内部类写法
        list.forEach(item -> {
            if ("1".equals(item)) {
                System.out.println("item的值: " + item);
            }
        });
 
 
        //contains
        list.stream().filter(s -> s.getName().contains("张三")).forEach(s -> System.out.print(s));
 
 
        //找出年龄最大
        Optional<User> max = list.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println("max : " + max);
 
 
        //找出年龄最小
        Optional<User> min = list.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println(min);
 
 
        //统计个数
        long count = list.stream().filter(s -> s.getName().equals("Shanghai")).count();
        System.out.println("count : " + count);
 
        //groupingBy
        Map<String, List<User>> groupingBy = list.stream().collect(Collectors.groupingBy(c -> c.getAddress()));
        System.out.println("groupingBy : " + groupingBy);
 
 
        //anyMatch
        boolean anyMatch = list.stream().anyMatch(s -> s.getName().equals("李四"));
        System.out.println("anyMatch : " + anyMatch);
 
        //返回所有Age大于14
        boolean matched = list.stream().allMatch(s -> s.getAge() > 14);
        System.out.println("matched : " + matched);
 
 
        //查找姓名是张三的员工
        Optional<User> findAny = list.stream().filter(s -> s.getName().equals("张三")).findAny();
        System.out.println("findAny : " + findAny);
 
 
        //获取年龄最高的前2条员工信息
        List<User> limit = list.stream().sorted((e1, e2) -> Integer.compare(e2.getAge(), e1.getAge()))
                .limit(2).collect(Collectors.toList());
        System.out.println("limit : " + limit);
 
        //获取平均年龄
        OptionalDouble average = list.stream().mapToInt(s -> s.getAge()).average();
        System.out.println("average:" + average);
 
        //工作地点的平均工资
        System.out.println(">>>>获取工作地点的平均年龄");
        OptionalDouble optionalDouble = list.stream().filter(s -> s.getAddress().equals("Shanghai")).mapToInt(s -> s.getAge()).average();
        System.out.println("optionalDouble:" + optionalDouble);
    }
}
 
@Data
class User {
 
    private String name;
    private int age;
    private String sex;
    private String address;
 
    public User() {
    }
 
    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
 
    public User(String name, int age, String sex, String address) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }
}
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/726805