stream流 lambda 练习

方法引用

 

lambda的方法引用注意super  ，this

super和this   的 引用 ，尤其是this不能调用本身的方法  ，内存溢出。

下面演示一段代码：

 

/**
 * @auther SyntacticSugar
 * @data 2018/9/2 0002下午 11:56
 * 准备1 : Greetable 函数式接口中定义 greet 无参无返回值方法.
 * 准备2 : 父类 Human 与子类 Man.       在子类中定义方法，把接口作为参数传进去
 * <p>
 * 通过   super  来引用
 */
public class Test005 {
    public static void main(String[] args) {
        Man man = new Man();
        man.sayHello();
    }
}

//
interface Greetable {
    void greet();
}

class Human {
    public void say() {
        System.out.println("我是熊大");
    }
}

class Man extends Human {
    public void sayHello(){
      // lambda
        method(()-> System.out.println("大家好"));
        //
        method(()->super.say());//通过super来调用  方法
//
        method(super::say);    //super 的引用写法

        //
        method(this::buy);   //this的  引用写法   迪欧用本类中的方法


    }
    public static void method(Greetable greetable) {
        greetable.greet();
    }
    public   void buy(){
        System.out.println("卖一辆宝马");
    }


}

可以传进去lambda表达式，作为参数、

也可使用lambda的升级版，，方法引用。

 

针对this的运用，引用其成员方法（非自身）。
否则会造成死循环，内存溢出。

package Test02;

import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003下午 9:41
 */
public class Test01 {
    public static void main(String[] args) {
        //1.请在测试类main方法中完成以下需求
        //已知有Integer[] arr = {-12345, 9999, 520, 0,-38,-7758520,941213}
        //a)使用lambda表达式创建 Predicate 对象p1,p1能判断整数是否是自然数(大于等于0)
        //b)使用lambda表达式创建Predicate 对象p2,p2能判断整数的绝对值是否大于100
        //c)使用lambda表达式创建Predicate对象p3,p3能判断整数是否是偶数
        //
        //	遍历arr，仅利用已创建的Predicate对象(不使用任何逻辑运算符)，完成以下需求
        //i.打印自然数的个数
        //ii.打印负整数的个数
        //iii.打印绝对值大于100的偶数的个数
        //iv.打印是负整数或偶数的数的个数


        Integer[] arr = {-12345, 9999, 520, 0, -38, -7758520, 941213};
//        myMethod(arr, (num)->num>=0);
//        sop("-------------------------------");
//        myMethod(arr, (num)->Math.abs(num)>100);
//        sop("-------------------------------");
//        myMethod(arr, (num)->num%2==0);
//        sop("-------------------------------");

        Predicate<Integer> p1 = (s) -> s >= 0;
        Predicate<Integer> p2 = (s) -> Math.abs(s) > 100;
        Predicate<Integer> p3 = (s) -> s % 2 == 0;
        //
        int count1 = 0;
        int count2 = 0;
        int count3 = 0;
        int count4 = 0;//负数的个数

        for (Integer integer : arr) {
            if (p1.test(integer)) {
                count1++;
            }else {
                count4++;
            }
            if (p2.test(integer)) {
                count2++;
            }
            if (p3.test(integer)||!p1.test(integer)) {
                count3++;
            }

        }
           sop(count1);//4
           sop(count4);//3
           sop(count2);//5
           sop(count3);//5


    }

