java8

stream

    public static void main(String[] args) {
        List<String> strs = new ArrayList<String>();
        strs.add("1  张三  123");
        strs.add("2 张2  234");
        strs.add("2 张5  234");
        strs.add("2 李2  234");
        Stream<String> stream = strs.stream();
        //遍历
        //stream.forEach( s -> System.out.println(s));
        stream.forEach(System.out:: println);
    }

flatMap

List<String> strs = new ArrayList<String>();
strs.add("1  张三  123");
strs.add("2 张2  234");
strs.add("2 张5  234");
strs.add("2 李2  234");

Stream<String> stream = strs.stream();

stream.flatMap(a ->{
    List<String> list = Arrays.asList(a.split("\\s+"));
    return  list.stream();
}).forEach(a -> System.out.println(a));

flatMapToInt

List<String> list = new ArrayList<>();
list.add("1 2 3");
list.add("4 5 6");
IntStream intStream1 = list.stream().flatMapToInt(element -> {
    String[] split = element.split("\\s+");
    IntStream intStream = IntStream.of(Integer.parseInt(split[0]), Integer.parseInt(split[1]), Integer.parseInt(split[2]));
    return intStream;
});
intStream1.forEach(a ->{
    int a1  = a;
    System.out.println(a1);
});

flatMapToDouble

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1 2 3");
    list.add("4 5 6");
    DoubleStream doubleStream = list.stream().flatMapToDouble(element -> {
        String[] split = element.split("\\s+");
        DoubleStream intStream = DoubleStream.of( Double.parseDouble(split[0]),  Double.parseDouble(split[1]),  Double.parseDouble(split[2]));
        return intStream;
    });
    doubleStream.forEach(a ->{
        double a1  = a;
        System.out.println(a1);
    });
}

flatMapToLong

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1 2 3");
    list.add("4 5 6");
    LongStream LongStream = list.stream().flatMapToLong(element -> {
        String[] split = element.split("\\s+");
        LongStream longStream = java.util.stream.LongStream.of(Long.parseLong(split[0]), Long.parseLong(split[1]), Long.parseLong(split[2]));
        return longStream;
    });
    LongStream.forEach(a ->{
        Long a1  = a;
        System.out.println(a1);
    });
}

filter

List<String> strs = new ArrayList<String>();
strs.add("1  张三  123");
strs.add("2 张2  234");
strs.add("2 张5  234");
strs.add("2 李2  234");
Stream<String> stream = strs.stream();
//过滤
stream.filter(a -> a.split("\\s+")[1].indexOf("张")!=-1).forEach(a -> System.out.println(a));

map

public static void main(String[] args) {
    List<String> strs = new ArrayList<String>();
    strs.add("1  张三  123");
    strs.add("2 张2  234");
    strs.add("2 张5  234");
    strs.add("2 李2  234");
    Stream<String> stream = strs.stream();
    //转换
    stream.map(a -> {
        String[] split = a.split("\\s+");
        String id =  split[0];
        String username =  split[1];
        String password =  split[2];
        Map<String,String> map =  new HashMap<String,String>();
        map.put("id",id);
        map.put("username",username);
        map.put("password",password);
        return map;
    }).forEach(map -> System.out.println(map));

}

limit

public static void main(String[] args) {
    List<String> strs = new ArrayList<String>();
    strs.add("1  张三  123");
    strs.add("2 张2  234");
    strs.add("2 张5  234");
    strs.add("2 李2  234");
    Stream<String> stream = strs.stream();
    
    //输出前两条数据
    stream.limit(2).forEach( a -> System.out.println(a));
}

排序

public static void main(String[] args) {
    List<Integer> strs = new ArrayList<Integer>();
    strs.add(9);
    strs.add(5);
    strs.add(3);
    strs.add(11);
    Stream<Integer> stream = strs.stream();
    //从小到大排序
    stream.sorted().forEach(a -> System.out.println(a));
}

