集合Collection和List的详解

1.什么是集合

存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。

集合的出现就是为了持有对象。集合中可以存储任意类型的对象,而且长度可变。在程序中有可能无法预先知道需要多少个对象,那么用数组来装对象的话,长度不好定义,而集合解决了这样的问题。

2.集合和数组的区别

数组和集合类都是容器

数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。

集合类的特点

用于存储对象，长度是可变的，可以存储不同类型的对象。

数组的缺点

存储类型单一的数据容器，操作复杂(数组一旦声明好不可变)

3.集合的分类

集合做什么

1：将对象添加到集合

2：从集合中删除对象

3: 从集合中查找一个对象

4：从集合中修改一个对象就是增删改查

注意：集合和数组中存放的都是对象的引用而非对象本身

Java工程师对不同的容器进行了定义,虽然容器不同,但是还是有一些共性可以抽取最后抽取了一个顶层接口,那么就形成了一个集合框架。如何学习呢?当然是从顶层学起,顶层里边具有最共性,最基本的行为。具体的使用,就要选择具体的容器了。为什么?因为不断向上抽取的东西有可能是不能创建对象的.抽象的可能性很大，并且子类对象的方法更多一些.所以是看顶层,创建底层。那么集合的顶层是什么呢 叫做Collection

集合框架体系

[java] view plain copy print?
---|Collection: 单列集合  
            ---|List: 有存储顺序, 可重复  
                ---|ArrayList:  数组实现, 查找快, 增删慢  
                            由于是数组实现, 在增和删的时候会牵扯到数组  
                                                增容, 以及拷贝元素. 所以慢。数组是可以直接  
                                                按索引查找, 所以查找时较快  
                ---|LinkedList: 链表实现, 增删快, 查找慢  
                            由于链表实现, 增加时只要让前一个元素记住自  
                                               己就可以, 删除时让前一个元素记住后一个元  
                                               素, 后一个元素记住前一个元素. 这样的增删效  
                                             率较高但查询时需要一个一个的遍历, 所以效率  
                                                较低  
                ---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低  
                             和ArrayList实现方式相同, 但考虑了线程安全问  
                                                题, 所以效率略低  
            ---|Set: 无存储顺序, 不可重复  
                ---|HashSet  
                ---|TreeSet  
                ---|LinkedHashSet  
---| Map: 键值对  
        ---|HashMap  
        ---|TreeMap  
        ---|HashTable  
        ---|LinkedHashMap

为什么出现这么多集合容器，因为每一个容器对数据的存储方式不同，这种存储方式称之为数据结构（data structure）

注意 --集合和数组中存放的都是对象的引用。

4.什么时候该使用什么样的集合

5.集合类Collection

Collection接口有两个子接口：List(链表|线性表)和Set(集)

1.特点：

Collection中描述的是集合共有的功能(CRUD)

List可存放重复元素，元素存取是有序的

Set不可以存放重复元素，元素存取是无序的

java.util.Collection  
        ---| Collection     描述所有接口的共性  
            ----| List接口    可以有重复元素的集合  
            ----| Set  接口   不可以有重复元素的集合

2：学习集合对象

学习Collection中的共性方法，多个容器在不断向上抽取就出现了该体系。发现Collection接口中具有所有容器都具备的共性方法。查阅API时，就可以直接看该接口中的方法。并创建其子类对象对集合进行基本应用。当要使用集合对象中特有的方法，在查看子类具体内容。

查看api 文档Collection在在java.util中（注意是大写Collection）

注意在现阶段遇到的 E T 之类的类型,需要暂时理解为object  因为涉及到了泛型.

3：创建集合对象,使用Collection中的List的具体实现类ArrayList

Collection coll=new Arraylist();

6.Collection接口的共性方法

增加：  
        1：add() 将指定对象存储到容器中  
                      add 方法的参数类型是Object 便于接收任意对象  
        2：addAll() 将指定集合中的元素添加到调用该方法和集合中  
删除：  
        3：remove() 将指定的对象从集合中删除  
        4：removeAll() 将指定集合中的元素删除  
修改  
        5：clear() 清空集合中的所有元素  