    //    public static void myMethod(Integer[] arr, Predicate<Integer> one) {
//        for (Integer integer : arr) {
//            boolean result = one.test(integer);
//            System.out.println(integer+"判断的结果为："+result);
//        }
//    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

 

 

练习2

package Test02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003下午 10:10
 * <p>
 * default <V> Function<V, R>
 */
public class Test02 {
    public static void main(String[] args) {
        //1.使用lambda表达式分别将以下功能封装到Function对象中
        //a)求Integer类型ArrayList中所有元素的平均数
        //b)将Map<String,Integer>中value存到ArrayList<Integer>中
        //2.已知学生成绩如下
        //姓名	成绩
        //岑小村	59
        //谷天洛	82
        //渣渣辉	98
        //蓝小月	65
        //皮几万	70
        //3.以学生姓名为key成绩为value创建集合并存储数据，使用刚刚创建的Function对象求学生的平均成绩

//        Function<ArrayList<Integer>, Integer> arrayListIntegerFunction = new Function<>();
        Function<ArrayList<Integer>, Integer> p1 = (s) -> {
            int sum = 0;
            for (int i = 0; i < s.size(); i++) {
                sum += s.get(i);
            }
            return sum / s.size();
        };
        //
        Function<Map<String, Integer>, ArrayList<Integer>> p2 = (s) -> {
            Collection<Integer> values = s.values();

            ArrayList<Integer> list = new ArrayList<>();
            for (Integer value : values) {
                list.add(value);
            }
            return list;
        };
        //把信息储存到学生集合中
        Map<String, Integer> map = new HashMap<>();
        map.put( "岑小村",	59);
        map.put( "谷天洛",	82);
        map.put( "渣渣辉",	98);
        map.put( "蓝小月",	65);
        map.put( "皮几万",	70);
        //
        Integer apply = p2.andThen(p1).apply(map);
        System.out.println(apply);

    }


}

 

 

package Test02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 8:59
 */
public class Test03 {
    public static void main(String[] args) {
        //简述单列集合、双列集合、数组分别如何获取Stream流对象，并进行演示
        //数组的并发流  获取

        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        HashMap<String, Integer> map = new HashMap<>();
        Stream<Integer> stream1 = map.values().stream();//value
        Stream<String> stream2 = map.keySet().stream();//key
        Stream<Map.Entry<String, Integer>> stream3 = map.entrySet().stream();//entry   健值对

        //以下为静态   stream.of 的底层实现
        /**public interface Stream<T> extends BaseStream<T, Stream<T>>
         *   //public interface BaseStream<T, S extends BaseStream<T, S>>
         *         extends AutoCloseable -->@return the element spliterator for this stream
         *         返回并发流
         */
        Integer[] integers = {2, 3, 4, 5, 6, 7, 8, 9, 10};
        Stream<Integer> integers1 = Stream.of(integers);//
        integers1.forEach(System.out::print);


        /**以下为Arrays.stream
         *   * @return a {@code Stream} for the array range
         *      返回数组范围的 stream  //return stream(array, 0, array.length);
         */
        Stream<Integer> stream4 = Arrays.stream(integers);
        sop(integers1);//java.util.stream.ReferencePipeline$Head@3834d63f
        sop(stream4);//java.util.stream.ReferencePipeline$Head@1ae369b7



    }


}

 

 

练习4

package Test02;

import java.util.Arrays;
import java.util.stream.Stream;

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 9:24
 */
public class Test04 {
    public static void main(String[] args) {
        //有如下7个元素 "黄药师", "冯蘅", "郭靖", "黄蓉", "郭芙", "郭襄", "郭破虏"
        // 将以郭字开头的元素存入新数组

        /**analyze:
         *stream . of   获取stream
         *使用filter 过滤出  不是姓郭的name
         *
         * 储存在数组中   ， toArray()--->返回object 数组
         * toArray(A[]..)----->返回A类型的数组
         */

        Stream<String> stringStream = Stream.of("黄药师", "冯蘅", "郭靖", "黄蓉", "郭芙", "郭襄", "郭破虏");
        Stream<String> stream = stringStream.filter((name) -> !name.startsWith("郭"));
        String[] strings = stream.toArray(String[]::new);
        //遍历
        sop(Arrays.toString(strings));//[黄药师, 冯蘅, 黄蓉]

    }
}

 

 

 

package Test02;

import java.util.ArrayList;
import java.util.Arrays;

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 9:36
 */
public class Test05 {
    public static void main(String[] args) {
        //已知ArrayList集合中有如下元素{陈玄风、梅超风、陆乘风、曲灵风、武眠风、冯默风、罗玉风}，使用Stream
        //1、取出前2个元素并在控制台打印输出。
        //2、取出后2个元素并在控制台打印输出。

        /**analyze:
         *
         *     获取ArrayList 的stream
         *limit 使用  限制size=2
         * skip
         */
        String[] str = {"陈玄风","梅超风","陆乘风","曲灵风","武眠风","冯默风","罗玉风"};
        ArrayList<String> list = new ArrayList<>();
        for (String s : str) {
            list.add(s);
        }
        //
        list.stream().limit(2).forEach(System.out::println);
        sop("------------------------------------");
        //
        list.stream().skip(list.size()-2).forEach(System.out::println);

    }
}

 

 

练习：

 

package Test02;

import java.util.Arrays;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 9:52
 *
 * <R> Stream<R> map​(Function<? super T,? extends R> mapper)
 * 返回由给定函数应用于此流的元素的结果组成的流。
 */
public class Test06 {
    public static void main(String[] args) {
        /**多个条的判断使用函数拼接
         *
         *
         * map   skip    concat    limit  filter
         */


        //有如下整数 1,-2,-3,4,-5
        //使用Stream取元素绝对值并打印

        Integer[]integers={1,-2,-3,4,-5};
        Arrays.stream(integers).map((s)->Math.abs(s)).forEach(System.out::println);
    }
}

 

 

package Test02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 10:33
 */
public class Test07 {
    public static void main(String[] args) {
        //已知数组arr1中有如下元素{"郭靖","杨康"};，arr2中有如下元素{"黄蓉","穆念慈"}，
        // 使用Stream将二者合并到List集合
/**
 *analyze:
 * 分别获取 str1   str2 数组，然后concat拼接（Stream 静态调用）
 *把拼接后的stream  放进（收集）list中
 */
        String[] arr1 = {"郭靖", "杨康"};
        String[] arr2 = {"黄蓉", "穆念慈"};

        Stream<String> stream1 = Arrays.stream(arr1);
        Stream<String> stream2 = Arrays.stream(arr2);
        //
        ArrayList<String> list = new ArrayList<>();
        List<String> list1 = Stream.concat(stream1, stream2).collect(Collectors.toList());//转化为list
        list1.forEach(System.out::println);//调用stream

    }
}

 

 

 

package Test02;

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

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 10:45
 *
 *并发流   两种方式;① 直接获取流 ，②调用pa
 */
public class Test08 {
    public static void main(String[] args) {
        //请分别写出获取并发流的两种方式。

        /**@return a possibly parallel {@code Stream} over the elements in this
         * collection
         * //parallelStream 是collection定义的
         *
         * //parallel  是baseStream  定义的
         *
         */



        ArrayList<String> list = new ArrayList<>();
        Stream<String> ps1 = list.parallelStream();//直接获取
        Stream<String> parallel = list.stream().parallel();//使用parallel  调用


    }
}

 

 

 

 

package Test02;

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

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 10:58
 * <p>
 * 多个条件    使用函数拼接
 */
public class Test09 {
    public static void main(String[] args) {
        //现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用Stream方式进行以
        //下若干操作步骤：
        //1. 第一个队伍只要名字为3个字的成员姓名；
        //2. 第一个队伍筛选之后只要前6个人；
        //3. 第二个队伍只要姓张的成员姓名；
        //4. 第二个队伍筛选之后不要前1个人；
        //5. 将两个队伍合并为一个队伍；
        //6. 根据姓名创建Student对象；
        //7. 打印整个队伍的Student对象信息。

        List<String> one = new ArrayList<>();
        String[] str1 = {"陈玄风", "梅超风", "陆乘风", "曲灵风", "武眠风", "冯默风", "罗玉风"};
        for (String s : str1) {
            one.add(s);
        }
        //  2条件
        Stream<String> stream1 = one.stream().filter((name) -> name.length() == 3).limit(6);
//        stream1.forEach(System.out::println);
        sop("----------------------------------------------");

        List<String> two = new ArrayList<>();
        String[] str2 = {"宋远桥", "俞莲舟", "俞岱岩", "张松溪", "张翠山", "殷梨亭", "莫声谷"};
        for (String s : str2) {
            two.add(s);
        }
        // 2 条件
        Stream<String> stream2 = two.stream().filter(name -> name.startsWith("张")).skip(1);
//        stream2.forEach(System.out::println);

//        //队伍合并   ---->list集合中
//        List<String> list = Stream.concat(stream1, stream2).collect(Collectors.toList());
//        list.stream().map(Student::new).forEach(System.out::println);

        5. 将两个队伍合并为一个队伍；//6. 根据姓名创建Student对象；//7. 打印整个队伍的Student对象信息。
        Stream.concat(stream1, stream2).map(Student::new).forEach(System.out::println);

    }
}
class Student{
    private String name;
    //

