枚举类+注解+集合

最新推荐文章于 2023-09-12 18:02:27 发布

cencen666

最新推荐文章于 2023-09-12 18:02:27 发布

阅读量299

点赞数

文章标签： java

本文链接：https://blog.csdn.net/cencen666/article/details/116902875

版权

第十二周总结
5.16

文章目录

枚举类
注解
- 使用场景
- 注解的使用
集合

枚举类

一、枚举类的使用

1.枚举类的理解：类的对象只有有限个，确定的，我们称此类为枚举类。
2.当需要定义一组常量时，强烈建议使用枚举类。
3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。

二、如何定义枚举类
方式一：jdk5.0之前，自定义枚举类

public class SeasonTest {

    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);

    }

}
//自定义枚举类
class Season{
    //1.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3.提供当前枚举类的多个对象：public static final的
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","夏日炎炎");
    public static final Season AUTUMN = new Season("秋天","秋高气爽");
    public static final Season WINTER = new Season("冬天","冰天雪地");

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

方式二：jdk5.0，可以使用enum关键字定义枚举类

public class SeasonTest2 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());

       System.out.println(Season1.class.getSuperclass());

    }
}

//使用enum关键字枚举类
enum Season2{
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值
    private Season2(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season2{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

三、Enum类中的常用方法：

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
toString()：返回当前枚举类对象常量的名称

四、使用enum关键字定义的枚举类实现接口的情况

情况一：实现接口，在enum类中实现抽象方法
情况二：让枚举类的对象分别实现接口中的抽象方法

public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());

//        System.out.println(Season1.class.getSuperclass());
        System.out.println("****************");
        //values():返回所有的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);
            values[i].show();
        }
        System.out.println("****************");
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);
        }

        //valueOf(String objName):返回枚举类中对象名是objName的对象。
        Season1 winter = Season1.valueOf("WINTER");
        //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
        System.out.println(winter);
        winter.show();
    }
}

interface Info{
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    //可以实现各自的show方法
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里？");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","冰天雪地"){
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
//全部只出现该句
//    @Override
//    public void show() {
//        System.out.println("这是一个季节");
//    }
}

项目三改成枚举表示

        Programmer p = (Programmer)e;//一定不会出现ClassCastException，即因为已经过了第二条判断语句，因此就能确定e属于Programmer
//        if ("BUSY".equals(p.getStatus().getNAME())){
//            throw new TeamException("该成员已是某团队成员");
//        }else if("VOCATION".equals(p.getStatus().getNAME())){
//            throw new TeamException("该成员正在休假，无法添加");
//        }
        switch (p.getStatus()){//byte\short\char\int\String\枚举类对象
            case BUSY:
                throw new TeamException("该成员已是某团队成员");
            case VOCATION:
                throw new TeamException("该成员正在休假，无法添加");
        }

//public class Status {
//    private final String NAME;
//    private Status(String NAME){
//        this.NAME = NAME;
//    }
//    public static final Status FREE = new Status("FREE");
//    public static final Status BUSY = new Status("BUSY");
//    public static final Status VOCATION = new Status("VOCATION");
//
//    public String getNAME() {
//        return NAME;
//    }
//
//    @Override
//    public String toString() {
//        return NAME;
//    }
//}
public enum Status{
    FREE,BUSY,VOCATION;
}

注解

从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是
Annotation(注解)
Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加
载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员
可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代
码分析工具、开发工具和部署工具可以通过这些补充信息进行验证
或者进行部署。
Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方
法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 Annotation
的 “name=value” 对中。
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，
忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如
用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗
代码和XML配置等。
未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以
上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的
Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上
可以说：框架 = 注解 + 反射 + 设计模式

使用场景

1 . 生成文档相关的注解