排序

    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(4);
        list.add(9);
        list.add(6);
        list.add(2);
        list.add(7);
        list.stream().sorted((a,b) -> b-a ).forEach(e->{
            System.out.println(e);
        });
    }

两个冒号用法

案例1：

package com;
import java.util.*;
public class Java8StreamUse {
    public static void main(String[] args) {
        List<String> al = Arrays.asList("a", "b", "c", "d");
        al.forEach(Java8StreamUse::printValue);
    }
    public static void  printValue(String str){
        System.out.println("print value : "+str);
    }
}

案例2：

public static void main(String[] args) {
    List<String> strs = new ArrayList<String>();
    strs.add("1  张三  123");
    strs.add("2 张2  234");
    strs.add("2 张5  234");
    strs.add("2 李2  234");
    Stream<String> stream = strs.stream();
    stream.forEach(System.out::println);
}

reduce方法

public static void main(String[] args) {
    Optional<Integer> reduce = Stream.of(1, 2, 3, 4, 5, 6, 7).reduce((a, b) -> a + b);
    Integer integer = reduce.get();
    System.out.println(integer);
}

distinct

public static void main(String[] args) {
    Stream.of(1, 5, 3, 4, 5, 5, 7).distinct().forEach(a -> System.out.println(a));
}

Match

public static void main(String[] args) {
    List<String> strs = Arrays.asList("a", "a", "a", "a", "a");
    boolean aa = strs.stream().anyMatch(str -> str.equals("a")); //只要有a就是true
    boolean bb = strs.stream().allMatch(str -> str.equals("a")); //所有都为a才是true
    boolean cc = strs.stream().noneMatch(str -> str.equals("c")); //全部不为a才是true
    System.out.println(aa);//输出true
    System.out.println(bb);//输出true
    System.out.println(cc);//输出true
}

findFirst

public static void main(String[] args) {
    List<String> strs = Arrays.asList("a1", "a2", "a3", "a4", "a5");
    Optional<String> first = strs.stream().findFirst();
    String s = first.get();
    System.out.println(s);
}

模拟java8 stream的api

MyStream

package com;
import java.util.*;

public class MyStream <T> {

    List<T> lists  = new ArrayList<>();

    public static class Tuple2<T1,T2>{
        T1 t1;
        T2 t2;
        public Tuple2(T1 t1,T2 t2){
            this.t1=t1;
            this.t2=t2;
        }

        @Override
        public String toString() {
            return "("+t1+","+t2+")";
        }
    }

    static interface ForEachFunction<T>{
        void execute(T t);
    }

    static interface MapCallback<SRCT,DISTT>{
        DISTT execute(SRCT t);
    }


    static interface FilterFunction<T>{
        boolean filter(T t);
    }

    static interface   FlatMapFunction <T>{
        List<T> callback(T t);
    }

    public static interface ReduceByKeyFunction<T2>{
      public T2 callback(T2 a,T2 b);
    }

    public static interface GroupByKeyFunction<T2>{
        public Object callback(List<T2> values);
    }


    public MyStream <T> initLists(List<T> lists) {
        copylist(lists,this.lists);
        return this;
    }

    public <SRCT,DIST> void copylist(List<SRCT> src,List<DIST> dist){
        //清空src
        dist.clear();
         for(SRCT t: src){
             dist.add((DIST)t);
         }
    }





   public void forech(ForEachFunction<T> callbanck){
         for(T element: lists){
             callbanck.execute(element);
         }
    }



    public MyStream <T> filter(FilterFunction<T> filterFunction){
      List<T> list = new ArrayList<>();
         for(T t: lists){
            boolean b =  filterFunction.filter(t);
            if(b){
                list.add(t);
            }
         }
        this.copylist(list,lists);
        return this;
    }



