集合【容器】

<-------概　　念------->

　　 java中容器也是对象,首先将容器抽象成一个接口collection，它有两个比较重要的子接口，分别是list和set，list和set由自己的子类实现

　　collection【集合】[接口][java.util包下]

　　　　　　　　add()[例一]

　　　　　　　　　　　----->添加数据

　　　　　　　　remove()[例二]

　　　　　　　　　　　　----->如果知道equals的，移除数据，获取当前数据的索引，让数组后面的数据整体前移，并且将最后一个数据赋值为null

　　　　　　　 size()[例三]

　　　　　　　　　　　　----->当我们调用数组长度方法的时候，直接返回size

　　　　　　　　clear()[例五]

　　　　　　　　　　　　----->清空数据,并且将数组长度变为0

　　　　　　　　removeAll[例六]

　　　　　　　　　　　　----->用于从列表中移除指定collection中包含的所有元素

　　　　　　　　contains[例七]

　　　　　　　　　　　　----->判断容器中是否包含所要查找的元素

　　　　　　　　equals()[例八]

　　　　　　　　　　　　----->判断对象是否相等

　　　　　　　　hashcode()[例九]

　　　　　　　　　　　　----->获取对象的哈希值，如果两个对象equals那么他们的hashcode一定相同，但hashcode相同不一定equals

　　　　　　　　isEmpty()[例十]

　　　　　　　　　　　　----->是否为空(判断当前容器是否有数据)

　　　　　　　　retainAll()[例十一]

　　　　　　　　　　　　----->取出两个容器的交集，判断是否有交集，返回值为boolean型【两种写法】

　　　　　　　　containsAll[例十二]

　　　　　　　　　　　　----->判断一个对象中是否有指定对象中的全部元素

　　　　List[接口]

　　　　　　特有方法：凡是可以操作角标的方法就是该体系特有的方法

　　　　　　 add(index,object)[例十三]

　　　　　　　　　　 ----->List中的方法，插入到指定的位置，后面的全体向后迁移

　　　　　　　get(index)[例十四]

　　　　　　　　　　 ----->获取指定位置元素

　　　　　　 set(index,)[例十五]

　　　　　　　　　　 ----->覆盖掉原来的值

　　　　　　　remove(index)[例三十六]

　　　　　　　　　　----->删除指定位置元素

　　　　　　 indexof()[例十六]

　　　　　　　　　 ----->搜索给定参数第一次出现的位置，使用 equals 方法进行相等性测试，没有所搜索项目会返回“-1”

lastindexof()[例十七]

　　　　　　　　　　----->返回指定的对象在列表中最后一次出现的位置索引，没有所搜索项目会返回“-1”

subList(int fromIndex, int toIndex)[例三十七]

　　　　　　　　　　 ----->返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图

listIterator( )[例三十八]

----->List特有的迭代器

　　　　　　特别注意：List集合特有的迭代器，是iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常，所以，在使用迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果需要进行其他的操作如添加，修改等，就需要使用其子接口listIterator，该接口只能通过List集合listIterator方法获取

　　　　　　　注意：collection有的方法List都有，而List有的方法collection不一定都有　　　　

　　　　　 ArrayList[类]

　　　　　　　　注意：collection和List有的方法，ArrayList都有，而ArrayList有的方法collection和List不一定都有　

　　　　 LinkedList【链表】[类][例三十九]

　　　　　　　　addFirst(object)

　　　　　　　　 ----->在头部添加元素

　　　　　　　　addLast(object)

　　　　　　　　　　 ----->在头部添加元素　

　　　　　　　　getFirst()[1.6版本之前]/peekFirst()[1.6版本之后]

　　　　　　　　　　 ----->获取头部元素

　　　　　　　　getLast()[1.6版本之前]/peekLast[1.6版本之后]

　　　　　　　　　　----->获取尾部元素

　　　　　　　　removeFirst()[1.6版本之前]/pollFirst[1.6版本之后]

　　　　　　　　　 ----->获取并删除头部元素

　　　　　　　　removeLast()[1.6版本之前]/pollLast[1.6版本之后]

　　　　　　　　　 ----->获取并删除尾部元素

　　　　　　　　注意：在1.6版本之前，如果所操作的集合为空，getFirst()、getLast()、removeFirst()、removeLast()这4个方法就会返回没有这个元素异常，在1.6版本之后进行了改进，改为了peekFirst()、peekLast、pollFirst、pollLast，当所操作的集合为空时，这4个方法会返回null，而不会返回异常　

　　　　　　　　应用[例四十]

　　　　　　　　用linkedList模拟出堆栈和队列

　　　　　　　　堆栈：先进后出队列：先进先出

　　　　　　　　注意：collection和List有的方法，LinkedList都有，而LinkedList有的方法collection和List不一定都有　

　　　　 Vector[类]　　

　　　　　　　　从 Java 2 平台 v1.2 开始，已改进此类以实现 List，这样它就成为了 Java 的集合框架的一部分。与新集合的实现不同，Vector 是同步的

　　　　　　　　通过枚举进行遍历的方式【 Vector特有！已被迭代器取代，详情见下文迭代器】

　　　　Set[接口]

　　　　　　HashSet[数据结构是哈希表][详情见下文HashSet底层代码分析]　

　　　　　　　 Set集合的功能和collection的功能是一致的　

　　 TreeSet[详情见下文TreeSet底层代码分析]

　　　　　　　 TreeSet中常用的两种比较器[详情见下文TreeSet中的两种比较器]

　　　　 LinkedHashSet[详情见下文LinkedHashSet应用解析]

　　　　Map[接口]

　　　　　 new map[例二十七]

　　　　　　　　 ----->创建对象

　　　　 put(key, value)[例二十八]

　　　　　　　　 ----->添加值

　　　　 remove(key)[例二十九]

　　　　　　　　 ----->删除值

　　　　 get(key)[例三十]　

　　　　　　　　 ----->获取值

size()[例三十一]

　　　　　　　　----->查看map的长度

　　　　 Set set=keySet()[例三十二]

　　　　　　　　 ----->获取所有的key

　　　　 containsKey(key)[例三十三]

　　　　　　　　 ----->判断是否包含指定的key

　　　　 containsValue(value)[例三十四]

　　　　　　　　 ----->判断是否包含指定的值

　　　　 clear()[例三十五]

　　　　　　　　 ----->清空数据，并清空map长度为0

　　　 HashMap[详情见下文HashMap应用解析]

　　　　　TreeMap[详情见下文TreeMap应用解析]

　　　　　HashTable

　　　　　　　　　　HashTable 是jdk1.0出现的。是一个线程安全的容器。 HashMap 是jdk1.2出现。是一个非线程安全的

　　　　　　　　　　[不常用，详情见下文HashTable遍历]　　　　

<-------Collection------->

　　Collection 表示一组对象，它是集中，收集的意思，就是把一些数据收集起来。

　　Collection函数库是在java.util 包下的一些接口和类，类是用来产生对象存放数据用的，而接口是访问数据的方式

　　Collection定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式

　　Collection 继承了Iterable

　　所有的Collection 类型，都可以使用iterator 进行迭代

　　Collection（无序，不唯一）的两个子接口：List(有序，下标) Set(无序，唯一)

<-------区别问题大汇总------->

Collection函数库【集合】中容器与数组的两点不同

　　1.数组的容量是有限制的，而Collection库没有这样的限制，它容量可以自动的调节 (没有限制值指在数字的可识别范围之内)

　　2.Collection函数库只能用来存放对象，而数组没有这样的限制。

　　Collection接口是Collection层次结构中的根接口，它定义了一些最基本的访问方法【提供了好多容器访问方式】，让我们能用统一的方式通过它或它的子接口来访问数据

　　区别：Collection代表一组对象，Collection函数库就是java中的集合框架，Collection接口，是这个集合框架中的根接口

　　存放在Collection 库中的数据【存在容器中的值】，被称为元素(element)

　　容器可以帮助我们快速开发，减少开发的时间。

ArrayList和LinkedList的区别

　　LinkedList链表

　　　　在内存中是不连续的空间，直接通过节点的next，previous属性访问
　　　　链表添加数据就是添加Node节点，让节点的next，previous分别指向对应的节点，注意添加节点可以从中间插
　　　　所以连接表的插入和删除操作比较快捷
　　　　链表只记录一个开始和结尾 first和last,缺点就是查找非常麻烦，要从第一个索引开始，这个索引是一个一个数出来的

　　　　链表分为单向链表和双向链表

　　　　单向链表：只会记录头节点

　　　　双向链表：一个节点有2个引用，一个指向它下一个节点，一个指向它上一个节点

　　　　简单地说就是：单向链表只能从头节点向后查看，而双向链表却既可以从头向后查看，还可以从后向查看

　 ArrayList
　　　　在内存中是连续的空间，这种方式将对象放在连续的位置中,可以按照索引访问，长度可变，存入数据类型可变
　　　　支持随机访问
　　　　所以数据的get（index）速度较快，所以进行查找操作比较方便

ArrayList和LinkedList区别

　　　相同点：都是有顺序的，元素有编号

　　不同点：

　　　　1：底层实现不同，ArrayList 底层使用数组实现。LinkedList 使用链表实现。
　　　　2：ArrayList根据索引查找，或者遍历效率比较高。插入元素(需要移动大量的元素)，删除元素(需要移动大量的元素)效率比较低。
　　　　LinkedList：根据索引查找效率相对较低。插入元素，删除元素效率比较高。（有实践为证）。

　　 LinkedList的执行效率远远高于ArrayList

　　　容器的选择取决于业务的需求，如果只是一些遍历的操作，那么使用ArrayList即可，如果有大量的插入删除的操作，建议使用LinkedList

　　ArrayList和LinkedList插入功能所用时间测试：

 1 import java.sql.Time;
 2 import java.util.ArrayList;
 3 import java.util.LinkedList;
 4 import java.util.List;
 5 
 6 public class ArrCompareLinkedList {
 7     public static void main(String[] args) {
 8 
 9         // 注意：所得数据不固定，仅供参考
10         LinkedListDemo.demo2();
11         ArrayLiskDemo.demo1();
12 
13     }
14 }
15 
16 class ArrayLiskDemo {
17     public static void demo1() {
18         List<String> list = new ArrayList<String>();
19         list.add("a");
20         list.add("b");
21         list.add("c");
22         list.add("b");
23         list.add("c");
24         list.add("b");
25         list.add("c");
26         list.add("b");
27         list.add("c");
28         list.add("b");
29 
30         long time = System.currentTimeMillis();
31         for (int i = 0; i < 200000; i++) {
32             list.add(5, "A");
33         }
34         System.out.println("ArrayList:" + (System.currentTimeMillis() - time)); // ArrayList:5487
35     }
36 }
37 
38 class LinkedListDemo {
39     public static void demo2() {
40 
41         List<String> list = new LinkedList<String>();
42         list.add("a");
43         list.add("b");
44         list.add("c");
45         list.add("b");
46         list.add("c");
47         list.add("b");
48         list.add("c");
49         list.add("b");
50         list.add("c");
51         list.add("b");
52         long time = System.currentTimeMillis();
53         for (int i = 0; i < 200000; i++) {
54             list.add(5, "A");
55 
56         }
57         System.out.println("LinkedList:" + (System.currentTimeMillis() - time)); // LinkedList:28
58     }
59 }

