集合框架_DAY16
1:List及其子类(掌握)
(1)List的特点：
Collection
|--List:元素有序(存入顺序和取出顺序一致),可重复。
|--Set:元素无序,唯一。
(2)List的特有功能：
A:添加功能
add(int index,Object obj)
B:删除功能
remove(int index)
C:获取功能
get(int index)
D:修改功能
set(int index,Object obj)
(3)案例：
List存储字符串并遍历。
List存储自定义对象并遍历。
注： 使用集合存储自定义对象的步骤：
1）、定义要存储到集合当中的类
2）、创建 集合<要存储到集合当中的类> 集合引用变量 = new 集合<要存储到集合当中的类>();
3）、创建要存储到集合当中的类的对象们
4）、调用集合方法，存储对应的对象
5）、返回对应集合的迭代器
6）、使用迭代器判断是否有下个元素
7）、如果有下个元素则获取下个元素
(4)List的三个子类的特点：
List:
|--ArrayList
底层数据结构是数组,查询快,增删慢。
线程不安全,效率高。
|--Vector
底层数据结构是数组,查询慢,增删慢。
线程安全,效率低。所以一般不用。
|--LinkedList
底层数据结构是链表,查询慢,增删快。
线程不安全,效率高。
到底使用谁?
是否需要安全：
是：Vector(将来其实也不用这个，会有更好的方式，后面提)
否：用ArrayList或者LinkedList
如何查询多：ArrayList
如果增删多：LinkedList
如果你根本就不知道用谁?用ArrayList。
(6)List的三个儿子的各自特有功能：(了解)
A:ArrayList
B:Vector
JDK1.0时候的功能。但是后来被替代。所以不用掌握。
C:LinkedList
由于是链表，所以，操作开头和结尾比较简答。提高了添加，删除，获取开头或者结尾。
(7)案例：
Collection
List
ArrayList
Vector
LinkedList
对上述集合分别存储字符串和自定义对象并遍历。
(8)遍历：
Collection：迭代器（所有集合都适用）
|--List：普通for
|--ArrayList
|--Vector 返回Enumeration
|--LinkedList
2:Set(掌握)
(1)Set集合的特点:
无序(存储和取出的顺序不一致),唯一。
(2)HashSet
如何保证元素的唯一性呢?
底层数据结构是哈希表。哈希表依赖于哈希值。（集合中存储的对象所在的类的中hashCode()和equals()方法需要重写，才能保正元素的唯一性）
最终依赖两个方法hashCode()和equals()。
比较顺序：
先比较hashCode()值：
相同：
继续走equals()方法，根据返回值：
true:说明元素重复。不添加。
false:说明元素不重复，添加。
不同：就直接添加到集合。
案例：
HashSet存储字符串并遍历。(String类重写了hashCode()和equals())
HashSet存储自定义对象并遍历。
存储Person对象，然后去掉重复值。(标准代码)
(3)TreeSet(理解)
如何保证元素的唯一性?
根据返回值是否是0。
如何保证元素的排序?
A:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
重写compareTo(T t)
B:比较器排序(集合具备比较性)
在创建集合对象的时候，传递Comparator接口的子类对象
重写compare(T t,T t2)
案例：
TreeSet存储字符串并遍历。(String实现了Comparable接口)
TreeSet存储自定义对象并遍历。
(标准代码 看懂就行)
存储学生对象，要求保证唯一和排序(先比较年龄，再比较姓名)。
(4)LinkedHashSet：(理解)
底层数据结构是哈希表和链表。
由哈希表保证元素唯一。
由链表保证元素有序。
3:增强for(掌握)
(1)是针对数组和Collection集合进行遍历的一种方式。
(2)格式：
for(数组或者Collection集合中的元素的数据类型 变量名 : 数组或者Collection集合对象) {
直接使用变量名即可，这个时候的变量名其实就是元素。
}
注意：
A:增强for的底层封装了迭代器的操作。
B:在使用增强for的时候，请保证迭代目标不为null。
C:增强for循环只能做展示数据的功能，不能修改数据。
附题：分别用ArrayList，LinkedList，HashSet，LinkeHashSet，TreeSet存储字符串和自定义对象并遍历
import java.util.*; public class SetTest { //分别用ArrayList,LinkedList，HashSet，LinkeHashSet,TreeSet存储字符串和自定义对象并遍历。 public static void main(String[] args) { System.out.println("ArrayList存储字符串和自定义对象并遍历:"); // ArrayList存储字符串和自定义对象并遍历 //字符串遍历 ArrayList arrayList1 = new ArrayList(); String str1 = "2杨幂"; String str2 = "3柳岩"; String str3 = "1哈哈"; String str4 = "2杨幂"; arrayList1.add(str1); arrayList1.add(str2); arrayList1.add(str3); arrayList1.add(str4); for (Object string : arrayList1) { System.out.println((String) string); } //自定义对象遍历 ArrayList arrayList2 = new ArrayList(); Person p1 = new Person(29, "2杨幂"); Person p2 = new Person(27, "3柳岩"); Person p3 = new Person(30, "1哈哈"); Person p4 = new Person(29, "1杨幂"); arrayList2.add(p1); arrayList2.add(p2); arrayList2.add(p3); arrayList2.add(p4); Iterator iterator = arrayList2.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } System.out.println("-----------------------"); System.out.println("LinkedList存储字符串和自定义对象并遍历"); //LinkedList存储字符串和自定义对象并遍历 //字符串遍历 LinkedList linkedList1 = new LinkedList(); linkedList1.add(str1); linkedList1.add(str2); linkedList1.add(str3); linkedList1.add(str4); for (Object string : linkedList1) { System.out.println((String) string); } //自定义对象遍历 LinkedList linkedList2 = new LinkedList(); linkedList2.add(p1); linkedList2.add(p2); linkedList2.add(p3); linkedList2.add(p4); Iterator iterator1 = linkedList2.iterator(); while (iterator1.hasNext()) { System.out.println(iterator1.next()); } System.out.println("----------------------"); System.out.println("HashSet存储字符串和自定义对象并遍历"); //HashSet存储字符串和自定义对象并遍历 //字符串对象遍历 HashSet hashSet1 = new HashSet(); hashSet1.add(str1); hashSet1.add(str2); hashSet1.add(str3); hashSet1.add(str4); for (Object string : hashSet1) { System.out.println(string); } //自定义对象并遍历 HashSet hashSet2 = new HashSet(); hashSet2.add(p1); hashSet2.add(p2); hashSet2.add(p3); hashSet2.add(p4); for (Object person : hashSet2) { System.out.println((Person) person); } System.out.println("----------------------"); System.out.println("LinkeHashSet存储字符串和自定义对象并遍历"); //LinkeHashSet存储字符串和自定义对象并遍历 //字符串遍历 LinkedHashSet linkedHashSet1 = new LinkedHashSet(); linkedHashSet1.add(str1); linkedHashSet1.add(str2); linkedHashSet1.add(str3); linkedHashSet1.add(str4); for (Object string : linkedHashSet1) { System.out.println((String) string); } //自定义对象并遍历 LinkedHashSet linkedHashSet2 = new LinkedHashSet(); linkedHashSet2.add(p1); linkedHashSet2.add(p2); linkedHashSet2.add(p3); linkedHashSet2.add(p4); for (Object person : linkedHashSet2) { System.out.println((Person) person); } System.out.println("-----------------------"); System.out.println("TreeSet存储字符串和自定义对象并遍历"); //TreeSet存储字符串和自定义对象并遍历 //字符串遍历 TreeSet treeSet = new TreeSet(); treeSet.add(str1); treeSet.add(str2); treeSet.add(str3); treeSet.add(str4); for (Object string : treeSet) { System.out.println(string); } //自定义对象并遍历 TreeSet treeSet2 = new TreeSet(new Comparator() { @Override public int compare(Object o1, Object o2) { Person p1=(Person)o1; Person p2=(Person)o2; int result=0; result=p1.getAge()-p2.getAge(); if(result==0){ result=p1.getName().compareTo(p2.getName()); } return result; } }); treeSet2.add(p1); treeSet2.add(p2); treeSet2.add(p3); treeSet2.add(p4); for (Object person : treeSet2) { System.out.println((Person) person); } } }
public class Person implements Comparable { //属性 int age; String name; //构造器 public Person() { } public Person(String name){ this.name=name; } public Person(int age, String name) { this.age = age; this.name = name; } //方法 public int getAge(){ return age; } public String getName(){ return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Person{" + "age=" + age + ", name='" + name + '\'' + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; if (age != person.age) return false; return name != null ? name.equals(person.name) : person.name == null; } @Override public int hashCode() { int result = age; result = 31 * result + (name != null ? name.hashCode() : 0); return result; } /*@Override //先比较年龄，在比较姓名 public int compareTo(Object o) { Person p=(Person) o; int result=0; result=this.age-p.age; if(result==0){ result=this.name.compareTo(p.getName()); } return result; }*/ @Override //先比较姓名，再比价年龄 public int compareTo(Object o) { Person p=(Person) o; int result=0; result=this.name.compareTo(p.name); if(result==0){ result=this.age-p.age; } return result; } }
