javase复习day26不可变集合、Stream流

未命名冀

于 2024-09-17 22:58:03 发布

阅读量191

点赞数 4

分类专栏： javase复习文章标签： java

本文链接：https://blog.csdn.net/m0_72625929/article/details/142234299

版权

javase复习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

不可变集合

书写格式

package com.itheima.a01immutable;


import java.util.Iterator;
import java.util.List;

public class ImmutableDemo1 {
    public static void main(String[] args) {
        /*
            创建不可变的List集合
            "张三", "李四", "王五", "赵六"
        */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        List<String> list = List.of("张三", "李四", "王五", "赵六");

        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));

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

        for (String s : list) {
            System.out.println(s);
        }

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


        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("---------------------------");

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("---------------------------");

        //list.remove("李四");
        //list.add("aaa");
        list.set(0,"aaa");
    }
}

package com.itheima.a01immutable;


import java.util.Iterator;
import java.util.Set;

public class ImmutableDemo2 {
    public static void main(String[] args) {
        /*
           创建不可变的Set集合
           "张三", "李四", "王五", "赵六"


           细节：
                当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性
        */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");

        for (String s : set) {
            System.out.println(s);
        }

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

        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

        System.out.println("-----------------------");
        //set.remove("王五");
    }
}

package com.itheima.a01immutable;

import java.util.Map;
import java.util.Set;

public class ImmutableDemo3 {
    public static void main(String[] args) {
       /*
        创建Map的不可变集合
            细节1：
                键是不能重复的
            细节2：
                Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对
            细节3：
                如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法

        */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海",
                "赵六", "广州", "孙七", "深圳", "周八", "杭州",
                "吴九", "宁波", "郑十", "苏州", "刘一", "无锡",
                "陈二", "嘉兴");


        Set<String> keys = map.keySet();
        for (String key : keys) {
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }

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

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("--------------------------");
    }




}

package com.itheima.a01immutable;

import java.util.HashMap;
import java.util.Map;

public class ImmutableDemo4 {
    public static void main(String[] args) {

        /*
            创建Map的不可变集合,键值对的数量超过10个
        */

        //1.创建一个普通的Map集合
        HashMap<String, String> hm = new HashMap<>();
        hm.put("张三", "南京");
        hm.put("李四", "北京");
        hm.put("王五", "上海");
        hm.put("赵六", "北京");
        hm.put("孙七", "深圳");
        hm.put("周八", "杭州");
        hm.put("吴九", "宁波");
        hm.put("郑十", "苏州");
        hm.put("刘一", "无锡");
        hm.put("陈二", "嘉兴");
        hm.put("aaa", "111");

        //2.利用上面的数据来获取一个不可变的集合
/*
        //获取到所有的键值对对象（Entry对象）
        Set<Map.Entry<String, String>> entries = hm.entrySet();
        //把entries变成一个数组
        Map.Entry[] arr1 = new Map.Entry[0];
        //toArray方法在底层会比较集合的长度跟数组的长度两者的大小
        //如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
        //如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用
        Map.Entry[] arr2 = entries.toArray(arr1);
        //不可变的map集合
        Map map = Map.ofEntries(arr2);
        map.put("bbb","222");*/


        //Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));


        Map<String, String> map = Map.copyOf(hm);
        map.put("bbb","222");

    }
}

Stream流

练习：体验Stream流的作用

package MyStreamDemo.Demo1;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        //使用Stream流
        list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name->System.out.println(name));



//        //把所有姓张的元素存储到新集合中
//        ArrayList<String > list1 = new ArrayList<>();
//        for (String name : list) {
//            if (name.startsWith("张")){
//                list1.add(name);
//            }
//        }
//        System.out.println(list1);
//        //一张开头，长度为3的存储到新集合中
//        ArrayList<String> list2 = new ArrayList<>();
//        for (String name : list1) {
//            if (name.length()==3){
//                list2.add(name);
//            }
//        }
//        //遍历输出
//        for (String name : list2) {
//            System.out.println(name);
//        }
    }
}

Stream流的作用

Stream流的使用步骤

获取流水线

双列集合要先转为单列集合再获取。

Steam流的中间方法

package MyStreamDemo.Demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五","张麻子","张致和","王三");

        //filter过滤
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                //返回值 为true则保留，为false则不保留
//                //将姓张的保留
//                if (s.startsWith("张")){
//                    return true;
//                }
//                return false;
//            }
//        }).forEach(s->System.out.println(s));
        list.stream().filter( s-> s.startsWith("张")).forEach(s->System.out.println(s));
        System.out.println("==========================================");

