java 集合（重要）

集合

什么是集合？有什么用？

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

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

集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库中有10条记录，那么假设把这10条记录查询出来，在Java程序中会将10条数据封装成10个Java对象，然后将10个Java对象放到某一个集合中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

1.2 集合存储什么

集合不能直接存储基本数据类型，另外集合也不能直接存储Java对象，集合当中存储的都是Java对象的内存地址（或者说集合中存储的是引用）

注意：集合在Java中本身就是一个容器，是一个对象，集合中任何时候存储的都是“引用”

1.3不同的集合，底层会对应不同的数据结构

在Java中每一个不同的集合，底层会对应不同的数据结构，往往在不同的集合中存储元素，等于将数据放到了不同的数据结构中。（数据存储的结构就是数据结构）
使用不同的集合等于使用了不同的数据结构。
例如：
new ArrayList（）； 创建一个集合，底层是数组
new LinkedList（）； 创建一个集合对象，底层是链表
new TreeSet（）；创建一个集合对象，底层是二叉树
…

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

Java.util. * ; (所有的集合类和集合接口都在Java.util包下）

1.5集合的继承结构图

集合继承结构图 ---- Collectiion部分

集合继承结构 ------ Map部分

总结：
ArrayList：底层是数组
LinkedList：底层是双向链表
Vector：底层是数组，线程是安全的，效率较低，使用较少
HashSet：底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合的key部分了
TreeSet：底层是TreeMap，放到TreeSet集合中的元素等同于放到TreeMap集合key部分了
HashMap：底层是哈希表
Hashtable：底层也是哈希表，只不过线程是安全的，效率较低，使用较少
Properties：是线程安全的，并且key和value只能存储字符串String
TreeMap:底层是二叉树，TreeMap集合的key可以自动按照大小顺序排序

1.6 Collection接口中常用的方法

注意：借口是抽象的，无法实例化

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

public class Test {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //Collection c = new LinkedList();
        c.add(10000);      //自动装箱，实际上是放进去了一个对象的内存地址，Integer x = new Integer(10000);
        c.add(new Object());
        c.add(true);         //都是自动装箱

        System.out.println("集合中元素的个数：" + c.size());  //3

        //清空集合
        c.clear();
        System.out.println("集合中元素的个数：" + c.size());    //0

        //再向集合中添加元素
        c.add("java");
        c.add("c");
        c.add("钢铁侠");
        c.add(666);
        c.add(new Student());

        //判断集合中是否包含 "钢铁侠"
        boolean flag =c.contains("钢铁侠");
        System.out.println(flag);         //true

        System.out.println(c.contains("java"));  //true

        //删除集合中的某个元素
        c.remove(666);   //如果集合中有相同的元素，则本语句只能删除其中的一个元素
        System.out.println(c);  //  [java, c, 钢铁侠]

        //判断集合是否为空
        System.out.println(c.isEmpty());  //false

        //将集合转换成数组
        Object[] objects = c.toArray();
        for (Object o : objects) {
            System.out.println(o);
        }                                    

    }
}

class Student{

}

1.7迭代器Iterator

迭代器遍历集合：
迭代器是一个对象，迭代器对象有三个方法

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CollectionTest {
    public static void main(String[] args) {
        //以下遍历方式/迭代方式，是所有Collection的通用的一种方式
        //在Map集合中不能使用，在所有的Collection以及子类中使用

        Collection c = new HashSet();  //无序不可重复

        c.add("Jay");
        c.add("lee hom");
        c.add(10000);
        c.add(new Object());

        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();

        /* 以下两个方法是迭代器对象Iterator中的方法；
        boolean hasNext() 如果仍有元素可以迭代，则返回true
        Object next（） 返回迭代的下一个元素
         */

        //第二步：遍历集合
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

注意：contains方法是用来判断集合中是否包含某个元素的方法，它在底层实现是调用了equals方法进行比对，equals方法方法返回true，就表示包含这个元素。

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

public class CollectionTest02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        User u1 = new User("jack");
        c.add(u1);

        User u2 = new User("jack");

        System.out.println(c.contains(u2));
        //假如User类没有重写equals方法，结果会是false，因为他会调用Object类的equals方法
        //当user类重写equals方法时，结果是true，比较的是那么值
    }

}
class User{
    private String name;
    public User(){}
    public User(String name) {
        this.name = name;
    }

    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);
    }

}

存放在一个集合中的类型，一定要重写equals方法

集合元素的remove（）方法
重点：当集合的结构发生改变时，迭代器必须重新获取，否则会出现异常。
重点：在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素
重点：在迭代元素的过程中，一定要使用Iterator的remove()方法删除元素时，因为这样会自动更新迭代器，并且更新集合（即删除集合中的元素）

1.8 List集合

List集合：List接口是Collection 接口的子接口
List集合存储元素的特点：有序可重复
有序：LIst集合中的所有元素都有下标，从0开始，依次递增
可重复：可以存储相同的元素

List 接口下面主要有两个实现 ArrayList 和 LinkedList，他们都是有顺序的，也就是放进去
是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组
ArrayList：查询数据比较快，添加和删除数据比较慢(基于可变数组)
LinkedList：查询数据比较慢，添加和删除数据比较快（基于链表数据结构）
List集合通过下标进行遍历

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List myList = new ArrayList();
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
        System.out.println(myList);  //[A, B, C, D]

        myList.add(1, "K");

        //迭代
        Iterator it = myList.iterator();
        while (it.hasNext()){
            Object object = it.next();
            System.out.println(object);
        }

        //根据下标获取元素
        Object firstObj = myList.get(0);  //A
        System.out.println(firstObj);

        for (int i = 0; i < myList.size(); i++){
            Object o = myList.get(i);
            System.out.println(o);
        }

        //获取指定对象第一次出现处的索引
        System.out.println(myList.indexOf("K"));  //  1

        //获取指定对象的最后一次出现处的索引
        System.out.println(myList.lastIndexOf("C"));// 3

        //删除指定下标的元素
        myList.remove(0);   // 删除下标为0的元素A
        System.out.println(myList);  // [K, B, C, D]

        //修改指定位置的元素
        myList.set(2, "Java");
        System.out.println(myList);  // [K, B, Java, D]
        
    }
}

ArrayList的三种构造方法：

mport java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class ArrayListTest {
    public static void main(String[] args) {
        //默认初始化容量为10
        List myList1 = new ArrayList();

        //指定初始化容量为50
        List myList2 = new ArrayList(50);

        //创建一个HashSet集合
        Collection c = new HashSet();
        c.add(111);
        c.add(222);
        c.add(333);
        c.add(444);

        //通过这个构造方法就可以贾昂HashSet集合转换为List集合
        List myList3 = new ArrayList(c);
        for (int i = 0; i < myList3.size(); i++){
            System.out.println(myList3.get(i));
        }
    }
}