ArrayList和数组区别

　　数组的长度一旦确定就无法改变，并且数组在定义时就要设置存入数据类型，不可改变

　　　 ArrayList的底层是可变长度的数组，所以长度可以改变，并且存入的数据类型可变

　　　数组的效率要比ArrayList高，两者各有所长

Vector向量和ArrayList的区别

　　相同点：底层都是使用数组实现。

　　　不同点：
1：Vector JDK1.0出现， ArrayList JDK 1.2出现。
2：Vector 是线程安全的。ArrayList 是非线程安全的。
ArrayList 是重效率，轻安全，是Vector 的替代类。并没有完全替代。
　　　　 Vector 随着JDK版本的更新，已经做了大量的修改，增加了很多的方法。
　　　　现在使用ArrayList 相对比较多。Vector 慢慢的使用的越来越少。

Collection 和 Collections的区别
　　　相同点：长得比较相似。
　　不同点：
　　 Collection 是一个接口，定义了一种类型的容器，特点：无序、不唯一。
　　 Collections 是一个类，封装了大量关于操作容器的方法。内部都是静态方法，类似于Arrays 类。工具类。帮助我们更好的操作容器对象

HashTable 和 HashMap 相同点和不同点
　　相同点：都是对键值对对象进行操作的。使用put get 等方法操作元素。
　　不同点：HashTable 是jdk1.0出现的。是一个线程安全的容器。 HashMap 是jdk1.2出现。是一个非线程安全的。
　　 HashTable 是一个重安全轻效率的一个容器。。HashMap 重效率轻安全的容器。HashMap的效率高于HashTable。
　　可以理解为HashMap 是HashTable的替代类。
　　 HashTable 的直接的父类是 Dictionary（字典）这个类。

　　 HashMap的key 和value 都可以null
　　 HashTable的key 和value 都不能是null

<-------迭代器Iterator------->

　　iterator是一个接口，作用其实就是集合的取出元素的方式

　　在集合框架中，我们可以通过Iterator 容器的迭代器对容器中的元素进行遍历

　　所有可以使用Iterator进行迭代的集合，都必须实现Iterable接口。也就是说，实现了Iterable接口的容器具备了可以被迭代的功能
　　该接口只有一个方法。iterator()得到当前容器的迭代器的功能

　　使用Iterator迭代器在迭代过程中，如果想操作Iterator所迭代的容器对象，必须使用迭代器提供的方法，而不能使用容器所提供的方法

　　注意：当一个迭代器对象产生后，进行迭代的结构已经生成。如果在迭代的过程中，想改变迭代元素的内容，必须使用迭代器自身的方法。而不能使用其他的方式修改迭代元素

　　我们一般把iterator称为集合的标准的迭代方式。
　　三个方法：
　　hasNext()
　　next()
　　remove()

　　Iterator

　　　　hasnext()

　　　　　　------->判断是否还有元素可以迭代，如果有返回true

示例代码　

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Exam2 {
 5     public static void main(String[] args) {
 6         add();
 7     }
 8 
 9     public static void add() {
10         ArrayList arrayList = new ArrayList();
11 
12         arrayList.add("A");
13         arrayList.add("B");
14         arrayList.add("C");
15         arrayList.add("D");
16         arrayList.add("E");
17 
18         Iterator iterator = arrayList.iterator();
19 
20         while (iterator.hasNext()) {
21             System.out.println(iterator.next()); // A,B,C,D,E
22 
23         }
24 
25     }
26 }

　　　　next()

　　　　　　------->返回迭代的下一个元素,迭代出下一个元素

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Exam2 {
 5     public static void main(String[] args) {
 6         add();
 7     }
 8 
 9     public static void add() {
10         ArrayList arrayList = new ArrayList();
11 
12         arrayList.add("A");
13         arrayList.add("B");
14         arrayList.add("C");
15         arrayList.add("D");
16         arrayList.add("E");
17 
18         Iterator iterator = arrayList.iterator();
19 
20         while (iterator.hasNext()) {
21             System.out.println(iterator.next()); // A,B,C,D,E
22 
23         }
24 
25     }
26 }

　　　　remove()

　　　　　　------->从迭代器指向的集合中移除迭代器返回的最后一个元素,移除元素中最后一个元素

示例代码

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Exam2 {
 5     public static void main(String[] args) {
 6         add();
 7     }
 8 
 9     public static void add() {
10         ArrayList arrayList = new ArrayList();
11 
12         arrayList.add("A");
13         arrayList.add("B");
14         arrayList.add("C");
15         arrayList.add("D");
16         arrayList.add("E");
17 
18         Iterator iterator = arrayList.iterator();
19 
20         while (iterator.hasNext()) {
21             System.out.println(iterator.next()); // A,B,C,D,E
22             iterator.remove();
23 
24         }
25 
26         System.out.println(arrayList); // []
27 
28     }
29 }

图像分析

运行过程视图

示例代码1[推荐]

1 Iterator iterator=list.iterator  //获取迭代器，用于取出容器中的元素
2 
3 while(list.hasnext){
4 
5 　　system.out.println(list.next());
6 
7 }

示例代码2

这种比较第一种方法的优点是节省内存，但是还是推荐第一种写法

1     for (Iterator iterator = arrayList.iterator(); iterator.hasNext();) {
2             System.out.println(iterator.next()); // A,B,C,D,E
3             iterator.remove();
4         }
5 
6         System.out.println(arrayList); // []
7 
8     }

List特有迭代器listIterator【见上文List方法】【不常用】

　　注意：listIterator有一个特殊方法hashPrevious【上一个位置是否有元素，如果以反向遍历列表，列表迭代器有多个元素，则返回 true】

　　前提是先正向迭代一次，再反向迭代，相当于有一个光标，正向迭代之前光标在最前面的位置，那个时候上一个位置是没有元素的所以while(hasPrevious)返回值为false，当正向迭代之后，光标就跑到了最后面的位置，此时while(hasPrevious)返回值为true，此时可以开始反向迭代

示例代码

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 import java.util.ListIterator;
 5 
 6 public class Exam2 {
 7     public static void main(String[] args) {
 8         add();
 9     }
10 
11     public static void add() {
12         List list = new ArrayList();
13 
14         list.add("ABC");
15         list.add("BCD");
16         list.add("CDE");
17         list.add("DEF");
18         list.add("EFG");
19 
20         ListIterator listIterator = list.listIterator();
21         
22         while(listIterator.hasNext()){
23             listIterator.next();
24         }
25 
26         while (listIterator.hasPrevious()) {
27             System.out.println(listIterator.previous()); /*                                                                             EFG
28                                                             DEF
29                                                             CDE
30                                                             BCD
31                                                             ABC
32                                                             */
33         }
34         
35     }
36 }

枚举

　　枚举是Vector特有的遍历方式，和迭代器是一样的，但是由于枚举的名称以及方法的名称过长，所以被迭代器取代了

 1 import java.util.Enumeration;
 2 import java.util.Vector;
 3 
 4 public class VectorDemo {
 5     public static void main(String[] args) {
 6 
 7         // 因为JDK1.0时还没有泛型的定义，所以什么类型的数据都可以，现在可以添加泛型规定数据类型
 8         // 所有带Element的方法都是比较老的方法
 9         Vector vector = new Vector();
10 
11         vector.addElement("ABC");
12         vector.addElement(12);
13         vector.addElement("C");
14         vector.addElement("A");
15         vector.addElement(80);
16 
17         // 当时的枚举遍历方法
18         Enumeration enumeration = vector.elements();
19 
20         while (enumeration.hasMoreElements()) {
21             System.out.println(enumeration.nextElement()); // ABC 12 C A 80
22         }
23 
24         // 现在可以用迭代器替代它
25     }
26 }
27

<-----Object【重写object方法】【快捷键Alt+Shift+S+O】----->

　　容器的底层就是一个数组Object[],它什么都可以往里放，当不知道要传入什么类型的数据时，可以选用object，因为object可以传入任何类型数据

示例代码

1 Object object = listIterator.next()

自定义类自动添加代码快捷方式

　　Alt+Shift+S+S->重写toString方法

　　Alt+Shift+S+H->重写hashcode和equals方法

　　Alt+Shift+S+O->写入构造器

　　Alt+Shift+S+R->写入get，set方法

　　toString
　　　　object:打印出来的就是当前类的信息@地址信息的hash值
　　　　vo类中【普通类】:打印出当前类所包含所有属性的信息 快捷键：alt+shift+s s
　　equals
　　　　两个对象比较的是地址,强调的是物理地址的相等，相当于==
　　　　普通对象中:两个对象逻辑上是否相等，比较的是两个对象的属性 快捷键： alt+shift+s h
　　hashcode
　　　　默认hashcode的编码由c语言生成

　　　一个对象会有一个唯一的hash值，然后不同对象hash值相等的概率几乎为0

　　　 hash值也是从对象的属性的值计算出来的

　　　如果两个对象equals，那么他们的hash值也是一样的
　　　如果两个对象的hash值一样，那么他们不一定equals 快捷键：alt+shift+s h

<-------hashcode应用以及Equals应用[例四]------->

　　容器内对象在调用remove，contains等方法时需要比较对象是否相等，这会涉及到对象类型equles方法和hashCode方法。　HashSet中的元素一般都需要实现Object的hashCode 方法和equals方法。用来生成哈希码查找位置和进行比较判断。但是对于自定义的类型，需要重写equles（快捷键： alt+shift+s h）和hashCode（快捷键：alt+shift+s h）方法以实现自定义的对象相等规则

　　HashSet 底层使用哈希表(散列码 int)实现，哈希表是一种非常重要的数据接口，遍历，插入，删除，查找都非常的快