//获取前几个元素limit;
        list.stream().limit(3).forEach(s->System.out.println(s));

        //跳过元素
        System.out.println("========================");
        list.stream().skip(3).forEach(s->System.out.println(s));
        System.out.println("==================================");

//获取中间两个元素
        //方法一
        list.stream().skip(2).limit(2).forEach(s->System.out.println(s));

        //方法二
        System.out.println("方法二=========================");
        list.stream().limit(4).skip(2).forEach(s->System.out.println(s));

    }
}

package MyStreamDemo.Demo1;

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","张三","张三","张三","李四","王五","张麻子","张致和","王三");
        list.stream().distinct().forEach(s->System.out.println(s));
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"小明","小张","小李");

        Stream<String> distinct = list.stream().distinct();
        Stream.concat(distinct,list1.stream()).forEach(s->System.out.println(s));
    }
}

package MyStreamDemo.Demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Demo3 {
    public static void main(String[] args) {

        /*
            map                 转换流中的数据类型

            注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");
        //需求：只获取里面的年龄并进行打印
        //String->int

        //第一个类型：流中原本的数据类型
        //第二个类型：要转成之后的类型

        //apply的形参s：依次表示流里面的每一个数据
        //返回值：表示转换之后的数据

        //当map方法执行完毕之后，流上的数据就变成了整数
        //所以在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在就是整数了
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                //先进行切割
                String[] split = s.split("-");
                //进行强转
                Integer s1 = Integer.valueOf(split[1]);
                return s1;
            }
        }).forEach(s->System.out.println(s));
        System.out.println("======================================");
        list.stream().map( s -> {
                //先进行切割
                String[] split = s.split("-");
                //进行强转
                Integer s1 = Integer.valueOf(split[1]);
                return s1;
        }).forEach(s->System.out.println(s));
        System.out.println("======================================");
        list.stream().map( s -> Integer.valueOf(s.split("-")[1])).forEach(s->System.out.println(s));

    }
}

终结方法

package com.itheima.a01mystream;

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

public class StreamDemo9 {
    public static void main(String[] args) {
       /*
            void forEach(Consumer action)           遍历
            long count()                            统计
            toArray()                               收集流中的数据，放到数组中
       */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");


        //void forEach(Consumer action)           遍历

        //Consumer的泛型：表示流中数据的类型
        //accept方法的形参s：依次表示流里面的每一个数据
        //方法体：对每一个数据的处理操作（打印）
        /*list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //list.stream().forEach(s -> System.out.println(s));



        // long count()                            统计
        //long count = list.stream().count();
        //System.out.println(count);



        // toArray()                               收集流中的数据，放到数组中
        //Object[] arr1 = list.stream().toArray();
        //System.out.println(Arrays.toString(arr1));

        //IntFunction的泛型：具体类型的数组
        //apply的形参:流中数据的个数，要跟数组的长度保持一致
        //apply的返回值：具体类型的数组
        //方法体：就是创建数组


        //toArray方法的参数的作用：负责创建一个指定类型的数组
        //toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
        //toArray方法的返回值：是一个装着流里面所有数据的数组
       /* String[] arr = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });

        System.out.println(Arrays.toString(arr));*/
        String[] arr2 = list.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(arr2));

    }
}

