Collection集合

1 集合概述：

1.1 什么是集合？有什么用？

数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

集合为什么说在开发中使用较多？

集合是一个容器，是一个载体，可以一次容纳多个对象。

在实际开发中，假设连接数据库，数据库当中有10条记录。那么假设把这10条记录查询出来，在java程序中会讲10条数据封装成10个java对象，

然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

1.2 集合不能直接存储基本数据类型，另外集合也不能直接存储Java对象。

集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）

list.add(100); // 自动装箱 Integer

注意：

集合在java中本身是一个容器，是一个对象。

集合中任何时候存储的都是“引用”

1.3 在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中，

什么是数据结构？数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如：

数组、二叉树、链表、哈希表...

以上这些都是常见的数据机构。

你往集合c1中放数据，可能是放到了数组上了。

你往集合c2中放数据，可能是放到了二叉树上了。

......

你使用不同的集合等同于使用了不同的数据结构。

你在java集合这一章节，你需要掌握的不是精通数据结构。java中已经将数据结构实现了，已经写好了这些常用的集合类，你只需要掌握怎么用？在什么情况下

选择哪一种合适的集合去使用即可。

new ArrayList(); 创建一个集合，底层是数组。

new LinkedList(); 创建一个集合对象，底层是链表。

new TreeSet(); 创建一个集合对象，底层是二叉树。

...

1.4 集合在java JDK中哪个包下？

java.util.*;

所有的集合类和集合接口都在和hava.util包下。

1.5 为了让大家掌握集合这块的内容，最好能将集合的继承结构图背会！！！

集合整个这个体系是怎么样的一个机构，你需要有印象。

1.6 在java中集合分为两大类：

一类是单个方式存储元素：

单个方式存储元素，这一类集合中的超级父接口：java.util.Collection;

一类是以键值对的方式存储元素

以键值对的方式存储元素，这一类集合中超级父类接口：java.util.Map;

2 总结重点：

第一个重点：把集合继承结构图背会。

第二个重点：把Collection接口中常用方法测试几遍。

第三个重点：把迭代器弄明白。

第四个重点：Collection接口中的remove方法和contains方法底层都会调用equals，把这个弄明白。

集合中存储的是对象的内存地址：

Iterator迭代器原理：（注意：集合对象中保存的是内存地址哦，不是直接保存的对象或者基本数据类型哦。）

迭代原理：

Collection接口中常用的方法：

package com.javase.Collection;


import java.util.ArrayList;
import java.util.Collection;


/*
关于java.util.Collection接口中常用的方法。
    1 Collection中能存放什么元素？
        没有使用“泛型”之前，Collection中可以存储Object的所有子类型。
        使用了“泛型”之后，Collection中只能存储某个具体的类型。
        集合后期我们会学习“泛型”语法。目前先不用管。Collection中什么都可以存，
        只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址。）
        
    2 Collection中的常用方法：
        boolean add(Object e) 向集合中添加元素
        int size() 获取集合中元素的个数。
        void clear() 清空集合
        boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true 不包含返回false
        boolean remove(Object o) 删除集合中的某个元素
        boolean isEmpty() 判断该集合中元素的个数是否为0
        Object[] toArray() 调用这个方法可以吧集合转换成数组。（作为了解，使用不多。）
*/
public class CollectionTest01 {
    public static void main(String[] args) {
        // 创建一个集合对象
        // Collection c  = new Collection(); // 接口是抽象的，无法实例化。
        // 多态
        Collection c = new ArrayList();
        // 测试Collection接口中常用的方法
        c.add(1200);// 自动装箱(java5的新特性)，实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
        c.add(3.14);// 自动装箱
        c.add(new Object());
        c.add(true);// 自动装箱
    
        // 获取集合中元素的个数
        System.out.println("集合中元素的个数是：" + c.size()); // 4
        
        // 清空集合中的元素
        c.clear();
        System.out.println("集合中元素的个数是：" + c.size()); // 0
        
        // 在向集合中添加元素
        c.add("hello");// "hello"对象的内存地址放到了集合当中。
        c.add("world");
        c.add("浩克");
        c.add("绿巨人");
        c.add("1");
        
        // 判断集合中是否包含"绿巨人"
        boolean flag = c.contains("绿巨人");
        System.out.println(flag); // true
    
        boolean flag2 = c.contains("绿巨人2");
        System.out.println(flag2); // false
    
        // 获取集合中元素的个数
        System.out.println("集合中元素的个数是：" + c.size()); // 5
        
        // 删除集合中某个元素
        c.remove("1");
    
        // 获取集合中元素的个数
        System.out.println("集合中元素的个数是：" + c.size()); // 4
        
        // 判断集合是否为空（集合中是否存在元素）
        System.out.println(c.isEmpty()); // false
        
        // 清空
        c.clear();
    
        System.out.println(c.isEmpty()); // true
        
        c.add(100);
        c.add("abc");
        c.add('中');
        c.add(true);
        c.add(new Student());
        
        // 转换成数组（使用不多，了解一下。）
        Object[] o = c.toArray();
        for (int i = 0; i < o.length; i++) {
            System.out.print(o[i] + " ");
        }
    
    }
}