@author 标明开发该类模块的作者，多个作者之间使用,分割
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@since 从哪个版本开始增加的
@param 对方法中某参数的说明，如果没有参数就不能写
@return 对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception 对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写
其中
@param @return 和 @exception 这三个标记都是只用于方法的。
@param的格式要求：@param 形参名形参类型形参说明
@return 的格式要求：@return 返回值类型返回值说明
@exception的格式要求：@exception 异常类型异常说明
@param和@exception可以并列多个

2. 在编译时进行格式检查（JDK内置的三个基本注解）

@Override: 限定重写父类方法, 该注解只能用于方法。
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择。
@SuppressWarnings: 抑制编译器警告性，实现替代配置文件功能。

3 .跟踪代码依赖性，实现替代配置文件功能

Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署。
spring框架中关于“事务”的管理。

注解的使用

1 . 理解Annotation:

① jdk 5.0 新增的功能
② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。

2 . Annocation的使用示例
示例一：生成文档相关的注解

/**
 * @Classname AnnotationTest
 * @Description TODO
 * @Date 2021/5/19 10:50
 * @Created by cencen
 */
public class AnnotationTest {
}

示例二：在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法。如果注解了其他非重写的方法，将会报错
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告

示例三：跟踪代码依赖性，实现替代配置文件功能

3 . 如何自定义注解：参照@SuppressWarnings定义

① 注解声明为：@interface
② 内部定义成员，通常使用value表示
③ 可以指定成员的默认值，使用default定义
④ 如果自定义注解没有成员，表明是一个标识作用。

1 . 如果注解有成员，在使用注解时，需要指明成员的值。即注解后要有值，可以统一设值。
2 . 自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
3 . 自定义注解通过都会指明两个元注解：Retention、Target

public @interface MyAnnotation {
    String value() default "hello";
}

//jdk 8之前的写法：
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
    private String name;
    private int age;

    public Person() {
    }
    @MyAnnotation
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人吃饭");
    }
}

4 . jdk 提供的4种元注解
元注解：对现有的注解进行解释说明的注解(修饰其他注解的注解）

Retention: 指定所修饰的 Annotation 的生命周期：SOURCE\CLASS(默认行为)\RUNTIME
只有声明为RUNTIME生命周期的注解，才能通过反射获取。

@Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用@Rentention 时必须为该 value 成员变量指定值:
RetentionPolicy.SOURCE: 在源文件中有效（即源文件保留），编译器直接丢弃这种策略的
注释
RetentionPolicy.CLASS: 在class文件中有效（即class保留），当运行 Java 程序时, JVM
不会保留注解。这是默认值
RetentionPolicy.RUNTIME: 在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会
保留注释。程序可以通过反射获取该注释。

Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素

********* 出现的频率较低 *********
Documented:表示所修饰的注解在被javadoc解析时，保留下来。
Inherited:被它修饰的 Annotation 将具有继承性。

5 .通过反射获取注解信息 —到反射内容时系统讲解

6 . jdk 8 中注解的新特性：可重复注解、类型注解
6.1 可重复注解：① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。

//jdk 8之前的写法：
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})

@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
    private String name;
    private int age;

    public Person() {
    }
    @MyAnnotation
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人吃饭");
    }
}

//jdk8之前用到
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {

    MyAnnotation[] value();
}

6.2 类型注解：
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

集合

一、集合框架的概述

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）

2.1 数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如：String[] arr;int[] arr1;Object[] arr2;

2.2 数组在存储多个数据方面的缺点：

一旦初始化以后，其长度就不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二、集合框架

  （1）Collection接口：单列集合，用来存储一个一个的对象
       |----List接口：存储有序的、可重复的数据。  -->“动态”数组
           |----ArrayList、LinkedList、Vector
       |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
          |----HashSet、LinkedHashSet、TreeSet

 （2）Map接口：双列集合，用来存储一对(key - value)一对的数据   -->高中函数：y = f(x)
           |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口中声明的方法

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

常用方法一

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1整个集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());

    }
}

常用方法二

