Java-Stream流，方法引用-第24节

学习目标：

• 理解流式思想，了解流的常用方法分类；
• 熟练使用方法获取流对象；
• 了解多种方法引用。

---

学习内容：

一、stream流

1、简介

• java.util.stream.Stream 并不是一个函数式接口
• JDK1.8之后出现
• 关注的是做什么而不是怎么做
• 当流已经调用方法之后就会被关闭而不能再被使用

2、流式思想概述

• 流相当于模型，起到占位作用，并不实际存储数据或者地址，既不是集合也不是数据结构
• 流与流之间的操作起到连接的作用，且流不被改变
• 多个操作将各种流连接在一起构成一个“流水线”–>管道式
• 基本步骤：
  • 准备数据源
  • 数据源转换成流
  • 执行操作得到结果

3、获取流的方式

• 所有的collection集合都可以通过stream默认方法获取流
  default Stream stream();
• Stream接口的静态方法of可以获取数组对应的流
  static Stream of(T… values); 参数是一个可变参数

4、常用方法

• 延迟方法
  • Stream filter(Predicate predicate);
    通过判断型接口筛选出想要保留的参数放入新的流中
  • Stream map(Function<T,E> function);
    通过转换型接口将流中的数据转换成想要获得的数据类型并储存在新的流中
  • Stream limit(long maxsize);
    截取想要的流中的前maxsize个数据组成一个新的流
  • Stream skip(long num);
    跳过前面num个元素获取后面的所有元素组成一个新的流
• 终结方法
  • forEach(Concumer consumer);
    循环遍历流中的所有内容并进行处理
  • long count();
    获取流中的元素个数并返回long类型的值表示
• 静态方法
  • Stream concat(Stream a, Stream b);
    将两个流拼接成为一个流，为Stream的静态方法

二、方法引用

1、简介

• lambda表达式在功能已经被定义为固定方法的情况下会比较累赘
• 通过方法引用可以直接通过对象调用方法取代lambda表达式

2、方法引用符

• ::
• 对象::方法;

3、几种引用方法

• 通过对象名引用成员方法
  • 首先，确定对应的对象中包含对应的成员方法
  • 其次，确定功能是否对应
  • 最后，确认替代部分是不是lambda表达式
• 通过对象名直接引用静态方法
  • 对象与静态方法都是存在的
• 通过super引用成员方法
  • 包含父子类关系
  • 含有lambda表达式
• 通过this调用本类的成员方法
• 构造方法的引用
  • 类名::new;

---

学习产出：

1、 流式思想与获取流

package demo01;

import java.util.ArrayList;

public class DemoStream {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Jim");
        list.add("Tom");
        list.add("Mary");
        list.add("Smith");
        list.add("Tony");
        tradition(list);
        stream(list);
    }

    private static void stream(ArrayList<String> list) {
        list.stream()
                    .filter(s->s.startsWith("T") || s.startsWith("J"))
                    .filter(s->s.length()==3)
                    .forEach(s-> System.out.println(s));
    }

    private static void tradition(ArrayList<String> list) {
        ArrayList<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("T") || s.startsWith("J")){
                list1.add(s);
            }
        }
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.length()==3){
                list2.add(s);
            }
        }
        for (String s : list2) {
            System.out.println(s);
        }
    }
}

package demo01;

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

public class DemoGetStream {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Stream<Integer> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        String[] strings = {"a","asd","dfgay"};
        Stream<String> stream7 = Stream.of(strings);
        int[] ints = {1,2,3,4,5};
        Stream<int[]> stream8 = Stream.of(ints);
    }
}

2、常用流的方法

package demo02;

import java.io.Serializable;
import java.util.stream.Stream;

public class DemoConcat {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4);
        Stream<String> stream1 = Stream.of("a", "v", "d");
        Stream<Integer> stream2 = Stream.of(12, 22);
        Stream<? extends Serializable> stream3 = Stream.concat(stream, stream1);
        stream3.forEach(i-> System.out.println(i));
    }
}

package demo02;

import java.util.stream.Stream;

public class DemoFilter {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> stream1 = stream.filter(i -> i > 3);
        stream1.forEach(i-> System.out.println(i));
    }
}

package demo02;

import java.util.stream.Stream;

public class DemoLimit {
    public static void main(String[] args) {
        String[] str = {"as","for","me","what"};
        Stream<String> stream = Stream.of(str);
        Stream<String> stream1 = stream.limit(3);
        stream1.forEach(s-> System.out.println(s));
    }
}

package demo02;

import java.util.stream.Stream;

public class DemoMap {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3");
        Stream<Integer> stream1 = stream.map(s -> Integer.parseInt(s));
        stream1.forEach(i-> System.out.println(i));
    }
}

package demo02;

import java.util.stream.Stream;

public class DemoSkip {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> stream1 = stream.skip(3);
        stream1.forEach(i-> System.out.println(i));
    }
}

package demo02;

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

public class DemoCount {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(7);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

package demo02;

import java.util.stream.Stream;

public class DemoForEach {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        stream.forEach(i-> System.out.println(i));
    }
}

3、 练习：集合元素处理

package demo02;

import java.util.stream.Stream;

public class Person {
    private String name;

    @Override
    public String toString() {
        return "Person{" + "name=" + name + '}';
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package demo02;

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

public class TestStream {
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>();
        a.add("Jim");
        a.add("Tom");
        a.add("Mary");
        a.add("Smith");
        a.add("Tony");
        Stream<String> stream = a.stream();
        Stream<String> stream1 = stream.filter(s -> s.contains("m")).limit(2);
        Stream<String> mike = Stream.of("Mike", "Toke", "Sike", "Loke");
        Stream<String> stream2 = mike.filter(s -> s.contains("k")).skip(2);
        Stream<String> stream3 = Stream.concat(stream1, stream2);

        stream3.map(s-> new Person(s)).forEach(s-> System.out.println(s));
    }
}

4、 方法引用

package demo03;

public class DemoFunctionImport {
    private static void printStr(printable p){
        p.printString();
    }

    public static void main(String[] args) {
        printStr(()-> System.out.println("Hello World!!!"));
        printStr(System.out::println);
    }
}

package demo03;

public class DemoObjImport {
    private static void printStr(printable p){
        p.printString();
    }

    public static void main(String[] args) {
        printStr(()->{
            PrintClass aClass = new PrintClass();
            aClass.printUpper("Hello");
        });
        PrintClass bClass = new PrintClass();
//        printStr(bClass::printUpper);
    }
}

package demo03;

public class DemoSuperImport extends Human {

    @Override
    public void sayHello() {
        System.out.println("Hello,I'm Man!");
    }

    public static void method(printable p){
        p.printString();
    }
    public void show(){
        method(super::sayHello);
    }

    public static void main(String[] args) {
        new DemoSuperImport().show();
    }
}

package demo03;

@FunctionalInterface
public interface printable {
    public abstract void printString();
}

package demo03;

public class PrintClass {
    public void printUpper(String str){
        System.out.println(str.toUpperCase());
    }
}

package demo03;

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("Hello,I'm Human!");
    }
}

package demo03;

public class Human {
    public void sayHello(){
        System.out.println("Hello,I'm Human!");
    };
}