class Student{
    
    public String toString() {
        return "这是一个Student类";
    }
}

关于集合遍历/迭代专题（重点 *****）

package com.javase.Collection;


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


/*
关于集合遍历/迭代专题（重点 *****）
*/
public class CollectionTest02 {
    public static void main(String[] args) {
        // 注意：以下讲解的遍历方式/迭代方式，是所有Collection通用的一种方式。
        // 在Map集合中不能用。在所有Collection以及子类中使用。
        // 创建集合对象
        Collection c = new ArrayList(); // 后面的集合无所谓，主要是看前面的Collection接口，怎么遍历/迭代
        // 添加元素
        c.add("abc");
        c.add(123);
        c.add(true);
        c.add(new Object());
        c.add('中');
        // 对集合Collection进行遍历/迭代
        // 第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();
        // 第二步：通过以上获取的迭代器对象开始迭代/遍历集合
        
        // Iterator迭代器中的方法
        /*
         boolean hasNext()  如果仍有元素可以迭代，则返回 true。
         Object next()  返回迭代的下一个元素。
         */
        // boolean hasNext = it.hasNext();
        while (it.hasNext()){
            // 不管你当初放进去什么，取出来统一都是Object。
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

迭代案例2：

package com.javase.Collection;


import java.util.*;


public class CollectionTest03 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c1 = new ArrayList(); // ArrayList集合：有序可重复。
        // 添加元素
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(1);
        
        // 迭代集合
        Iterator t1 = c1.iterator();
        while (t1.hasNext()){
            // 存进去是什么类型，取出来还是什么类型。
            Object o = t1.next();
            /*if(o instanceof Integer){
                System.out.println("Integer类型");
            }*/
            // 只不过在输出的时候会转换成字符串。因为这里println()会调用toString()方法。
            System.out.println(o);
        }
        
        // 创建HashSet集合对象: 无序不可重复
        Collection c2 = new HashSet();
        // 无序：存进去和取出的顺序不一定不同。
        // 不可重复： 已经存储了100了 不能在存储100了。
        c2.add(100);
        c2.add(200);
        c2.add(300);
        c2.add(400);
        c2.add(500);
        c2.add(600);
        c2.add(700);
        c2.add(800);
        c2.add(900);
        c2.add(100);
        // 迭代集合
        Iterator t2 = c2.iterator();
        while (t2.hasNext()){
            System.out.println(t2.next());
        }
    }
}

Collection中的contains()方法底层原理：

深入Collection集合的contains方法：

package com.javase.Collection;


import java.util.ArrayList;
import java.util.Collection;


/*
深入Collection集合的contains方法：
    boolean contains(Object o)
    判断集合中是否包含某个对象o
    如果包含返回true 如果不包含返回false
    
    contains 方法是用来判断集合中是否包含某个元素的方法，
    那么他在底层是怎么判断集合中是否包含某个元素的呢？
        调用了equals方法进行比对。
        equals方法返回true，就表示包含这个元素。
*/
public class CollectionTest04 {
    public static void main(String[] args) {
        // 创建集合
        Collection c = new ArrayList();
        
        // 添加元素
        String s1 = new String("abc"); // 0x1111
        c.add(s1);// 放进去了一个"abc"
        
        String s2 = new String("def"); // 0x2222
        c.add(s2);
        
        // 集合中的元素个数
        System.out.println(c.size());
        
        // 新建的对象String
        String x = new String("abc"); // 0x2222
        // c集合中是否包含x?结果猜测一下是true还是false？
        System.out.println(c.contains(x));// 判断集合中是否存在"abc"  true
    }
}

测试contains方法和remove方法案例：

package com.javase.Collection;



import java.util.ArrayList;
import java.util.Collection;



/*
测试contains方法
测试remove方法。
结论：存放在一个集合中的类型，一定要重写equals方法。
*/
public class CollectionTest05 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();
        // 创建User对象
        User u1 = new User("jack");
        User u2 = new User("jack");
        // 将对象加到集合中
        c.add(u1);
        //判断集合中是否包含u2
        
