Java高级-Lambda 表达式、异常处理、集合、泛型、List集合、Map集合、Collections类

最新推荐文章于 2024-02-22 17:39:04 发布

一个萌新柒

最新推荐文章于 2024-02-22 17:39:04 发布

阅读量1k

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_65696574/article/details/127571062

版权

Lambda 表达式

Lambda 表达式（Lambda expression）是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）。现在很多语言都支持 Lambda 表达式，如 C++、C#、Java、 Python 和 JavaScript 等。

Lambda 表达式是推动 Java 8 发布的重要新特性，它允许把函数作为一个方法的参数（函数作为参数传递进方法中），下面通过例 1 来理解 Lambda 表达式的概念。

public interface Demo01 {
    int add(int num1, int num2);
}

public class Demo02 {
    public static void main(String[] args) {
        // 创建接口类型对象
        Demo01 d1 = new Demo01() {
            @Override
            public int add(int num1, int num2) {
                System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
                return 0;
            }
        };

        Demo01 d1 = (int num1, int num2) -> {
                System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
                return 0;
        };

        d1.add(1, 2);

        // Demo01 d2 = (int n1, int n2) ->  n1 + n2;
        Demo01 d2 = Integer::sum;

        System.out.println(d2.add(1, 2));
    }
}

Java Lambda 表达式的优缺点

优点：

代码简洁，开发迅速
方便函数式编程
非常容易进行并行计算
Java 引入 Lambda，改善了集合操作（引入 Stream API）

缺点：

代码可读性变差
在非并行计算中，很多计算未必有传统的 for 性能要高
不容易进行调试

异常处理

Exception 处理及常见异常

Java 中的异常又称为例外，是一个在程序执行期间发生的事件，它中断正在执行程序的正常指令流。为了能够及时有效地处理程序中的运行错误，必须使用异常类，这可以让程序具有极好的容错性且更加健壮。

在 Java 中一个异常的产生，主要有如下三种原因：

1、Java 内部错误发生异常，Java 虚拟机产生的异常。

2、编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。

3、通过 throw 语句手动生成的异常，一般用来告知该方法的调用者一些必要信息。

Java 通过面向对象的方法来处理异常。在一个方法的运行过程中，如果发生了异常，则这个方法会产生代表该异常的一个对象，并把它交给运行时的系统，运行时系统寻找相应的代码来处理这一异常。

我们把生成异常对象，并把它提交给运行时系统的过程称为拋出（throw）异常。运行时系统在方法的调用栈中查找，直到找到能够处理该类型异常的对象，这一个过程称为捕获（catch）异常。

try catch语句

Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。

public class Demo01 {
    public static void main(String[] args) {
        /**
         * try catch语句，捕获异常并且处理异常
         * 语法：
         *      try{
         *          代码块（可能出现错误的代码）
         *      } catch(异常的类型){
         *          处理异常的逻辑代码块
         *      } catch () {
         *
         *      }.....
         */

        int[] arr = new int[1];

//        System.out.println(arr[30]);

        try{
            // System.out.println(arr[30]);
            int num = 2 / 0;
        }catch(NullPointerException e){
            System.out.println("空指针异常");
            System.out.println(e.getMessage());
            e.printStackTrace();
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("程序出错了, 数组下标越界异常");
            e.printStackTrace();// 打印异常栈信息
            System.out.println(e.getMessage());
        }catch (Exception e) {
            System.out.println("未知的异常");
            System.out.println(e.getMessage());
        }
    }
}

try catch finally语句

Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只回收堆内存中对象所占用的内存。

所以为了确保一定能回收 try 块中打开的物理资源，异常处理机制提供了 finally 代码块，并且 Java 7 之后提供了自动资源管理（Automatic Resource Management）技术。

public class Demo02 {
    public static void main(String[] args) {
        /**
         * try catch finally语句
         * 语法：
         *      try{
         *          可能出现异常的代码块
         *      }catch(异常的类型){
         *          处理异常的代码
         *      }catch (异常的类型) {
         *          处理异常的代码
         *      }......{
         *
         *      }finally{
         *          代码块（不管异常处理结果如何，最终都会走该语句块）
         *          注意：该语句块是在方法结束之前调用的（return语句之前执行）
         *      }
         *
         *
         */
        System.out.println(add(0, 0));
    }

