集合简介

关系示例图

Collection接口实现类的特点

Collection接口常用方法

Collection接口遍历元素方式：

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！

*/public class Main {
    public static void main(String[] args) {
        Collection List=new ArrayList();
        List.add(new Book("小米","雷军",28.9));
        List.add(new Book("小米","雷军",28.9));
        List.add(new Book("小米","雷军",28.9));
        List.add(new Book("小米","雷军",28.9));
        Iterator iterator=List.iterator();//返回List的迭代器（Iterator）
        while (iterator.hasNext())//判断返迭代器中下一个是元素还是抛出异常，是元素返回true
        {
            Object object=iterator.next();//返回下一个元素，返回类型是Object
            System.out.println(object);
        }
        //增加for循环，底层仍然是迭代器
        for (Object book:List)
            System.out.println(book);

    }
}
class Book{
    private String name;
    private String author;
   private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

List接口常用方法

package com.List;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class test {
    public static void main(String[] args) {
        List list= new ArrayList();
        list.add("续爱");
        list.add("小美");
        System.out.println(list);//[续爱, 小美]
        System.out.println(list.get(1));//小美可获取对应下标序列的数据
        //1表示加入的数据插入的位置下标
        list.add(1,"续期");
        System.out.println(list);//[续爱, 续期, 小美]
        List list1=new ArrayList();
        list1.add("小怒");
        //在指定位置插入另一个集合
        list.addAll(0,list1);
        System.out.println(list);//[小怒, 续爱, 续期, 小美]
        System.out.println(list.lastIndexOf("小怒"));//最后一次出现的位置（下标）
        System.out.println(list.indexOf("小怒"));//第一次出现该数据的位置（下标）
        list.remove(0);//移除指定下标的数据
        System.out.println(list);//[续爱, 续期, 小美]
        list.set(2,"梦里");//指定位置的数据替换成我们现在输入的数据
        System.out.println(list);//[续爱, 续期, 梦里]
        System.out.println(list.subList(0,2));//[续爱, 续期]从0号下标的数据到2号下标前一位数据。

    }
}

例题：

package com.List.test01;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
ListExercise.java
●添加10个以上的元素(比如String"hello”),在2号位插入一个元素“韩顺平教
育”,获得第5个元素,删除第6个元素,修改第7个元素,在使用迭代器遍历集
合,要求:使用List的实现类ArrayList完成。
*/public class test01 {
    public static void main(String[] args) {
        List list= new ArrayList();
        list.add("美女");
        list.add("帅哥");
        list.add("小胡");
        list.add("小美");
        list.add("东东");
        list.add("美女");
        list.add("帅哥");
        list.add("小胡");
        list.add("小美");
        list.add("东东");
        list.add(1,"韩顺平");
       list.get(4);
       list.remove(5);
        list.set(6,"小敏");
        for (Object o :list) {
            System.out.print(o+" ");

        }


    }
}

List三种遍历方法

package com.List.test02;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用List的实现类添加三本图书,并遍历,打印如下效果

名称:xx
名称:xx
名称:xx
要求
1)按价格排序,从低到高(使用冒泡法)
2)要求使用ArrayList、LinkedList 和 Vector三种集合实现

