Stream流常用方法

1. 获取Stream流

	1. 所有的Collection<T>集合都有对应的Stream();
	2. 可以通过Stream类中的static Stream of()获取
		static Stream<T> of(T... t);
		static Stream<T> of(T t);

package com.qfedu.first.streamget;

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

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo1 {
    public static void main(String[] args) {
        // List接口获取对应的Stream流类对象
        ArrayList<String> list = new ArrayList<>();
        // 根据list保存元素的类型来约束对应的Stream流对象操作所需类型
        Stream<String> stream = list.stream();

        // 通过Set集合获取对应Stream流对象
        HashSet<String> set = new HashSet<>();
        Stream<String> stream1 = set.stream();

        HashMap<String, String> map = new HashMap<>();
        // Map双边队列中所有键对应的Set集合
        Set<String> keySet = map.keySet();
        Stream<String> stream2 = keySet.stream();

        // Map双边队列中所有value对应的Collection集合
        Collection<String> values = map.values();
        Stream<String> stream3 = values.stream();

        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entrySet.stream();

        Stream<String> stringStream = Stream.of("灵台方寸山", "斜月三星洞");
        String[] arr = {"为天地立心", "为生民立命", "为往圣继绝学", "为万世开太平"};
        Stream<String> arrStream = Stream.of(arr);

        // 不建议这样使用
        ArrayList<String> list1 = new ArrayList<>();
        Stream<ArrayList<String>> list11 = Stream.of(list1);
    }
}

2. foreach方法

void foreach(Consumer<? super T> action);
/*
终结方法:
	需要一个Consumer接口进行操作处理，消耗一个数据
	Consumer接口是一个【函数式接口】那就可以使用Lambda表达式
	Consumer接口中方法是
		void accept(T t);
*/

package com.qfedu.first.streamfunction;

import org.w3c.dom.ls.LSOutput;

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

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("111");
        list.add("2222");
        list.add("3333");
        list.add("4444");

        Stream<String> stream = list.stream();

        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String string) {
                System.out.println(string);
            }
        });

        stream.forEach(string -> System.out.println(string));

        stream.forEach(System.out::println);
    }
}

3. filter方法

Stream<T> filter(Predicate<? super T> condition);
/*
	filter是过滤方式，需要的参数是Predicate接口，Predicate是一个函数式接口，可以直接使用Lambda表达运行。
	这里返回值类型是Stream类对象，是经过过滤之后的Stream类型，可以进行链式操作
	Predicate接口中需要实现的方法
		boolean test(T t);
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("111");
        list.add("222");
        list.add("33");
        list.add("4444");

        Stream<String> stringStream = list.stream().filter(s -> s.length() >= 3);
        stringStream.forEach(System.out::println);
    }
}

4. map方法

<R> Stream<R> map(Function<? super T, ? super R> fun);
/*
类型转换操作，得到的一个转换之后数据类型的Stream流对象
这里需要的参数是Functtion函数式接口，
	R apply(T t);
	T类型的数据转换成R类型数据
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("1, ljw, 22");
        list.add("2, lzw, 36");
        list.add("3, lq, 46");
        list.add("4, lb, 56");
        list.add("5, fsc, 66");
        list.add("6, zwj, 76");

        System.out.println(list);

        Stream<Person> personStream = list.stream().map(s -> {
            String[] split = s.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            return person;
        });

        personStream.forEach(System.out::println);
    }
}

5. count方法

long count();
/*
返回当前Stream流对象中有多少个元素
类似有Collection接口下的size(). String的length();
【终结方法】
	一旦执行Stream流对象被关闭
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("111");
        list.add("222");
        list.add("33");
        list.add("4444");

        long count = list.stream().filter(s -> s.length() >= 3).count();
        System.out.println(count);
    }
}

6. limit方法

Stream<T> limit(long maxSize);
/*
对于当前Stream流对象操作的数据进行限制操作，限制个数到maxSize
例如:
	Stream流中保存的有10个元素，limit 5 ==> 前五个元素
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("11");
        list.add("22");
        list.add("33");
        list.add("444");
        list.add("55");
        list.add("6666");

        Stream<String> stream = list.stream();

        stream.limit(5).forEach(System.out::println);
    }
}

7. skip方法

Stream<T> skip(long n);
/*
返回值依然是一个Stream流对象，这里跳过当前Stream流对象前n个元素
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("11");
        list.add("22");
        list.add("3333");
        list.add("4444");
        list.add("555555");
        list.add("66666");

        list.stream().skip(2).forEach(System.out::println);
    }
}

8. concat方法

static Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 
/*
拼接两个Stream流对象，是一个静态方法，得到新的Stream流对象
*/

package com.qfedu.first.streamfunction;

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 * Create By 刘珈玮 on 2020/3/12.
 */
public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("11");
        list.add("22");
        list.add("33");
        list.add("444");
        list.add("55");
        list.add("6666");

        ArrayList<String> list1 = new ArrayList<>();

        list.add("11");
        list.add("22");
        list.add("3333");
        list.add("4444");
        list.add("555555");
        list.add("66666");

        Stream<String> stream = list.stream();
        Stream<String> stream1 = list1.stream();

        Stream<String> concat = Stream.concat(stream, stream1);

        concat.forEach(System.out::println);
    }
}