Java8 Stream

簡單認識Java stream

Java8出了一個stream流式編程，在開發中或多或少用到接觸過，怎么說呢！舉個例子把，一起我們在遍歷一個集合的時候，我們是從外部去遍歷的，然后才能拿到結果，這樣來效率就會變得相對低一點，而這個時候我們去內部去遍歷集合的時候，直接從內部拿資料，減少資源消耗，提升效率，

什么是stream呢？

Stream它并不是一個容器，它只是對容器的功能進行了增強，添加了很多便利的操作,例如查找、過濾、分組、排序等一系列的操作，并且有串行、并行兩種執行模式，并行模式充分的利用了多核處理器的優勢，使用fork/join框架進行了任務拆分，同時提高了執行速度，簡而言之，Stream就是提供了一種高效且易于使用的處理資料的方式，

首先我們來看下簡單的一個執行流程

從這簡單的圖可以看出，總共就只有三步，相對來說還是比較容易接受，第一步是創建stream這個容器，然后再從這個集合或者陣列中去獲取這個流，第二步則是一些中間操作，比如對資料進行處理啊，第三步則就是手機我們處理的資料，

例：

public class Stream {

    public static void main(String[] args) {
        list();//傳統for遍歷
        bigForList();//增強for遍歷
        iteratorList();//使用迭代器iterator遍歷
      
    }

    private static void list(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        int i;
        int size;
        for (i=0,size=list.size(); i<size; i++){
            Integer integer = list.get(i);
            System.out.println(integer);
        }

    }
    private static void bigForList(){
        List<String > arrlist = new ArrayList<>();
        arrlist.add("張三");
        arrlist.add("李四");
        arrlist.add("王二");
        for (String list :arrlist){
            System.out.println(list);
        }
    }
    private static void iteratorList(){
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("demo");
        list.add("test");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
    }
  

以上就是我們我們之前常用的三種遍歷方式，可能大家更加傾向于這三種，因為我們在平時開發中或者自己練習的時候，用的比較多，也就慢慢就接受了，但是如果資料量一大？大量資料進行遍歷的時候那個這效率，就變得低起來了，所以，steam就出來了，首先我們看看code：

//look code
public static void main (String[] args){
        List<String> sList = Arrays.asList("zhangsan","heqing","lisi","...");
          //創建順序流
        java.util.stream.Stream<String> stream = sList.stream();
        //創建并接流
        java.util.stream.Stream<String> stringStream = sList.parallelStream();
        stream.forEach(System.out::println);
    }
    //Arrays.asList
    //stream
    //parallelStream
    

stream是順序流，由主執行緒按順序對流執行操作，而parallelStream是并行流，內部以多執行緒并行執行的方式對流進行操作，需要注意使用并行流的前提是流中的資料處理沒有順序要求（會亂序，即使用了forEachOrdered），

當然我們也可以去創建一個順序流

//look code
public static void main (String[] args){
        List<Integer> sList = Arrays.asList(1,2,3,4,5);
        //把順序流通過.parallel()轉化為并行流
        Optional<Integer> findFirst = sList.stream().parallel().filter(x->x>5).findFirst();
          //創建順序流
        java.util.stream.Stream<String> stream = sList.stream();
        //創建并接流
        java.util.stream.Stream<String> stringStream = sList.parallelStream();
        stream.forEach(System.out::println);
    }

在stream中提供了很多方法比如filter；
在以前我們要去一個集合或者陣列中篩選我們想要的資料，還要進行一系列的操作，首先創建陣列或者集合，然后遍歷 然后判斷，然后寫邏輯等等，，，很麻煩

  public static void main(String [] args){
	List list= new ArrayList<>();
	list.add();
	....
	for(){
	....
	....
	...
	邏輯代碼等，，，，

	}		
}

但是如果用到了stream后就沒不會有這么判斷條件，切代碼量小了，效率高了，誰又不想少寫代碼呢？早點下班不香嗎？
廢話不多說，look code；

 public static void main(String[] args){
        List<Integer> list = Arrays.asList(1,2,3,4,5,52,46,48,0,12);
        java.util.stream.Stream<Integer> stream= list.stream();
        //通過filter過濾去，獲取list中大于12的資料
        stream.filter(x -> x > 12).forEach(System.out::println);
    }
    //就三行代碼完成，如果按照以前的寫法，起碼10行把！
    
    

還有映射 map、flatMap等
look code

map：一個元素型別為 T 的流轉換成元素型別為 R 的流，這個方法傳入一個Function的函式式介面，接收一個泛型T，回傳泛型R，map函式的定義，回傳的流，表示的泛型是R物件；

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

 public static void main(String [] args) {
    Stream.of("張三:20").map(s -> {
        String[] str = s.split(":");
        Person person = new Person(str[0],Integer.valueOf(str[1]));
        return person;
    }).forEach(Person -> System.out.println(Person));
    }

flatMap：接收一個函式作為引數，將流中的每個值都換成另一個流，然后把所有流連接成一個流，
look code

    public static void main(String [] args) {
        List<String> list = Arrays.asList("k,l,s,x,z","1,5,2,4,8");
        List<String> newList = list.stream().flatMap(s -> {
            String[] str = s.split(",");
            Stream<String> stream = Arrays.stream(str);
            return stream;
        }).collect(Collectors.toList());
        System.out.println("處理前的集合"+list);
        System.out.println("處理后的集合"+newList);
    }

總之呢，stream給我們提供了非常大的幫助，只要能夠熟練使用的話，確實能夠加速開發效率，就會覺得原來寫代碼居然是那么好玩，easy啦，據說stream加lamda運算式寫的代碼簡直就是像詩一樣優美，不過我不知道什么是美，反正lamda用著挺不習慣的，
最后：各位看客老爺萬福金安啊，一波三聯可以嗎？可以嗎？