　　注意：相等的对象应该具有相等的hashCode，但是具有相等的hashCode不一定具有相等的equles，hashCode就相当于一个索引

　　举例：equles是字典中的某个字，hashCode就是字典中的索引列表，如果所以相同，可能对应的字不是同一个字，但是如果字是同一个字，那么索引hashCode一定相同

　 HashCode结构组成：一个顺序表(数组)+一个链表

　　HashCode的基本实现策略

　　1.生成的哈希码和所有的成员属性都相关

　　2.使用素数，然后将所有的属性相关的哈希码的值相加的一个结果

　　3.为了保证：相同类型的对象，所生成的哈希码的值所定位到的顺序表的索引，产生尽量少的冲突

<-------泛　　型------->

　出现缘由

　　 JDK1.5之前，人们都是口头约定，没有限定类型的方法，所以我们需要一种规范来强制约束规范我们传入的数据类型

　 JDK1.5之后出现的新特性，用于解决安全问题，是一个安全机制，优点如下

　　　 1.将运行时期出现的问题ClassCastException[类型转换异常]，转移到了编译时期，方便程序员解决问题，让运行时期问题减少，安全。

　　　 2.避免了强制转换的麻烦

　 书写格式

通过<>来定义要操作的引用数据类型

误区

　　为什么泛型不能定义成基本数据类型？

　　泛形要求能包容的是对象类型，而基本类型在java里不属于对象

示例代码

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Exam7 {
 5     public static void main(String[] args) {
 6         ArrayList<String> arrayList = new ArrayList<String>();
 7 
 8         arrayList.add("ABC");
 9         arrayList.add("BCD");
10         arrayList.add("CDE");
11         arrayList.add("DEF");
12         arrayList.add("EFG");
13 
14         Iterator<String> iterator = arrayList.iterator();
15 
16         while (iterator.hasNext()) {
17             System.out.println(iterator.next());// ABC BCD CDE DEF EFG
18 
19         }
20     }
21 
22 }

　 什么情况下写泛型

通常在集合的框架中很常见，只要看到<>既要定义泛型

　　　其实<>就是用来接收类型的

　　　当使用集合时，将集合中要储存的数据类型作为参数传递到<>中即可，和函数传参数是一回事

　泛型类

　 什么时候定义泛型类

　当类中要操作的引用类型不确定的情况下，早期定义Object来完成扩展，现在定义泛型来完成扩展

示例代码

 1 public class Exam6 {
 2     public static void main(String[] args) {
 3         Utils<Worker> u = new Utils<Worker>();// 创建一个新的对象
 4         // 自定义类型 自定义类型
 5         u.setObject(new Worker()); // 调用Utils类的setObject方法
 6 
 7         Worker w = u.getObject(); // 定义Worker类型的对象w来接收通过Utils类的getObject方法获取到的内容
 8 
 9     }
10 }
11 
12 // 定义泛型类
13 class Utils<QQ> {
14     private QQ q;// 等以一个QQ类型静态变量
15 
16     public void setObject(QQ q) { // 定义一个QQ类型方法
17         this.q = q;
18     }
19 
20     public QQ getObject() { // 定义一个QQ类型方法
21         return q;
22     }
23 }
24 
25 class Worker { // 这个类需要先提前创建，如果不提前创建Eclipse也会提示出错，可以通过Eclipse提示创建
26 
27 }

　泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型都已固定了

为了让不同的方法或者同一个方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上

示例代码

 1 public class Exam8 {
 2     public static void main(String[] args) {
 3         Tools tools = new Tools();
 4 
 5         tools.show("13"); // show:13
 6         tools.print(123); // print:123
 7         tools.show(123); // show:123
 8 
 9     }
10 }
11 
12 class Tools {
13     public <S> void show(S s) { // 这里的S只是个自定义的类型，写什么都没关系，只在这个方法中有效
14         System.out.println("show:" + s);
15     }
16 
17     public <T> void print(T t) { // 这里的S只是个自定义的类型，写什么都没关系，只在这个方法中有效
18         System.out.println("print:" + t);
19     }
20 }

　特殊之处

　　静态方法[static]不可以访问类上定义的泛型，因为静态先加载，但是那个时候还没有对象

　　如果静态方法操作的引用数据类型不确定，可以将类型定义在方法上

示例代码

 1 public class Exam8 {
 2     public static void main(String[] args) {
 3         Tools tools = new Tools();
 4 
 5         tools.show("13"); // show:13
 6         tools.print(123); // print:123
 7         tools.show(123); // show:123
 8         tools.method(20); //method:20
 9 
10     }
11 }
12 
13 class Tools {
14     public <S> void show(S s) { // 这里的S只是个自定义的类型，写什么都没关系，只在这个方法中有效
15         System.out.println("show:" + s);
16     }
17 
18     public <T> void print(T t) { // 这里的S只是个自定义的类型，写什么都没关系，只在这个方法中有效
19         System.out.println("print:" + t);
20     }
21     
22     public static<W> void method(W w) { //在静态方法中定义泛型
23         System.out.println("method:"+w);
24     }
25 }

　泛型定义在接口

示例代码

 1 interface Inter<T> { // 定义接口并使用泛型
 2     void show(T t); // 定义方法[注意接口内的方法不能在接口中实现]
 3 }
 4 
 5 class Interface<T> implements Inter<T> { // 定义类实现接口
 6     public void show(T t) { // 实现接口中的方法
 7         System.out.println("show:" + t);
 8     }
 9 }
10 
11 public class Exam9 {
12     public static void main(String[] args) {
13         Interface<Integer> interface1 = new Interface<Integer>(); // 创建对象
14 
15         interface1.show(10); // show:10 //向方法中传入数据
16 
17     }
18 
19 }

<-------collections【collection中的工具类】------->

　　collections是针对容器的一个工具类，它提供了一系列静态方法实现了对各容器的的排序，搜索，线程安全等操作

　　　　addAll(c)[例十八]

　　　　　　------->将所有指定元素添加到指定 collection 中

　　　　fill(list, obj)[例十九]

　　　　　　------->填充List,将所有的值都改为填充的值

　　　　max(coll)[例二十]　　

　　　　　　------->根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

　　　　min(coll)[例二十]

　　　　　　------->根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

　　　　replaceAll(list, oldVal, newVal)[例二十一]

　　　　　　------->替换指定元素

　　　　reverse(list)[例二十二]

　　　　　　------->按逆序排列

　　　　shuffle(list)[例二十三]

　　　　　　------->使用默认随机源随机更改指定列表的序列

　　　　shuffle(list, rnd)[例二十四]

　　　　　　------->使用指定的随机源随机更改指定列表的序列

　　　　sort(list)[例二十五]

　　　　　　 ------->根据元素的自然顺序对指定列表按升序进行排序

　　　　Collections.binarySearch(list, key)[例二十六]

　　　　　　------->使用二进制搜索算法来搜索指定列表，以获得指定对象。

<-------ArrayList的底层代码分析------->
　

　　Object[] elementData;//存放数据
　　int size;计数，数组实际存放数据的数量
　　Object[] EMPTY_ELEMENTDATA = {};//一个空数组

　 private Object[] elementData;

　　　在list内部有一个私有的数组，而且这个数组只能装引用类型
　　　这个对象什么类型的数据都可以存放
　　　创建对象的时候，直接给成员变量赋值了一个空数组
　　　this.elementData = EMPTY_ELEMENTDAT

　　创建对象
　　　　List list = new ArrayList();
　　　　　　super();
　　　　this.elementData = EMPTY_ELEMENTDATA;
　　版本差异
　　　　1.5时候，创建数据每次都创建一个长度为10的数组
　　　　1.7时候，每次都指向一个静态空数组,JDK7的时候创建静态空数组长度为0,而且不管创建再多的arrayList，其实就是一个对象
　　新增数据
　　　　list.add(new Student());
　　　　首选判断数组是否是第一次，如果是第一次直接创建一个大小为10的数组
　　　　然后在数组的第一个位置存放数据
　　　　elementData[size++] = obj;
　　　　list.add(new Student());
　　　　以后每次存放数据，首先判断数组大小是否够用，如果不够用，扩容1.5倍
　　　　如果数据够用
　　　　elementData[size++] = obj;
　　删除数据
　　　　list.remove(index);
　　　　判断索引是否有效
　　　　System.arraycopy(elementData,index+1,elementData,index,size-index-1);
　　　　elementData[--size] = null;
　　　　list.remove(student);
　　　　首先遍历判断当前对象所在的索引
　　　　根据当前数据的索引开始删除
　　　　System.arraycopy(elementData,index+1,elementData,index,size-index-1);
　　　　elementData[--size] = null;
　　获取数据
　　　　list.get(index);
　　　　判断索引是否有效
　　　　直接返回索引对应的数据elemenetData[index];
　　设置数据
　　　　list.set(index,new Student());
　　　　判断索引是否有效
　　　　如果有效直接赋值elementData[index]=obj;

示例代码

 1 import java.util.ArrayList;
 2 import java.util.LinkedList;
 3 import java.util.List;
 4 
 5 import java.util.ArrayList;
 6 
 7 public class HelloArrayAndHelloLinked {
 8     public static void main(String[] args) {
 9         // 创建两个List对象
10         List array = new ArrayList();
11 
12         array.add("ABC");
13         array.add("BCD");
14         array.add("CDE");
15         array.add("EFG");
16 
17         System.out.println(array.size()); // 4
18 
19         array.remove("CDE");
20 
21         System.out.println(array.size()); // 3
22 
23         System.out.println(array.remove(0)); // ABC
24 
25         System.out.println(array.size()); // 2
26 
27         System.out.println(array.get(0)); // BCD
28         
29         array.set(0,"AAA");
30         
31         System.out.println(array); //[AAA, EFG]
32 
33     }
34 }

误区：为什么api上面说构造一个初始容量为 10 的空列表。

　　　　JDK5的时候创建数组长度默认为10
　　　　JDK7的时候创建静态空数组长度为0,而且不管创建再多的arrayList，其实就是一个对象
　　　　当我们添加数据的时候
　　　　ensureCapacityInternal(size+1);
　　　　当我们第一次使用的时候，默认创建一个大小为10的数组
　　　　elementData[size++] = e;
　　　　让size位置存放数据，并且size自增，size存放的是当前数组的实际长度
　　　　当数组的长度不满足当前需求的时候，每次就会扩容1.5倍

<-------LinkedList【链表】的底层代码分析------->

　　创建对象
　　　　直接创建一个空对象
　　　　int size = 0;
　　　　Node first = null;
　　　　Node last = null;
　　新增数据
　　　　默认将数据拼接到链表的末尾
　　　　创建一个新节点，新节点指向上个节点，原来的最后一个节点指向新节点，last指向新节点
　　删除数据