    public <DISTT> MyStream <DISTT> map(MapCallback<T,DISTT> mapCallback){
        List<DISTT> list2 = new ArrayList<DISTT>();
        for(T element: lists){
            list2.add((DISTT) mapCallback.execute(element));
        }
        copylist(list2,this.lists);
        return (MyStream<DISTT>) this;
    }


    public  MyStream <T> flatMap(FlatMapFunction<T> flatMapFunction){
        List<T> list2 = new ArrayList<T>();
          for(T t: lists){
              List<T> ts =  flatMapFunction.callback(t);
              for(T t2 :ts){
                  list2.add(t2);
              }
          }
          this.copylist(list2,this.lists);
        return this;
    }


    public<T1,T2> MyStream<T>  reduceByKey(ReduceByKeyFunction<T2> reduceByKeyFunction){


        Map<T1,List<T2>> map = new HashMap<>();
        for(T t: lists){
            Tuple2<T1,T2> tuple2 = (Tuple2<T1,T2>)t;
             T1 t1 =  tuple2.t1;
             T2 t2 =  tuple2.t2;
             List<T2> values = map.get(t1);
             if(values==null){
                 ArrayList<T2> t2s = new ArrayList<>();
                 t2s.add(t2);
                 map.put(t1,t2s);
             }else {
                 values.add(t2);
             }
        }



        Set<T1> t1s = map.keySet();

        List<Tuple2<T1,T2>> reduceResult = new ArrayList<>();
        for(T1 key: t1s){

            List<T2> vlaues = map.get(key);
            T2 t2s = vlaues.get(0);

            for(int i=1;i<vlaues.size();i++){
                T2 t2 = vlaues.get(i);
                t2s =  reduceByKeyFunction.callback(t2s,t2);
            }

            reduceResult.add(new Tuple2<T1,T2>(key,t2s));
        }

          this.copylist(reduceResult,this.lists);
        return this;
    }

    public<T1,T2> MyStream<T>  groupByKey(GroupByKeyFunction<T2> groupByKeyFunction){


        Map<T1,List<T2>> map = new HashMap<>();
        for(T t: lists){
            Tuple2<T1,T2> tuple2 = (Tuple2<T1,T2>)t;
            T1 t1 =  tuple2.t1;
            T2 t2 =  tuple2.t2;
            List<T2> values = map.get(t1);
            if(values==null){
                ArrayList<T2> t2s = new ArrayList<>();
                t2s.add(t2);
                map.put(t1,t2s);
            }else {
                values.add(t2);
            }
        }



        Set<T1> t1s = map.keySet();

        List<Tuple2<T1,Object>> reduceResult = new ArrayList<>();
        for(T1 key: t1s){
            Object value = groupByKeyFunction.callback(map.get(key));
            reduceResult.add(new Tuple2<T1,Object>(key,value));
        }
        this.copylist(reduceResult,this.lists);
        return this;
    }


}

测试类演示

package com;
import java.util.*;
import java.util.stream.Stream;
public class Test {
    public static void main(String[] args) {
        MyStream<String> myStream = new MyStream<String>();
        List<String> list = Arrays.asList("java java", "hello java","java hello kafka");

        MyStream<MyStream.Tuple2<String, Integer>> map = myStream.initLists(list).flatMap(a -> {
            List<String> list1 = Arrays.asList(a.split("\\s+"));
            return list1;
        }).map(a ->  new MyStream.Tuple2<String, Integer>(a, 1));

        MyStream<MyStream.Tuple2<String, Integer>> tuple2MyStream = map.reduceByKey((Integer a, Integer b) -> {
            return a+ b;
        });
        tuple2MyStream.forech(a ->{
            System.out.println(a.t1+"  "+a.t2);
        });

        System.out.println("=================================================");

        map.groupByKey((List<Integer> list1) ->{

            int count = 0;
            for (Integer a: list1){
                count += a;
            }

            return "单词数为： "+count;
        }).forech(a ->{
            System.out.println(a);
        });
    }
}

想了解更多进入： juejin.cn/user/175884…