标签：Stream stream System Javaheima12 names println out

Java

不可变集合

• 如果某个数据不能修改,把它防御性地拷贝到不可变集合红是个很好的实践
• 或者当集合对象被不可信的库调用时,不可变形式是安全的

创建

• 再List,Set,Map接口中,都存在of方法,可以创建一个不可变的集合

方法名称	说明
static List of(E...elements)	创建一个具有指定元素的List集合对象
static Set of(E...elements)	创建一个具有指定元素的Set集合对象
static <K,V> Map<K,V> of(E...elements)	创建一个具有指定元素的Map集合对象

• 创建完成后不能添加,不能修改,不能删除.

Stream流

概述

• 再Java 8 中,得意于Lambda所带来的函数式编程,引入了一个全新的Stream流概念
• 目的:用于简化集合和数组操作的API

package com.yu.Day0525Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StreamTest {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        Collections.addAll(lists,"张无忌","周芷若","赵敏","张三丰","张强","张xx");
        System.out.println(lists);

//        List<String> ZhangLists = new ArrayList<>();
//        for (String list:lists
//             ) {
              //筛选姓张的
//            if(list.startsWith("张")){
                  // 筛选姓名长度为三个字的
//                if(list.length() == 3){
//                    ZhangLists.add(list);
//                }
//            }
//        }
//        System.out.println(ZhangLists);
//        lists.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        lists.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(s -> System.out.println(s));
}
}

思想和使用步骤

• 先得到集合或者数组的Stream流.
• 把元素放上去
• 然后就用这个Stream流简化的API来方便的操作元素

三类方法

获取Stream流

• 创建一条流水线,并把数据放到流水线上准备进行操作

Stream操作集合或者数组的第一步是先得到Stream流,然后才能使用流的功能

集合获取Stream流的方式

• 可以使用Collection接口中的默认方法stream()生成流

• 名称	什么
  default Stream stream()	获取当前集合对象的Stream流

数组获取Stream流的方式

名称	说明
public static Stream stream(T[] array)	获取当前数组的Stream流
public static Stream of(T...values)	获取当前数组/可变数据的Stream流

package com.yu.Day0526Demo;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo01 {
    public static void main(String[] args) {
        /**---------------Colleaction集合获取流---------------**/
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();
        /**---------------Map集合获取流---------------**/
        Map<String,Integer> maps = new HashMap<>();
        //获取键流
        Stream<String> keys = maps.keySet().stream();
        //获取值流
        Stream<Integer> values = maps.values().stream();
        //键值对流
        Stream<Map.Entry<String,Integer>> keyvalues = maps.entrySet().stream();
        /**---------------数组获取流---------------**/
        String[] names = {"yu","xiao","yu"};
        Stream<String> nameStream = Arrays.stream(names);
        Stream<String> nameStream2 = Stream.of(names);
        System.out.println();
    }
}

中间方法

• 流水线上的操作,一次操作完毕之后,还可以继续进行其他操作

名称	说明
Stream filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	获取前几个元素
Stream skip(long n)	跳过前几个元素
Stream distinct()	去除流中重复的元素.依赖(hashCode和equals方法)
static Stream concat(Stream a,Stream b)	合并a和b两个流为一个流

注意

• 中间方法也称为非终结方法,调用完成后返回新的Stream流可以继续使用,支持链式编程
• 在Stream流中无法直接修改集合,数组中的元素

package com.yu.Day0526Demo;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamAPI01 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("张无忌");
        names.add("周芷若");
        names.add("张三丰");
        names.add("赵敏");
        names.add("张强");
        names.add("张弓长");

        //Stream<T> filter(Predicate<? super T> predicate)
        //对流中数据进行过滤
//        names.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//        });
        names.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        long size = names.stream().filter(s->s.length()==3).count();
        System.out.println(size);
        names.stream().filter(s -> s.length() == 3).limit(2).forEach(s -> System.out.println(s));
        System.out.println("---------我是一条分界线-----------");
        names.stream().filter(s -> s.length() == 3).skip(2).forEach(System.out::println);
        System.out.println("---------我是一条分界线-----------");
//        names.stream().map(s -> "金庸的:"+s).forEach(s -> System.out.println(s));
        //将集合放到对象中
        names.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s));
        //                方法引用                构造器引用
        names.stream().map(Student::new).forEach(System.out::println);
        //合并流
        Stream<String> s1 = names.stream().filter(s -> s.length() == 3);
        Stream<String> s2 = Stream.of("yu","xiao");
        Stream.concat(s1,s2).forEach(s-> System.out.println(s));
    }
}

终结方法

• 一个Stream流只能有一个终结方法,是流水线上的最后一个操作

• 名称	说明
  void forEach(Consumer actiog)	对此流的每个元素指向遍历操作
  long count()	返回此流中的元素个数

• *** 注意:终结操作方法,调用完成流就无法继续使用了,原因是不会返回Stream了

总结

终结和非终结方法的含义是什么?

终结方法后流不可以继续使用,非终结方法会返回新的流,支持链式编程

标签：Stream,stream,System,Javaheima12,names,println,out
来源： https://www.cnblogs.com/yuxxiao/p/16336403.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。