判断  
        6：isEmpty() 判断集合是否为空  
        7：contains() 判断集合何中是否包含指定对象  
              
        8：containsAll() 判断集合中是否包含指定集合  
                            使用equals()判断两个对象是否相等    
获取:           9：int size()    返回集合容器的大小  
  
转成数组        10： toArray()   集合转换数组  

增加：

 1 public static void main(String[] args) {  
 2         Collection list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         System.out.println(list);  
 8         // [计算机网络, 现代操作系统, java编程思想]  
 9           
10         // 增加2 将list容器元素添加到list2容器中  
11         Collection list2 = new ArrayList();  
12         list2.add("java核心技术");  
13         list2.addAll(list);  
14         list2.add("java语言程序设计");  
15         System.out.println(list2);  
16         // [java核心技术, 计算机网络, 现代操作系统, java编程思想, java语言程序设计]  
17     } 

删除：

1 // 删除1 remove  
2         boolean remove = list2.remove("java核心技术");  
3         System.out.println(remove); // true  
4         System.out.println(list2); //  
5         //删除2 removeAll() 将list中的元素删除  
6         boolean removeAll = list2.removeAll(list);  
7         System.out.println(removeAll);//true  
8         System.out.println(list2);//[java语言程序设计]  

修改：

 1 public static void main(String[] args) {  
 2         Collection list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         System.out.println(list);  
10         // 修改 clear() 清空集合中的所有元素  
11         list.clear();  
12         System.out.println(list); //[]   
13     }  

判断：

 1 public static void main(String[] args) {  
 2         Collection list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         System.out.println(list);  
10           
11         boolean empty = list.isEmpty();  
12         System.out.println(empty);// false  
13         boolean contains = list.contains("java编程思想");  
14         System.out.println(contains);// true  
15         Collection list2 = new ArrayList();  
16         list2.add("水许传");  
17         boolean containsAll = list.containsAll(list2);  
18         System.out.println(containsAll);// false  
19   
20     }  

获取：

 1 public static void main(String[] args) {  
 2         Collection list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         System.out.println(list);  
10         // 获取  集合容器的大小   
11         int size = list.size();  
12         System.out.println(size);   
13     } 

下面写个例子~集合中添加自定义对象:

 1 public static void main(String[] args) {  
 2   
 3         // 创建集合对象  
 4         Collection coll = new ArrayList();  
 5   
 6         // 创建Person对象  
 7         Person p1 = new Person("jack", 25);  
 8         Person p2 = new Person("rose", 22);  
 9         Person p3 = new Person("lucy", 20);  
10         Person p4 = new Person("jack", 25);  
11   
12         // 集合中添加一些Perosn  
13   
14         // 删除指定Person  
15   
16         // 删除所有Person  
17   
18         // 判断容器中是否还有Person  
19   
20         // 判断容器中是否包含指定Person  
21   
22         // 获取容器中Person的个数  
23   
24         // 将容器变为数组,遍历除所有Person  
25   
26     }  

分析:

1：Person类

    1：姓名和年龄

     2：重写hashCode和equals方法

          1：如果不重写，调用Object类的equals方法，判断内存地址，为false

                    1：如果是Person类对象，并且姓名和年龄相同就返回true

          2：如果不重写，调用父类hashCode方法

                   1：如果equals方法相同，那么hashCode也要相同，需要重写hashCode方法

          3：重写toString方法

                   1：不重写，直接调用Object类的toString方法，打印该对象的内存地址