    public static int add(int num1, int num2){
        /**
         * 要求num1和num2不能为0
         */
        if (num1 == 0 || num2 == 0) {
            // 处理异常
            try{
                //int num = 1 / 0;
                return 1;
            }catch (NullPointerException e){
                e.printStackTrace();
                return 2;
            }catch (Exception e){
                System.out.println("处理了异常信息: " + e.getMessage());
                return 3;
            }finally {
                System.out.println("程序出现了异常或者没有异常都要执行我这里的代码块");
            }
        }

        return num1 + num2;
    }
}

throws 声明异常

当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。使用 throws 声明的方法表示此方法不处理异常。throws 具体格式如下：

public class Demo03 {
    public static void main(String[] args) {
        /**
         * 当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，
         * 以便将该异常传递到方法的外部进行处理。使用 throws 声明的方法表示此方法不处理异常
         */
        try {
            new Demo03().getArrayElement(10);
        } catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常");
        }
    }

    /**
     * 获取int类型数组的元素
     * @return
     */
    public int getArrayElement(int index) throws ArrayIndexOutOfBoundsException{
        int[] arr = {1, 3, 5, 7, 9};
        return arr[index];
    }
}

throw 拋出异常

与 throws 不同的是，throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象

当 throw 语句执行时，它后面的语句将不执行，此时程序转向调用者程序，寻找与之相匹配的 catch 语句，执行相应的异常处理程序。如果没有找到相匹配的 catch 语句，则再转向上一层的调用程序。这样逐层向上，直到最外层的异常处理程序终止程序并打印出调用栈情况。

public class Demo05 {
    public static void main(String[] args) {
        try {
            fun1(1, 0);
        } catch (Exception e) {
            System.out.println("自己捕获异常");
            e.printStackTrace();
        }
    }

    public static double fun1(int num, int a) throws Exception {
        // 判断a是否为0，如果为0，则抛出异常
        if (a == 0) {
            /**
             * 与 throws 不同的是，throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象
             * 语法：
             *      throw new 异常类型(异常信息声明)
             */
            throw new Exception("a不能为0");
        }
        return num / a;
    }
}

自定义异常

如果 Java 提供的内置异常类型不能满足程序设计的需求，这时我们可以自己设计 Java 类库或框架，其中包括异常类型。实现自定义异常类需要继承 Exception 类或其子类，如果自定义运行时异常类需继承 RuntimeException 类或其子类。

创建一个UsernameOrPasswordErrorException类

public class UsernameOrPasswordErrorException extends RuntimeException {
    public UsernameOrPasswordErrorException() {
        super();
    }

    public UsernameOrPasswordErrorException(String message) {
        super(message);
    }

    public UsernameOrPasswordErrorException(String message, Throwable cause) {
        super(message, cause);
    }

    public UsernameOrPasswordErrorException(Throwable cause) {
        super(cause);
    }

    protected UsernameOrPasswordErrorException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

创建一个调用方法

import java.util.Scanner;

public class Demo06 {
    /**
     * 模拟登录：
     *      流程：
     *          1、用户输入用户名和密码
     *          2、比较用户名和密码
     *          3、如果用户名或者密码出错则抛出用户名或者密码错误异常
     */
    public static void main(String[] args) {
        try {
            login();
        }catch (UsernameOrPasswordErrorException e){
            System.out.println(e.getMessage());
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    public static void login() throws UsernameOrPasswordErrorException{
        String name = "大锤";
        String pwd = "123456";

        // 用户输入用户名和密码
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = scan.next();

        System.out.println("请输入用密码：");
        String password = scan.next();

        // 比较用户名和密码
        if (name.equals(username) && pwd.equals(password)) {
            System.out.println("恭喜你登录成功");
        }else{
            // 抛出用户名或者密码错误异常
            throw new UsernameOrPasswordErrorException("用户名或者密码错误");
        }
    }
}

集合、泛型

集合

为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），[Java](http://c.biancheng.net/java/) 提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。Java 所有的集合类都位于 java.util 包下，提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。

集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量），而集合里只能保存对象（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。

Collection接口

Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * collection接口
         */
        // 定义集合
        Collection col = new ArrayList();
        // 添加集合元素
        col.add(1);
        col.add(new Date());
        col.add("Hello Collection");

        // 获取集合长度
        int len = col.size();
        System.out.println(len);

        // 去除集合所有元素
        // col.clear();
        // System.out.println(col.size());

        // 判断集合中是否存在指定元素
        boolean b = col.contains("Hello java");
        System.out.println(b);

        // 判断集合是否为空
        boolean empty = col.isEmpty();
        System.out.println(empty);

        // 返回一个 Iterator 对象，用于遍历集合中的元素
        Iterator iterator = col.iterator();
        // 遍历集合
        while (iterator.hasNext()) {
            // 取元素
            System.out.println(iterator.next());
        }

        // 从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，
        // 该方法只删除第一个符合条件的元素，该方法将返回 true。
        col.remove(1);

        System.out.println("-------------------------");
        for (Object o : col) {
            System.out.println(o.toString());
        }

        // 把集合转换为一个数组，所有的集合元素变成对应的数组元素。
        Object[] objects = col.toArray();
        System.out.println(objects.length);

    }
}

List集合

List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。

import java.util.*;
import java.util.function.Consumer;

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 利用forEach语法遍历集合元素
         */
        List<String> lt = new LinkedList<>();
        lt.add("Java");
        lt.add("C");
        lt.add("SQL");

