• JAVA实训第三天

    目录

    方法引用

    示例

    接口

    类

    测试类

    Stream

    ​编辑 Stream 的操作三个步骤

     创建 Stream 的 4 种方法

     常见Stream接口的继承关系

    Stream的中间操作

     中间操作常用方法

     Stream的终止操作

     Stream的终止操作-collect()

     示例代码演示

     作业

    方法引用

            在Lamda新特性的支持下，JAVA8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法（如java中已经定义好的方法），在这时候java8新特性“方法引用”将会进一步简化操作（注意：需要有Lamda的支持）。

    • 方法引用的四种形式：
    • 引用静态方法 --> 类名称 ::static 方法名称；
    • 引用某个对象的实例的普通方法 --> 实例化对象 :: 普通方法；
    • 引用 特定类型 的 任意对象 的实例方法 --> 特定类 :: 普通方法；
    • 引用构造方法 --> 类名称 ::new

    • 定义一个方法获取供给型接口类型的参数，调用 get 方法获取返回对象，并执行普通方法

     

     

    示例

    接口

    1. package part4;
    2.  
    3. /**
    4.  * @date : 2022/11/23 9:36
    5.  */
    6. @FunctionalInterface
    7. public interface PersonInterface {
    8.   public static  final   String name = "tidy";
    9.   public static  final   Integer age =18;
    10.  
    11.  
    12.   public void methodA();
    13.  
    14.  
    15.  
    16. }

    类

    1. package part4;
    2.  
    3. /**
    4.  * @date : 2022/11/23 9:31
    5.  */
    6. public   class Person {
    7.  
    8.     String name;
    9.     Integer age;
    10.  
    11.     public static int   method1() {
    12.         System.out.println("static静态方法...");
    13.         return 0;
    14.     }
    15.  
    16.     public static int   method2(int a) {
    17.         System.out.println("static静态方法..."+a);
    18.         return 0;
    19.     }
    20.  
    21.  
    22.  
    23.     public Person() {
    24.     }
    25.  
    26.     public Person(String name, Integer age) {
    27.         this.name = name;
    28.         this.age = age;
    29.     }
    30.  
    31.     public String getName() {
    32.         return name;
    33.     }
    34.  
    35.     public void setName(String name) {
    36.         this.name = name;
    37.     }
    38.  
    39.     public Integer getAge() {
    40.         return age;
    41.     }
    42.  
    43.     public void setAge(Integer age) {
    44.         this.age = age;
    45.     }
    46.  
    47.  
    48.     @Override
    49.     public String toString() {
    50.         return "Person{" +
    51.                 "name='" + name + '\'' +
    52.                 ", age=" + age +
    53.                 '}';
    54.     }
    55. }

    测试类

    1. package part4;
    2.  
    3.  
    4. import java.util.ArrayList;
    5. import java.util.List;
    6. import java.util.function.BiFunction;
    7. import java.util.function.Consumer;
    8. import java.util.function.Function;
    9. import java.util.function.Supplier;
    10.  
    11.  
    12. /**
    13.  * @date : 2022/11/23 9:29
    14.  */
    15. public class MethodReferenceDemo {
    16.  
    17.     public static void main(String[] args) {
    18.      /*   方法引用的四种形式：
    19.         引用静态方法-->类名称::static 方法名称；
    20.         引用某个对象的实例的普通方法-->实例化对象::普通方法；
    21.         引用特定类型的任意对象的实例方法-->特定类::普通方法；
    22.         引用构造方法-->类名称::new
    23. */
    24.  
    25. //        1）引用构造方法-->类名称::new
    26.         /*Person person = new Person();
    27.         System.out.println(person);*/
    28. //        注意事项1：方法引用 前提要使用lambda表达式--》功能性函数
    29. //        Person person = Person::new;
    30.  
    31. //        注意事项2：接口中没有构造方法  调用不成
    32. //        PersonInterface personInterface =  PersonInterface::new;
    33.  
    34. //        借助于供给型接口 实例化对象
    35.         Supplier<Person> supplier = Person::new;
    36.         Person person = supplier.get();
    37.         System.out.println(person);
    38.  
    39.  
    40. //        2) 引用静态方法-->类名称::static 方法名称；
    41.         Supplier<Integer> method1 = Person::method1;
    42.         Integer result = method1.get();
    43.         System.out.println("result:"+result);
    44.  
    45.         System.out.println("==================");
    46. //        调用静态方法时：选定和这个静态方法相匹配的功能性函数（是否匹配：是否有参数 是否有返回值--》使用哪个功能性函数）
    47.         Function<Integer,Integer> function = Person::method2;
    48.         Integer apply = function.apply(66);
    49.         System.out.println("applay:"+apply);
    50.  
    51.         System.out.println("==================");
    52. //        3)引用某个对象的实例的普通方法-->实例化对象::普通方法；
    53.         Person person1 = new Person("tidy",18);
    54.         Supplier<String> stringSupplier =person1::getName;
    55.         String name = stringSupplier.get();
    56.         System.out.println("name:"+name);
    57.  
    58.  
    59. //        4)引用特定类型的任意对象的实例方法-->特定类::普通方法；
    60. //        String equals方法  比较两个字符串是否相等  2个字符串
    61. //        BiFunction
    62.         BiFunction<String,String,Boolean> biFunction = String::equals;
    63.         Boolean resultFlg = biFunction.apply("hello", "hello");
    64.         System.out.println("resultFlg:"+resultFlg);
    65.  
    66.         System.out.println("6666666666666666666:");
    67.         List<Integer> list = new ArrayList();
    68.         list.add(10);
    69.         list.add(30);
    70.         list.add(30);
    71. //        内部类
    72.        /* Consumer<Integer> consumer = new Consumer<Integer>() {
    73.             @Override
    74.             public void accept(Integer integer) {
    75.                 System.out.println(integer);
    76.             }
    77.         };
    78.         list.forEach(consumer);*/
    79.         /*list.forEach(new Consumer<Integer>() {
    80.             @Override
    81.             public void accept(Integer integer) {
    82.                 System.out.println(integer);
    83.             }
    84.         });*/
    85.  
    86. //        list.forEach(t-> System.out.println(t));
    87. //        println(..):有参数没有返回值
    88.        /*Consumer consumer =  System.out::println;
    89. //        方法引用
    90.         list.forEach(consumer);*/
    91.  
    92.         list.forEach(System.out::println);
    93.     }
    94. }

    Stream

     Stream 的操作三个步骤

    创建 Stream ：一个数据源(如:集合、数组),获取一个流

    中间操作 ：一个中间操作链，对数据源的数据进行处理

    终止操作(终端操作) ：一个终止操作，执行中间操作链，并产生结果

     创建 Stream 的 4 种方法

    •通过Collection中的steam()方法创建流
    •通过Collection中的parallelSteam()方法创建流
    •通过Arrays中的steam()方法创建流
    •通过Stream中的of()静态方法创建流
    •通过Stream中的iterate()方法创建流
    •通过Steam中的generate()方法创建流

     常见Stream接口的继承关系

    Stream的中间操作

           多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理而在终止操作时一次性全部处理，称为“惰性求值”。

     上面这个例子主要是对一组String数据进行操作，主要涉及到的中间操作方法有filter(),limit(),skip(),distinct()终止操作方法有forEach()，下面我们对这些常用方法进行简单介绍

     中间操作常用方法

    分类

    方法

    描述

    筛选和切片

    filter(Predicate p)

    接收Lambda,从流中排除某些元素

    limit(long maxSize)

    截断流，使其元素不超过给定数量

    skip(long n)

    跳过元素，返回一个跳过前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补

    distinct()

    筛选，通过流所生成元素的hashCode()和equals()去除重复元素

    映射

    map(Function f)

    接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

    mapToDouble(ToDoubleFunction f)

    接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream

    mapTolnt(ToIntFunction f)

    同上

    mapToLong(ToLongFunction f)

    同上

    flatMap(Function f)

    接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流

    排序

    sorted()

    产生一个新流，其中按自然顺序排序

    sorted(Comparator c)

    产生一个新流，其中按比较器顺序排序

     Stream的终止操作

    分类

    方法

    描述

    查找与匹配

    allMatch(Predicate p)

    检查是否匹配所有元素

    anyMatch(Predicate p)

    检查是否至少匹配一个元素

    findFirst()

    检查是否没有匹配所有元素返回第一个元素

    findAny()

    返回当前流中的任意元素

    count()

    返回流中元素总数

    max(Comparator c)

    返回流中最大值

    min(Comparator c)

    返回流中最小值

    forEach()

    内部迭代

    归约

    reduce(T iden, BinaryOperator b)

    可以将流中元素反复结合起来，得到一个值。返回T

    reduce(BinaryOperator b)

    可以将流中元素反复结合起来，得到一个值。返回 Optional

    收集

    collect(Collector c)

    将流转换为其他形式。接收一个 Collector 接口的实现，用于给 Stream 中元素做汇总的方法

     演示

     Stream的终止操作-collect()

      Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set/Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

    方法

    返回类型

    作用

    toList

    List

    把流中元素收集到 List

    toSet

    Set

    把流中元素收集到 Set

    toCollection

    Collection

    把流中元素收集到 Collection

    counting

    Long

    计算流中元素的个数

    summingInt

    Integer

    对流中元素的整数属性求和

    averagingInt

    Double

    计算流中元素Integer属性的平均值

    summarizingInt

    IntSummaryStatistics

    收集流中Integer属性的统计值，如：平均值

    joining

    String

    连接流中每个字符串

    maxBy

    Optional

    根据比较器选择最大值

    minBy

    Optional

    根据比较器选择最小值

    reducing

    归约产生的类型

    收集流中Integer属性的统计值，如：平均值

    collectingAndThen

    转换函数返回的类型

    包裹另一个收集器，对其结果转换函数

    groupingBy

    Map

    根据某属性值对流分组，属性为K，结果为V

    partitioningBy

    Map

    根据true或false进行分区

     

     

     

     示例代码演示

    1. package part5;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.*;
    6. import java.util.stream.Collectors;
    7. import java.util.stream.Stream;
    8.  
    9. /**
    10.  * @date : 2022/11/23 14:30
    11.  */
    12. public class JunitStream {
    13.  
    14.  
    15.     /**
    16.      * 数据源（集合、数组、变量、字符串。。。）---》Stream流对象
    17.      * 1、创建Stream流对象
    18.      */
    19.     @Test
    20.     public void createStream() {
    21.  
    22. //        list1数据源
    23.         List<Integer> list1 = new ArrayList<>();
    24.         list1.add(10);
    25.         list1.add(30);
    26.         list1.add(20);
    27.  
    28. //        1)集合对象中 stream()
    29.         Stream<Integer> stream = list1.stream();
    30.         stream.forEach(t -> System.out.println(t));
    31.  
    32. //         2)集合中方式2
    33.         Stream<Integer> stream2 = list1.parallelStream();
    34.         stream2.forEach(t -> System.out.println(t));
    35.  
    36. //        3)数组数据源--》Stream
    37.         Integer[] arr = {1, 3, 5, 7};
    38.         Stream<Integer> stream3 = Arrays.stream(arr);
    39.  
    40.  
    41. //        4)Stream中的of方法
    42.         Stream<Integer> stream4 = Stream.of(1, 2, 3, 4, 5);
    43.         stream4.forEach(t-> System.out.println(t));
    44.  
    45.  
    46. //        5)Stream中iterate
    47. //        数据进行计算：从0开始 让他每次+2 :0 2 4 6 8 10.....
    48. //         iterate无限流
    49. //        Stream<Integer> stream5 = Stream.iterate(0, t -> t + 2);
    50.  
    51.  
    52.         //        limit(3) 获取前3个数据
    53.         Stream<Integer> stream6 = Stream.iterate(0, t -> t + 2).limit(3);
    54.         stream6.forEach(t -> System.out.println(t));
    55.  
    56.         System.out.println("===================");
    57. //        6）Stream.generate
    58. //        Math.random()--double
    59. //        Stream.generate(()->{return Math.random();});
    60. //        Stream.generate(()-> Math.random());
    61. //        Stream<Double> generate = Stream.generate(Math::random);
    62.         Stream<Double> stream7 = Stream.generate(Math::random).limit(2);
    63.         stream7.forEach(t -> System.out.println(t));
    64. //        stream7.forEach(System.out::println);
    65.  
    66.  
    67.     }
    68.  
    69.  
    70.     /**
    71.      * 2、流操作：
    72.      * 中间操作
    73.      */
    74.     @Test
    75.     public void operation() {
    76.         Stream<String> stream = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");
    77.  
    78. //      1)中间操作-->新Stream流
    79. //      filter：过滤流  返回true条件都会添加到这个新流当中
    80.         Stream<String> newStream = stream.filter(str -> {
    81.             if (",".equals(str)) {
    82.                 return false;
    83.             } else {
    84.                 return true;
    85.             }
    86.         });
    87.  
    88.         newStream.forEach(t -> System.out.println(t));
    89.  
    90.         System.out.println("---------------------------");
    91.  
    92.         Stream<String> stream2 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");
    93.  
    94. //        中间操作--limit  获取前X个数据
    95.         Stream<String> newStream2 = stream2.limit(2);
    96.  
    97.         newStream2.forEach(t -> System.out.println(t));
    98.  
    99.  
    100.         System.out.println("------1111111111----------------------------");
    101.         Stream<String> stream3 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");
    102.  
    103. //        中间操作---skip跳过前多少个数据
    104.         Stream<String> streamNew = stream3.skip(2);
    105.         streamNew.forEach(t -> System.out.println(t));
    106.  
    107.         System.out.println("----distict:-----------------------------");
    108.         Stream<Integer> streamDistinct = Stream.of(10, 20, 30, 10, 5);
    109. //         中间操作去重--distinct
    110.         Stream<Integer> newDistinctStream = streamDistinct.distinct();
    111.         newDistinctStream.forEach(t -> System.out.println(t));
    112.  
    113.  
    114. //        数组  1,3,7,8,9,2,4,7,2----去重后求其数据个数
    115.         Integer[] arr2 = {1, 3, 7, 8, 9, 2, 4, 7, 2};
    116.         Stream<Integer> stream1 = Arrays.stream(arr2);
    117.         long count = stream1.distinct().count();
    118.         System.out.println("count:" + count);
    119.  
    120.  
    121.         Stream<String> stream4 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");
    122. //        Stream<String> count1 = stream.filter(str -> !",".equals(str) ? true : false).limit(3).skip(1).distinct();
    123. //        中间流  可以使用连续操作---链式编程
    124.         long count1 = stream4.filter(str -> !",".equals(str) ? true : false).limit(3).skip(1).distinct().count();
    125.         System.out.println("count1:" + count1);
    126.  
    127.         System.out.println("=========sorted=============");
    128.         Integer[] arr = {1, 3, 7, 8, 9, 2, 4, 7, 2};
    129. //        使用流的操作：数组去重  按照升序进行输出
    130.         Stream<Integer> stream5 = Arrays.stream(arr);
    131. //        按照升序进行输出
    132. //        stream5.distinct().sorted().forEach(t-> System.out.println(t));
    133. //        降序进行输出
    134.         stream5.distinct().sorted((a1, a2) -> a2.compareTo(a1)).forEach(t -> System.out.println(t));
    135.  
    136.  
    137.         System.out.println("flatMap:===================");
    138. //        需求："e", "d", "c", "a", "f", "b"--->"edcafb"
    139.         Stream<String> stream6 = Stream.of("e", "d", "c", "a", "f", "b");
    140.         stream6.flatMap(t -> Stream.of(t)).forEach(t -> System.out.print(t));
    141.  
    142.         System.out.println("=============================");
    143.  
    144.         Integer[] arr66 = {1, 3, 7, 8, 9, 2, 4, 7, 2, 60, 70};
    145. //        分类：>=10归为一类数据    ----》999      <10归为两类----》0
    146.         Stream<Integer> stream66 = Arrays.stream(arr66);
    147.         Stream<Integer> stream661 = stream66.map(t -> t >= 10 ? 999 : 0);
    148.         stream661.forEach(t -> System.out.println(t));
    149.  
    150.     }
    151.  
    152.  
    153.     /**
    154.      * 流操作注意事项：
    155.      * Stream 自己不会存储元素----》：数据源--》转换为流
    156.      * Stream 不会改变源对象。相反,他们会返回一个持有结果的新 Stream
    157.      * Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
    158.      * Stream 只能被"消费"一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
    159.      */
    160.     @Test
    161.     public void operation2() {
    162.         Integer[] arr = {1, 3, 7, 8, 9, 2, 4, 7, 2};
    163.         Stream<Integer> stream = Arrays.stream(arr);
    164.         /*Stream<Integer> stream = Arrays.stream(arr);
    165.  
    166.         Stream<Integer> newStream = stream.skip(2).distinct();
    167.  
    168.         long count = newStream.count();*/
    169. //        Stream 只能被"消费"一次，一旦遍历过就会失效
    170.         stream.forEach(t -> System.out.println(t));
    171.  
    172.  
    173. //        java.lang.IllegalStateException: stream has already been operated upon or closed
    174.         long count = stream.distinct().count();
    175.  
    176.  
    177.     }
    178.  
    179.  
    180.     /**
    181.      * 2、流操作：
    182.      * 终止操作
    183.      */
    184.     @Test
    185.     public void operation3() {
    186.  
    187. //        Integer[] arr = {11, 3, 17};
    188. //        Stream<Integer> stream = Arrays.stream(arr);
    189.  
    190. //        判断数组中至少含有一个大于10数据
    191. //        anyMatch:至少含有一个
    192.        /* boolean result1 = stream.anyMatch(t -> t > 10);
    193.         System.out.println("result1:"+result1);*/
    194.  
    195. //        判断数组中所有的数据都大于5  true
    196.        /* boolean resultALl = stream.allMatch(t -> t >5);
    197.         System.out.println("resultALl:"+resultALl);*/
    198.  
    199.  
    200. //   求 数组中所有元素之和
    201.        /* Optional<Integer> reduce = stream.reduce((num1, num2) -> num1 + num2);
    202.         Integer sum = reduce.get();
    203.         System.out.println("sum:"+sum);*/
    204.  
    205.  
    206. //        求 数组中所有数据乘积
    207.         /*Optional<Integer> reduce2 = stream.reduce((num1, num2) -> num1 * num2);
    208.         Integer result = reduce2.get();
    209.         System.out.println("result:"+result);
    210.  
    211.         Stream<String> streamNew = Stream.of("a", "b", "c");
    212.  
    213.         Optional<String> reduce3 = streamNew.reduce((str1, str2) -> str1 + str2);
    214.         String str = reduce3.get();
    215.         System.out.println(str);*/
    216.  
    217.      /*   Integer[] arr1 = {1, 2, 3, 4, 5};
    218.         Stream<Integer> stream1 = Arrays.stream(arr1);
    219. //        求 数组中所有奇数和
    220.         Optional<Integer> reduce7 = stream1.filter(t -> t % 2 != 0).reduce((a, b) -> a + b);
    221.         Integer result77 = reduce7.get();
    222.         System.out.println(result77);*/
    223.  
    224.  
    225. //        System.out.println("=======collect:=流--》集合对象转换===============");
    226.  
    227.         /*Stream<String> stream2 = Stream.of("e", "d", "c", "a", "f", "b");    //把流中元素收集到
    228.  
    229.  
    230.         List<String> list = stream2.collect(Collectors.toList());   // 调用终止操作的方法后需要重新定义
    231.  
    232.  
    233.         Stream stream = Stream.of("e", "d", "c", "a", "f", "b");   // 把流中元素收集到
    234.  
    235.         Set<String> set = stream2.collect(Collectors.toSet());
    236.  
    237.         stream = Stream.of("e", "d", "c", "a", "f", "b");
    238. //         把流中元素收集到 Collection(ArrayList)
    239. //         ArrayList::new 等同于()->new ArrayList()
    240. //         ArrayList::new 可以是list,set接口下的任意实现类
    241.         ArrayList<String> alist = stream2.collect(Collectors.toCollection(ArrayList::new));
    242.         System.out.println(list); // [e, d, c, a, f, b]
    243.         System.out.println(set); // [a, b, c, d, e, f]
    244.         System.out.println(alist); // [e, d, c, a, f, b]
    245. */
    246.  
    247.         System.out.println("====collect===Collectors:功能===============");
    248.  
    249.  
    250.         Integer[] arr2 = {1, 2, 3, 4, 5};
    251.         Stream<Integer> stream1 = Arrays.stream(arr2);
    252. //        计数
    253.         /*Long count = stream1.collect(Collectors.counting());
    254.         System.out.println("count:"+count);*/
    255.  
    256. //   求和
    257.         Integer sum = stream1.collect(Collectors.summingInt(t -> t));
    258.         System.out.println("sum:"+sum);
    259.  
    260.  
    261.         System.out.println("========================");
    262.  
    263. //        groupingBy:   分班 java314 精英班  成绩要求都是80分（含）以上     80分以下分数---java00
    264.         Integer[] scores = {85, 90, 100, 70, 80,75};
    265. //        java314---》 85 90 100 80
    266. //        java00--->70 75
    267.  
    268.         Stream<Integer> stream = Arrays.stream(scores);
    269.         Map<String, List<Integer>> map = stream.collect(Collectors.groupingBy(t -> t >= 80 ? "java314" : "java00"));
    270.         map.forEach((k,v)-> System.out.println(k+"----"+v));
    271.  
    272.  
    273.     }
    274.  
    275.  
    276. }

     作业

    1. package part5;
    2.  
    3. import java.util.*;
    4. import java.util.stream.Collectors;
    5. import java.util.stream.Stream;
    6.  
    7. /**
    8.  * @author : cqq
    9.  * @date : 2022/11/23 13:13
    10.  */
    11. public class Task {
    12.  
    13.     public static void main(String[] args) {
    14.  
    15. //        1.	给一个整数集合，分别求集合中偶数和与奇数和
    16.  
    17.         List<Integer> list1 = new ArrayList<>();
    18.         list1.add(1);
    19.         list1.add(2);
    20.         list1.add(3);
    21.         list1.add(4);
    22.         list1.add(5);
    23.         list1.add(6);
    24.         list1.add(7);
    25.         list1.add(8);
    26.         list1.add(9);
    27.         list1.add(10);
    28.  
    29. //        list1.stream().filter(t->t%2==0).forEach(a-> System.out.println(a));
    30.         Optional<Integer> reduce = list1.stream().filter(t -> t % 2 == 0).reduce((x, y) -> x + y);
    31.         Integer ou = reduce.get();
    32.         System.out.println("ou和:"+ou);
    33. //        list1.stream().filter(t->t%2!=0).forEach(a-> System.out.println(a));
    34.         Optional<Integer> ji = list1.stream().filter(t -> t % 2 != 0).reduce((x, y) -> x + y);
    35.         System.out.println("ji和:"+ji.get());
    36. //
    37. //
    38. //
    39. //
    40. //
    41.        System.out.println("---------------------");
    42. //        2. 给一个整数集合，将集合分成偶数集合和奇数集合
    43.         ArrayList<Integer> li = new ArrayList<>();
    44.         li.add(1);
    45.         li.add(2);
    46.         li.add(3);
    47.         li.add(4);
    48.         li.add(5);
    49.         li.add(6);
    50.         List<Integer> ou1 = li.stream().filter(t->t%2==0).collect(Collectors.toList());
    51.         System.out.println("ou:"+ou1);
    52.         List<Integer> ji1 = li.stream().filter(t->t%2!=0).collect(Collectors.toList());
    53.         System.out.println("ji:"+ji1);
    54.  
    55.  
    56.  
    57. /*//        List<Integer> list22 = list1.stream().filter(t -> t % 2 == 0).collect(Collectors.toList());
    58.         List<String> list66 = list1.stream().map(t -> t + "").collect(Collectors.toList());
    59.         System.out.println(list66);
    60.  
    61.  
    62.         System.out.println("---------888888888888------------");
    63.         List list7 = new ArrayList<>();
    64.         list7.add("hello");
    65.         list7.add(2);
    66.         System.out.println(list7);
    67.  
    68.         System.out.println("===========999999999:=============");
    69. //
    70. //*/
    71. //
    72. //        3. 集合转换：[[1, 2, 3, 4, 5], [2, 1, 9, 3, 6, 7], [3, 1, 6]] -> ["1", "2", "4", "5", "2", …… "3", "1","6"]
    73.         List<Integer> list4 = new ArrayList<>();
    74.         List<Integer> list2 = new ArrayList<>();
    75.         List<Integer> list3 = new ArrayList<>();
    76.  
    77.         Collections.addAll(list4,1,2,3,4,5);
    78.         Collections.addAll(list2,3,1,6);
    79.         Collections.addAll(list3,2,1,9,3,6,7);
    80.         List<String> list = new ArrayList<>();
    81.         list1.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
    82.         list2.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
    83.         list3.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
    84.         System.out.println(list);
    85.  
    86.  
    87. /*        List<Integer> list99 = new ArrayList<>();
    88.         list99.add(1);
    89.         list99.add(2);
    90.         list99.add(3);
    91.  
    92.         List<Integer> list5 = new ArrayList<>();
    93.         list5.add(11);
    94.         list5.add(21);
    95.         list5.add(31);
    96.  
    97.         List<Integer> list88 = new ArrayList<>();
    98.         list88.add(88);
    99.         list88.add(99);
    100.  
    101.         list5.stream().map(t -> list99.add(t)).collect(Collectors.toList());
    102.         System.out.println(list99);
    103.         System.out.println("list................");
    104.  
    105.         list88.stream().map(t -> list99.add(t)).collect(Collectors.toList());
    106.         System.out.println(list99);
    107.  
    108.  
    109. //        Stream<String> stringStream = Stream.of("e", "d", "c", "a", "f", "b");
    110. //        String st = stringStream.reduce("", (str1, str2) -> str1 = str1 + str2);
    111. //        System.out.println(st);*/
    112.  
    113.  
    114.     }
    115. }

  • 相关阅读:
    另一个博客
    力扣labuladong——一刷day39
    java计算机毕业设计-人事管理系统-源码+数据库+系统+lw文档+mybatis+运行部署
    2022最新版-李宏毅机器学习深度学习课程-P51 BERT的各种变体
    C语言结构体大小分析
    【ML on Kubernetes】第 7 章：模型部署和自动化
    MIPI CSI-2笔记（19） -- 数据格式（用户自定义数据格式）
    LeetCode 数据结构与算法：最大子数组和
    awk,gawk基本用法笔记221107
    【Azure 环境】【Azure Developer】使用Python代码获取Azure 中的资源的Metrics定义及数据
  • 原文地址：https://blog.csdn.net/qq_63202674/article/details/128029124