public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        
        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new String("Tom")));//true
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry",20)));//false -->true，重写方法
//输出Person equals()....代表调用次数//以上同理
//Person equals()....//和123比
//Person equals()....//和456比
//Person equals()....//和"Jerry",20比，一致即true
//true


        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll1));//false由于前边添加的集合为123，456。而这里多了一个7.所以false
    }

//重写的equals方法
  @Override
    public boolean equals(Object o) {
        System.out.println("Person equals()....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

常用方法三

 public void test2(){
        //3.remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        coll.remove(1234);
        System.out.println(coll);//[123, 456, Person{name='Jerry', age=20}, Tom, false]

        coll.remove(new Person("Jerry",20));
        System.out.println(coll);//[123, 456, Tom, false]

        //4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);//[Tom, false]
    }

常用方法四

 public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

//        5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);//[123, 456]

        //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add(123);
        coll1.add(new Person("Jerry",20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        System.out.println(coll.equals(coll1));//false->涉及到有序问题，456和123顺序反了就是false
    }

常用方法五

    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //8.集合 --->数组：toArray()
        Object[] arr = coll.toArray();
        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

        //拓展：数组 --->集合:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);

        List arr1 = Arrays.asList(new int[]{123, 456});//存一个int型数组看做是一个对象
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(new Integer[]{123, 456});//存两个
        System.out.println(arr2.size());//2

        List<int []> arr3 = Arrays.asList(new int[]{123,456});
        System.out.println(arr3);//[[I@722c41f4]  原因是把以上两个数当做一个元素看待
        //9.iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测
    }

三、集合元素的遍历操作

方法一： 使用迭代器Iterator接口
Iterator对象成为迭代器，主要用于遍历Collection集合中的元素

迭代器模式的定义： 提供一种方法访问一个容器（在java中不是集合就是数组，但数组没必要迭代器）对象中的各个元素，而又不不需要暴露该对象的内部细节

迭代器执行原理：
在这里插入图片描述
hasNext()是指针下移
Iteration用于遍历而不是是容器

集合元素的遍历操作，使用迭代器Iterator接口

内部的方法：hasNext() 和 next()
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
默认游标都在集合的第一个元素之前。
内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

public class IteratorTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //报异常：NoSuchElementException
//        System.out.println(iterator.next());

        //方式二：不推荐
//        for(int i = 0;i < coll.size();i++){
//            System.out.println(iterator.next());
//        }

        //方式三：推荐
        hasNext():判断是否还有下一个元素
        while(iterator.hasNext()){
            //next():①指针下移 ②将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }

    }

    @Test
    public void test2(){

        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //错误方式一：
//        Iterator iterator = coll.iterator();
//        while((iterator.next()) != null){//判断123的确不等于null
//            System.out.println(iterator.next());//但到该语句时就直接输出next的内容了，就忽视了123，结果是跳着输出
//        }

        //错误方式二：
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());//结果一直输出123 
        }


    }

    //测试Iterator中的remove()
    //如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
    // 再调用remove都会报IllegalStateException。
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
//                iterator.remove();
            }

        }
        //遍历集合
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

方法二： foreach循环遍历集合或项目
for(String s : arr){ }的s是新创建的一个值，因此一下对s操作均对原集合不产生影响