package MyStreamDemo.Demo1;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Demo5 {
    public static void main(String[] args) {

        /*
            collect(Collector collector)            收集流中的数据，放到集合中 (List Set Map)

            注意点：
                如果我们要收集到Map集合当中，键不能重复，否则会报错
       */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");


        //收集List集合当中
        //需求：
        //我要把所有的男性收集起来
        List<String> list1 = list.stream().filter(s -> s.split("-")[1].equals("男")).collect(Collectors.toList());
        System.out.println(list1);
        //System.out.println(newList1);


        //收集Set集合当中
        //需求：
        //我要把所有的男性收集起来
        Set<String> stringSet = list.stream().filter(s -> s.split("-")[1].equals("男")).collect(Collectors.toSet());
        System.out.println(stringSet);
        //System.out.println(newList2);


        //收集Map集合当中
        //谁作为键,谁作为值.
        //我要把所有的男性收集起来
        //键：姓名。 值：年龄
        Map<String, Integer> map = list.stream()
                .filter(s -> s.split("-")[1].equals("男"))

                /*
                 *   toMap : 参数一表示键的生成规则
                 *           参数二表示值的生成规则
                 *
                 * 参数一：
                 *       Function泛型一：表示流中每一个数据的类型
                 *               泛型二：表示Map集合中键的数据类型
                 *
                 *        方法apply形参：依次表示流里面的每一个数据
                 *               方法体：生成键的代码
                 *               返回值：已经生成的键
                 *
                 *
                 * 参数二：
                 *        Function泛型一：表示流中每一个数据的类型
                 *                泛型二：表示Map集合中值的数据类型
                 *
                 *       方法apply形参：依次表示流里面的每一个数据
                 *               方法体：生成值的代码
                 *               返回值：已经生成的值
                 *
                 * */
                .collect(Collectors.toMap(
                        new Function<String, String>() {
                            @Override
                            public String apply(String s) {
                                String s1 = s.split("-")[0];
                                return s1;
                            }
                        },
                        new Function<String, Integer>() {
                            @Override
                            public Integer apply(String s) {
                                Integer i = Integer.parseInt(s.split("-")[2]);
                                return i;
                            }
                        }));
        System.out.println(map);

//化简为Lambda表达式
        Map<String, Integer> map1 = list.stream()
                .filter(s -> s.split("-")[1].equals("男"))
                .collect(Collectors.toMap( s-> s.split("-")[0], s-> Integer.parseInt(s.split("-")[2])));
        System.out.println(map1);
    }
}

Stream流小结

练习一：数据过滤

package StreamTest;

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

public class Test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        //保留偶数
        List<Integer> l1 = list.stream().filter(s -> s % 2 == 0).collect(Collectors.toList());
        System.out.println(l1);
    }
}

练习二：数据操作

package StreamTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");

        //
        Map<String, Integer> map = list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //获取年龄
                String[] split = s.split(",");
                String s1 = split[1];
                int i = Integer.parseInt(s1);
                if (i >= 24) {
                    return true;
                }
                return false;
            }
        }).collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split(",")[1]);
            }
        }));
        System.out.println(map);

        //进行化简
        Map<String, Integer> map1 = list.stream()
                .filter(s-> Integer.parseInt(s.split(",")[1]) >= 24)
                .collect(Collectors.toMap(s-> s.split(",")[0], s-> Integer.parseInt(s.split(",")[1])));
        System.out.println(map1);

    }
}

练习三：数据操作

package StreamTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test3 {
    public static void main(String[] args) {
         /*
        现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄。
        姓名和年龄中间用逗号隔开。
        比如：张三,23
        要求完成如下的操作：
        1，男演员只要名字为3个字的前两人
        2，女演员只要姓杨的，并且不要第一个
        3，把过滤后的男演员姓名和女演员姓名合并到一起
        4，将上一步的演员信息封装成Actor对象。
        5，将所有的演员对象都保存到List集合中。
        备注：演员类Actor，属性有：name，age

        男演员：  "蔡坤坤,24" , "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27"
        女演员：  "赵小颖,35" , "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33"
      */


        //1.创建两个ArrayList集合
        ArrayList<String> manList = new ArrayList<>();
        ArrayList<String> womenList = new ArrayList<>();
        ArrayList<Actor> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
        Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");

        //男演员只要名字为3个字的前两人
        Stream<String> stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);
//        System.out.println(manNewlist);

        //2，女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womenList.stream().filter(s -> s.startsWith("杨")).skip(1);
//        List<String> wNewlist = (List<String>) limit2
//        System.out.println(wNewlist);

        //合并
        Stream<String> concat = Stream.concat(stream1, stream2);
//        concat.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                String[] split = s.split(",");
//                int i = Integer.parseInt(split[1]);
//                Actor actor = new Actor(split[0],i);
//                list.add(actor);
//            }
//        });
//        System.out.println(list);
        List<Actor> list1 = concat.map(new Function<String, Actor>() {
            @Override
            public Actor apply(String s) {
//                Actor actor = new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1]));
                return new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1]));
            }
        }).collect(Collectors.toList());
        System.out.println(list1);

    }
}

方法引用

概述

package Method_references;

import java.util.Arrays;
import java.util.Comparator;