*/public class test02 {
    public static void main(String[] args) {
      List list=  new ArrayList();
      list.add(new Book("小米","雷军",1999));
      list.add(new Book("泪目","设计",1234));
      list.add(new Book("箱子哦","啊上档次",120));
      manner_(list);
    }
    static void manner_(List list)
    {
        for(int i=0;i<list.size()-1;i++)
        {
            for(int j=0;j<list.size()-1-i;j++)
            {

                Book o=(Book)list.get(j);
                Book o1=(Book)list.get(j+1);

                if (o.getPrice()>o1.getPrice())
                {
                    list.set(j,o1);
                    list.set(j+1,o);

                }


            }
        }
        Iterator iterator=list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}
class Book{
    private String name;
    private String author;
    double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

ArrayList注意事项

ArrayList源码

调用ArrayList无参构造器的源码代表此时的elementData为默认的一个elemenData深入可发现目前就是空的一个数组

ensuCapacityInternal（）确认容量是否够，然后再赋值

ensuCapacityInternal（）方法内容是先判断elementData是否空数组，是就给你添个扩容值。扩容值从与minCapacity中选大的那个，而此时默认值是10，minCaoacity是我们上面那步传进来的1，所以再调用ArrayList无参构造器时，第一次添加给的容积为10，确定了扩容值后再来到该方法确定是否真的要扩容

modCound++表示当前集合修改的次数，再往下的判断表示，要扩容的值是否能被当前有的容积容纳，当前的容积是否够，如果大于0代表不够，开始扩容

来到扩容的方法，表示，新的容积等于当前的容积加上当前的容积除以2（向右移一位）也就是扩成当前的1.5倍，再来判断，新的是否小于之前需要的容量，小于那么就让新的容量变成需要的容量

然后开始扩容数组，

使用copyof（）来完成这个方法是因为他不会覆盖原有的值进行扩容

要去掉该选项，不然Debug会阉割数据

走有参构造器的ArrayList，创建一个指定大小的数组

Vector介绍

Vector与ArrayList比较

使用无参构造器，底层默认给你十个容量

到加数据的方法add，modCount也是记录修改的次数。然后ensureCapcityHelper是确定需要的空间和已有的空间匹不匹配。如果大于零则不够需要扩容

判断capacityIncrement是否大于0.如果不大于0则就是oldCapacity加oldCapacity为当前容量，也就是所说的按2倍扩容。

有参构造器

LinkedList介绍

底层解析

链表调用无参构造器删除的是第一个节点

ArrayList与LinkedList比较

Set接口

Set接口常用方法

HashSet介绍

底层机制介绍

占位作用

得到传进来的数的hash值，这个值决定着数存放的位置

package com.test01;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
定义一个Employee类,该类包含:private成员属性name,age要求:
1.创建3个Employee放入HashSet中
2.当name和age的值相同时,认为是相同员工,不能添加到HashSet集合中
*/public class test01 {
    public static void main(String[] args) {
       HashSet set = new HashSet();
        System.out.println(set.add(new Employee("小米",18)));
        System.out.println(set.add(new Employee("小米",18)));

    }
}
class Employee{
    private String name;
    private int  age;

    public Employee(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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package com.test02;

import java.util.HashSet;
import java.util.Objects;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
定义一个Employee类,该类包含:private成员属性name,sal,birthday(MyDate类
型),其中birthday为MyDate类型(属性包括:year,month,day),要求:
1.创建3个Employee放入HashSet中
2.当name和birthday的值相同时,认为是相同员工,不能添加到HashSet集合中
*/public class test02 {
    public static void main(String[] args) {
        //Employee employee = new Employee("小美", "女", new Employee.myDate(2003, 1, 1));
        HashSet set = new HashSet();
        System.out.println(set.add(new Employee("小美", "女", new Employee.myDate(2003, 1, 1))));
        System.out.println(set.add(new Employee("小美", "女", new Employee.myDate(2003, 1, 1))));


    }

}
class Employee{
    private String name;
    private String sex;
    myDate birthday;
    static class myDate{
        private int year;
        private int month;
        private int day;

        public myDate(int year, int month, int day) {
            this.year = year;
            this.month = month;
            this.day = day;
        }

        public int getYear() {
            return year;
        }

        public void setYear(int year) {
            this.year = year;
        }

        public int getMonth() {
            return month;
        }

        public void setMonth(int month) {
            this.month = month;
        }

        public int getDay() {
            return day;
        }

        public void setDay(int day) {
            this.day = day;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            myDate myDate = (myDate) o;
            return year == myDate.year && month == myDate.month && day == myDate.day;
        }

        @Override
        public int hashCode() {
            return Objects.hash(year, month, day);
        }
    }

    public Employee(String name, String sex, myDate birthday) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
    }

    public Employee(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(name, employee.name) && Objects.equals(sex, employee.sex) && Objects.equals(birthday, employee.birthday);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sex, birthday);
    }
}

 TreeSet解析

解析：

TreeSet底层是TreeMap，

使用add（）方法添加数据时，使用m调用了方法put（）

将需要传入的数据传入方法p）中，以及，为支持映射的对象关联的虚拟值。

进入put（K key, V value）方法后，又调用了，put（K key, V value，replaceOld），值得一提的是，此时的key为传入的值，value为，

再然后进入到put（K key, V value，replld）方法，创建一个类型的t用来指向前面创建得同类型的root，root默认值为null所以此时，t也为null，所以可以进入下面的判断语句，该判断语句内调用了方法

进入该方法先是将传入的key传入中，传入第一个数据进入该方法其实是为了判断传入的是否为null值此时的key的值都为传入的数据“ab”，进入该方法内，我们需要判断comparator是否为null，注该变量是初始值是随机生成的，每次都不太一样，但尽管如此，也都不为null，所以在该方法就需要返回这部分的结果，因为我们在之前创建Comparator对象时重写了Comparator的compare（）方法，所以这时调用的就是重写的这个方法进行比较，传入的值

重写的方法调用了该方法进行比较，比较方法是拿到字符串底层的数组value，然后将v1和v2数组指向需要比较的两个字符串的ASCII值，注意JDK9之后由byte类型的数组来存储String，维护了一个属性coder，它是一个编码格式的标识，使用LATIN1还是UTF-16，这个是在String生成的时候自动的，如果字符串中都是能用LATIN1就能表示的就是0，否则就是UTF-16.显然我们得例子这次都可以使用LATIN1，所以c判断为真，

进入中

该方法拿到两个数组的长度，然后又调用了

这个方法首先调用Math类的min方法拿到两个数组长度中较小的值，然后作为遍历的结束因素，然后进入for循环，开始逐个数据逐个数据比较，如果，两个数组当前的数据不相同，则进入判断返回两个数据的ASCII值的差数，如果知道遍历结束都没有进入if判断，则直接返回两个数组的长度差

经过层层调用比较又回到了这，新建一个Entry对象，并且将我们传入的值key和value传入新建的这个对象，此时这个对象里的key为“ab”，value的值为，parent的值为null。

然后将为null的root指向他，​​​​​​​此时，完成了数据的存放，所以记录数据个数的size赋值为1，然后记录修改次数的modCount也需要++，接着回到了这进行下一步直接返回null

一路返回到这，可以看出来，这里进行了一个判断，因为返回的是null所以为真，所以最终会返回true，那么代表 System.out.println(treeSet.add("ab"));结果会打印出true。

此时第一个数据才算真的装入完毕。

当我们要接着装入值时，前面步骤一致，来到这才有所不同，

 通过第一个数据的加入可知，root不再是null。所以t的不是null，那么将不再进入第一个判断语句，

接着往下走，我们可知Comparator的值不是为null是有默认值的，所以，将进入第二个判断语句，

将新建的parent变量指向了我们得t，然后再讲t指向的地址中的key的值与刚传入的key进行比较，之前有分析过比较的方式是最终会返回不同字母时的ASCII值的差或者长度差，因为我们这次传入的是cd，上次是ab，所以这次返回的是2，那么cmp就为2，2是大于0的所以进入这个判断，将t指向t.right,因为从未有过关于t.right的操作并且right默认值是null，所以目前t也为null，所以将退出此循环，来到该方法，将我们本次传入的数据传入新建的entry对象中，然后因为传入的cmp<0是小于0所以addToleft为false则进入else中，将传入的parent也就是原本指向上一个传入的数据的right指向刚传入的数据

为红黑树的设计暂时不研究，然后就是记录数据的size++，记录修改次数的modCount++。由上可得知，大的成为右节点，小的成为他的左节点

LinkHashSet介绍

底层介绍

package com.test02;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Objects;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
Car类(属性:name,price),如果name和price一样,
则认为是相同元素,就不能添加。
*/public class test03 {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        System.out.println(linkedHashSet.add(new Car("小牧",1233)));
        System.out.println(linkedHashSet.add(new Car("小牧",1233)));

    }
}
class Car{
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

Map接口介绍及常用方法

Map体系继承图

常用方法

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用HashMap添加3个员工对象,要求
键:员工id
值:员工对象
并遍历显示工资>18000的员工(遍历方式最少两种)
员工类:姓名、工资、员工id
*/public class test01 {
    public static void main(String[] args) {
        Map map = new HashMap();
        //Employee employee = new Employee(12, "小美", 12340);
//        Employee employee1 = new Employee(13, "亚美", 12240);
//        Employee employee2 = new Employee(14, "猪猪", 12349);
        map.put(12,new Employee(12, "小美", 12340));
        map.put(14,new Employee(14, "猪猪", 123499));
        map.put(15, new Employee(15, "猪猪", 12349));
        Set set = map.entrySet();
        for (Object o :set)//将set逐个给了o，
        {
            Map.Entry m=(Map.Entry)o;//因为具体的key，value的值再Map.Entry里，相应拿到就需要强转
            Employee e=(Employee) m.getValue();//因为要判断工资，所以为了拿到工资，我们需要拿到value部分并强转成Employee类
            if (e.getSalary()>18000)//拿到并判断
            {
                System.out.println(m.getValue());}//使用getValue方法打印相应数据


        }
        Set set1 = map.entrySet();
        Iterator iterator=set.iterator();
        while (iterator.hasNext())
        {
            Map.Entry m=(Map.Entry) iterator.next();
            Employee n=(Employee)m.getValue();
            if (n.getSalary()>18000)
                System.out.println(m.getValue());

        }
        Set keySet = map.keySet();//通过方法keySet（）将Map中所有的key值放入keySet中
        for (Object o :keySet) {
            Employee e=(Employee) map.get(o);//通过get（key）方法拿到key对应的value，强转成Employee
            if (e.getSalary()>18000)
            System.out.println(o+" "+map.get(o));

        }


    }
}
class Employee{
   private int id;
   private String name;
   private double salary;

    public Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public Employee(int id) {
        this.id = id;
    }

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

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

 HashMap底层解析

把Node转为entry类型，然后放到entryset里，不过只是指向，目的是方便遍历，因为里面有getvalue和getkey方法

将数据传传入，hash（）方法计算hash值的，由此可见传入的是key，所以key的数据对hash值有直接影响，然后进入putVal（）方法

为true表示不改值和为false表示为创建模式，此时前者为false后者为true，该判断中，注意，若是第一次放入数据则，table初始就为null，tab为刚新建的，通过赋值过程，tab目前也为null，则开始调用方法，进行扩容，然后再将扩容好的数组让tab指向，此时tab不再为null，n接收此时扩容好的tab的数组长度，

扩容细节介绍

先创建一个一个数组oldTab指向当前的table数组，然后再来确定oldCap的值，如果oldTab为null则oldCap就为0否则就为oldTab数组的长度，因为首次table为null，所以oldCap就为0，可见oldCap存放的是数组长度

由上可得threshold默认值为0，则初次时oldThr也为0，再进行到下一步的判断，由于一开始，oldCap为0则不进入次if，又因为oldThr也为0则也不进入else if（）所以会直接到达else

为默认初始容量，值为16，所以此时的newC16，而为加载因子，初始值为0.75，用于提前为扩容考量的，当使用的空间到达用这个数计算出的值就会开始扩容，而不是等到到达当前所拥有的空间的极限才开始扩容，比如此时的newThr为16*0.75=12，则空间占用到12则开始实施扩容。

接着往下走，判断newThr是否为0，此时newThr为12，所以不进入此if

直接来到该步骤，将刚刚计算的临界值付给threshold，此时threshold不再为0而为12，然后新建一个数组容量为newCap（16）的数组newTab

由于第一次存入数据，oldTab还是null，所以不执行则语句直接返回刚刚新建的数组

接收到新建的数组后将tab指向返回的数组，然后将其长度赋给n此时n的值为16

然后再来判断tab的这个位置是否存有数据，如果没有，则将刚刚传入的数据放入该位置，并且让p指向该数据如果有了则判断现在传进来的hash值跟p指向的数据的hash值是否一样，传进来的key值是否和p指向的数据是否一样或者传进来的key是否为null且传入的key与p指向的key是否相同（使用equals判断就要看程序员是否重写equals了，具体判定是哪方面的相同全看equals方法的写法），之所以进行这样的判断是因为，hash值的多少与key的值密不可分（之前计算hash值时传入key参与计算了）。如果此判断为真，则将创建得e指向p，所以现在e也指向了p所指向的数据，

通过以上步骤则来到该判断，因为e指向与p同样的地址且地址是有存放数据的则e不可能为null，所以进入此判断语句，表示当前e指向的地址的value值，将其赋给oldValue，然后来到判断，因为原本是false，通过！符号就为true了，则进入该判断语句，通过将传入的value赋给e当前指向的地址所存放的value。从而改变value的值，返回原value值。

倘若顺利进行到这一步，则下一步

赋完数据，直接来到，这表示记录修改次数，

这个size数值个数的计算，判断当前数据是否大于设置的临界值如果大于则扩容，若是第一次数据加入则为12，不大于则进行下一步返回null

另外此方法还未写所以目前来说调用也还无意义

l

HashMap扩容解析

 HashMap小结

HashTable介绍

关系图

HashMap和Hashtable对比

Properties介绍

示意图

总结各类型的选择

示例：

import java.util.*;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class test02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("tom");
        list.add("nice");
        list.add("io");
        list.add("der");
        Collections.reverse(list);
        System.out.println("翻转顺序后"+list);//翻转顺序后[der, io, nice, tom]
        Collections.shuffle(list);
        System.out.println("随机排序后"+list);//随机排序后[tom, nice, der, io]，每运行一次结果都不同
        Collections.sort(list);
        System.out.println("根据元素进行升序排序"+list);//根据元素进行升序排序[der, io, nice, tom]
        Collections.sort(list, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
               // return( (String)o1).compareTo((String) o2);//自行设计排序的比较方法这时字母大小升序排
                return ( (String)o1).length()-((String)o2).length();//这是字符串长度升序排
            }
        });
        System.out.println("自定义排序比较方法"+list);
        Collections.swap(list,0,3);
        System.out.println("下标为0位与下标为三位数据进行交换结果为"+list);//第0位与第三位数据进行交换结果为[nice, der, tom, io]
        System.out.println("返回出最大的数据"+Collections.max(list)); //返回出最大的数据tom，同样可以自定义比较方法来得到最大的值
        System.out.println("返回最长的数据"+Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ( (String)o1).length()-((String)o2).length();
            }
        }));//返回最长的数据nice
        System.out.println("返回出最小的数据"+Collections.min(list)); //返回出最小的数据der同样可以自定义比较方法来得到最大的值

        System.out.println("返回最短的数据"+Collections.min(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ( (String)o1).length()-((String)o2).length();
            }
        }));//返回最短的数据io
        System.out.println("返回指定集合中指定的值在其中出现的次数"+Collections.frequency(list,"io"));//返回指定集合中指定的值在其中出现的次数1
        List list1 = new ArrayList();//必须要让背copy的集合大小不大于copy进去的集合，
        // 所以我们就先让新的集合容量跟被copy的一样，然后再实验copy（）方法
        for(int i=0;i<list.size();i++)
        {
            list1.add(" ");
        }
        Collections.copy(list1,list);
        System.out.println("copylist集合的值后的list1的值为："+list1);
        //copylist集合的值后的list1的值为：[nice, der, tom, io]
        Collections.replaceAll(list,"tom","谭娜");
        System.out.println("替换后"+list);//替换后[nice, der, 谭娜, io]


    }

}