　　　一定要保证对象有正确的equals方法，可以保证逻辑上的相等
　　　　删除节点的时候只需要改变相邻节点的上下链接就可以
　　　　根据索引遍历数据，只需要遍历链表的一半
　　　　获取到指定节点
　　　　根据节点的位置改变pre next first last的指向

　　修改数据
　　　　循环到指定的节点
　　　　修改值
　　查询数据
　　　　节点在内存中是无序，我们不能按照顺序号进行随机访问
　　　　但是为了list接口，所以linked重写了get(index)方法
　　　　我们也可以根据索引来获取数据，只不过这个索引是一个一个数出来的

示例代码

 1 import java.util.LinkedList;
 2 
 3 public class HelloLinekd {
 4     public static void main(String[] args) {
 5         // 创建链表
 6         List list = new LinkedList();
 7         // 新增数据
 8         list.add("ABC1");
 9         list.add("ABC2");
10         list.add("ABC3");
11         list.add("ABC4");
12         list.add("ABC5");
13         list.add("ABC6");
14         list.add("ABC7");
15 
16         System.out.println(list); // [ABC1, ABC2, ABC3, ABC4, ABC5, ABC6, ABC7]
17 
18         // 删除数据
19         list.remove(5);
20         System.out.println(list);// [ABC1, ABC2, ABC3, ABC4, ABC5, ABC7]
21         // 修改数据
22         list.set(3, "BCD");
23         System.out.println(list);// [ABC1, ABC2, ABC3, BCD, ABC5, ABC6, ABC7]
24         // 查询
25         System.out.println(list.get(3)); // ABC4
26 
27     }
28 }

<--------Map属性------->

　　Map是一个键值对结构的数据类型
　　key:我们要通过key去找我们对应的值
　　value:我们存放的具体信息
　　我们存储的信息都是以key作为标识，所以key不能重复
　　如果key信息重复，后面会把前面的给覆盖掉

示例代码

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("DEF", 567);
17 
18         System.out.println(map); // {BCD=234, ABC=123, DEF=567, CDE=345}
19 
20     }
21 }

误区：为什么Map输出的元素不按照添加顺序排列？

顺序问题　　

　　HashMap 和 HashSet是不保证顺序的
　　TreeMap 和 TreeSet是自动排序的
　　list是按照添加顺序的

　 HashSet是按照Hash值【哈希值】来存的，输出结果有的时候和存入顺序相同，有的时候不相同

<-------Map的底层代码分析------->

　　创建对象
　　　　默认的初始容量16
　　　　static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
　　　　默认的使用的大小是总大小的75%
　　　　static final float DEFAULT_LOAD_FACTOR = 0.75f;
　　　　map中数组可用的大小
　　　　int threshold;
　　　　map中数组存放数据大小
　　　　int size;
　　　　创建对象的时候默认创建一个空的entry数组
　　　　transient Entry[] table = (Entry[]) EMPTY_TABLE;
　　存放数据
　　　　第一次存放数据
　　　　首先检查数组是不是默认的，如果是第一次需要创建一个新的
　　　　新创建的数组是entry类型的，大小为16,可用为12
　　　　计算key的hash值，相对是唯一的
　　　　然后根据数组的大小计算当前key所应该处于的索引位置，算法：hash&table.length
　　　　然后创建新的entry将数据存放至数组
　　　　第一次之后加入数据
　　　　首先计算key对应的hash值，算出对应的位置索引

　　　　判断当前key有没有指定值,
　　　　如果已经存在值
　　　　就会把原来的值返回，并且新的value覆盖掉原来的值
　　　　如果不存在值
　　　　然后创建一个新的enpty对象，最后将其存放至容器
　　　　在存入容器之前，我们还需要判断当前数组容量是否足够
　　　　扩容大小为原来的两倍,可用的大小也为原来的两倍，总大小的0.75
　　　　重新计算每一个数据的位置，重新将数据进行散列

　　　　比较特殊的情况

　　　　就是对象不同但是计算的索引的位置一样
　　　　使用单向链表解决
　　　　数组指向新的，新的指向旧的

　　取出数据
　　　　首先判断map是否为空，为空直接null
　　　　不为空，计算当前key的hash值，然后计算索引值
　　　　取出map的数组中指定位置的entry,然后进行比较
　　　　比较当前对象，如果当前对象不equals，开始比较单向链表中的entry
　　　　比较的时候先比较hash && 如果hash都不一样，对象肯定不一样，提高效率

　　删除数据

　　　　遍历Map，然后根据hash，equals判断对象是否一致，进行删除

示例代码　

import java.util.HashMap;
import java.util.Map;
import java.util.HashMap;

public class TestMap {
    public static void main(String[] args) {
        // 创建对象
        Map<String, String> map = new HashMap<>();
        // 存放数据
        System.out.println(map.put("ABC", "000")); //nul
        System.out.println(map.put("BCD", "111"));  //null
        System.out.println(map.put("BCD", "222")); //111
        for (int i = 0; i < 16; i++) {
            String key = "bjsxt" + i;
            String value = "sxt" + i;
            if (i == 0 || i == 12) {
                System.out.println("TestMap.main()"); /*TestMap.main()
                                                        TestMap.main()*/
            }
            map.put(key, value);
        }

        System.out.println(map.get("BCD")); //222

    }
}

误区：为什么map数组的大小只允许使用75%？　

　　假如数组用满，他并不是将数组的每个索引全部占用
　　当我们用对象的hash值去&数组大小的时候，不避免会产生相同的索引
　　这样就会导致一个索引有可能存放两个不同key,这个时候使用单向链表解决
　　首先数组索引指向新创建的entry,新entry有一个next属性会指向原来的entry对象，形成一个单向链表
　　其实如果使用单向链表存储数据的时候，已经违背了map设计的思想
　　所以我们最好重写每一个对象的hashcode方法
　　当我们的map里面的数组进行扩容的时候，当扩容完毕，首先散列我们现有存储的对象,尽量吧存在链表的地方给分开，提高查询效率

Entry:记录
　　我们map为了存放数据，所以专门创建的一个静态内部类
　　类似于我们数组中的一个元素
　　entry里面有两个属性
　　　　key
　　　　value
　　另外为了避免一些问题:不同hash算出相同index
　　　　next:
　　另外为了查找更加的快捷，专门记录了key的hash值
　　　　hash:比较的时候线比较hash值
　　hashmap中可以存放空值

<-------Set的底层代码分析------->

　　创建过程
　　　　private static final Object PRESENT = new Object();
　　　　传入的对象一直都是一个[object]，所以取值【查询】，是没有意义的
　　　　private transient HashMap<E,Object> map;
　　　　map = new HashMap();
　　　　set的底层就是一个map
　　添加数据
　　　　map.put(e, PRESENT)
　　　　e为传入数据【相当于Map中的key】，PRESENT相当于添加的对象【值】
　　　　其实就是向map中添加了一个Object对象
　　　　set中绝地不会有重复的值
　　　　原因见【误区】
　　删除数据
　　　　map.remove(o)

示例代码

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;

public class HelloSet {
    public static void main(String[] args) {
        //创建
        Set<String> set = new HashSet<>();
        //添加
        for (int i = 0; i <8; i++) {
            set.add("ABC" + i);
        }
        
        System.out.println(set);//[bjsxt3, bjsxt4, bjsxt5, bjsxt6, bjsxt0, bjsxt1, bjsxt2, bjsxt7]

        //删除
        set.remove("ABC3");
        System.out.println(set); //[ABC0, ABC1, ABC7, ABC6, ABC5, ABC4, ABC2]
        

    }
}

误区：为什么set中绝地不会有重复的值?

　　因为set相当于Map中的key，由于Key不可以重复，所以set不可以重复

<-------HashSet的底层代码分析------->

HashSet实现原理图

HashSet：无序、唯一。重写 hashCode 和equals 方法

　Hashset保证元素唯一性的依据

　　　是通过元素的两个方法，hashcode和equals来完成

　　　如果元素的hashcode值相同，才会判断equals是否为true

　　　如果元素的hashcode不同，不会调用equals

示例代码1

 1 public class Exam5 {
 2     public static void main(String[] args) {
 3         Demo demo1 = new Demo();
 4         Demo demo2 = new Demo();
 5 
 6         // 两者哈希值相等但是不是同一个对象
 7         System.out.println(demo1); // Demo@61
 8         System.out.println(demo2); // Demo@61
 9 
10     }
11 
12 }
13 
14 class Demo {
15     public int hashCode() {
16         return 97;
17 
18     }
19 }

示例代码2

 1 import java.util.HashSet;
 2 import java.util.Iterator;
 3 
 4 public class Exam5 {
 5     public static void main(String[] args) {
 6 
 7         HashSet hashSet = new HashSet();
 8 
 9         // 二者哈希值和所属对象相同，所以第一组数据存入成功，第二组不能存入，存入失败
10         System.out.println(hashSet.add("ABC")); // true
11         System.out.println(hashSet.add("ABC")); // false
12 
13         hashSet.add("BCD");
14         hashSet.add("CDE");
15         hashSet.add("EDF");
16         hashSet.add("GHJ");
17         hashSet.add("BCD");
18         hashSet.add("CDE");
19 
20         Iterator iterator = hashSet.iterator();
21 
22         while (iterator.hasNext()) {
23             // 之所以输出值没有重复的是因为重复的元素，哈希值相等并且属于同一对象，所以添加数据不成功
24             System.out.println(iterator.next());// BCD ABC GHJ EDF CDE
25 
26         }
27     }
28 }

<-------LinkedHashSet性质解析------->

　　LinkedHashSet 是HashSet的子类。在原有的基础上增加了一个链表用来维护添加元素的顺序。在遍历的时候添加和遍历输出的顺序一致

 1 import java.util.Iterator;
 2 import java.util.LinkedHashSet;
 3 import java.util.Set;
 4 
 5 public class LinkedHashSetDemo {
 6     public static void main(String[] args) {
 7         Set<String> set = new LinkedHashSet<>();
 8 
 9         set.add("ABC");
10         set.add("BCD");
11         set.add("CDE");
12         set.add("DEF");
13         set.add("EFG");
14         set.add("FGH");
15 
16         Iterator<String> iterator = set.iterator();
17         while (iterator.hasNext()) {
18             System.out.println(iterator.next()); // ABC BCD CDE DEF EFG FGH
19         }
20     }
21 }