public class Demo1 {
    public static void main(String[] args) {
        //需求：创建一个数组，进行倒序排列
        Integer[] arr = {3, 5, 4, 1, 6, 2};
        //匿名内部类

//        Arrays.sort(arr, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o2-o1;
//            }
//        });



        //lambda表达式
        //因为第二个参数的类型Comparator是一个函数式接口
//        Arrays.sort(arr, (Integer o1, Integer o2)-> {
//                return o2-o1;
//            }
//        );
        //化简写法
//        Arrays.sort(arr, (o1,o2)-> o2-o1);
//
//        System.out.println(Arrays.toString(arr));

        //方法引用
        //1.引用处需要是函数式接口
        //2.被引用的方法需要已经存在
        //3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
        //4.被引用方法的功能需要满足当前的要求

        //表示引用FunctionDemo1类里面的subtraction方法
        //把这个方法当做抽象方法的方法体
        Arrays.sort(arr,Demo1::subtraction);

        System.out.println(Arrays.toString(arr));

    }



    //可以是Java已经写好的，也可以是一些第三方的工具类
    public static int subtraction(int num1, int num2) {
        return num2 - num1;
    }
}

小结

方法引用的分类

引用静态方法

练习：

package Method_references;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5","6");

        //需要进行类型转换可以使用流中的Map方法
//        list.stream().map(new Function<String, Integer>() {
//
//            @Override
//            public Integer apply(String s) {
//                int i = Integer.parseInt(s);
//                return i;
//            }
//        }).forEach(s->System.out.println(s));
        //使用方法引用，由于Integer中有将String转换为Int类型的方法所以进行引用
        list.stream().map(Integer::parseInt).forEach(s->System.out.println(s));



    }
}

引用成员方法

本类和父类的引用处不能是静态方法。

练习一：

package Method_references;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张五局","周芷若","赵明","张强","张三丰");

        //过滤数据
//        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s->System.out.println(s));

        //两个要求一起判断
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张")&&s.length()==3;
//            }
//        }).forEach(s->System.out.println(s));
        //使用同包不同类的方法进行方法引用

        list.stream().filter(new pqp()::qqq).forEach(s->System.out.println(s));


    }

}

package Method_references;

import java.util.function.Predicate;

public class pqp {
    public boolean qqq(String s){
        return s.startsWith("张")&&s.length()==3;
    }

}

练习二：

package Method_references.a02game;

import javax.swing.*;
import java.awt.*;

public class LoginJFrame extends MyJFrame {


    JButton go = new JButton("Go");

    public LoginJFrame() {
        //设置图标
        setIconImage(Toolkit.getDefaultToolkit().getImage("myfunction\\image\\logo.jpg"));

        //设置界面
        initJframe();

        //添加组件
        initView();

        //界面显示出来
        this.setVisible(true);

    }

    //添加组件
    public void initView() {
        JLabel image = new JLabel(new ImageIcon("myfunction\\image\\kit.jpg"));
        image.setBounds(100,50,174,174);
        this.getContentPane().add(image);



        go.setFont(new Font(null,1,20));
        go.setBounds(120,274,150,50);
        go.setBackground(Color.WHITE);
//引用父类的方法
        go.addActionListener(super::method1);

        this.getContentPane().add(go);

    }

    //设置界面
    public void initJframe() {
        //设置标题
        this.setTitle("随机点名器");
        //设置大小
        this.setSize(400, 500);
        //设置关闭模式
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口无法进行调节
        this.setResizable(false);
        //界面居中
        this.setLocationRelativeTo(null);
        //取消内部默认居中放置
        this.setLayout(null);
        //设置背景颜色
        this.getContentPane().setBackground(Color.white);
        this.setAlwaysOnTop(true);//置顶
    }





}

package Method_references.a02game;

import javax.swing.*;
import java.awt.event.ActionEvent;

public class MyJFrame extends JFrame {

    public void method1(ActionEvent e) {
        System.out.println("go按钮被点击了");
    }
}

引用构造方法

练习

package Method_references;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Demo4 {
    public static void main(String[] args) {
                /*
        方法引用（引用构造方法）
        格式
                类名::new

        目的：
                创建这个类的对象

        需求：
             集合里面存储姓名和年龄，要求封装成Student对象并收集到List集合中

        方法引用的规则：
            1.需要有函数式接口
            2.被引用的方法必须已经存在
            3.被引用方法的形参和返回值，需要跟抽象方法的形参返回值保持一致
            4.被引用方法的功能需要满足当前的需求
       */

        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13", "张强,20", "张三丰,100", "张翠山,40", "张良,35", "王二麻子,37", "谢广坤,41");

//        List<Student> collect = list.stream().map(new Function<String, Student>() {
//            @Override
//            public Student apply(String s) {
//                return new Student(s.split(",")[0], Integer.parseInt(s.split(",")[1]));
//            }
//        }).collect(Collectors.toList());
//        System.out.println(collect);
        List<Student> collect = list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(collect);


    }
}