        // 没有重写equals方法之前
        // System.out.println(c.contains(u2)); // false
        
        // 重写equals方法之后，比较的时候会比较name。
        System.out.println(c.contains(u2));//true
        
        c.remove(u2);
        System.out.println(c.size());//0
        
        /*Integer x = new Integer(10000);
        c.add(x);
    
        Integer y = new Integer(10000);
        System.out.println(c.contains(y));//true*/
        
        // Integer 类的 equals方法重写了。
        // x.equals(y) --> true
        
        // 创建集合对象
        Collection c1 = new ArrayList();
        // 创建字符串对象
        String  s1 = new String("hello");
        // 加进去
        c1.add(s1);
        // 创建字符串对象
        String  s2 = new String("hello");
        // 删除s2
        c1.remove(s2);
        // 集合中元素的个数是？
        System.out.println(c1.size());// 0
    }
}



class User{
    private String name;
    
    public User() {
    }
    
    public User(String name) {
        this.name = name;
    }
    
    // 重写equals方法
    // 将来调用equals方法的时候，一定是调用这个重写的equals方法。
    // 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。
    public boolean equals(Object o) {
        if(o == null || !(o instanceof User)) return false;
        if(o == this) return true;
        User u = (User)o;
        //如果名字一样表示同一个人。（不再比较对象的内存地址了。比较内容）
        return  u.name.equals(this.name);
    }
}

关于集合元素的remove：

package com.javase.Collection;


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
关于集合元素的remove
    重点：当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，会出现异常：java.util.ConcurrentModificationException
    
    重点：在迭代器集合元素的过程中，不能调用集合对象的remove方法，删除元素：
        c.remove(0);迭代过程中不能这样。
        会出现：java.util.ConcurrentModificationException异常。
        
    重点：在迭代元素过程当中，一定要使用迭代器Iterator的remove方法，删除元素。不要使用集合自带的remove方法删除元素。
*/
public class CollectionTest06 {
    public static void main(String[] args) {
        // 创建集合
        Collection collection = new ArrayList();
        
        // 注意：此时获取的迭代器，指向的是那时集合中没有元素状态下的迭代器。
        // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。
        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException
        // Iterator iterator = collection.iterator();
        
        // 添加元素
        collection.add(1);
        collection.add(2);
        collection.add(3);
        // 获取迭代器
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()){
            // 编写代码时next()返回值类型必须是Object
            // Integer i = iterator.next();
            Object obj = iterator.next();
            System.out.println(obj);
        }
        
        Collection c1 = new ArrayList();
        c1.add("abc");
        c1.add("def");
        c1.add("xyz");
        
        Iterator it1 = c1.iterator();
        while (it1.hasNext()){
            Object o = it1.next();
            // 删除元素
            // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器。
            // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常。
            // 出异常根本原因：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了。）
            // c1.remove(o);//直接通过集合去删除元素，没有通知迭代器，（导致迭代器的快照和原集合状态不同。）
            // System.out.println(o);
            // 使用迭代器来删除可以吗？
            // 迭代器去删除时，会自动更新迭代器，并且更新集合(删除集合中的元素)。
            it1.remove();// 删除的一定是迭代器指向的当前元素。
            System.out.println(o);
        }
    
        System.out.println(c1.size());
    }
}