从零开始学习 Java:简单易懂的入门指南之不可变集合、方法引用(二十六)

简介: 从零开始学习 Java:简单易懂的入门指南之不可变集合、方法引用(二十六)


1.不可变集合

1.1 什么是不可变集合

是一个长度不可变,内容也无法修改的集合

1.2 使用场景

如果某个数据不能被修改,把它防御性地拷贝到不可变集合中是个很好的实践。

当集合对象被不可信的库调用时,不可变形式是安全的。

简单理解:

不想让别人修改集合中的内容

比如说:

1,斗地主的54张牌,是不能添加,不能删除,不能修改的

2,斗地主的打牌规则:单张,对子,三张,顺子等,也是不能修改的

3,用代码获取的操作系统硬件信息,也是不能被修改的

1.3 不可变集合分类

  • 不可变的list集合
  • 不可变的set集合
  • 不可变的map集合

1.4 不可变的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");
    }
}

1.5 不可变的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("王五");
    }
}

1.6 不可变的Map集合

1.6.1:键值对个数小于等于10
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("--------------------------");
    }
}
1.6.2:键值对个数大于10
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");
    }
}

2.方法引用

2.1体验方法引用

  • 方法引用的出现原因
    在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿参数做操作
    那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑呢?答案肯定是没有必要
    那我们又是如何使用已经存在的方案的呢?
    这就是我们要讲解的方法引用,我们是通过方法引用来使用已经存在的方案
  • 代码演示
public interface Printable {
    void printString(String s);
}
public class PrintableDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrintable方法
//        usePrintable((String s) -> {
//            System.out.println(s);
//        });
      //Lambda简化写法
        usePrintable(s -> System.out.println(s));
        //方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(Printable p) {
        p.printString("爱生活爱Java");
    }
}

2.2方法引用符

  • 方法引用符
    :: 该符号为引用运算符,而它所在的表达式被称为方法引用
  • 推导与省略
  • 如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
  • 如果使用方法引用,也是同样可以根据上下文进行推导
  • 方法引用是Lambda的孪生兄弟

2.3引用类方法

引用类方法,其实就是引用类的静态方法

  • 格式
    类名::静态方法
  • 范例
    Integer::parseInt
    Integer类的方法:public static int parseInt(String s) 将此String转换为int类型数据
  • 练习描述
  • 定义一个接口(Converter),里面定义一个抽象方法 int convert(String s);
  • 定义一个测试类(ConverterDemo),在测试类中提供两个方法
  • 一个方法是:useConverter(Converter c)
  • 一个方法是主方法,在主方法中调用useConverter方法
  • 代码演示
public interface Converter {
    int convert(String s);
}
public class ConverterDemo {
    public static void main(String[] args) {
    //Lambda写法
        useConverter(s -> Integer.parseInt(s));
        //引用类方法
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}
  • 使用说明
    Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数

2.4引用对象的实例方法

引用对象的实例方法,其实就引用类中的成员方法

  • 格式
    对象::成员方法
  • 范例
    “HelloWorld”::toUpperCase
    String类中的方法:public String toUpperCase() 将此String所有字符转换为大写
  • 练习描述
  • 定义一个类(PrintString),里面定义一个方法
    public void printUpper(String s):把字符串参数变成大写的数据,然后在控制台输出
  • 定义一个接口(Printer),里面定义一个抽象方法
    void printUpperCase(String s)
  • 定义一个测试类(PrinterDemo),在测试类中提供两个方法
  • 一个方法是:usePrinter(Printer p)
  • 一个方法是主方法,在主方法中调用usePrinter方法
  • 代码演示
public class PrintString {
    //把字符串参数变成大写的数据,然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}
public interface Printer {
    void printUpperCase(String s);
}
public class PrinterDemo {
    public static void main(String[] args) {
    //Lambda简化写法
        usePrinter(s -> System.out.println(s.toUpperCase()));
        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
    }
    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}
  • 使用说明
    Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数

2.5引用类的实例方法

引用类的实例方法,其实就是引用类中的成员方法