<-------TreeSet底层代码分析------->

实现分析

　　底层使用二叉树，通过比较实现，Comparable Comparator 接口

　　特点：元素有序（升序），并且具有唯一性

<-------TreeSet中的两种比较器------->

　TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)
如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
内部比较器在类上implement Comparable
重写compareTo()方法
在方法内定义比较算法, 根据大小关系, 返回正数负数或零
在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储[见上图]

　　CompareTo的比较原理

　　compareTo() 的返回值是int, 它是先比较对应字符的大小(ASCII码顺序)

　 　　1、如果字符串相等返回值0
 　　　2、如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值前字符串的值小于后字符串，正值前字符串大于后字符串）
　 　　3、如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完,这时就比较字符的长度.

　　TreeSet是依靠TreeMap来实现的

　　TreeSet是一个有序集合，TreeSet中的元素将按照升序排列，缺省是按照自然排序进行排列，意味着TreeSet中的元素要实现Comparable接口。或者有一个自定义的比较器。
　　从而使我们可以在构造TreeSet对象时，传递实现Comparator接口的比较器对象

　　在使用Arrays对数组中的元素进行排序的时候，可以传递一个比较器。

　　在使用Collections对集合中的元素进行排序的时候，可以传递一个比较器。

　　那么在使用TreeSet对加入到其中的元素进行排序的时候可以传入一个比较器。

内部比较器

　　让元素所对应的类实现Comparable 接口，实现compareTo方法，并重写compareTo方法

 1 /**
 2  * CompareDemo
 3  */
 4 import java.util.Iterator;
 5 import java.util.LinkedList;
 6 import java.util.List;
 7 import java.util.Set;
 8 import java.util.TreeSet;
 9 
10 public class CompareDemo {
11     public static void main(String[] args) {
12         Set<Student> set=new TreeSet<Student>();
13 
14         Student student = new Student("张三", 20, "男", 20.3);
15         Student student1 = new Student("李四", 26, "男", 85.3);
16         Student student2 = new Student("王五", 31, "女", 38.3);
17         Student student3 = new Student("王五", 31, "女", 38.3);
18 
19         set.add(student);
20         set.add(student1);
21         set.add(student2);
22         set.add(student3);
23 
24         Iterator<Student> iterator = set.iterator();
25 
26         while (iterator.hasNext()) {
27             System.out.println(iterator.next());
28         }
29     }
30 }

  1 /**
  2  * Student.class
  3  */
  4 public class Student implements Comparable {
  5     private String name;
  6     private int age;
  7     private String sex;
  8     private double weight;
  9 
 10     @Override
 11     public int compareTo(Object o) {
 12         Student student = (Student) o;
 13         int result = this.age - student.age;
 14         if (result == 0) {
 15             result = this.name.compareTo(student.name);
 16         }
 17         if (result == 0) {
 18             result = this.sex.compareTo(student.sex);
 19         }
 20         if (result == 0) {
 21             if (this.weight < student.weight) {
 22                 return -1;
 23             } else if (this.weight > student.weight) {
 24                 return 1;
 25             } else {
 26                 return 0;
 27             }
 28         }
 29         return result;
 30     }
 31     // ---------------以下代码由快捷键生成---------------//
 32 
 33     @Override
 34     public String toString() {
 35         return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", weight=" + weight + "]";
 36     }
 37 
 38     @Override
 39     public int hashCode() {
 40         final int prime = 31;
 41         int result = 1;
 42         result = prime * result + age;
 43         result = prime * result + ((name == null) ? 0 : name.hashCode());
 44         result = prime * result + ((sex == null) ? 0 : sex.hashCode());
 45         long temp;
 46         temp = Double.doubleToLongBits(weight);
 47         result = prime * result + (int) (temp ^ (temp >>> 32));
 48         return result;
 49     }
 50 
 51     @Override
 52     public boolean equals(Object obj) {
 53         if (this == obj)
 54             return true;
 55         if (obj == null)
 56             return false;
 57         if (getClass() != obj.getClass())
 58             return false;
 59         Student other = (Student) obj;
 60         if (age != other.age)
 61             return false;
 62         if (name == null) {
 63             if (other.name != null)
 64                 return false;
 65         } else if (!name.equals(other.name))
 66             return false;
 67         if (sex == null) {
 68             if (other.sex != null)
 69                 return false;
 70         } else if (!sex.equals(other.sex))
 71             return false;
 72         if (Double.doubleToLongBits(weight) != Double.doubleToLongBits(other.weight))
 73             return false;
 74         return true;
 75     }
 76 
 77     public Student(String name, int age, String sex, double weight) {
 78         super();
 79         this.name = name;
 80         this.age = age;
 81         this.sex = sex;
 82         this.weight = weight;
 83     }
 84 
 85     public String getName() {
 86         return name;
 87     }
 88 
 89     public void setName(String name) {
 90         this.name = name;
 91     }
 92 
 93     public int getAge() {
 94         return age;
 95     }
 96 
 97     public void setAge(int age) {
 98         this.age = age;
 99     }
100 
101     public String getSex() {
102         return sex;
103     }
104 
105     public void setSex(String sex) {
106         this.sex = sex;
107     }
108 
109     public double getWeight() {
110         return weight;
111     }
112 
113     public void setWeight(double weight) {
114         this.weight = weight;
115     }
116 
117 }

外部比较器

　　自定义一个外部比较器实现Comparator接口。实例化TreeSet 对象时，指定外部比较器

 1 /**
 2  * ComparatorDemo
 3  */
 4 import java.util.Iterator;
 5 import java.util.Set;
 6 import java.util.TreeSet;
 7 
 8 public class ComparatorDemo {
 9     public static void main(String[] args) {
10         Set<Student> set = new TreeSet<>(new CompareDemo());
11 
12         Student student = new Student(20, "张三", "男", 20.3);
13         Student student1 = new Student(26, "李四", "男", 85.3);
14         Student student2 = new Student(20, "王五", "女", 38.3);
15         Student student3 = new Student(20, "王五", "女", 38.3);
16 
17         set.add(student);
18         set.add(student1);
19         set.add(student2);
20         set.add(student3);
21 
22         Iterator<Student> it = set.iterator();
23 
24         while (it.hasNext()) {
25             System.out.println(it.next());
26         }
27 
28     }
29 }

 1 /**
 2  * Student
 3  */
 4 public class Student {
 5     private int age;
 6     private String name;
 7     private String sex;
 8     private double weight;
 9 
10     // ------------以下代码由快捷键生成--------------//
11 
12     @Override
13     public String toString() {
14         return "Student [age=" + age + ", name=" + name + ", sex=" + sex + ", weight=" + weight + "]";
15     }
16 
17     @Override
18     public int hashCode() {
19         final int prime = 31;
20         int result = 1;
21         result = prime * result + age;
22         result = prime * result + ((name == null) ? 0 : name.hashCode());
23         result = prime * result + ((sex == null) ? 0 : sex.hashCode());
24         long temp;
25         temp = Double.doubleToLongBits(weight);
26         result = prime * result + (int) (temp ^ (temp >>> 32));
27         return result;
28     }
29 
30     @Override
31     public boolean equals(Object obj) {
32         if (this == obj)
33             return true;
34         if (obj == null)
35             return false;
36         if (getClass() != obj.getClass())
37             return false;
38         Student other = (Student) obj;
39         if (age != other.age)
40             return false;
41         if (name == null) {
42             if (other.name != null)
43                 return false;
44         } else if (!name.equals(other.name))
45             return false;
46         if (sex == null) {
47             if (other.sex != null)
48                 return false;
49         } else if (!sex.equals(other.sex))
50             return false;
51         if (Double.doubleToLongBits(weight) != Double.doubleToLongBits(other.weight))
52             return false;
53         return true;
54     }
55 
56     public Student(int age, String name, String sex, double weight) {
57         super();
58         this.age = age;
59         this.name = name;
60         this.sex = sex;
61         this.weight = weight;
62     }
63 
64     public int getAge() {
65         return age;
66     }
67 
68     public void setAge(int age) {
69         this.age = age;
70     }
71 
72     public String getName() {
73         return name;
74     }
75 
76     public void setName(String name) {
77         this.name = name;
78     }
79 
80     public String getSex() {
81         return sex;
82     }
83 
84     public void setSex(String sex) {
85         this.sex = sex;
86     }
87 
88     public double getWeight() {
89         return weight;
90     }
91 
92     public void setWeight(double weight) {
93         this.weight = weight;
94     }
95 
96 }

 1 /**
 2  * CompareDemo
 3  */
 4 import java.util.Comparator;
 5 
 6 public class CompareDemo implements Comparator<Student> {
 7 
 8     @Override
 9     public int compare(Student o1, Student o2) {
10         Student student = o1;
11         Student student1 = o2;
12         int result = student.getAge() - student1.getAge();
13         if (result == 0) {
14             result = student.getName().compareTo(student1.getName());
15         }
16         if (result == 0) {
17             result = student.getSex().compareTo(student1.getSex());
18         }
19         if (result == 0) {
20 
21             if (student.getWeight() < student1.getWeight()) {
22                 return -1;
23             } else if (student.getWeight() > student1.getWeight()) {
24                 return 1;
25             } else {
26                 return 0;
27             }
28 
29         }
30 
31         return result;
32     }
33 
34 }

<-------集合的遍历------>

ArrayList的遍历

　　三种方法

　　 1.for循环

　 2.foreach增强for循环

　 3.迭代器

示例代码

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class ListDemo {
 6     public static void main(String[] args) {
 7 
 8         List<String> list = new ArrayList<String>();
 9 
10         list.add("AB");
11         list.add("BC");
12         list.add("CD");
13         list.add("DE");
14         list.add("EF");
15 
16         // for循环遍历
17         for (int i = 0; i < list.size(); i++) {
18             System.out.println(list.get(i)); // AB BC CD DE EF
19         }
20         System.out.println("------------------------------");
21 
22         // foreach增强for循环，注意foreach的底层是迭代器
23         for (String string : list) {
24             System.out.println(string);// AB BC CD DE EF
25         }
26         System.out.println("------------------------------");
27 
28         // 迭代器遍历方法
29         Iterator<String> iterator = list.iterator();
30         while (iterator.hasNext()) {
31             System.out.println(iterator.next());// AB BC CD DE EF
32         }
33 
34     }
35 }

LinkedList的遍历

　　　三种方法

　　 1.for循环

　　 2.foreach增强for循环

　 3.迭代器