    public Student(String name) {
        this.name = name;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

 

package Test02;

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

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 11:25
 */
public class Test10 {
    public static void main(String[] args) {
        //以下是某不知名机构评出的全球最佳影片及华人最佳影片前十名 ： 
        //全球
        //　　1、 《教父》
        //　　2、 《肖申克的救赎》
        //　　3、 《辛德勒的名单》
        //　　4、 《公民凯恩》
        //　　5、 《卡萨布兰卡》 
        //　　6、 《教父续集》
        //　　7、 《七武士》
        //　　8、 《星球大战》
        //　　9、 《美国美人》
        //　　10、 《飞跃疯人院》
        //　
        //华人
        //　  1、    《霸王别姬》
        //　　2、    《大闹天宫》
        //　　3、    《鬼子来了》
        //　　4、    《大话西游》
        //　　5、    《活着》
        //　　6、    《饮食男女》
        //　　7、    《无间道》
        //　　8、    《天书奇谭》
        //　　9、    《哪吒脑海》
        //　　10、    《春光乍泄》
        //
        //
        //1、现将两个榜单中的影片名，分别按排名顺序依次存入两个ArrayList集合
        //2、通过流的方式
        //	1）打印全球影片排行榜中的前三甲影片名
        //	2）打印华人影片排行榜中倒数5名的影片名
        //	3）将两个排行榜中的前5名挑出来共同存入新的集合
        //	4）定义电影 Film 类，以影片名为name创建Film对象并保存至集合
        String[] strings1 = {"《教父》","《肖申克的救赎》","《辛德勒的名单》","《公民凯恩》","《卡萨布兰卡》",
                "《教父续集》","《七武士》","《星球大战》","《美国美人》","《飞跃疯人院》"};
        ArrayList<String> list1 = new ArrayList<>();
        for (String s : strings1) {
            list1.add(s);
        }
        //条件
        list1.stream().limit(3).forEach(System.out::println);
        Stream<String> limit1 = list1.stream().limit(5);//前五
        sop("-----------------------------------");

        String[] strings2 = {"《霸王别姬》","《大闹天宫》","《鬼子来了》","《大话西游》","  《活着》",
                "《饮食男女》","《无间道》","《天书奇谭》","《哪吒脑海》","《春光乍泄》" };
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : strings2) {
            list2.add(s);
        }
        //条件
        list2.stream().limit(list2.size()-5).forEach(System.out::println);
        Stream<String> limit2 = list2.stream().limit(5);//前五

        //	4）定义电影Film类，以影片名为name创建Film对象并保存至集合
        List<String> newList = Stream.concat(limit1, limit2).collect(Collectors.toList());
        //
        newList.stream().map(Film::new).forEach(System.out::println);//创建打印
    }
}
class Film{
    private String name;