        // 遍历list集合
        lt.forEach(s -> System.out.println(s));

        // 创建set集合
        Set<Student> stus = new HashSet<>();

        stus.add(new Student(1, "大锤", "123"));

        Student student = new Student();
        student.setId(2);
        student.setName("令狐冲");
        student.setPwd("456");

        stus.add(student);

        stus.add(new Student(3, "任我行", "789"));

        // 遍历set集合
        stus.forEach(set -> System.out.println(set));


        // 遍历list集合并且删除元素
        List<String> list = new LinkedList<>();
        list.add("Java");
        list.add("C");
        list.add("SQL");

        System.out.println("遍历集合之前：" + list);

        System.out.println("------------------------------");
        // 获取迭代器对象
        Iterator<String> iterator = list.iterator();
        // 循环遍历集合
        while (iterator.hasNext()) {
            // 取出元素
            System.out.println(iterator.next());
            // 将取出来的元素删除
            iterator.remove();
        }
        System.out.println("------------------------------");

        System.out.println("遍历集合之后：" + list);

        /**
         * Java 8 为 Iterator 引入了一个 forEachRemaining(Consumer action) 默认方法，
         * 该方法所需的 Consumer 参数同样也是函数式接口。当程序调用 Iterator 的
         * forEachRemaining(Consumer action) 遍历集合元素时，程序会依次将集合元素传给
         * Consumer 的 accept(T t) 方法（该接口中唯一的抽象方法）。
         */

        List<String> list1 = new LinkedList<>();
        list1.add("Java");
        list1.add("C");
        list1.add("SQL");


        // 获取迭代器对象
        Iterator<String> itr = list1.iterator();
        // 利用lambda遍历迭代器对象
        itr.forEachRemaining(result -> System.out.println(result));

    }
}

创建一个学生类来测试

public class Student {
    private Integer id;
    private String name;
    private String pwd;

    /**
     * 添加有参和无参构造器
     *
     * 添加get和set方法
     *
     * 添加toString方法
     */

    public Student() {
    }

    public Student(Integer id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

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

ArrayList 类

ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。

、

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        /**
         * ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。
         * 它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。
         * 使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，
         * 不过，向 ArrayList 中插入与删除元素的速度相对较慢。
         */
        // ArrayList al = new ArrayList();
        List list = new ArrayList();
        list.add(1);
        list.add("list集合");
        list.add(new Date());

        // 创建集合，指定集合元素的类型
        List<String> ls = new ArrayList<>();
        ls.add("1");
        ls.add("java");
        ls.add("python");
        ls.add("C");
        ls.add("C#");
        ls.add("python");

        // 获取指定位置的元素
        String s1 = ls.get(1);
        System.out.println(s1);

        // 获取集合的长度
        System.out.println(ls.size());

        // 返回元素在集合中第一次出现的索引
        System.out.println(ls.indexOf("python"));
        // 返回元素在集合中最后一次出现的位置
        System.out.println(ls.lastIndexOf("python"));

        // 修改指定位置的元素
        // ls.set(3, "C++");
        ls.set(ls.indexOf("C"), "C++");
        System.out.println(ls.get(3));

        // 截取部分集合元素
        List<String> subList = ls.subList(1, 3);
        System.out.println(subList.toString());
    }
}

LinkedList 类

LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素

import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo01 {
    public static void main(String[] args) {
        /**
         * LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。
         * 需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，
         * 但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特
         * 定索引位置的元素。
         */
        LinkedList<Integer>  list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.addFirst(0);
        list.addLast(3);
        list.addLast(99);

        System.out.println(list);

        // 返回此集合的第一个元素
        System.out.println(list.getFirst());
        // 返回此集合的最后一个元素
        System.out.println(list.getLast());

        /**
         * ## 3、ArrayList 类和 LinkedList 类的区别
         *
         * 		ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List
         * 的所有未实现的方法，只是实现的方式有所不同。
         *
         * 		ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。
         * LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于
         * ArrayList。
         *
         * 		对于快速访问对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集
         * 合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高。
         *
         * 		不同的结构对应于不同的算法，有的考虑节省占用空间，有的考虑提高运行效率，
         * 对于程序员而言，它们就像是“熊掌”和“鱼肉”，不可兼得。高运行速度往往是以牺牲空间为代价的，
         * 而节省占用空间往往是以牺牲运行速度为代价的。
         */
    }
}