示例代码

 1 import java.util.Iterator;
 2 import java.util.LinkedList;
 3 import java.util.List;
 4 
 5 public class LinkedListDemo {
 6     public static void main(String[] args) {
 7 
 8         List<String> list = new LinkedList<String>();
 9 
10         list.add("ABC");
11         list.add("BCD");
12         list.add("CDE");
13         list.add("DEF");
14         list.add("EFG");
15 
16         for (int i = 0; i < list.size(); i++) {
17             System.out.println(list.get(i)); // ABC BCD CDE DEF EFG
18         }
19     
20         for (String string : list) {
21             System.out.println(string); //ABC BCD CDE DEF EFG
22         }
23         
24         Iterator<String> iterator=list.iterator();
25         
26         while (iterator.hasNext()) {
27             System.out.println(iterator.next()); //ABC BCD CDE DEF EFG
28         }
29     }
30 
31 }

HashSet的遍历

　　 两种方法

　　 1.foreach增强for循环

　 2.迭代器

示例代码

 1 import java.util.HashSet;
 2 import java.util.Iterator;
 3 import java.util.Set;
 4 
 5 public class HashSetDemo {
 6     public static void main(String[] args) {
 7 
 8         Set<String> set = new HashSet<String>();
 9 
10         set.add("ABC");
11         set.add("BCD");
12         set.add("CDE");
13         set.add("DEF");
14         set.add("EFG");
15 
16         for (String string : set) {
17             System.out.println(string);// ABC BCD CDE DEF EFG
18         }
19 
20         Iterator<String> iterator = set.iterator();
21         while (iterator.hasNext()) {
22             System.out.println(iterator.next());// ABC BCD CDE DEF EFG
23         }
24 
25     }
26 }

HashMap的遍历

　　三种方法

　　 1.map.keySet

 1 import java.util.HashMap;
 2 import java.util.Iterator;
 3 import java.util.Map;
 4 import java.util.Set;
 5 
 6 public class HashMapDemo {
 7     public static void main(String[] args) {
 8 
 9         Map<String, String> map = new HashMap<>();
10 
11         map.put("AB", "赵一");
12         map.put("BC", "钱一");
13         map.put("CD", "孙一");
14         map.put("DE", "李一");
15         map.put("EF", "周一");
16         map.put("FG", "吴一");
17 
18         Set<String> set = map.keySet();
19         Iterator<String> iterator = set.iterator();
20 
21         while (iterator.hasNext()) {
22             String aString = iterator.next();
23             System.out.println(aString + ":" + map.get(aString));
24             // AB:赵一 BC:钱一 CD:孙一 DE:李一 EF:周一 FG:吴一
25         }
26 
27     }
28 }

　　 2.map.values

 1 import java.util.Collection;
 2 import java.util.HashMap;
 3 import java.util.Iterator;
 4 import java.util.Map;
 5 
 6 public class HashMapDemo1 {
 7     public static void main(String[] args) {
 8         Map<String, String> map = new HashMap<>();
 9 
10         map.put("AB", "赵一");
11         map.put("BC", "钱一");
12         map.put("CD", "孙一");
13         map.put("DE", "李一");
14         map.put("EF", "周一");
15         map.put("FG", "吴一");
16 
17         Collection<String> collection = map.values();
18 
19         Iterator<String> iterator = collection.iterator();
20         while (iterator.hasNext()) {
21             System.out.println(iterator.next()); // 赵一 钱一 孙一 李一 周一 吴一
22         }
23 
24     }
25 }

　　 3.Set<Entry<String, String>>

 1 import java.util.HashMap;
 2 import java.util.Iterator;
 3 import java.util.Map;
 4 import java.util.Set;
 5 import java.util.Map.Entry;
 6 
 7 public class HashMapDemo2 {
 8     public static void main(String[] args) {
 9         Map<String, String> map = new HashMap<>();
10 
11         map.put("AB", "赵一");
12         map.put("BC", "钱一");
13         map.put("CD", "孙一");
14         map.put("DE", "李一");
15         map.put("EF", "周一");
16         map.put("FG", "吴一");
17 
18         Set<Entry<String, String>> set = map.entrySet();
19 
20         Iterator<Entry<String, String>> iterator = set.iterator();
21         while (iterator.hasNext()) {
22             Entry<String, String> aString = iterator.next();
23 
24             System.out.println(aString.getKey() + ":" + aString.getValue());
25         }
26 
27     }
28 }

TreeMap的遍历

　　三种方法

　　1.map.value

　　2.map.KeySet

　　3.Set<Entry<K, V>>

 1 import java.util.Collection;
 2 import java.util.Iterator;
 3 import java.util.Set;
 4 import java.util.TreeMap;
 5 import java.util.Map.Entry;
 6 
 7 public class TreeMapDemo {
 8     public static void main(String[] args) {
 9         TreeMap<String, String> treeMap = new TreeMap<>();
10 
11         treeMap.put("AB", "12");
12         treeMap.put("BC", "23");
13         treeMap.put("CD", "34");
14         treeMap.put("DE", "45");
15         treeMap.put("EF", "56");
16 
17         // System.out.println("-------------map.value方法----------------")\\
18         Collection<String> collection = treeMap.values();
19 
20         Iterator<String> iterator = collection.iterator();
21         while (iterator.hasNext()) {
22             System.out.println(iterator.next());
23         }
24 
25         // System.out.println("-------------map.KeySet方法----------------")\\
26 
27         Set<String> set = treeMap.keySet();
28         Iterator<String> iterator2 = set.iterator();
29         while (iterator2.hasNext()) {
30             String aString = iterator2.next();
31 
32             System.out.println(aString + ":" + treeMap.get(aString));
33         }
34         // System.out.println("-------------map.set<Entry<K,V>方法----------------")\\
35 
36         Set<Entry<String, String>> set2 = treeMap.entrySet();
37         Iterator<Entry<String, String>> iterator3 = set2.iterator();
38 
39         while (iterator3.hasNext()) {
40             Entry<String, String> bString = iterator3.next();
41 
42             System.out.println(bString.getKey() + "--" + bString.getValue());
43 
44         }
45     }
46 }

HashTable的遍历

　　两种方法[老方法，新方法同样适用]

　　1.hashtable.keys()

　 2.hashtable.elements()

 1 import java.util.Collection;
 2 import java.util.Enumeration;
 3 import java.util.Hashtable;
 4 import java.util.Iterator;
 5 import java.util.Set;
 6 import java.util.Map.Entry;
 7 
 8 public class HashTableDemo {
 9     public static void main(String[] args) {
10 
11         Hashtable hashtable = new Hashtable();
12 
13         hashtable.put("A", "123");
14         hashtable.put("B", "234");
15         hashtable.put("C", "345");
16         hashtable.put("D", "456");
17         hashtable.put("E", "678");
18 
19         // 老版本的遍历方式1
20         Enumeration enumeration = hashtable.keys();
21 
22         while (enumeration.hasMoreElements()) {
23             Object object = enumeration.nextElement();
24             System.out.println(object + ":" + hashtable.get(object));
25             /*
26              * E:678 D:456 C:345 B:234
27              */
28 
29             // 老版本的遍历方式2
30             Enumeration enumeration2 = hashtable.elements();
31 
32             while (enumeration2.hasMoreElements()) {
33                 Object object2 = enumeration2.nextElement();
34                 System.out.println(object2);
35                 /*
36                  * E:678 D:456 C:345 B:234
37                  */
38 
39                 // 注意：现在新版本也适用，新版本的方法和HashMap的方法一样
40                 Collection<String> collection = hashtable.values();
41                 Iterator<String> iterator = collection.iterator();
42                 while (iterator.hasNext()) {
43                     String string = (String) iterator.next();
44                     System.out.println(string);
45                     /*
46                      * E:678 D:456 C:345 B:234
47                      */
48                 }
49 
50                 Set<String> set = hashtable.keySet();
51                 Iterator<String> iterator2 = set.iterator();
52 
53                 while (iterator2.hasNext()) {
54                     String string = iterator2.next();
55                     System.out.println(string + ":" + hashtable.get(string));
56                     /*
57                      * E:678 D:456 C:345 B:234
58                      */
59                 }
60 
61                 Set<Entry<String, String>> set2 = hashtable.entrySet();
62                 Iterator<Entry<String, String>> iterator3 = set2.iterator();
63                 while (iterator3.hasNext()) {
64                     Entry<String, String> string = iterator3.next();
65                     System.out.println(string.getKey() + "：" + string.getValue());
66                     /*
67                      * E:678 D:456 C:345 B:234
68                      */
69                 }
70             }
71         }
72 
73     }
74 }

<-------示例代码------->

例一

　　添加数据

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         System.out.println(collection.toString()); // [ABC, BCD, CDE, DEF, EFG]
13 
14     }
15 }

例二

　如果知道equals的，移除数据，获取当前数据的索引，让数组后面的数据整体前移，并且将最后一个数据赋值为null

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11         
12         collection.remove("BCD");
13         System.out.println(collection.toString()); //[ABC, CDE, DEF, EFG]
14 
15 
16     }

例三

　　当我们调用数组长度方法的时候，直接返回size

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11         
12         
13         System.out.println(collection.size()); //5
14 
15     }
16 }

例四【转载】

　　Java中的equals()方法是在Object类中定义，Object类是所有类的父类。换句话说，任何类都隐含地继承了该方法。判断两个对象的内容是否相同，必须使用equals()方法，对于没有重写该方法的类，需要重写该方法。重写equals()方法代码如下：

 1 /**
 2  * equlas()方法重写实例
 3  */
 4 class User {
 5     /**
 6      * 方法描述：设置name值 输入参数：String name 返回类型：void
 7      */
 8     public void setName(String name) {
 9         this.name = name;
10     }
11 
12     /**
13      * 方法描述：获取name值 输入参数： 返回类型：String
14      */
15     public String getName() {
16         return name;
17     }
18 
19     /**
20      * 方法描述：重写equals()方法 输入参数：Object obj 返回类型：boolean
21      */
22 
23     public boolean equals(Object obj) {
24         if (this == obj) {
25             return true;
26         }
27         if (null == obj) {
28             return false;
29         }
30         if (getClass() != obj.getClass()) {
31             return false;
32         }
33 
34         User user = (User) obj;
35         if (!name.equals(user.name)) {
36             return false;
37         }
38         return true;
39     }
40 
41     private String name;
42 }
43 
44 public class EqualsDemo {
45     public static void main(String[] args) {
46         User userA = new User();
47         userA.setName("王明");
48 
49         User userB = new User();
50         userB.setName("王明");
51 
52         User userC = new User();
53         userC.setName("王亮");
54 
55         System.out.println("userA equals userB:" + userA.equals(userB));
56         System.out.println("userA equals userC:" + userA.equals(userC));
57     }
58 }

