java8--stream

java8-stream

Stream API

• Stream API
  • 创建Stream
  • filter、map和flatMap方法
  • limit()、skip()和concat():提取子流和组合流
  • distinct()、Sorted():有状态转换
  • 聚合方法–终止流操作
  • Optional类型
  • 原始流类型
  • 并行流

Stream 是java8中处理集合的关键抽象概念，他可以制定你希望对集合进行的操作，但是将执行操作的时间交给具体实现来决定。

要点

• 可以从集合、数组、生成器或者迭代器中创建Stream。
• 使用filter来选择元素，使用map来改变元素。
• 其他改变Stream的操作包括limit、distinct、sorted。
• 要从Stream中获得结果，请使用reduction操作符，例如count、max、min、findFirst或findAny、其中一些方法会返回一个Optional值。
• Optional类型的目的是为了安全的替代使用null值。要想安全的使用，需要借助ifPresent和orElse方法。
• 可以收集集合、数组、字符串或map中的Stream结果。
• Collectors类的groupingBy和partitioningBy允许对Stream中的内容分组，并获取每个组的结果。
• java8对原始类型int、long和double提供了专门的Stream。
• 当使用并行Stream时，请确保不带有副作用，并考虑放弃排序约束。

---

Stream Example:

    @Test//*不使用Stream的方法*
    public void testCount(){
        List<String> words = getWords();
        int count = 0;
        for (String w: words) {
            if(w.length()>10)count++;
        }
        System.out.println(count);
    }
    @Test//*使用Stream*
    public void testStream(){
        List<String> words = getWords();
        long count=0;
        count =words.stream().filter(w->w.length()>10).count();
        System.out.println(count);
    }
    public List<String> getWords(){
        List<String> words = new ArrayList<String>();
        for (int i = 0; i < 20; i++) {
            words.add("aaabbbccc"+i);
        }
        return words;
    }

可以看出来Stream给我们带来了很大的方便性和可读性
当使用Stream时，通过三个阶段来建立一个操作流水线
1. 创建一个Stream
2. 在一个或多个步骤中，制定将初始Stream转换为另一个Stream的中间操作。
3. 使用一个终止操作来产生一个结果。该操作会强制他之前的延迟操作立即执行。在这之后，该Stream就不会在被使用了。

创建Stream

java8在Collection接口中添加了stream方法，可以将任何一个集合转化为一个Stream。

    Stream<String> words = Stream.of(contents.split(","));
    //split方法返回一个String[]数组
    //of方法接受可变长度的参数,因此可以构造一个含有任何个参数的Stream
    Stream<String> words = Stream.of("hello","world","java8","lambda");

使用Arrays.stream(array,from,to)方法将数组的一部分转化为Stream
如果要创建一个不含任何元素的Stream，可以使用静态的Stream.empty方法：

Stream<String> words = Stream.empty();

Stream接口有两个用来创建无限Stream的静态方法。generate方法接受一个无参函数，

    @Test
    public void testInit(){
        Stream<String> echos = Stream.generate(()->"Echo");
        Stream<Double> randoms= Stream.generate(Math::random);
    }

Java8中添加了许多能够产生Stream的方法。比如 Pattern类添加了一个splitAsStream方法。

Stream<String> words = Pattern.complie(",").splitAsStream(contents);

filter、map和flatMap方法

• filter方法的参数是一个Predicate对象–即一个从T到boolean的函数。
  

  Stream<String> words = getWords().stream().filter(w->w.length()>10);
  

• 当对一个流中的值进行某种转换时，使用map方法。
  

  //将单词转换为大写
  Stream<String> words = getWords().stream().map(String::toUpperCase);
  //获得单词的第一个字母
  Stream<Character> wordsFirstChar = getWords().stream().map(s->s.charAt(0));
  

• flatMap
  

      @Test
      public void testMapAndFlatMap(){
          Stream<Stream<Character>> chars = getWords().stream().map(w->getCharacter(w));
          //这里可以用flatMap
          //flatMap 会对每个对象调用getCharacter()方法，并展开结果
          Stream<Character> charss=getWords().stream().flatMap(w->getCharacter(w));
      }
      public Stream<Character> getCharacter(String s){
          List<Character> chars = new ArrayList<Character>();
          for (char c: s.toCharArray()) {
              chars.add(c);
          }
          return chars.stream();
      }
  

limit()、skip()和concat():提取子流和组合流

• Stream.limit(n)会返回一个包含n个元素的新流如果原始流长度小于n，则返回原始流
  

  //返回1个具有100个随机数的流
  Stream<Double> randoms100 = Stream.generate(Math::random).limit(100);
  

• Stream.skip(n)会跳过n个元素。
  

  //跳过第一个单词组成流
  Stream<String> wordsWithoutFirst = getWords().stream().skip(1);
  System.out.println(wordsWithoutFirst.count());//打印为 19  略过了第一个元素
  

• Stream.concat() 静态方法。合并两个流。
  合并流的第一个应该为无限状态
  

      Stream<String> total = Stream.concat(getWords().stream().skip(10), getWords().stream());
      System.out.println(total.count());
  

distinct()、Sorted():有状态转换

上面的流转换都是无状态的。也就是获得的结果不依赖前面的元素。java8也提供了有状态的转换。例如distinct()
distinct()方法需要记录已存储的单词。然后判断重复及是否添加

    Stream<String> unique = Arrays.asList("todo","todo","todo","today").stream().distinct();
    System.out.println(unique.count());//2

