java学习--集合

集合简介

关系示例图

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值的链表后面