Java:Stream流

逃离我推掉我的手 2024-03-31 11:38 68阅读 0赞

**目录**

Stream流

1、Stream流的使用步骤

2、Stream流的获取方式

3、Stream流的中间方法

4、Stream流的终结方法

--------------------

### Stream流 ###

作用：结合了Lambda表达式，简化集合、数组的操作

#### **1、Stream流的使用步骤** ####

1、先得到一条Stream流（流水线)，并把数据放上去

2、使用中间方法对流水线上的数据进行操作

3、使用终结方法对流水线上的数据进行操作

利用Stream流中的API进行各种操作

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>过滤</td> 
   <td>转换</td> 
   <td>中间方法</td> 
   <td>方法调用完毕之后，还可以调用其他方法<br> &nbsp;</td> 
  </tr> 
  <tr> 
   <td>统计</td> 
   <td>打印</td> 
   <td>终结方法<br> &nbsp;</td> 
   <td>最后一步，调用完毕之后，不能调用其他方法<br> &nbsp;</td> 
  </tr> 
 </tbody> 
</table>

#### 2、Stream流的获取方式 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>&nbsp;获取方式</td> 
   <td>方法名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>单列集合<br> &nbsp;</td> 
   <td>default Stream&lt;E&gt; stream()<br> &nbsp;</td> 
   <td>collection中的默认方法<br> &nbsp;</td> 
  </tr> 
  <tr> 
   <td>双列集合<br> &nbsp;</td> 
   <td>无</td> 
   <td>无法直接使用stream流<br> &nbsp;</td> 
  </tr> 
  <tr> 
   <td>数组<br> &nbsp;</td> 
   <td>public static &lt;T&gt; Stream&lt;T&gt; stream(T[ ]array)<br> &nbsp;</td> 
   <td>Arrays工具类中的静态方法<br> &nbsp;</td> 
  </tr> 
  <tr> 
   <td>一堆零散数据<br> &nbsp;</td> 
   <td>public static&lt;T&gt; Stream&lt;T&gt; of(T... values)<br> &nbsp;</td> 
   <td>Stream接口中的静态方法</td> 
  </tr> 
 </tbody> 
</table>

**单列集合**

List<String> list = new ArrayList<>();
            Collections.addAll(list,"a","s","d","f");
            //获取一条流水线，并把数据放在流水线上
            Stream<String> stream = list.stream();
            //使用终结方法打印流水线所有数据
            stream.forEach(new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(s);
                }
            });
            System.out.println("-----------------");
            //简化
            list.stream().forEach(s -> System.out.println(s));

**双列集合**

//1.创建双列集合
            HashMap<String,Integer> hm = new HashMap<>();
            //2.添加数据
            hm.put("aaa",111);
            hm.put("bbb",222);
            hm.put("ccc",333);
            hm.put("ddd",444);
            //3.第一种获取stream流
            // hm.keySet().stream( ).forEach(s -> system.out.println(s)) ;
            //4.第二种获取stream流
            hm.entrySet().stream( ).forEach(s-> System.out.println(s)) ;

**数组**

//1.创建数组
            int[] arr1 = {1,2,3,4,5};
            String[] arr2 = {"a","b","c"};
            //2.获取stream流
            Arrays.stream( arr1).forEach(s-> System.out.println(s)) ;
            System.out.println( "-----------------------");
            Arrays.stream( arr2).forEach(s-> System.out.println(s));

**零散数据**

Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
    System.out.println("-----------------");
    Stream.of("a","b","c").forEach(s-> System.out.println(s));

**注意:**

Stream接口中静态方法of的细节

方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组，但是数组必须是引用数

据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。

#### 3、Stream流的中间方法 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>Stream&lt;T&gt; filter(Predicate&lt;? super T&gt; predicate)</td> 
   <td>过滤</td> 
  </tr> 
  <tr> 
   <td>Stream&lt;T&gt; limit(long maxSize)</td> 
   <td>获取前几个元素</td> 
  </tr> 
  <tr> 
   <td>Stream&lt;T&gt; skip(long n)</td> 
   <td>跳过前几个元素</td> 
  </tr> 
  <tr> 
   <td>Stream&lt;T&gt; distinct()</td> 
   <td>元素去重，依赖(hashcode和equals方法)</td> 
  </tr> 
  <tr> 
   <td>static &lt;T&gt; Stream&lt;T&gt; concat(Stream a, Stream b)</td> 
   <td>合并a和b两个流为一个流</td> 
  </tr> 
  <tr> 
   <td>Stream&lt;R&gt; map(Function&lt;T , R&gt; mapper)</td> 
   <td>转换流中的数据类型</td> 
  </tr> 
 </tbody> 