public class ForTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素的类型 局部变量 : 集合对象)
        //内部仍然调用了迭代器。
        for(Object obj : coll){
            System.out.println(obj);
        }
    }

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //for(数组元素的类型 局部变量 : 数组对象)
        for(int i : arr){
            System.out.println(i);
        }
    }

    //练习题
    @Test
    public void test3(){

        String[] arr = new String[]{"MM","MM","MM"};

//        //方式一：普通for赋值
//        for(int i = 0;i < arr.length;i++){
//            arr[i] = "GG";//输出为GG    
//		   }

        //方式二：增强for循环
        for(String s : arr){
            s = "GG";//输出仍为MM
        }

        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

四、Collection子接口之一：List接口

重写equals（）
1.List接口框架存储 有序的、可重复 的数据

|----Collection接口：单列集合，用来存储一个一个的对象
      |----List接口：存储 **有序的、可重复**  的数据。  -->“动态”数组,替换原有的数组
          |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
          |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
          |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

2. ArrayList的源码分析：
2.1 jdk 7情况下

  ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
  list.add(123);//elementData[0] = new Integer(123);
  ...
   list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
   默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

2.2 jdk 8中ArrayList的变化：

    ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
 
 	list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

//	...
//	后续的添加和扩容操作与jdk 7 无异。

2.3 小结：
jdk7中的ArrayList的对象的创建类似于单例的饿汉式；
jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

3.LinkedList的源码分析：

 LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null 
 list.add(123);//将123封装到Node中，创建了Node对象。

其中，Node定义为：体现了LinkedList的双向链表的说法

private static class Node<E> {
	 E item;
	 Node<E> next;
 	 Node<E> prev;

	 Node(Node<E> prev, E element, Node<E> next) {
 		this.item = element;
		this.next = next;
 		this.prev = prev;
	 }
 }

4. Vector的源码分析： jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。

面试题：ArrayList、LinkedList、Vector三者的异同？
同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：见上

5. list接口常用方法

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素

 @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
//        list.add(list1);
        System.out.println(list.size());//9

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));//123
    }
}

int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        int index = list.indexOf(4567);
        System.out.println(index);//-1

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));//4

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);//123
        System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456]

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);//[Person{name='Tom', age=12}, 456]
        System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]
    }

总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式 ② 增强for循环 ③ 普通的循环

//遍历
public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

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

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }

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

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
    }

面试题：区分List中remove(int index)和remove(Object obj)

public class ListExer {
    /*
    区分List中remove(int index)和remove(Object obj)
     */
    @Test
    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);
    }

    private void updateList(List list) {
//        list.remove(2);//删下标对应的值得[1,2]
        list.remove(new Integer(2));//删内容值得[1,3]
    }

}

五、Collection子接口之一：Set接口

重写equals()和hashcode()

1 . Set接口的框架：

 |----Collection接口：单列集合，用来存储一个一个的对象
         |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
              |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
                    |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
                    					会额外的增加双向链表，用于记录添加的先后顺序
                                        对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
              |----TreeSet：可以按照添加对象的指定属性，进行排序。

2 . Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

3 .

要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码（即hashcode）
- 重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。
问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的 “冲突”就越少，查找起来效率也会提高。（减少冲突）
并且31只占用5bits,相乘造成数据溢出的概率较小。
31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
-31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)

一、Set：存储无序的、不可重复的数据
以HashSet为例说明：

无序性： 不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
不可重复性： 保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。

二、添加元素的过程：以HashSet为例：
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功。 —>情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值
-> 如果hash值不相同，则元素a添加成功。—>情况2
-> 如果hash值相同，进而需要调用元素a所在类的equals()方法：
--------- equals()返回true,元素a添加失败
--------- equals()返回false,则元素a添加成功。—>情况3
```
 对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
 jdk 7 :元素a放到数组中，指向原来的元素。
 jdk 8 :原来的元素在数组中，指向元素a
 总结：七上八下
 先用hashcode比位置，再用equals比内容
```

HashSet底层：数组+链表的结构。

HashSet的使用

 @Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

LinkedHashSet的使用

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。即使用双向链表。
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

HashSet和LinkedHashSet的区别

类HashSet和LinkedHashSet都是接口Set的实现，两者都不能保存重复的数据。主要区别是

HashSet不保证集合中元素的顺序，即不能保证迭代的顺序与插入的顺序一致。
LinkedHashSet按照元素插入的顺序进行迭代，即迭代输出的顺序与插入的顺序保持一致。

TreeSet
1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

Comparable:用compareTo(Object obj)
Comparator:用compare(Object o1,Object o2)

