Stream流的学习

1.1、体验Stream流

package com.itheima01;

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
//       创建一个集合，存储姓名
        ArrayList<String> array=new ArrayList<>();
        array.add("张伯伦");
        array.add("梁朝伟");
        array.add("张继科");
        array.add("张浩");
        array.add("田云");
        array.add("老铁");
        array.add("老王");
        array.stream().filter(s->s.startsWith("张")).filter(s->s.length()>=3).forEach(s-> System.out.println("姓张的三个字的名字有："+s));
    }

}

1.2、Stream流的生成方式

Collection体系的集合可以使用默认方法stream()生成流
            default Stream<E>stream()
Map体系的集合间接的生成流
数组可以通过Stream接口的静态方法of(T...values)生成流

package com.itheima02;
/*
Collection体系的集合可以使用默认方法stream()生成流
    default Stream<E>stream()
Map体系的集合间接的生成流
数组可以通过Stream接口的静态方法of(T...values)生成流
*/


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

public class StreamDemo {
    public static void main(String[] args) {
//        Collection体系的集合可以使用默认方法stream()生成流
//        default Stream<E>stream()
        List<String> list = new ArrayList<>();
        Stream<String> ListStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();
//        Map体系的集合间接的生成流
        Map<String, Integer> map = new HashMap<String, Integer>();

        Set<String> keyset = map.keySet();
        Stream<String> keysetStream = keyset.stream();
//        Integer value = map.get(keyset);
        Collection<Integer> v = map.values();
        Stream<Integer> iStream = v.stream();

        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> vStream = map.values().stream();


        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Stream<Map.Entry<String, Integer>> entryStream = entry.stream();
//        数组可以通过Stream接口的静态方法of(T...values)生成流
        String[] strArray = {"hello", "world", "java"};
        Stream<String> strArrayStream=Stream.of(strArray);

        Stream<String> sStream=Stream.of("hello","world","java");

    }
}

Stream常见的方法：

limit()返回指定长度的流的元素

skip()

package com.itheima01;

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
//       创建一个集合，存储姓名
        ArrayList<String> array=new ArrayList<>();
        array.add("张伯伦");
        array.add("梁朝伟");
        array.add("张继科");
        array.add("张浩");
        array.add("田云");
        array.add("老铁");
        array.add("老王");
//        array.stream().filter(s->s.startsWith("张")).filter(s->s.length()>=3).forEach(s-> System.out.println("姓张的三个字的名字有："+s));
//        Stream<T> limit(long maxSize)返回此流中的元素组成的流，截取指定的参数个数的数据
        array.stream().limit(2).forEach(System.out::println);
//        Stream<T> skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的
        System.out.println("-------跳过指定参数个数的数据，返回由该流的剩余元素组成的-----");
        array.stream().skip(3).forEach(System.out::println);


    }

}

1.3、Stream常见的中间操作方法

Stream<T> filter(Predicate predicate) 用于对流中的数据进行过滤

        Predicate接口的中方法              boolean test（T t）对给定的参数进行判断，返回一个布尔值

Stream<T> limit(long maxSize)      返回此流中的元素组成的流，截取前指定参数个数的数据 

Stream<T> skip(long n)         跳过指定参数个数的数据，返回由该流的剩余元素组成的流

static<T>Stream<T> concat(Stream a,Stream b)合并a和b两个流为一个流 

Stream<T> distinct() 返回由该流的不同元素（根据Object.equals(Object)）组成的流

Stream<T> sorted() 返回由此流的元素组成的流，根据自然顺序排序

Stream<T> sorted(Comparator Comparator) 返回由该流的元素组成的流，根据提供的Comparator进行排序 

package com.itheima03;

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

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("科比");
        list.add("詹姆斯");
        list.add("杜兰特");
        list.add("欧文");
        list.add("哈登");
        list.add("乔治");
        list.add("小卡");
        list.add("库里");
        list.add("戴维斯");
//        使用filter()过滤
list.stream().filter(s->s.startsWith("小")).forEach(s->System.out.println(s));
//        需求1：截取4个数据组成一个流
        Stream<String> s1=list.stream().limit(4);
//        需求2：跳过2个数据组成一个流
        Stream<String> s2=list.stream().skip(2);
        System.out.println("————————————合并两个流——————————————————————");
//        需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1,s2).forEach(System.out::println);
//        需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);




    }
}

package com.itheima03;

import java.util.ArrayList;
//Stream<T> sorted() 返回由此流的元素组成的流，根据自然顺序排序
//Stream<T> sorted(Comparator Comparator) 返回由该流的元素组成的流，根据提供的Comparator进行排序 
public class StreamDemo02 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("kobe");
        list.add("jans");
        list.add("rose");
        list.add("harden");
        list.add("ads");
        list.add("kill");
        list.add("cuer");
//        需求1：按照字母顺序把数据在控制台输出
//        list.stream().sorted().forEach(s->System.out.println(s));
//        list.stream().sorted().forEach(System.out::println);
//需求2：按照字符串长度把数据在控制台输出
//     字符串短的排前面   list.stream().sorted((s1,s2)->-s1.length()-s2.length()).forEach(System.out::println);
          list.stream().sorted((s1,s2) ->{
              int num=s1.length()-s2.length();
              int num2=num==0?s1.compareTo(s2):num;
              return num2;
          }).forEach(System.out::println);

    }
}

<R>Stream<R> map(Function mapper) 返回由给定函数应用于此流的元素的结果组成的流

                Function接口中的方法                R apply(T t)

IntStream map ToInt(ToIntFunction tion mapper) 返回一个IntStream其中包含将给定函数应用于此流的元素结果

                IntStream表示原始int流

                ToIntFunction 接口中的方法      int applyAsInt(T value)

1.4、Stream流的常见终结操作

void forEach(Consumer action) 对此流的每个元素执行操作

        Consumer接口的方法                void acceopt(T t)对给定的参数执行此操作

long count()返回此流中的元素数

package com.itheima03;

import java.util.ArrayList;

public class StreamDemo04 {
    public static void main(String[] args) {
//       创建一个集合，存储姓名
        ArrayList<String> array=new ArrayList<>();
        array.add("张伯伦");
        array.add("梁朝伟");
        array.add("张继科");
        array.add("张浩");
        array.add("田云");
        array.add("老铁");
        array.add("老王");
//需求1：把集合中元素在控制台输出
        long countZhangName = array.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(countZhangName);
    }

}