</table>

注意1∶中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程、

注意2:修改Stream流中的数据，不会影响原来集合或者数组中的数据  
示例：

ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌","周芷若", "赵敏" ,"张强","张三丰","张翠山","张良","王二麻子","谢广坤");
    //filter过滤把张开头的留下，其余数据过滤不要
    list.stream().filter(new Predicate<String>() {
          @Override
           public boolean test(String s) {
                //如果返回值为true，表示当前数据留下
                //如果返回值为false，表示当前数据舍弃不要
                return s.startsWith("张");
           }
       }).forEach(s -> System.out.println(s));
    System.out.println("-----------------");
    //简化 
    //是否有张，长度是否等于3
    list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
    System.out.println("-----------------------");
    //获取前几个元素
    list.stream().limit(3).forEach(s -> System.out.println(s));
    System.out.println("--------------------");
    //跳过前几个元素
    list.stream().skip(4).forEach(s -> System.out.println(s));
    System.out.println("--------------------");
    //元素去重
    ArrayList<String> list1 = new ArrayList<>();
    Collections.addAll(list1, "张无忌","张无忌","张无忌","张强","张三丰","张举山","张良","王二麻子","谢广坤");
    ArrayList<String> list2 = new ArrayList<>();
    Collections.addAll(list2,"周芷若","赵敏");
    // distinct 元素去重，依赖(hashcode和equals方法)
    list1.stream().distinct() .forEach(s -> System.out.println( s)) ;
    System.out.println("--------------------");
    //合并两个流
    Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));

#### 4、Stream流的终结方法 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>void forEach(Consumer action)</td> 
   <td>遍历</td> 
  </tr> 
  <tr> 
   <td>long count()</td> 
   <td>统计</td> 
  </tr> 
  <tr> 
   <td>toArray()</td> 
   <td>收集流中的数据，放到数组中</td> 
  </tr> 
  <tr> 
   <td>collect(Collector collector)</td> 
   <td>收集流中的数据，放到集合中</td> 
  </tr> 
 </tbody> 
</table>

遍历

ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌","周芷若", "赵敏" ,"张强","张三丰","张翠山","张良","王二麻子","谢广坤");
    // Consumer的泛型:表示流中数据的类型
    // accept方法的形参s:依次表示流里面的每一个数据
    // 方法体:对每一个数据的处理操作（打印>|
    list.stream().forEach(new Consumer<String>() {
          @Override
          public void accept(String s) {
              System.out.println(s);
          }
       });
    //简化
    list.stream().forEach(s -> System.out.println(s));

统计

//统计
    long count = list.stream().count();
    System.out.println(count);

收集流中的数据，放到数组中

//空参
            Object[] objects = list.stream().toArray();
            System.out.println(Arrays.toString(objects));
    
            //有参
            //IntFunction的泛型:具体类型的数组
            // apply的形参:流中数据的个数，要跟数组的长度保持一致
            // apply的返回值:具体类型的数组
            //方法体:就是创建数组
    
            //toArray方法的参数的作用:负责创建一个指定类型的数组
            // toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
            // toArray方法的返回值:是一个装着流里面所有数据的数组
            //匿名内部类
            String[] strings = list.stream().toArray(new IntFunction<String[]>() {
                @Override
                public String[] apply(int value) {
                    return new String[value];
                }
            });
            System.out.println(Arrays.toString(strings));
            //lambda表达式的写法
            String[] strings1 = list.stream().toArray(value -> new String[value]);
            System.out.println(Arrays.toString(strings1));

收集流中的数据，放到集合中

ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"张无忌-男-20","周芷若-女-20");
            //收集在list集合中
            List<String> collect = list.stream().collect(Collectors.toList());
            System.out.println(collect);
            //收集在set集合中,可以去除重复元素
            Set<String> collect1 = list.stream().collect(Collectors.toSet());
            System.out.println(collect1);
            //收集在map集合中
            Map<String, Integer> collect2 = list.stream().collect(Collectors.toMap(
                    s -> s.split("-")[0],
                    s -> Integer.parseInt(s.split("-")[2])));
            System.out.println(collect2);