  • 格式
    类名::成员方法
  • 范例
    String::substring
    public String substring(int beginIndex,int endIndex)
    从beginIndex开始到endIndex结束,截取字符串。返回一个子串,子串的长度为endIndex-beginIndex
  • 练习描述
  • 定义一个接口(MyString),里面定义一个抽象方法:
    String mySubString(String s,int x,int y);
  • 定义一个测试类(MyStringDemo),在测试类中提供两个方法
  • 一个方法是:useMyString(MyString my)
  • 一个方法是主方法,在主方法中调用useMyString方法
  • 代码演示
public interface MyString {
    String mySubString(String s,int x,int y);
}
public class MyStringDemo {
    public static void main(String[] args) {
    //Lambda简化写法
        useMyString((s,x,y) -> s.substring(x,y));
        //引用类的实例方法
        useMyString(String::substring);
    }
    private static void useMyString(MyString my) {
        String s = my.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}
  • 使用说明
    Lambda表达式被类的实例方法替代的时候
    第一个参数作为调用者
    后面的参数全部传递给该方法作为参数

2.6引用构造器

引用构造器,其实就是引用构造方法

  • l格式
    类名::new
  • 范例
    Student::new
  • 练习描述
  • 定义一个类(Student),里面有两个成员变量(name,age)
    并提供无参构造方法和带参构造方法,以及成员变量对应的get和set方法
  • 定义一个接口(StudentBuilder),里面定义一个抽象方法
    Student build(String name,int age);
  • 定义一个测试类(StudentDemo),在测试类中提供两个方法
  • 一个方法是:useStudentBuilder(StudentBuilder s)
  • 一个方法是主方法,在主方法中调用useStudentBuilder方法
  • 代码演示
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
public interface StudentBuilder {
    Student build(String name,int age);
}
public class StudentDemo {
    public static void main(String[] args) {
    //Lambda简化写法
        useStudentBuilder((name,age) -> new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
    }
    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}
  • 使用说明
    Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数

后记
👉👉💕💕美好的一天,到此结束,下次继续努力!欲知后续,请看下回分解,写作不易,感谢大家的支持!! 🌹🌹🌹

相关文章
|
2天前
|
Java 关系型数据库 MySQL
Elasticsearch【问题记录 01】启动服务&停止服务的2类方法【及 java.nio.file.AccessDeniedException: xx/pid 问题解决】(含shell脚本文件)
【4月更文挑战第12天】Elasticsearch【问题记录 01】启动服务&停止服务的2类方法【及 java.nio.file.AccessDeniedException: xx/pid 问题解决】(含shell脚本文件)
23 3
|
4天前
|
存储 Java
Java动态转发代理IP的实现方法
Java动态转发代理IP的实现方法
20 11
|
4天前
|
JavaScript Java 测试技术
基于Java的驾考自主学习预约平台的设计与实现(源码+lw+部署文档+讲解等)
基于Java的驾考自主学习预约平台的设计与实现(源码+lw+部署文档+讲解等)
15 0
|
5天前
|
JavaScript Java 测试技术
基于Java的精品课程在线学习系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的精品课程在线学习系统的设计与实现(源码+lw+部署文档+讲解等)
25 1
|
5天前
|
JavaScript Java 测试技术
基于Java的中文学习系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的中文学习系统的设计与实现(源码+lw+部署文档+讲解等)
20 0
|
5天前
|
Java
Java接口中可以定义哪些方法?
【4月更文挑战第13天】
7 0
Java接口中可以定义哪些方法?
|
11天前
|
Java Shell
Java 21颠覆传统:未命名类与实例Main方法的编码变革
Java 21颠覆传统:未命名类与实例Main方法的编码变革
12 0
|
11天前
|
Java 存储
键值之道:深入学习Java中强大的HashMap(二)
键值之道:深入学习Java中强大的HashMap
20 0
键值之道:深入学习Java中强大的HashMap(二)
|
4天前
|
安全 Java
深入理解 Java 多线程和并发工具类
【4月更文挑战第19天】本文探讨了Java多线程和并发工具类在实现高性能应用程序中的关键作用。通过继承`Thread`或实现`Runnable`创建线程,利用`Executors`管理线程池,以及使用`Semaphore`、`CountDownLatch`和`CyclicBarrier`进行线程同步。保证线程安全、实现线程协作和性能调优(如设置线程池大小、避免不必要同步)是重要环节。理解并恰当运用这些工具能提升程序效率和可靠性。
|
5天前
|
安全 Java
java多线程(一)(火车售票)
java多线程(一)(火车售票)