compareTo和compare的区别

1.练习：在List内去除重复数字值，要求尽量简单
利用list的不可重复性，删去重复后遍历输出。


    public static List duplicateList(List list) {
        HashSet set = new HashSet();
        set.addAll(list);
        return new ArrayList(set);
    }
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(4));
        list.add(new Integer(4));
        List list2 = duplicateList(list);
        for (Object integer : list2) {
            System.out.println(integer);
        }
    }

2 .

  @Test
    public void test3(){
        HashSet set = new HashSet();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");

        set.add(p1);
        set.add(p2);
        System.out.println(set);
//目的想删除AA这一项
//但是当AA改为CC时，remove找到的对象未必为原来AA所在位置的对象
//因为remove是根据索引找寻，它很有可能找到其他hashcode值的对象
//导致删的是其他对象
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);

//此时加的是真正的属于CC的另一个位置，而之前的CC是原先AA在的位置，所以可以重复      
        set.add(new Person(1001,"CC"));
        System.out.println(set);
        
 //由于此时找到的位置AA位置已被改成CC，所以可以重新在该1001位子上加AA
        set.add(new Person(1001,"AA"));
        System.out.println(set);

    }

结果：
在这里插入图片描述

六、 Map接口

一、Map的实现类的结构：

 |----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
      |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
          |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
                    原因：在原有的HashMap底层结构基础上，添加了一对 指针，指向前一个和后一个元素。
                          对于频繁的遍历操作，此类执行效率高于HashMap。
      |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
                      底层使用红黑树。存储null的key
      |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
          |----Properties:常用来处理配置文件。key和value都是String类型

HashMap的底层：
数组+链表（jdk7及之前）
数组+链表+红黑树（jdk 8）

面试题：

HashMap的底层实现原理？
HashMap 和 Hashtable的异同？
CurrentHashMap 与 Hashtable的异同？（暂时不讲）

二、Map结构的理解：

Map中的key:无序的、不可重复的，使用Set存储所有的key —> key所在的类要重写equals()和hashCode() （以HashMap为例）
Map中的value:无序的、可重复的，使用Collection存储所有的value —>value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所有的entry

三、HashMap的底层实现原理？以jdk7为例说明：

    HashMap map = new HashMap():
    在实例化以后，底层创建了长度是16的一维数组Entry[] table。
      ...可能已经执行过多次put...
    map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
      如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
      如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
            如果equals()返回false:此时key1-value1添加成功。----情况3
            如果equals()返回true:使用value1替换value2。
                       
补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

jdk8 相较于jdk7在底层实现方面的不同：

new HashMap():底层没有创建一个长度为16的数组
jdk 8底层的数组是：Node[],而非Entry[]
首次调用put()方法时，底层创建长度为16的数组
jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR： HashMap的默认加载因子：0.75
threshold： 扩容的临界值，=容量 * 填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

面试题：负载因子值的大小，对HashMap有什么影响

负载因子的大小决定了HashMap的数据密度。
负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,
造成查询或插入时的比较次数增多，性能会下降。
负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的
几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性
能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建
议初始化预设大一点的空间。
按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此
时平均检索长度接近于常数。

四、LinkedHashMap的底层实现原理（了解）
能记录加入先后顺序
源码中：

static class Entry<K,V> extends HashMap.Node<K,V> {
	Entry<K,V> before, after;//能够记录添加的元素的先后顺序
 	Entry(int hash, K key, V value, Node<K,V> next) {
 		super(hash, key, value, next);
 	}
 }

在这里插入图片描述
五、Map中定义的方法：
1 . 添加、删除、修改操作：

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中。有重复的key，位置为最开始添加key的位置，而取值为最后一次出现的key的value。value值可以相同

