黑马教程强化day2-3

一、Steam流

1.定义

JDK8开始新增的一套API，可以用来操作集合或者数组的数据。
优势：Stream流大量的结合了Lambda的语法风格来编程，功能强大，性能高效，代码间接，可读性好。

2.Stream流的使用步骤

• 1.获取数据流：代表一条流水线，并能与数据源建立连接。
• 2.调用流水线的各种方法：对数据进行处理、计算
• 3.获取处理的结果：遍历、统计、收集到一个新集合中返回。

代码演示：

package com.item.deom3Stream;

import java.util.*;
import java.util.stream.Collectors;
public class Streamdemo1 {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张翠山");
        list.add("张强");
        //1.用传统方案，找出姓张的人，名字为3个字的，存入到一个新集合中去。
        List<String> newList=new ArrayList<>();
        for(String name:list){
            if(name.startsWith("张")&&name.length()==3){//startsWith()判断字符串开头
                newList.add(name);
            }
        }
        System.out.println(newList);//[张无忌, 张三丰, 张翠山]
        //2.用Stream流方案，找出姓张的人，名字为3个字的，存入到一个新集合中去。一个一个条件的过滤，然后收集。
        List<String> newList2=list.stream().filter(name->name.startsWith("张")).filter(s->s.length()==3).collect(Collectors.toList());//可以理解传送带，一个一个放上去
        System.out.println(newList2);//[张无忌, 张三丰, 张翠山]
    }
}

3.获取Stream流：

获取集合的Stream流：

• default Stream stream() :获取当前集合对象的Stram流。

获取数组的Stream流：

• public static Stream stream(T[] array):获取当前数据的Stream流。
• public static Stream of(T…valuese)：获取当前接受数据的Stream流。

代码演示：

package com.item.deom3Stream;
import java.util.ArrayList;
import java.util.*;
import java.util.stream.Stream;
public class Streamdemo2 {
    public static void main(String[] args) {
        //1.获取集合的Stream流
        Collection<String> list=new ArrayList<>();
        Stream<String> s1=list.stream();
        //2.获取Map集合的Stream流
        Map<String,String> map=new HashMap<>();
        //map.stream();会报错，不行。
        //获取键流
        Stream<String> s2=map.keySet().stream();
        //获取值流
        Stream<String> s3=map.values().stream();
        //获取键值对流
        Stream<Map.Entry<String, String>> s4=map.entrySet().stream();
        //3.获取数组的Stream流
        String[] arr={"张三","王五","叠山","李斯"};
        Stream<String> s5=Arrays.stream(arr);
        System.out.println(s5.count());//4
        Stream<String> s6=Stream.of(arr);
        Stream<String> s7=Stream.of("张三","王五","叠山","李斯");
        System.out.println(s7.count());//4
        System.out.println(s6.count());//4

    }
}

4.中间方法

定义：指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）
常用：

• filter(Predicate p)：过滤流中的元素，返回满足条件的元素
• limit(long maxSize)：截取流中的元素，返回截取后的新流
• skip(long n)：跳过指定数量的元素，返回剩余的元素
• distinct()：去重，返回去重后的新流
• map(Function f)：映射，返回一个新流，通过指定的函数对元素进行转换
• sorted()：排序，返回一个新流，通过比较器对元素进行排序
• concat(Stream a,Stream b)：连接两个流，返回一个新流

代码演示：

package com.item.deom3Stream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class Streamdemo3 {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张翠山");
        list.add("张强");
        //1.过滤方法filter
        list.stream().filter(name->name.startsWith("张")&&name.length()==3).forEach(s->System.out.println(s));
        System.out.println("==========");
        //2.排序方法sorted
        List<Double> scores =new ArrayList<>();
        scores.add(99.9);
        scores.add(66.6);
        scores.add(77.7);
        scores.add(55.5);
        scores.add(99.9);
        scores.add(99.9);
        scores.stream().sorted().forEach(s->System.out.println(s));//默认升序
        System.out.println("==========");
        scores.stream().sorted((s1,s2)->Double.compare(s2,s1)).forEach(s->System.out.println(s));//降序
        System.out.println("==========");
        scores.stream().sorted((s1,s2)->Double.compare(s2,s1)).limit(2).forEach(s->System.out.println(s));//只要前2名
        System.out.println("==========");
        scores.stream().sorted((s1,s2)->Double.compare(s2,s1)).skip(2).forEach(s->System.out.println(s));//跳过前2名
        //3.去重方法distinct
        scores.stream().distinct().forEach(s->System.out.println(s));
        System.out.println("==========");
        //4.映射方法map：把流上原来的数据拿出来变成新的数据有放到流上去。
        scores.stream().map(s->"加10分后："+(s+10)).forEach(s->System.out.println(s));
        //5.合并方法concat
        Stream<String> s1= Stream.of("张无忌","周芷若");
        Stream<Integer> s2=Stream.of(11,12);
        Stream<Object> concat=Stream.concat(s1,s2);
    }
}

5.常用终结方法

常用：

• void forEach(Consumer action):对此流运算后的元素执行遍历
• long count():返回此流中的元素数
• Optional max(Comparator<? super T> comparator):返回此流中的最大元素
• Optional min(Comparator<? super T> comparator):返回此流中的最小元素

6.收集Stream流

