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