    public Film(String name) {
        this.name = name;
    }

    public Film() {
    }
    //

    @Override
    public String toString() {
        return "Film{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

 

综合练习：

package Test02;

import java.util.Arrays;

import static Test02.Test01.sop;

/**
 * @auther SyntacticSugar
 * @data 2018/9/4 0004上午 11:47
 */
public class Test11 {
    public static void main(String[] args) {
        //我国有34个省级行政区，分别是：
        //23个省：
        //河北省、山西省、吉林省、辽宁省、黑龙江省、陕西省、甘肃省、青海省、山东省、福建省、
        //浙江省、台湾省、河南省、湖北省、湖南省、江西省、江苏省、安徽省、广东省、海南省、四川省、贵州省、云南省。
        //4个直辖市：
        //北京市、天津市、上海市、重庆市。
        //5个自治区：
        //内蒙古自治区、新疆维吾尔自治区、宁夏回族自治区、广西壮族自治区、西藏自治区。
        //2个特别行政区：
        //香港特别行政区、澳门特别行政区。
        //
        //使用流：
        //1、统计三个字的省份的个数
        //2、统计名字中包含方位名词的省份（东西南北）的个数
        //3、打印名字中包含方位名词的普通省份（非自治区直辖市特别行政区）的名字
        //4、将所有的特殊省份（自治区直辖市特别行政区）提取出来并放到新数组中
        String[]strings1={"河北省","山西省","吉林省","辽宁省","黑龙江省","陕西省","甘肃省","青海省","山东省",
                "福建省", "浙江省","台湾省","河南省","湖北省","湖南省","江西省","江苏省","安徽省","广东省",
                "海南省","四川省", "贵州省","云南省","北京市","天津市","上海市","重庆市",
                "内蒙古自治区","新疆维吾尔自治区","宁夏回族自治区","广西壮族自治区","西藏自治区",
                "香港特别行政区","澳门特别行政区"};
        long count = Arrays.stream(strings1).filter((s) -> s.length() == 3).count();
        sop(count);//打印count    26
        //
        long count1 = Arrays.stream(strings1).filter((s) -> s.contains("东") || s.contains("南")
                || s.contains("西") || s.contains("北")).count();
        sop(count1);//14
        //
        long count2 = Arrays.stream(strings1).filter((s) -> s.contains("东") || s.contains("南")
                || s.contains("西") || s.contains("北")).filter((s) -> s.contains("省")).count();
        sop(count2);
        //将所有的特殊省份（自治区直辖市特别行政区）提取出来并放到新数组中
        String[] strings = Arrays.stream(strings1).filter((s) -> !s.contains("省")).toArray(String[]::new);
        for (String string : strings) {
            sop(string);
        }
    }
}