Person类：

 1 class Person {  
 2     private String name;  
 3     private int age;  
 4   
 5     public Person() {  
 6   
 7     }  
 8   
 9     public Person(String name, int age) {  
10   
11         this.name = name;  
12         this.age = age;  
13     }  
14   
15     @Override  
16     public int hashCode() {  
17         return this.name.hashCode() + age;  
18     }  
19   
20     @Override  
21     public boolean equals(Object obj) {  
22         if (!(obj instanceof Person)) {  
23             return false;  
24         }  
25         Person p = (Person) obj;  
26         return this.name.equals(p.name) && this.age == p.age;  
27     }  
28   
29     @Override    
30     public String toString() {  
31         return "Person :name=" + name + ", age=" + age;  
32     }  
33   
34 }  

 1 public static void main(String[] args) {  
 2         Person p1 = new Person("张三", 19);  
 3         Person p2 = new Person("李四", 20);  
 4         Person p3 = new Person("王五", 18);  
 5         Collection list = new ArrayList();  
 6         list.add(p1);  
 7         list.add(p2);  
 8         list.add(p3);  
 9         // isEmpty() 判断集合是否为空  
10         boolean empty = list.isEmpty();  
11         System.out.println(empty);  
12         // 返回集合容器的大小  
13         int size = list.size();  
14         System.out.println(size);  
15          // contains()判断集合何中是否包含指定对象  
16         boolean contains = list.contains(p1);  
17         System.out.println(contains);  
18   
19         // remove(); 将指定的对象从集合中删除  
20         list.remove(p1);  
21           
22         // clear() 清空集合中的所有元素  
23         list.clear();  
24         System.out.println(list);  
25   
26     }

7.List集合:

---| Iterable     接口   
          Iterator iterator()  
    ----| Collection     接口  
        ------| List      接口 元素可以重复，允许在指定位置插入元素，并通过索引来访问元素  

List集合特有方法:

1：增加  
        void add(int index, E element) 指定位置添加元素              
        boolean addAll(int index, Collection c) 指定位置添加集合    
2：删除  
E remove(int index) 删除指定位置元素  
  
3：修改  
        E set(int index, E element)    返回的是需要替换的集合中的元素  
4：查找：  
        E get(int index)             注意： IndexOutOfBoundsException  
        int indexOf(Object o)         // 找不到返回-1  
        lastIndexOf(Object o)   
5：求子集合  
         List subList(int fromIndex, int toIndex) // 不包含toIndex  

增加：

 1 public static void main(String[] args) {  
 2         List list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         System.out.println(list);  
10         // 删除0角标元素  
11         Object remove = list.remove(0);  
12         System.out.println(remove);  
13     }

修改：

 1 public static void main(String[] args) {  
 2         List list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         System.out.println(list);  
10         // 修改2角标位置的书，返回的原来2角标位置的书  
11         Object set = list.set(2, "边城");  
12         System.out.println(set); //java编程思想  
13         System.out.println(list);   
14           
15     } 

查找：

 1 List list = new ArrayList();  
 2         // 增加：add() 将指定对象存储到容器中  
 3         list.add("计算机网络");  
 4         list.add("现代操作系统");  
 5         list.add("java编程思想");  
 6         list.add("java核心技术");  
 7         list.add("java语言程序设计");  
 8         System.out.println(list);  
 9         // 查找： E get(int index)  注意角标越界  
10         Object set = list.get(list.size() - 1);  
11         System.out.println(set); // java语言程序设计  
12         System.out.println(list);  
13         list.get(list.size()); //IndexOutOfBoundsException  
14     } 

 1 public static void main(String[] args) {  
 2         List list = new ArrayList();  
 3         // 增加：add() 将指定对象存储到容器中  
 4         list.add("计算机网络");  
 5         list.add("现代操作系统");  
 6         list.add("java编程思想");  
 7         list.add("java核心技术");  
 8         list.add("java语言程序设计");  
 9         list.add("java编程思想");  
10         System.out.println(list);  
11         // 查找： E get(int index) 注意角标越界  
12         Object set = list.get(list.size() - 1);  
13         System.out.println(set); // java语言程序设计  
14         System.out.println(list);  
15         // list.get(list.size()); //IndexOutOfBoundsException  
16   
17         // indexOf(Object o) 返回第一次出现的指定元素的角标  
18         int indexOf = list.indexOf("java编程思想");  
19         System.out.println(indexOf); // 2  
20         // 没有找到，返回-1  
21         int indexOf2 = list.indexOf("三国志");  
22         System.out.println(indexOf2); // -1  
23   
24         // lastIndexOf 返回最后出现的指定元素的角标  
25         int lastIndexOf = list.lastIndexOf("java编程思想");  
26         System.out.println(lastIndexOf); // 5  
27     }