package Method_references;

public class Student {
    private String name;
    private int age;

    public Student() {

    }
    //由于要调用构造方法，所以修改构造方法为相同形参
    public Student(String s) {
        this.name = s.split(",")[0];
        this.age = Integer.parseInt(s.split(",")[1]);
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

使用类名引用成员方法

练习

package Method_references.a02game;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Demo5 {
    public static void main(String[] args) {
          /*
        方法引用（类名引用成员方法）
        格式
                类名::成员方法
        需求：
             集合里面一些字符串，要求变成大写后进行输出


        方法引用的规则：
        1.需要有函数式接口
        2.被引用的方法必须已经存在
        3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致。
        4.被引用方法的功能需要满足当前的需求

        抽象方法形参的详解：
        第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
                    在Stream流当中，第一个参数一般都表示流里面的每一个数据。
                    假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法

        第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

        局限性：
            不能引用所有类中的成员方法。
            是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

       */

        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "aaa", "bbb", "ccc", "ddd");

        //3.变成大写后进行输出
        //map(String::toUpperCase)
        //拿着流里面的每一个数据，去调用String类中的toUpperCase方法，方法的返回值就是转换之后的结果。
//        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));

        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
//        List<String> collect = list.stream().map(new Function<String, String>() {
//            @Override
//            public String apply(String s) {
//                return s.toUpperCase();
//            }
//        }).collect(Collectors.toList());
//        System.out.println(collect);

        //String --> String
       /* list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s -> System.out.println(s));*/

    }
}

引用数组的构造方法

练习

package com.itheima.a01myfunction;

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

public class FunctionDemo6 {
    public static void main(String[] args) {
        /*
        方法引用（数组的构造方法）
        格式
                数据类型[]::new
        目的：
                创建一个指定类型的数组
        需求：
             集合中存储一些整数，收集到数组当中

        细节：
            数组的类型，需要跟流中数据的类型保持一致。

       */

        //1.创建集合并添加元素
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5);
        //2.收集到数组当中

        Integer[] arr2 = list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr2));

        /*Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });*/
        //3.打印



    }
}

方法引用总结

方法引用练习


//练习一

public class Test1 {
    public static void main(String[] args) {
        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13", "张强,20", "张三丰,100", "张翠山,40", "张良,35", "王二麻子,37", "谢广坤,41");

        //Student中的构造方法是修改过的
        Student[] array = list.stream().map(Student::new).toArray(Student[]::new);
        for (Student s : array) {
            System.out.println(s);
        }


    }
}

//练习二
public class Test2 {
    public static void main(String[] args) {
        //Student中的构造方法是修改过的
        //准备数据
        Student s1 = new Student("张三",12);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("王五",15);
        Student s4 = new Student("赵六",17);
        Student s5 = new Student("五脊六兽",14);

        ArrayList<Student > list = new ArrayList<>();
        Collections.addAll(list,s1,s2,s3,s4,s5);

//        Integer[] array = list.stream().map(new Function<Student, Integer>() {
//            @Override
//            public Integer apply(Student student) {
//                return student.getAge();
//            }
//        }).toArray(Integer[]::new);
        //化简
//        Integer[] array = list.stream().map(student-> student.getAge()).toArray(Integer[]::new);

        String[] array = list.stream().map(Student::getName).toArray(String[]::new);
        for (String i : array) {
            System.out.println(i);
        }
    }
}

//练习三
public class Test3 {
    public static void main(String[] args) {
        //Student中的构造方法是修改过的
        //准备数据
        Student s1 = new Student("张三",12);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("王五",15);
        Student s4 = new Student("赵六",17);
        Student s5 = new Student("五脊六兽",14);

        ArrayList<Student > list = new ArrayList<>();
        Collections.addAll(list,s1,s2,s3,s4,s5);

        String[] array = list.stream().map(new Function<Student, String>() {
            @Override
            public String apply(Student student) {

                return student.getName() + "-" + student.getAge();
            }
        }).toArray(String[]::new);
        for (String s : array) {
            System.out.println(s);
        }

    }
}