收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。
Stream流：方便操作集合/数组的手段；集合/数组：才是开发中的目的。
收集Stream提供的常用终结方法：

• R collect(Collector collector)：把流处理后结果收集到一个指定的集合中去。
• Object[] toArray() :把流处理后的结果收集到一个数组中去。

Collectors工具类提供了具体的收集方式：

• public static Collector toList():把元素收集到List集合中。
• public static Collector toSet():把元素收集到Set集合中。
• public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中。

代码演示（5，6）：

主类代码

package com.item.deom3Stream;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Streamdemo4 {
    public static void main(String[] args) {
        List<Teacher> teachers =new ArrayList<>();
        teachers.add(new Teacher("小王", 18,3245.2));
        teachers.add(new Teacher("小李", 19,3345.3));
        teachers.add(new Teacher("小孙", 20,3609.4));
        teachers.add(new Teacher("小张", 18,2780.3));
        //终结方法一：forEach方法
        teachers.stream().filter(t->t.getAge()>18).forEach(System.out::println);
        System.out.println("======");
        //终结方法二：count方法
        long count =teachers.stream().filter(t->t.getAge()>18).count();
        System.out.println(count);
        System.out.println("======");
        //终结方法三、max方法
        Optional<Teacher> max=teachers.stream().max((t1,t2)->Double.compare(t1.getSalary(),t2.getSalary()));
        Teacher  maxteacher=max.get();//获取Optional对象中的数据
        System.out.println(maxteacher);
        //终结方法四、min方法
        Optional<Teacher> min=teachers.stream().min((t1,t2)->Double.compare(t1.getSalary(),t2.getSalary()));
        Teacher  mintacher=min.get();//获取Optional对象中的数据
        System.out.println(mintacher);
        System.out.println("-----------------");
        List<String> list =new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张翠山");
        list.add("张强");
        //流只能收集一次
        //收集到集合或者数组中去
        Stream<String> s1=list.stream().filter(name->name.startsWith("张"));
        //收集到List集合中
        List<String> list1=s1.collect(Collectors.toList());
        System.out.println(list1);
        System.out.println("========");
        //收集到Set集合中
        /*Set<String> set=s1.collect(Collectors.toSet());
        System.out.println(set);//这样会报错*/
        Stream<String> s2=list.stream().filter(name->name.startsWith("张"));
        Set<String> set=s2.collect(Collectors.toSet());
        System.out.println(set);
        System.out.println("========");
        //收集到数组中
        Stream<String> s3=list.stream().filter(name->name.startsWith("张"));
        Object[] array=s3.toArray();
        System.out.println(Arrays.toString(array));
        System.out.println("========");
        //收集到Map集合
        Stream<Teacher> s4=teachers.stream();
        //键是老师，值是老师名称
        Map<String,Double> map=s4.collect(Collectors.toMap(new Function<Teacher,String>() {
            @Override
            public String apply(Teacher teacher) {
                return teacher.getName();
            }
        },  new Function<Teacher, Double>() {
            @Override
            public Double apply(Teacher teacher) {
                return teacher.getSalary();
            }
        }));
        System.out.println(map);
        //优化
        //Map<String,Double> map=s4.collect(Collectors.toMap(Teacher::getName, Teacher::getSalary));
        System.out.println(map);
    }
}

Teacher类代码：

package com.item.deom3Stream;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;
    private double salary;

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}'+"\n";
    }
    //解决方法1：重写方法，比较两个对象的大小
    @Override
    public int compareTo(Teacher o) {
        //按照年龄升序
        return this.getAge()-o.getAge();
    }
}

7.方法中可变参数

定义：就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型。。。参数名称；
可变参数特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
可变参数好处：常常用来灵活的接受数据。
注意事项：

• 1.可变参数在方法内就是一个数组。
• 2.一个形参列表中可变参数只能有一个。
• 3.可变参数必须放在形参列表的最后面。

8.Collections工具类

定义：是一个用来操作集合的工具类。
Collections提供的常用静态方法：

• public static boolean addAll(Collection<? super T>,c,T…elements：给集合批量添加元素。
• public static void shuffle(List<?> lsit)：打乱List集合元素的顺序。
• public static void sort(List list)：对List集合元素进行升序排序。
• public static void sort(List list,Comparator<? super T> c)：对list集合中元素，按照比较器对象指定的规则进行排序。

代码演示（7，8）：

package com.item.deom3Stream;
import java.util.Arrays;
import java.util.stream.Stream;
import java.util.*;
public class Streamdemo5 {
    public static void main(String[] args) {
        sum();
        sum(10);
        sum(10,20,30,40);
        sum(new int[]{11,20,30,50});
        //优势：接受参数很灵活，可以替代数组传参。
        System.out.println("===========");
        List<String> list=new ArrayList<>();
        //1.Collections的方法批量加
        Collections.addAll(list, "张三丰", "张翠山", "张无忌", "赵敏", "周芷若");
        System.out.println(list);
        //2.Collections集合的方法打乱顺序
        Collections.shuffle(list);
        System.out.println(list);

    }
    public static void sum(int... a) {
        //内部怎么拿数据
        //可变参数对内实际上就是一个数组，nums就是数组。
        System.out.println(a.length);
        System.out.println(Arrays.toString(a));
        System.out.println("========");
    }
}