运行结果

总结

　　1.对象内容的比较，需要使用equals()方法，若是对于已经重写该方法的类，例如String类，就无需再重写；若是没有重写，例如自定义的User类，就需要重写。

　　2.Java语言中的“==”对于基本数据类型就是比较其值，而对于对象就是比较对象的引用。

注意

　　第一如果你传入的比较对象跟被比较对象是==的，既两个对象的内存都一样，肯定是相同一个，则返回true
　　第二如果你传入比较的对象是空值，则返回false
　　第三如果你传入的比较对象跟被比较对象是同一类型就把比较对象转换成被比较对象类型，返回根据对象能确定唯一的元素比较值
　　最后都不满足返回false

例五

　　清空数据,并且将数组长度变为0

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         collection.clear();
13         System.out.println(collection.size()); // 0
14 
15     }
16 }

例六

　　用于从列表中移除指定collection中包含的所有元素

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         collection2.add("ASD");
15         collection2.add("SDF");
16         collection2.add("DFG");
17         collection2.add("FGH");
18         collection2.add("GHJ");
19 
20         collection2.removeAll(collection2);
21         System.out.println(collection2.size()); // 0
22 
23     }
24 }

例七

　　判断容器中是否包含所要查找的元素

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         collection2.add("ASD");
15         collection2.add("SDF");
16         collection2.add("DFG");
17         collection2.add("FGH");
18         collection2.add("GHJ");
19 
20         System.out.println(collection.contains("ABC")); // true
21         System.out.println(collection.contains("AB")); // false
22 
23     }
24 }

例八

　　判断对象是否相等

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         collection2.add("ABC");
15         collection2.add("BCD");
16         collection2.add("CDE");
17         collection2.add("DEF");
18         collection2.add("EFG");
19 
20         System.out.println(collection.equals(collection2)); // true
21         System.out.println(collection.hashCode()+"==="+collection2.hashCode());// 1557782627===1557782627
22 
23     }
24 }

例九

　　获取对象的哈希值，如果两个对象equals那么他们的hashcode一定相同，但hashcode相同不一定equals

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         collection2.add("ABC");
15         collection2.add("BCD");
16         collection2.add("CDE");
17         collection2.add("DEF");
18         collection2.add("EFG");
19 
20         System.out.println(collection.equals(collection2)); // true
21         System.out.println(collection.hashCode()+"==="+collection2.hashCode());// 1557782627===1557782627
22 
23     }
24 }

例十

　　是否为空(判断当前容器是否有数据)

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         System.out.println(collection.isEmpty()); // false
15         System.out.println(collection2.isEmpty()); // true
16     }
17 }

例十一

代码一

　　取出两个容器的交集，判断是否有交集，返回值为boolean型

 1 public class Exam {
 2     public static void main(String[] args) {
 3         // 首先创建一个容器对象
 4         Collection collection = new ArrayList();
 5         // 开始使用容器中的方法
 6         collection.add("ABC");
 7         collection.add("BCD");
 8         collection.add("CDE");
 9         collection.add("DEF");
10         collection.add("EFG");
11 
12         Collection collection2 = new ArrayList();
13 
14         collection2.add("ABC");
15         collection2.add("BCD");
16         collection2.add("CDSE");
17         collection2.add("SES");
18         collection2.add("ESFG");
19 
20         System.out.println(collection.retainAll(collection2)); // true
21     }
22 }

代码二

　　取出两个容器的交集，输出交集元素

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         // 首先创建一个容器对象
 8         Collection list = new ArrayList();
 9         // 开始使用容器中的方法
10         list.add("ABC");
11         list.add("BCD");
12         list.add("CDE");
13         list.add("DEF");
14         list.add("EFG");
15 
16         Collection list1 = new ArrayList();
17 
18         list1.add("BCD");
19         list1.add("EFG");
20         list1.add("CDE");
21 
22         list.retainAll(list1);
23         System.out.println(list); //[BCD, CDE, EFG]
24 
25 
26     }
27 }

例十二

　　判断一个对象中是否有指定对象中的全部元素

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         // 首先创建一个容器对象
 8         Collection list = new ArrayList();
 9         // 开始使用容器中的方法
10         list.add("ABC");
11         list.add("BCD");
12         list.add("CDE");
13         list.add("DEF");
14         list.add("EFG");
15 
16         Collection list1 = new ArrayList();
17 
18         list1.add("BCD");
19         list1.add("EFG");
20         list1.add("CDE");
21 
22         System.out.println(list.containsAll(list1)); // true
23 
24     }
25 }

例十三

　　List中的方法，插入到指定的位置，后面的全体向后迁移

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 public class Exam {
 5     public static void main(String[] args) {
 6         // 首先创建一个容器对象
 7         List list = new ArrayList();
 8         // 开始使用容器中的方法
 9         list.add("ABC");
10         list.add("BCD");
11         list.add("CDE");
12         list.add("DEF");
13         list.add("EFG");
14 
15         list.add(2, "ASD");
16         System.out.println(list.toString()); // [ABC, BCD, ASD, CDE, DEF, EFG]  在2和3之间插入
17 
18 
19     }
20 }

例十四

　　获取指定位置元素

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 public class Exam {
 5     public static void main(String[] args) {
 6         // 首先创建一个容器对象
 7         List list = new ArrayList();
 8         // 开始使用容器中的方法
 9         list.add("ABC");
10         list.add("BCD");
11         list.add("CDE");
12         list.add("DEF");
13         list.add("EFG");
14 
15         System.out.println(list.get(2)); //CDE
16 
17     }
18 }

例十五

　　覆盖掉原来的值

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 public class Exam {
 5     public static void main(String[] args) {
 6         // 首先创建一个容器对象
 7         List list = new ArrayList();
 8         // 开始使用容器中的方法
 9         list.add("ABC");
10         list.add("BCD");
11         list.add("CDE");
12         list.add("DEF");
13         list.add("EFG");
14 
15         list.set(2,"AAA");
16         System.out.println(list.get(2)); //AAA
17 
18     }
19 }

例十六

　　搜索给定参数第一次出现的位置，使用 equals 方法进行相等性测试，没有所搜索项目会返回“-1”

 1 public class HelloList {
 2     public static void main(String[] args) {
 3         List list = new ArrayList();
 4         list.add("bjsxt0");
 5         list.add("bjsxt1");
 6         list.add("bjsxt2");
 7         list.add("bjsxt3");
 8         list.add("bjsxt4");
 9         list.add("bjsxt5");
10         list.add("bjsxt6");
11         list.add("bjsxt7");
12         list.add("bjsxt5");
13 
14         System.out.println(list.indexOf("bjsxt5") + "=====" + list.indexOf("bjsxt0")); //5====0
15         
16 
17     }
18 }

例十七

　　返回指定的对象在列表中最后一次出现的位置索引，没有所搜索项目会返回“-1”

 1 public class HelloList {
 2     public static void main(String[] args) {
 3         List list = new ArrayList();
 4         list.add("bjsxt0");
 5         list.add("bjsxt1");
 6         list.add("bjsxt2");
 7         list.add("bjsxt3");
 8         list.add("bjsxt4");
 9         list.add("bjsxt5");
10         list.add("bjsxt6");
11         list.add("bjsxt7");
12         list.add("bjsxt5");
13 
14 
15         System.out.println(list.lastIndexOf("bjsxt5") + "=====" + list.lastIndexOf("bjsxt0")); //5====0
16 
17     }
18 }

例十八

　　将所有指定元素添加到指定 collection 中

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class CollectionsDemo {
 6     public static void main(String[] args) {
 7 
 8         List<String> list = new ArrayList<>();
 9 
10         list.add("ABC");
11         list.add("BCD");
12         list.add("CDE");
13         list.add("DEF");
14 
15         System.out.println(list); //[ABC, BCD, CDE, DEF]
16         Collections.addAll(list, "123", "456", "789", "852"); //[ABC, BCD, CDE, DEF, 123, 456, 789, 852]
17 
18         System.out.println(list);
19 
20     }    
21 }

例十九

　　填充List,将所有的值都改为填充的值

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         List list = new ArrayList();
 8 
 9         for (int i = 0; i < 8; i++) {
10             list.add("ABC"+i);
11         }
12         
13         Collections.fill(list, "BCD");
14         
15         System.out.println(list); //[BCD, BCD, BCD, BCD, BCD, BCD, BCD, BCD, BCD]
16 
17     }
18 }

例二十

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         List list = new ArrayList();
 8 
 9         for (int i = 0; i < 8; i++) {
10             list.add("ABC" + i);
11         }
12 
13         System.out.println(Collections.max(list)); // ABC7
14         System.out.println(Collections.min(list)); // ABC0
15 
16     }
17 }

例二十一

　　替换指定元素

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         List list = new ArrayList();
 8 
 9         for (int i = 0; i < 8; i++) {
10             list.add("ABC" + i);
11         }
12 
13         Collections.replaceAll(list, "ABC2","ABC12");
14         System.out.println(list); //[ABC0, ABC1, ABC12, ABC3, ABC4, ABC5, ABC6, ABC7]
15 
16     }
17 }

例二十二

　　按逆序排列

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         List list = new ArrayList();
 8 
 9         for (int i = 0; i < 8; i++) {
10             list.add("ABC" + i);
11         }
12 
13         Collections.reverse(list);
14         System.out.println(list);//[ABC7, ABC6, ABC5, ABC4, ABC3, ABC2, ABC1, ABC0]
15 
16     }
17 }

例二十三

　　使用默认随机源随机更改指定列表的序列

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Exam {
 6     public static void main(String[] args) {
 7         List list = new ArrayList();
 8 
 9         for (int i = 0; i < 8; i++) {
10             list.add("ABC" + i);
11         }
12 
13         Collections.shuffle(list);
14         
15         System.out.println(list);
16         /*[ABC3, ABC6, ABC4, ABC1, ABC7, ABC5, ABC0, ABC2]
17          *[ABC5, ABC6, ABC3, ABC4, ABC0, ABC7, ABC2, ABC1]
18          */
19 
20 
21     }
22 }

例二十四

　　使用指定的随机源随机更改指定列表的序列

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 import java.util.Random;
 5 
 6 public class Exam {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9 
10         for (int i = 0; i < 8; i++) {
11             list.add("ABC" + i);
12         }
13 
14         Collections.shuffle(list,new Random());
15         
16         System.out.println(list);
17         /*[ABC0, ABC5, ABC4, ABC7, ABC2, ABC6, ABC3, ABC1]
18          *[ABC2, ABC4, ABC5, ABC1, ABC0, ABC6, ABC7, ABC3]
19          */
20 
21     }
22 
23 }

