day17 Stream流和方法引用

Stream流

流过滤的方法

Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤

• Stream filter(Predicate<? super T> predicate);
  filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤

Predicate中的抽象方法:

• boolean test(T t);
  使用Stream流的方式,遍历集合,对集合中的数据进行过滤
  Stream流是JDK1.8之后出现的
  关注的是做什么,而不是怎么做

public class Demo02Stream {
    public static void main(String[] args) {
        //创建一个List集合,存储姓名
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        //对list集合中的元素进行过滤,只要以张开头的元素,存储到一个新的集合中
        //对listA集合进行过滤,只要姓名长度为3的人,存储到一个新集合中
        //遍历listB集合
        list.stream()
                .filter(name->name.startsWith("张"))
            .filter(name->name.length()==3)
            .forEach(name-> System.out.println(name));
	}
}

获取流的方法

java.util.stream.Stream是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：

• default Stream stream​()
  所有的Collection集合都可以通过stream默认方法获取流；
• static Stream of​(T… values)
  Stream接口的静态方法of可以获取数组对应的流。
  参数是一个可变参数,那么我们就可以传递一个数组

遍历流的方法

Stream流中的常用方法_forEach

• void forEach(Consumer<? super T> action);
  该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
  Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数据

简单记:
forEach方法,用来遍历流中的数据
是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法

流中类型转换的方法

Stream流中的常用方法_map:用于类型转换
如果需要将流中的元素映射到另一个流中，可以使用map方法.

• Stream map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

Function中的抽象方法:

• R apply(T t);

流中统计元素个数的方法

Stream流中的常用方法_count:用于统计Stream流中元素的个数

• long count();
  count方法是一个终结方法,返回值是一个long类型的整数
  所以不能再继续调用Stream流中的其他方法了

流中截取元素的方法

Stream流中的常用方法_limit:用于截取流中的元素
limit方法可以对流进行截取，只取用前n个。方法签名：

• Stream limit(long maxSize);
  参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作

注意：
limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法

流中跳过元素的方法

Stream流中的常用方法_skip:用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：

• Stream skip(long n);
  如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

组合流的静态方法

Stream流中的常用方法_concat:用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

• static Stream concat(Stream<? extends T> a, Stream<? extends T> b)

方法引用

对象名引用成员方法

通过对象名引用成员方法
使用前提是对象名是已经存在的,成员方法也是已经存在
就可以使用对象名来引用成员方法

定义一个函数式接口

@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    void print(String s);
}

定义一个成员方法,传递字符串,把字符串按照大写输出

public class MethodRerObject {
    //定义一个成员方法,传递字符串,把字符串按照大写输出
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}

定义一个测试类

public class Demo01ObjectMethodReference {
    //定义一个方法,方法的参数传递Printable接口
    public static void printString(Printable p){
        p.print("Hello");
    }

    public static void main(String[] args) {
        //调用printString方法,方法的参数Printable是一个函数式接口,所以可以传递Lambda表达式
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            //调用MethodRerObject对象中的成员方法printUpperCaseString,把字符串按照大写输出
            obj.printUpperCaseString(s);
        });

        /*
            使用方法引用优化Lambda
            对象是已经存在的MethodRerObject
            成员方法也是已经存在的printUpperCaseString
            所以我们可以使用对象名引用成员方法
         */
        //创建MethodRerObject对象
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }
}

类名引用静态成员方法

通过类名引用静态成员方法
类已经存在,静态成员方法也已经存在
就可以通过类名直接引用静态成员方法

格式：

• 类名::成员方法名

super引用类的成员方法

使用super引用类的成员方法
super是已经存在的
父类的成员方法也已经存在的
所以我们可以直接使用super引用父类的成员方法

格式:

• super::成员方法名

this引用本类的成员方法

使用方法引用优化Lambda表达式
this是已经存在的
本类的成员方法也已经存在的
所以我们可以直接使用this引用本类的成员方法

格式

• this::方法名

类的构造器(构造方法)引用

使用方法引用优化Lambda表达式
构造方法new Person(String name) 已知
创建对象已知 new
就可以使用Person引用new创建对象

格式：

• Person::new

数组的构造器引用

使用方法引用优化Lambda表达式
已知创建的就是int[]数组
数组的长度也是已知的
就可以使用方法引用
int[]引用new,根据参数传递的长度来创建数组

格式：

• int[ ]::new

课外补充

Stream流的补充

Sorted(排序)
排序是一个 中间操作，返回的是排序好后的 Stream。如果你不指定一个自定义的 Comparator 则会使用默认排序。
创建一个集合

List<String> stringList = new ArrayList<>();
stringList.add("ddd2");
stringList.add("aaa2");
stringList.add("bbb1");
stringList.add("aaa1");
stringList.add("bbb3");
stringList.add("ccc");
stringList.add("bbb2");
stringList.add("ddd1");

测试 Sort (排序)

 stringList
              .stream()
              .sorted()
              .filter((s) -> s.startsWith("a"))
              .forEach(System.out::println);// aaa1 aaa2

需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据stringCollection是不会被修改的：

System.out.println(stringList);// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

方法引用补充

Java 8允许您通过::关键字传递方法或构造函数的引用。 上面的示例显示了如何引用静态方法。 但我们也可以引用对象方法：

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

接下来看看构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

接下来我们指定一个用来创建Person对象的对象工厂接口：

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来，而不是手动实现一个完整的工厂：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我们只需要使用 Person::new 来获取Person类构造函数的引用，Java编译器会自动根据PersonFactory.create方法的参数类型来选择合适的构造函数。