Set集合

Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序。也就是说 Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合。Set 集合中不能包含重复的对象，并且最多只允许包含一个 null 元素。、

HashSet 类

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。

HashSet 具有以下特点：

1、不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。

2、HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。

3、集合元素值可以是 null。

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

public class HashSetDemo01 {
    public static void main(String[] args) {
        /**
         * HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。
         * HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。
         *
         * HashSet 具有以下特点：
         * 1、不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
         * 2、HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
         * 3、集合元素值可以是 null。
         *
         * 注意：我们说的set集合无序指的是存放元素的顺序与取元素的顺序不一致
         */

        // 创建set集合
        Set<String> set = new HashSet<>();
        // 添加元素
        set.add("Python");
        set.add("Java");
        set.add("C");
        set.add("JavaScript");
        set.add("Python");
        set.add("Java");
        set.add("C");
        set.add("JavaScript");

        // 获取set集合的大小
        int size = set.size();
        System.out.println(size);

        // 判断set集合是否为null
        boolean empty = set.isEmpty();
        System.out.println(empty);

        // 打印set集合
        System.out.println(set);

        // 遍历集合
        // 方式一
        for (String s : set) {
            System.out.println(s);
            // 删除集合
            // set.remove(s); // java.util.ConcurrentModificationException

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

        // 方式二
        // 获取迭代器
        Iterator<String> iterator = set.iterator();
        // 判断是否有下一个元素
        while (iterator.hasNext()){
            // 取出元素
            String next = iterator.next();
            System.out.println(next);
            // 删除集合
            // set.remove(next); // java.util.ConcurrentModificationException
        }

        // 清空集合
        set.clear();
        System.out.println(set);

    }
}

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据该hashCode 值决定该对象在 HashSet 中的存储位置。如果有两个元素通过 equals() 方法比较返回的结果为 true，但它们的 hashCode 不相等，HashSet 将会把它们存储在不同的位置，依然可以添加成功。

也就是说，两个对象的 hashCode 值相等且通过 equals() 方法比较返回结果为 true，则 HashSet 集合认为两个元素相等。

在 HashSet 类中实现了 Collection 接口中的所有方法。HashSet 类的常用构造方法重载形式如下。

1、HashSet()：构造一个新的空的 Set 集合。

2、HashSet(Collection<? extends E>c)：构造一个包含指定 Collection 集合元素的新 Set 集合。其中，“< >”中的 extends 表示HashSet 的父类，即指明该 Set 集合中存放的集合元素类型。c 表示其中的元素将被存放在此 Set 集合中。

Map集合

Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。

Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另外一组值用于保存 Map 里的 value，key 和 value 都可以是任何引用类型的数据。Map 的 key 不允许重复，value 可以重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false。

Map 中的 key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value。从 Map 中取出数据时，只要给出指定的 key，就可以取出对应的 value。

Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。

import java.util.*;

public class HashMapDemo {
    public static void main(String[] args) {
        /**
         * Map 集合最典型的用法就是成对地添加、删除 key-value 对，接下来即可判断该
         * Map 中是否包含指定 key，也可以通过 Map 提供的 keySet() 方法获取所有 key
         * 组成的集合，进而遍历 Map 中所有的 key-value 对。
         */
        // 定义map集合
        Map<String, Object> map = new HashMap<>();

        // 往map集合当中添加键值对
        map.put("java", "hello 詹姆斯高斯林");
        map.put("生日", 1995);
        map.put("content", "分布式与微服务，面向对象");

        map.put("date", new Date());
        map.put("date", "new Date()");

        map.put("java", "詹姆斯高斯林你为什么要设计Java语言，让我现在学的好辛苦");
        map.put("python", "new Date()");

        // 获取map集合的键值对个数
        System.out.println(map.size());

        // 判断集合是否为空
        System.out.println(map.isEmpty());

        // 取元素
        String java = map.get("java").toString();
        System.out.println(java);

        System.out.println(map);

        System.out.println("-------------------------------");
        // 查询 Map 中是否包含指定的 key，如果包含则返回 true。
        System.out.println(map.containsKey("生日"));
        // 查询 Map 中是否包含一个或多个 value，如果包含则返回 true。
        System.out.println(map.containsValue(1995));
        // 从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
        Object val = map.remove("java");
        System.out.println(val.toString());

        System.out.println(map);

        // 这是 Java8 新增的方法，删
        // 除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除
        // 该 key-value 对，该方法返回 true，否则返回 false。
        map.remove("python", "new Date()");
        System.out.println(map);

        // 遍历集合
        // 获取key的set集合对象
        Set<String> keySet = map.keySet();
        // 遍历key
        // 方式一
        for (String key : keySet) {
            // 工具key查找value
            Object value = map.get(key);
            System.out.println(key + " = " + value.toString());
        }

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

        // 方式二
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            // 取出每一个key
            String key = iterator.next();
            // 根据key获取value
            Object value = map.get(key);
            System.out.println(key + " = " + value);
        }

