阅读量:0
集合简介
关系示例图
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值的链表后面