例题：

package test05;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
按要求实现:
(1)封装一个新闻类,包含标题和内容属性,提供get、set方法,重写toString方法,打印对象
时只打印标题;
·(2)只提供一个带参数的构造器,实例化对象时,只初始化标题;并且实例化两个对象:
新闻一:新冠确诊病例超千万,数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二:男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生
(3)将新闻对象添加到ArrayList集合中,并且进行倒序遍历;
(4)在遍历集合过程中,对新闻标题进行处理,超过15字的只保留前15个,然后在后边加“.”
(5)在控制台打印遍历出经过处理的新闻标题;
*/public class Test01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new News("新冠确诊病例超千万,数百万印度教信徒赴恒河“圣浴”引民众担忧"));
        list.add(new News("男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生"));
        Collections.reverse(list);
        for (Object o :list) {
            News news=(News) o;

            System.out.println(Process(news.getTitle()));

        }


    }
    public static String Process(String st)
    {
        if (st==null)
            return null;
        else if (st.length()>15)
            return st.substring(0,15)+"...";
        else
            return st;
    }

}
class News{
    private String title;

    public News(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

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

package test05;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用ArrayList 完成对 对象 Car {name,price}的各种操作
1.add:添加单个元素
2.remove:删除指定元素
3.contains:查找元素是否存在
4.size:获取元素个数
5.isEmpty:判断是否为空
6.clear:清空
7.addAll:添加多个元素
8.containsAll:查找多个元素是否都存在
9.removeAll:删除多个元素
使用增强for和 迭代器来遍历所有的car,需要重写Car的toString方法

Car car=new Car(“宝马”,400000);
Car car2=new Car("宾利”,5000000);
*/public class Test02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        Car car=new Car("宝马",400000);
        Car car2=new Car("宾利",5000000);
        list.add(car);
        list.add(car2);
        list.remove(0);
        System.out.println(list);
        System.out.println(list.contains(car));
        System.out.println(list.size());
        System.out.println(list.isEmpty());
       // list.clear();
        System.out.println(list);
       List list1 = new ArrayList();
      list1.addAll(list);
        System.out.println(list1);
        System.out.println(list1.containsAll(list));
        list1.removeAll(list);
        System.out.println(list1);
        for(Object o:list)
        {
            System.out.println(o);
        }
        Iterator iterator=list.iterator();
        while (iterator.hasNext())
        {
            Object next=iterator.next();
            System.out.println(next);
        }

    }
}
class Car{
    private String name;
    double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

package test05;

import javax.swing.text.html.HTMLDocument;
import java.security.KeyStore;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
按要求完成下列任务
1)使用HashMap类实例化一个Map类型的对象m,键(String)和值(int)分别用于存储员
jack-650元;tom-1200元;smith-2900元;

工的姓名和工资,存入数据如下:
2)将jack的工资更改为2600元
3)为所有员工工资加薪100元;
4)遍历集合中所有的员工
5)遍历集合中所有的工资
*/public class Test03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(1,new employee("jack",650));
        map.put(2,new employee("tom",1200));
        map.put(3,new employee("smith",2900));
      Set set=map.entrySet();
        for (Object o :set) {
            Map.Entry e=(Map.Entry)o;
            employee p=(employee) e.getValue();
            if (p.getName().compareTo("jack")==0)
            {
                p.setSalary(2600.0);

            }
            else
                p.setSalary(p.getSalary()+100);

            System.out.println(p.getName());

        }
        Iterator iterator=set.iterator();
        while (iterator.hasNext()) {
            Map.Entry y=(Map.Entry)iterator.next();
            employee m=(employee) y.getValue();
            System.out.println(m.getSalary());


        }




    }
}
class employee{
   private String name;
   double salary;

    public employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

因为在此改了p1的内容，所以这个时候的p1跟最开始的那个p1的hash值是不一样的，所以说这个时候移除p1是无法移除存在集合里的，而在此加入的数据，虽然具体数据跟p1现在的数据是一样的，但是存放位置是要用hash值来判断的，最开始存p1hash值是以“AA”来计算的，所以此时这个以cc来计算是会在不同的位置，因此可存放，

因为这次存的数据与最开始的数据p1是一样的所以hash值也是一样的，那么位置就在同一个位置。但是p1后面的内容被改写了，那么他们就会存入在p1值的链表后面