sorted方法排序必须遍历整个流。并在产生任何元素之前对他进行排序。

    Stream<String> sortWords = getWords().stream().sorted(Comparator.comparing(String::length).reversed());

Collections.sort方法会对原有集合进行排序，Stream.sorted方法会返回一个新的已排序的流;

聚合方法–终止流操作

聚合方法都是终止操作。当一个流应用了终止操作以后，他就不能在进行其他操作了。
聚合方法主要有：count(),max(),min(),findFirst,findAny,allMatch,noneMatch等

    //找到排序最大的单词 min同理
    Optional<String> max = getWords().stream().max(String::compareToIgnoreCase);
    if(max.isPresent()){
        System.out.println(max.get());
    }
    //找到所有的以a开头的单词
    Optional<String> words = getWords().stream().filter(s->s.startsWith("a")).findAny();
    //找到所有的以a开头的第一个单词
    Optional<String> wordFirst = getWords().stream().filter(s->s.startsWith("a")).findFirst();

allMatch,noneMatch分别表示所有元素和没有元素匹配predicate返回true。

Optional类型

• Optional对象或者是对一个T类型对象的封装，或表示不是任何对象。他比一般指向T类型的引用更安全，因为他不会返回null–但也是在正确的使用前提下。
  如果存在被封装的对象，那么 get方法会返回该对象，否则会抛出一个NoSuchElementException.所以，可以用isPresend()来判断一下。
  

      Optional<String> max = getWords().stream().max(String::compareToIgnoreCase);
          if(max.isPresent()){
              //do something
          }
  

• 高效使用Optional的关键在于，使用一个或接受正确值、或者返回另一个替代值的方法
  

  String result = max.orElse("");
  

  
  如果没有值则用“”替代。
  此外orElse还有两个方法
  orElseGet(Lambda):可以调用代码计算值
  orElseThrow(Exception):抛出异常
• 创建optional
  利用Optional的静态方法可以创建对象，比如Optional.of(result)或者Optional.empty();
  ofNullable(obj)方法会跟据obj的值来进行创建optional，如果obj==null，那么这个方法间接等于Optional.empty(),
  如果obj！=null 那么 间接等于Optional.of(obj);
  +收集结果
  可以通过iterator方法生成一个迭代器，用来访问结果的元素，或者使用stream.toArray()，他会返回一个Object[]数组。如果想获得具体类型的。
  可以把类型传递给数组的构造函数
  

  String[] result = words.toArray(String[]::new);
  

  
  如果要把结果收集到一个HashSet中，如果这个过程是并行的，那么不能将元素放到一个单独的Hashset中，因为HashSet不是线程安全的。所以要使用collect方法，他接受三个参数
  1. 一个能创建目标类型实例的方法，例如hashset的构造函数。
  2. 一个江元素添加到目标中的方法，例如一个add方法。
  3. 一个将两个对象整合到一起的方法，例如addALl方法。
  

  HashSet<String> result = stream.collect(HashSet::new,HashSet::add,HashSet::addAll);
  

  
  在实际中，通常不需要这么做，因为Collector借口已经提供了这三个方法，
  

  List<String> result = getWords().stream().collect(Collectors.toList());
  List<String> result = getWords().stream().collect(Collectors.toSet());
  TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet::new));
  

  
  Collectors还有许多方法，可以自己去看一下api

原始流类型

主要有IntStream、DoubleStream、LongStream等。
IntStream:short、char、byte、boolean
DoubleStream：float
LongStream:long

IntStream intStream = IntStream.of(1,2,3,4);
intStream = Arrays.stream(value,from,to);  //value 为一个int[]数组

• 原始流和对象流转换

当有一个对象流的时候，可以通过mapToInt、mapToLong或者mapToDouble方法将他们转换为一个原始流。

Stream<String> words = getWords();
IntStream length = words.mapToInt(String::length);

将一个原始流转换为对象流时，可以使用boxed方法。

Stream<Integer> integers = IntStream.range(0,100).boxed();

并行流

默认情况下，流操作会创建一个串行流,方法Collection.parallelStream()除外。parallel方法可以将任意一个串行流变为一个并行流。

Stream<String> words = getWords().stream().parallel();

只要在终止方法执行时，流处于并行模式，那么所有的延迟执行的流操作就都会被并行执行。
当并行运行流时，他应返回与串行运行时相同的结果。这些操作都是无状态的，因此可以以任意顺序被执行
下面是一个反例，用来提示不应该这么做，假设你需要绩一个字符串流中所有短单词的总数：

        int[] shortWords = new int[11];
        Stream<String> words = Arrays.asList("java","c++","javac","eclipse","tomcat","helloworld").stream();
        words.parallel().forEach(s->{if(s.length()<5)shortWords[s.length()]++;});
        System.out.println(Arrays.toString(shortWords));

传递给foreach的函数会在多个线程中并发运行，来更新一个共享数组，这是一个经典的条件竞争。如果多运行几次，很有可能会得到不同的总数，并且没有一个是对的。
使用并行流操作的函数都应该是线程安全的。

当执行一个流(串行和并行)操作时，并不会修改流底层的集合，流不会收集他自己的数据–这些数据总是存在另一个集合中。如果想要修改原有的集合，那么就无法定义流操作的输出。

下面这么做是可以的。

List<String> words = ...;
Stream<String> wordStream=words.stream();
words.add("end");
long n  = wordStream.distinct().count();

下面是不可以的，因为干扰了原集合

Stream<String> wordStream = words.stream();
wordStream.forEach(s->if(s.length<12)words.remove(s));