public void test1(){
        Map map = new HashMap();
        //添加
        map.put("AA",1);
        map.put("bb",2);
        map.put("Acc",3);
        //修改
        map.put("AA",4);
        System.out.println(map);
 输出：{AA=4, bb=2, Acc=3}

void putAll(Map m):将m中的所有key-value对存放到当前map中

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);
        System.out.println(map);

输出：{AA=87, BB=56, CC=123, DD=123, 45=123}

Object remove(Object key)：移除指定key的key-value对，并返回value

        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

		Object value1 = map.remove("CC");
        System.out.println(value);
        System.out.println(map);
输出：123
	 {AA=87, BB=56, DD=123, 45=123}
	 null
	 {AA=87, BB=56, DD=123, 45=123}

void clear()：清空当前map中的所有数据

        map.clear();//与map = null操作不同
        System.out.println(map.size());
        System.out.println(map);
输出：0
	 {}

2 .元素查询的操作：

Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        
        // Object get(Object key)
        System.out.println(map.get(45));//123
        
        //containsKey(Object key)
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);//true
        
        //containsValue(Object value)
        isExist = map.containsValue(123);
        System.out.println(isExist);//true

        System.out.println(map.isEmpty());//false
        map.clear();
        System.out.println(map.isEmpty());//true
    }

3 .元视图操作的方法：

Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合

 public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        System.out.println();
}
结果: AA
      BB
	  45

	  123
	  56
 	  1234

Set entrySet()：返回所有key-value对构成的Set集合

 public void test5(){
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
        System.out.println();
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);
        }
    }

4 .总结：常用方法：

添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet() / values() / entrySet()

TreeMap两种排序方法
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
//因为要按照key进行排序：自然排序、定制排序


    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配！");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

Properties:常用来处理配置文件。 key和value都是String类型

在名字.iml中添加名字.properties文件
文件里的内容=前后不要有空格

2.在类中

public class PropertiesTest {
    public static void main(String[] args) {
    
//下
        FileInputStream fis = null;
        try {
            Properties pros = new Properties();
            fis = new FileInputStream("jjj.properties");
            pros.load(fis);
            String name = pros.getProperty("name");
            String password = pros.getProperty("password");
            System.out.println("name = "+name+"  password = "+password);
//上   重点代码

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Collections:操作Collection、Map的工具类

常用方法

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

@Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(765);
        list.add(765);
        list.add(-97);
        list.add(0);

        System.out.println(list);//[123, 43, 765, 765, 765, -97, 0]
        //反转
        Collections.reverse(list);
        System.out.println(list);//[0, -97, 765, 765, 765, 43, 123]
        //打乱
        Collections.shuffle(list);
        System.out.println(list);//[765, -97, 0, 765, 765, 123, 43]每次都会不一样，是主动打乱而非无须
        //排序
        Collections.sort(list);
        System.out.println(list);//[-97, 0, 43, 123, 765, 765, 765]

        //交换位置
        Collections.swap(list,1,2);
        System.out.println(list);//[-97, 43, 0, 123, 765, 765, 765]

        //找出现次数
        int frequency = Collections.frequency(list, 123);
        System.out.println(list);//[-97, 43, 0, 123, 765, 765, 765]
        System.out.println(frequency);//1

    }

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

  @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);

        //报异常：IndexOutOfBoundsException("Source does not fit in dest")
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确的：
        List dest = Arrays.asList(new Object[list.size()]);//也就是开了一个一样大小的list
        System.out.println(dest.size());//list.size();
        Collections.copy(dest,list);

        System.out.println(dest);

        /*
        Collections 类中提供了多个 synchronizedXxx() 方法，
        该方法可使将指定集合包装成线程同步的集合，从而可以解决
        多线程并发访问集合时的线程安全问题
         */
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);
    }

Map存储数据的特点是什么？并指明key，value，entry存储数据的特点。
双列数据，存储key-value对数据。

key：无序的、不可重复的 —> Set存储
value:无序的、可重复的 –> Collection存储
key-value:无序的、不可重复 —> Set存储