        System.out.println("-------------------------------");
        // 返回该 Map 里所有 value 组成的 Collection
        Collection<Object> values = map.values();
        for (Object value : values) {
            System.out.println(value.toString());
        }

        // 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
        Set<Map.Entry<String, Object>> entries = map.entrySet();


    }
}

Collection 接口

Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

public class Demo01 {
    public static void main(String[] args) {
        // 定义集合
        Collection col = new ArrayList();
        // 添加集合元素
        col.add(1);
        col.add(new Date());
        col.add("Hello wangfu");
        // 获取集合长度
        int len = col.size();
        System.out.println(len);
        // 判断集合中是否存在指定元素
        boolean b = col.contains("Hello erzi");
        System.out.println(b);
        // 判断集合是否为空
        boolean empty = col.isEmpty();
        System.out.println(empty);
        // 返回一个 Iterator 对象，用于遍历集合中的元素
        Iterator iterator = col.iterator();
        // 遍历集合
        while (iterator.hasNext()) {
            // 取元素
            System.out.println(iterator.next());
        }

        col.remove(1);

        System.out.println("#######################");
        for (Object o : col) {
            System.out.println(o.toString());
        }
        // 把集合转换为一个数组，所有的集合元素变成对应的数组元素。
        Object[] objects = col.toArray();
        System.out.println(objects.length);

    }
}

Collections 类

Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制等操作。

Collections 提供了如下方法用于对 List 集合元素进行排序。

void reverse(List list)：对指定 List 集合元素进行逆向排序。
void shuffle(List list)：对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。
void sort(List list)：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List 集合元素进行排序。
void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j 处元素进行交换。
void rotate(List list, int distance)：当 distance 为正数时，将 list 集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度

import java.util.*;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。
         * Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、
         * 查找替换和复制等操作。
         */

        List<String> lt = new ArrayList<>();
        lt.add("java");
        lt.add("C");
        lt.add("C++");
        lt.add("Python");

        // 创建set集合
        Set set = new HashSet<>();
        // 将集合lt放到set集合中
        // 将所有指定的元素添加到指定的集合。
        Collections.addAll(set, lt);

        set.add(lt);

        // 查看set集合的长度
        System.out.println(set.size());

        System.out.println(set);

        Set<List<String>> st = new HashSet<>();


    }
}

练习

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 用指定的元素替换指定列表的所有元素。
         */
        List<String> lt = new ArrayList<>();
        lt.add("java");
        lt.add("C");
        lt.add("C++");
        lt.add("Python");

        System.out.println("替换之前：" + lt);

        // 用指定的元素替换指定列表的所有元素。
//        Collections.fill(lt, "SQL");
//
//        System.out.println("替换之后：" + lt);

        /**
         * 根据其元素的 自然顺序返回给定集合的最大元素。
         */
        String max = Collections.max(lt);
        System.out.println(max);

        /**
         * 根据其元素的 自然顺序返回给定集合的最小元素。
         */
        String min = Collections.min(lt);
        System.out.println(min);

        /**
         * 将列表中一个指定值的所有出现替换为另一个。
         */
        Collections.replaceAll(lt, "java", "JAVA");
        System.out.println(lt);

        /**
         * 反向输出集合内容
         */
        Collections.reverse(lt);
        System.out.println(lt);

        /**
         * 默认排序集合
         */
        Collections.sort(lt);
        System.out.println(lt);

        /**
         * 根据指定的比较器引起的顺序对指定的列表进行排序。
         */
        Collections.sort(lt, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });
        System.out.println(lt);


        /**
         * 交换指定列表中指定位置的元素。
         */
        Collections.swap(lt, 0, lt.size() - 1);
        System.out.println(lt);

    }
}