一、Collection
Collection接口：单列数据，定义了存取-组对象的方法集合；
1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器；
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储；
2. 数组在存储多个数据方特点
2.1数组在存储多个数据方面的特点；
a.数据一旦初始化后，长度就确定了，
b.一旦定义好，其元素的类型也确定，只能操作指定类型的元素；
2.2数组在存储多个数据方面的缺点
a.数据一旦初始化后，长度就确定了，不方便；
b.数组中提供的方法非常有限，对添加、删除、插入数据等操作，非常有限
c.获取数组中实际元素的个数，数组没有现成的属性和方法
d.存储数据的特点：有序、可重复。对于无线、不可重复的需要，不能满足；
二、Java集合可以分为Collection 和 Map体系；
- -组对象的方法集合；
- List:元素有序、可重复的集合（动态数组）：ArrayList/LinkedList/Vector
- Set:无序、不可重复的集合；（高中的集合）：HashSet/LinkedHashSet/TreeSet
- -value”的集合；（高中函数）
- HashMap/LinkedHashMap/TreeMap/HashTable/Properties
三、Collection中的方法；
注意：向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals方法；
Collection 15个方法；
- boolean add(E e) 向集合中添加元素
- 清空集合
- boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
- boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
- boolean equals(Object o) ：比较此 collection 与指定对象是否相等。
- int hashCode() ：返回此 collection 的哈希码值。
- boolean isEmpty() ：如果此 collection 不包含元素，则返回 true（查看size()是否为0）。
- <E> iterator() ：返回在此 collection 的元素上进行迭代的迭代器。
- boolean remove(Object o) ：从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
- boolean removeAll(Collection<?> c) ：移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
- boolean retainAll(Collection<?> c) ：仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
- int size() ：返回此 collection 中的元素数。
- Object[] toArray() ：返回包含此 collection 中所有元素的数组。
- <T> T[]
- toArray(T[] a)
测试方法代码如下：
1 @Test
2 public void test1() {
3 Collection coll = new ArrayList();
4 //1.add(Object e):将元素e添加到集合coll中；
5 coll.add("AA");
6 coll.add("BB");
7 coll.add(123);
8 coll.add(new Date());
9 System.out.println("Collection中的add()方法："+coll);
10 //size():获取添加元素的个数
11 System.out.println("Collection中的size()方法："+coll.size());
12 //addAll(Collection c),将coll1集合中的元素添加到当前集合中
13 Collection coll1 = new ArrayList();
14 coll1.add(1234);
15 coll1.add("abc");
16 coll.addAll(coll1);
17 System.out.println(coll.size());//6
18 System.out.println("Collection中的addAll()方法："+coll.toString()+",此时 coll元素个数："+coll.size());
19
20 //isEmpty():判断当前元素是否为空；
21 System.out.println("Collection中的isEmpty()方法："+coll.isEmpty());//false,就是看size()是否为0；
22
23 //clear():清空集合元素
24 coll.clear();
25 System.out.println("Collection中的clear()方法，此时coll:"+coll.isEmpty());//true
26
27 coll.add(123);
28 coll.add(456);
29 coll.add(123);
30 coll.add(new String("tom"));
31 coll.add(false);
32 coll.add(new Person("joy",1));
33 //contains(Object obj):判断当前集合中是否包含obj
34 boolean contain = coll.contains(123);
35 System.out.println("Collection中的contains()方法，此时返回boolean:"+contain);
36 System.out.println(coll.add(new String("tom")));//判断的是内容，调用的是equals方法；
37 System.out.println(coll.contains(new Person("joy",1)));//判断的是内容
38 //2.containsAll(collection coll1)
39 //判断新城coll1中所有元素是否都存在于当前集合中；
40 coll1.clear();
41 coll1.add(123);
42 coll1.add(456);
43 boolean flag = coll.containsAll(coll1);
44 System.out.println(flag);
45 System.out.println("Collection中的containsAll()方法，此时返回boolean:"+flag);
46
47 //remove(Object obj)移除对象（从当前集合中）,只移除一个对象；
48 boolean removeFlag = coll.remove(123);
49 System.out.println("Collection中的remove()方法，此时返回boolean:"+removeFlag);
50 System.out.println("Collection中的remove()方法，此时返回coll:"+coll.toString());
51 //removeAll(Collection coll1),从当前集合中移除所有的coll1中存在的元素；
52 System.out.println(coll.removeAll(coll1));
53 System.out.println("Collection中的removeAll()方法，此时返回coll:"+coll.toString());
54
55 //retainAll(coll1) 取当前集合和coll1 的交集 ,交集给了当前集合；
56 //[123, 456, 123, tom, false, Person [name=joy, age=1], tom]
57 //[123, 456]
58 //交集就是[123, 456]
59 /
60 coll.retainAll(coll1); System.out.println(coll);
61 /
62
63
64 //equals(Object obj) obj也是集合，比较两个集合是否一样；集合中的各个元素顺序必须一样才可以；
65 Collection coll6 = new ArrayList();
66 Collection coll7 = new ArrayList();
67 Collection coll8 = new ArrayList();
68 coll6.add(123);
69 coll6.add(456);
70 coll6.add(789);
71 coll7.add(123);
72 coll7.add(456);
73 coll7.add(789);
74 coll8.add(789);
75 coll8.add(456);
76 coll8.add(123);
77 System.out.println("Collection中的equals()方法，equeal结果:"+coll6.equals(coll7));
78 System.out.println("Collection中的equals()方法,equeal结果:"+coll6.equals(coll8));
79
80 //hashCode();返回当前对象的哈希值
81 System.out.println("Collection中的hashCode()方法,当前hashcode值:"+coll8.hashCode());
82
83 //toArray()集合转数组
84 Object[] arr = coll.toArray();
85 for(int i = 0;i<arr.length;i++) {
86 System.out.println("第"+(i+1)+"个元素："+arr[i]);
87 }
88 //拓展：数组转集合
89 List<String> asList = Arrays.asList(new String[] {"aa","bb","cc"});
90 System.out.println(asList);
91
92 //iterator():返回接口的实例，拥有遍历集合元素。
93 //内部方法： hasNext()和next()方法
94 //原理图
95 Iterator iterator = coll.iterator();
96 while(iterator.hasNext()) {
97 System.out.println("iterator遍历："+iterator.next());
98 }
99
100 //iterator():移除当前集合中的某条数据数据
101 //内部的方法：hasNext()和next();
102 //集合对象每次调用iterator()方法都得到一个全新的迭代器对象
103 //默认游标都在集合的第一个元素之前
104 //内部定义了remove()方法，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove()；
105 //如果还未调用next()或上一次调用next方法之后已经调用了remove方法，再调用remove都会报错；
106 iterator = coll.iterator();
107 while(iterator.hasNext()) {
108 Object obj = iterator.next();
109 if(obj.equals("tom")) {
110 iterator.remove();//移除
111 }
112 }
113 iterator = coll.iterator();
114 while(iterator.hasNext()) {
115 Object obj = iterator.next();
116 System.out.println("iterator删除后"+iterator.next());
117 }
118 System.out.println("coll.toString()=>"+coll.toString());
119
120 //补充：foreach循环，用于遍历集合、数组（jdk1.5新增）
121 //for(集合元素的类型 局部遍历：集合对象)
122 //此种方式不能更改值
123 for(Object obj:coll){
124 System.out.println("foreach=》"+obj);
125 }
126
四、List
1、ArrayList源码分析：
jdk7情况下：
ArrayList list = new ArrayList();//底层创建了长度为10的Object[]数组 Object[] elementData；
list.add(123); ...
list.add(111);//如果此次的添加导致底层elementData数组容量不够，则扩容，类似StringBuilder;
关于扩容：默认情况下，扩容为原来的1.5倍，同时需要将原有数组种的数据复制到新的数组中；
结论：建议开发中使用带参的构造器，ArrayList list = new ArrayList(int capacity);指定数组长度；
jdk8情况下：
1 ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组；
2
3 list.add(123);//第一次调用add(),底层才创建长度为10的数组，并把数据123添加到elementData; 后续与1.7一致；小结：jdk1.7中的ArrayList的对象的创建类似于单例的饿汉式，1.8的类似于懒汉式，1.8延迟创建数组，节省内存；
2、LinkedList的源码分析
LinkedList list = new LinkedList();//内部声明了Node类型的first 和last属性，默认值为null;
list.add(123);//将123封装到Node中，创建了Node对象；
其中,Node定义为：提现了LinkedList的双向链表的说法；
1 private static class Node<E> {
2 E item;
3 Node<E> next; Node<E> prev;
4
5 Node(Node<E> prev, E element, Node<E> next) {
6 this.item = element;
7 this.next= next; this.prev = prev;
8 }
93、vector的源码分析
- jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组
- 在扩容方面，默认扩容为原来数组长度的2倍
4、List常用方法
- int index,Object ele);在index位置插入ele元素
- int index,Collection eles),在index位置插入eles中的所有元素添加进来
- int index)获取指定index位置的元素；
- int indexOf(Object obj);返回obj在集合中首次出现的位置
- int lastIndexOf(Object obj)回obj在集合中末次出现的位置
- int index),移除指定index位置的元素,返回删除元素的对象
- int index,Object ele):设置指定index位置的元素为ele;
- int fromIndex,int toIndex);返回从fromIndex到toIndex位置的集合；
总结：常用方法
- obj);
- int index)
- int index,Object ele);
- int index)
- int index,Object ele)
- 长度：size()
- 遍历：
- Iteraror
- for
- 增强for循环
测试常用方法：
@Test
public void test1() {
ArrayList arrayList = new ArrayList();
arrayList.add(123);
arrayList.add(456);
arrayList.add("AA");
arrayList.add(new Person("Tom",1));
arrayList.add(456);
System.out.println(arrayList.toString());
//void add(int inde,Object elemnet),在index位置插入element元素
arrayList.add(1, "BB");
System.out.println(arrayList.toString());
//void addAll(int inde,Collection elemnets),在index位置插入elements的所有功能元素元素
ArrayList arrayList2 = new ArrayList();
arrayList2.add("aa");
arrayList2.add("bb");
arrayList.addAll(1, arrayList2);
System.out.println(arrayList.toString());
//查看元素个数
System.out.println(arrayList.size());
//访问第一个元素
System.out.println(arrayList.get(0));
//int indexOf(Object obj);返回obj在集合中首次出现的位置,没有返回-1；
System.out.println(arrayList.indexOf("AA"));
//int lastIndexOf(Object obj)回obj在集合中末次出现的位置
System.out.println(arrayList.lastIndexOf(456));
//Object remove(int index),移除指定index位置的元素返回删除元素的对象
System.out.println(arrayList.remove(7));
//Object set(int index,Object ele):设置指定index位置的元素为ele;
System.out.println(arrayList.set(0, "set"));//设置指定index位置的元素为ele;
System.out.println(arrayList.toString());
//List subList(int fromIndex,int toIndex);返回从fromIndex到toIndex位置的集合；
System.out.println(arrayList.subList(0, 4));
//遍历List
Iterator iterator = arrayList.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
for(Object obj : arrayList) {
System.out.println(obj);
}
for(int i=0;i<arrayList.size();i++) {
System.out.println(arrayList.get(i));
}
}
五、Set
1、Set:无序、不可重复的集合；（高中的集合）
- HashSet：作为Set接口的主要实现类，线程不安全，可以存储null值；
- LinkedHashSet:是HashSet的子类；遍历内部数据，可以按照添加的顺序遍历；
- TreeSet：使用红黑树存储数据；要求数据是同一个对象new的；可以按照添加对象的指定属性排序
- 关于无序的说明
1.无序性：但是不是随机性；无序性是指，元素插入的位置不是按顺序插入，而是随机插入
不可重复性：保证添加的元素 ，按照equals()方法判断时，不能返回true，即：相同的元素只能添加一个
- 添加元素的过程（以HashSet为例）：
我们想HashSet中，添加元素a：
1、首先调用元素a所在类的hasCode()方法，计算元素a的哈希值，
此哈希值接着通过某种计算出在HashSet底层数组中的存放位置（即:索引位置）；
2、判断数组此位置上是否已经有元素；
-----》情况1
如果此位置上有其他元素b(或以链表形式存在多个元素)，则比较元素a与元素b的hash值，
-----》情况2
如果has值相同，进而需要调用元素a所在类的equals方法，比较
equals返回true，元素a添加失败，否则元素a添加成功；---------》情况3
对于添加成功的情况2和情况3而言，元素a 与已经存在指定位置上索引位置上数据以链表形式存储；
- jdk7. 元素a放到数组中，指向原来的元素；
- jdk8. 原来的元素放到数组中，指向a元素；
- hashset底层：数组+链表结构存放；
补充：
- Object类中的hashCode方法计算的哈希值是随机的，所以，需要重写hashCode方法；
- 同理 Object类中的equals方法，默认是==运算符，所以类需要判断equals，则需要重写equals方法
- HashSet的使用：输出就是无序的；
1 @Test
2 public void test1() {
3 Set set = new HashSet();
4 set.add(456);
5 set.add(123);
6 set.add("AA");
7 set.add("AA");
8 set.add("CC");
9 set.add(new Person("Tom",12));
10 set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
11 set.add(129);
12 Iterator iterator = set.iterator();
13 while(iterator.hasNext()) {
14 System.out.println(iterator.next());
15 }
16
LinkedHashSet的使用：（按照插入顺序输出）
作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据
优点：遍历频繁的操作，效率较高
1 /**
2 *linkedHashSet的使用：
3 *作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据
4 *优点：遍历频繁的操作，效率较高；
5 *
6 */
7 @Test
8 public void test2() {
9 LinkedHashSet set = new LinkedHashSet();
10 set.add(456);
11 set.add(123);
12 set.add("AA");
13 set.add("AA");
14 set.add("CC");
15 set.add(new Person("Tom",12));
16 set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
17 set.add(129);
18 Iterator iterator = set.iterator();
19 while(iterator.hasNext()) {
20 System.out.println(iterator.next());
21 }
22
TreeSet的使用：
1.向TreeSet中添加的数据，要求是相同类的对；
* TreeSet 的类的对象中，必须实现Compare接口orComparator接口（Compare接口orComparator接口的使用可点击查看）
* 自然排序中，比较两对象是否相同的标准为；CompareTo()返回0，不再是equals();
1 @Test
2 public void test3() {
3 TreeSet set = new TreeSet();
4 set.add(new Person("Tom",12));
5 set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
6 set.add(new Person("Jay",14));//
7 Iterator iterator = set.iterator();
8 while(iterator.hasNext()) {
9 System.out.println(iterator.next());
10 }
11 }
12 //TreeSet Comparator接口实现方法
13 @Test
14 public void test4() {
15 Comparator com = new Comparator<Person>() {
16 @Override
17 public int compare(Person o1, Person o2) {
18 // TODO Auto-generated method stub
19 return o1.getName().compareTo(o2.getName());
20 }
21
22
23
24 };
25 TreeSet set = new TreeSet(com);
26 set.add(new Person("Tom",12));
27 set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
28 set.add(new Person("Jay",14));//
29 Iterator iterator = set.iterator();
30 while(iterator.hasNext()) {
31 System.out.println(iterator.next());
32 }
33
Person类：
1 package collection;
2
3 public class Person implements Comparable {
4
5 private String name;
6 private int age;
7 public String getName() {
8 return name;
9 }
10 public void setName(String name) {
11 this.name = name;
12 }
13 public int getAge() {
14 return age;
15 }
16 public void setAge(int age) {
17 this.age = age;
18 }
19 public Person(String name, int age) {
20 super();
21 this.name = name;
22 this.age = age;
23 }
24 public Person() {
25 super();
26 }
27 @Override
28 public String toString() {
29 return "Person [name=" + name + ", age=" + age + "]";
30 }
31 @Override
32 public int hashCode() {
33 final int prime = 31;//这里使用31为了减少冲突、提高算法效率
34 int result = 1;
35 result = prime * result + age;
36 result = prime * result + ((name == null) ? 0 : name.hashCode());
37 return result;
38 }
39 @Override
40 public boolean equals(Object obj) {
41 if (this == obj)
42 return true;
43 if (obj == null)
44 return false;
45 if (getClass() != obj.getClass())
46 return false;
47 Person other = (Person) obj;
48 if (age != other.age)
49 return false;
50 if (name == null) {
51 if (other.name != null)
52 return false;
53 } else if (!name.equals(other.name))
54 return false;
55 return true;
56 }
57 @Override
58 public int compareTo(Object o) {
59 Person person = (Person)o;
60 if(this.age>person.age) {
61 return -1;
62 }else {
63 return 1;
64 }
65
66 }
67
68
69
View Code
3、Set接口中没有定义额外的方法；使用的都是Collectio中声明过的方法；
- 要求：向Set中添加的数据，其所在的类一定要重写hasCode()和equals()；
- 要求：重写的hashCode()和equals()尽可能保持一致，相等的对象必须具有相等的散列码；
- 一般重写的hashCode()就可以保证一致性；
4、其他
Set集合不允许包含相同的元素；如果试把两个相同的元素加入同一个Set集合中，则添加操作失败
Set判断两个对象是都相同不是使用 == 运算符，而是根据equals()方法；
我从来不相信什么懒洋洋的自由。我向往的自由是通过勤奋和努力实现的更广阔的人生。 我要做一个自由又自律的人，靠势必实现的决心认真地活着。