例二十五

　　 根据元素的自然顺序对指定列表按升序进行排序

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 import java.util.Random;
 5 
 6 public class Exam {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9 
10         for (int i = 0; i < 8; i++) {
11             list.add("ABC" + i);
12         }
13 
14         Collections.sort(list);
15         
16         System.out.println(list);//[ABC0, ABC1, ABC2, ABC3, ABC4, ABC5, ABC6, ABC7]
17 
18     }
19 
20 }

例二十六

　　使用二进制搜索算法来搜索指定列表，以获得指定对象

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 import java.util.Random;
 5 
 6 public class Exam {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9 
10         for (int i = 0; i < 8; i++) {
11             list.add("ABC" + i);
12         }
13 
14         Collections.sort(list);
15         System.out.println(Collections.binarySearch(list, "ABC3")); //3
16 
17     }
18 }

例二十七

　　创建对象

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import javax.crypto.MacSpi;
 4 import sun.net.www.content.text.plain;
 5 import java.util.Collection;
 6 
 7 public class Exam {
 8     public static void main(String[] args) {
 9         Map<String, Object> map = new HashMap<>();
10 
11         System.out.println(map); // {}
12 
13     }
14 }

例二十八

　　添加值

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import javax.crypto.MacSpi;
 4 import sun.net.www.content.text.plain;
 5 import java.util.Collection;
 6 
 7 public class Exam {
 8     public static void main(String[] args) {
 9         Map<String, Object> map = new HashMap<>();
10 
11         map.put("ABC", 123);
12         map.put("BCD", 234);
13         map.put("CDE", 345);
14         map.put("DEF", 456);
15         map.put("EFG", 567);
16 
17         System.out.println(map); //{BCD=234, ABC=123, DEF=456, EFG=567, CDE=345}
18 
19 
20     }
21 }

例二十九

　　删除值

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18         map.remove("CDE");
19 
20         System.out.println(map); // {BCD=234, ABC=123, DEF=456, EFG=567}
21 
22     }
23 }

例三十

　　获取值

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18         System.out.println(map.get("DEF")); // 456
19 
20     }
21 }

例三十一

　　查看map的长度

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18         System.out.println(map.size()); //5
19 
20     }
21 }

例三十二

　　获取所有的key

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import java.util.Collection;
 6 
 7 public class Exam {
 8     public static void main(String[] args) {
 9         Map<String, Object> map = new HashMap<>();
10 
11         map.put("ABC", 123);
12         map.put("BCD", 234);
13         map.put("CDE", 345);
14         map.put("DEF", 456);
15         map.put("EFG", 567);
16         
17         Set set = map.keySet();
18         System.out.println(set); //[BCD, ABC, DEF, EFG, CDE]
19 
20     }
21 }

例三十三

　　判断是否包含指定的key

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18         System.out.println(map.containsKey("EFG")); //true
19         System.out.println(map.containsKey("AAA")); //false
20         
21     }
22 }

例三十四

　　判断是否包含指定的值

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18 
19         System.out.println(map.containsValue(234)); //true 
20         System.out.println(map.containsValue(1111)); //false
21         
22     }
23 }

例三十五

　　清空数据，并清空map长度为0·

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import javax.crypto.MacSpi;
 5 import sun.net.www.content.text.plain;
 6 import java.util.Collection;
 7 
 8 public class Exam {
 9     public static void main(String[] args) {
10         Map<String, Object> map = new HashMap<>();
11 
12         map.put("ABC", 123);
13         map.put("BCD", 234);
14         map.put("CDE", 345);
15         map.put("DEF", 456);
16         map.put("EFG", 567);
17 
18         map.clear();
19 
20         System.out.println(map); // {}
21         System.out.println(map.size()); // 0
22 
23     }
24 }

例三十六

　　删除指定位置元素

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class Exam2 {
 6     public static void main(String[] args) {
 7         add();
 8     }
 9 
10     public static void add() {
11         List list = new ArrayList();
12 
13         list.add("ABC");
14         list.add("BCD");
15         list.add("CDE");
16         list.add("DEF");
17         list.add("EFG");
18 
19         list.remove(2);
20 
21         System.out.println(list); // [ABC, BCD, DEF, EFG]
22 
23     }
24 }

例三十七

　　返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class Exam2 {
 6     public static void main(String[] args) {
 7         add();
 8     }
 9 
10     public static void add() {
11         List list = new ArrayList();
12 
13         list.add("ABC");
14         list.add("BCD");
15         list.add("CDE");
16         list.add("DEF");
17         list.add("EFG");
18 
19         List sub=list.subList(2, 4);
20 
21         System.out.println(sub); // [CDE, DEF]
22 
23 
24     }
25 }

例三十八

　　List特有的迭代器

 1 import java.util.LinkedList;
 2 import java.util.List;
 3 import java.util.ListIterator;
 4 
 5 public class ListIteratorDemo {
 6     public static void main(String[] args) {
 7         add();
 8     }
 9 
10     public static void add() {
11         List<String> list = new LinkedList<String>();
12 
13         list.add("ABC");
14         list.add("BCD");
15         list.add("CDE");
16         list.add("DEF");
17 
18         ListIterator<String> listIterator = list.listIterator();
19         while (listIterator.hasNext()) {
20             String string = listIterator.next();
21 
22             if (string.equals("ABC")) {
23                 listIterator.add("AAA");// [ABC, AAA, BCD, CDE, DEF] 在指定元素后面添加
24             }
25             if (string.equals("DEF")) {
26                 listIterator.set("BBB");
27             }
28 
29             if (string.equals("BCD")) {
30                 listIterator.remove(); // [ABC, AAA, CDE, BBB] 移除指定元素
31             }
32         }
33         System.out.println(list); // [ABC, AAA, BCD, CDE, BBB] 修改指定元素
34 
35     }
36 }

例三十九

　　LinkedList特有方法

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.LinkedList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class Exam2 {
 8     public static void main(String[] args) {
 9         add0();
10         add();
11     }
12 
13     private static void add0() {
14         LinkedList linkedList = new LinkedList();
15 
16         linkedList.addFirst("A");
17         linkedList.addFirst("B");
18         linkedList.addFirst("C");
19         linkedList.addFirst("D");
20 
21         System.out.println(linkedList); // [D, C, B, A]
22     }
23 
24     private static void add() {
25 
26         LinkedList linkedList = new LinkedList();
27 
28         linkedList.addLast("A");
29         linkedList.addLast("B");
30         linkedList.addLast("C");
31         linkedList.addLast("D");
32 
33         System.out.println(linkedList); // [A, B, C, D]
34 
35         System.out.println(linkedList.getFirst()); // A
36 
37         System.out.println(linkedList.getLast()); // D
38 
39         linkedList.removeFirst();
40         System.out.println(linkedList.size()); // 3
41         System.out.println(linkedList); // [B, C, D]
42 
43         linkedList.removeLast();
44 
45         System.out.println(linkedList.size()); // 2
46         System.out.println(linkedList); // [B, C]
47 
48     }
49 
50 }

　　取出全部元素

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.LinkedList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class Exam2 {
 8     public static void main(String[] args) {
 9         add();//用迭代器
10         add1();// 不用迭代器
11     }
12 
13     private static void add() {
14 
15         LinkedList linkedList = new LinkedList();
16 
17         linkedList.addLast("A");
18         linkedList.addLast("B");
19         linkedList.addLast("C");
20         linkedList.addLast("D");
21 
22         Iterator iterator = linkedList.iterator();
23 
24         while (iterator.hasNext()) {
25             System.out.println(iterator.next());
26         }
27 
28     }
29 
30     private static void add1() {
31         LinkedList linkedList = new LinkedList();
32 
33         linkedList.addLast("A");
34         linkedList.addLast("B");
35         linkedList.addLast("C");
36         linkedList.addLast("D");
37 
38         while (!linkedList.isEmpty()) {
39             System.out.println(linkedList.removeFirst());
40         }
41     }
42 
43 }

　　JDK1.6后改进方法

 1 import java.util.LinkedList;
 2 
 3 public class LinkedListNewMethod {
 4     public static void main(String[] args) {
 5         LinkedList<String> linkedList = new LinkedList<>();
 6 
 7         linkedList.add("A");
 8         linkedList.add("B");
 9         linkedList.add("C");
10 
11         // push的作用是添加到链表的最前面，实现先进后出，后进先出
12         linkedList.push("D");
13         linkedList.push("H");
14         System.out.println(linkedList); // [H, D, A, B, C]
15         // getFirst方法的作用只是获取头节点
16         System.out.println(linkedList.getFirst()); // H
17         System.out.println(linkedList); // [H, D, A, B, C]
18         // pop方法是返回头节点对象并且从链表中删除
19         linkedList.pop();
20         System.out.println(linkedList.pop()); // D
21         System.out.println(linkedList); // [A, B, C]
22         System.out.println(linkedList.peek()); // A
23         System.out.println(linkedList.peekFirst()); // A
24 
25     }
26 }

例四十

　　linkedList应用

 1 import java.util.LinkedList;
 2 
 3 public class Exam3 {
 4     public static void main(String[] args) {
 5         Duilie duilie = new Duilie();
 6 
 7         duilie.addElement("A");
 8         duilie.addElement("B");
 9         duilie.addElement("C");
10         duilie.addElement("D");
11 
12         while (!duilie.isEmpty()) {
13             System.out.println(duilie.removeElement());
14         }
15 
16     }
17 }
18 
19 class Duilie {
20 
21     LinkedList link = new LinkedList();
22 
23     public void addElement(Object object) {// 像这种不需要返回给主方法结果值的就不用设定返回值
24         link.addFirst(object);
25     }
26 
27     public Object getElement() { // 封装需要定义返回值是因为在主方法调用这个方法的时候的时候，需要返回这个方法所得到的数据传入主方法，所以需要定义一个返回值，将此方法计算出来的结果返回给主方法
28         return link.getFirst();
29     }
30 
31     public Object removeElement() {
32         return link.removeFirst();
33     }
34 
35     public boolean isEmpty() {
36         return link.isEmpty();
37     }
38 }

posted @ 2016-08-08 21:03 IT蓄水池阅读(257) 评论(0) 收藏举报

刷新页面返回顶部

IT蓄水池

集合【容器】

公告