【Java】（二十）Java集合框架，Collection接口，List接口与实现类（ArrayList、Vector、LinkedList）

Java集合视频学习资料：【千锋】最新版 Java集合框架详解 通俗易懂

Java集合框架主要学习：
（1）集合的概念：对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
（2）List集合：有序、有下标、元素可以重复。（ArrayList、LinkedList、Vector）
（2）Set集合：无序、无下标、元素不可重复。（HashSet、TreeSet）
（3）Map集合：存储一对数据，无序、无下标，键不可重复，值可重复。（HashMap、HashTable、TreeMap）
（4）Collections集合工具类：定义了除了存取以外的集合常用方法。

1 集合的概念

1. 集合的概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
2. 和数组区别:
   （1）数组长度固定，集合长度不固定。
   （2）数组可以存储基本类型和引用类型，集合只能存储引用类型。

1.1 Collection体系集合

上两层的接口是不能用来创建对象的，得使用底下的实现类。

查找JDK阅读学习类方法，搜索快捷键Ctrl+F

2 Collection父接口

1. 特点：代表一组任意类型的对象，无序、无下标、不能重复。
2. 创建集合：Collection collection = new ArrayList();
3. 常用方法：调用方法对象.方法名(参数列表)
   （1）添加元素
   boolean add(Object obj)//添加一个对象。
   boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中。
   （2）删除元素
   boolean remove(Object o)//在此集合中移除o对象
   void clear()//清空此集合中的所有对象。
   （3）判断
   boolean isEmpty()//判断此集合是否为空
   int size()//返回此集合中的元素个数。
   boolean contains(Object o)//检查此集合中是否包含o对象
   boolean equals(Object o)//比较此集合是否与指定对象相等。
   （4）转换
   Object[] toArray()//将此集合转换成数组。
4. 遍历方法：
   （1）使用增强for循环【不能直接使用for循环，因为集合无序无下标】
   
   （2）使用迭代器
   

package study.collection;

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

public class CollectionText {
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();

        System.out.println("1.添加元素");
        a1.add("张三");
        a1.add("李四");
        a1.add("王五");
        System.out.println(a1);
        System.out.println("元素个数"+a1.size());

        System.out.println("2.删除元素");
        a1.remove("李四");//按目标删除
//        a1.remove(0);//按下标序列删除
//        a1.clear();//清空
        System.out.println(a1);
        System.out.println("元素个数"+a1.size());

        System.out.println("3.遍历元素");
        System.out.println("用增强for循环遍历（foreach）");
        for (Object o:a1) {
            System.out.println(o);
        }
        System.out.println("使用迭代器遍历");
        //hasNext()有没有下一个元素;next()获取下一个元素;remove()删除当前元素
        Iterator i1 = a1.iterator();
        while (i1.hasNext()) {
            String s = (String)i1.next();
            System.out.println(s);
            //i1.remove();//使用迭代器删除
        }
        System.out.println("元素个数"+a1.size());

        System.out.println("4.判断");
        System.out.println(a1.size());
        System.out.println(a1.contains("王五"));
        System.out.println(a1.isEmpty());
    }
}

/*
1.添加元素
[张三, 李四, 王五]
元素个数3
2.删除元素
[张三, 王五]
元素个数2
3.遍历元素
用增强for循环遍历（foreach）
张三
王五
使用迭代器遍历
张三
王五
元素个数2
4.判断
2
true
false
 */

3 List接口与实现类

List子接口：

1. 特点：有序、有下标、元素可以重复。
2. 创建集合：List list = new ArrayList<>();
3. 方法：包含Collection父接口里面所有方法(继承)，同时新增—些方法。
   （1）添加元素。同时add方法会对基本元素进行自动装箱。
   void add(int index，0bject o)//在index位置插入对象o。
   boolean addAll(int index，Collection c)//将一个集合中的元素添加到此集合中的index位置。
   （2）删除元素。基本元素装箱后将不能通过基本类型元素值进行删除，需要强制转换成包装类型。
   list.remove((Object)10); 或list.remove(new Integer(10));//当删除数字与索引矛盾时，对数字强转换
   （3）查找元素
   Object get(int index)//返回集合中指定位置的元素。
   List subList(int fromIndex，int toIndex)//返回fromIndex和toIndex之间的集合元素。
   int indexOf(Object o) 返回此列表中指定元素的第一个出现的索引，如果此列表不包含元素返回-1。
4. 遍历方法
   （1）使用for遍历。【List有序且有下标】
   （2）使用增强for
   （3）使用迭代器
   （4）使用列表迭代器。
   ListIterator listIterator = l1.listIterator();一个列表的迭代器，允许程序员在两个方向遍历列表，在迭代过程中修改列表，并获得在列表中的迭代器的当前位置。

package study.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListText {
    public static void main(String[] args) {
        List l1 = new ArrayList<>();

        //添加元素，自动装箱
        l1.add(20);
        l1.add(30);
        l1.add(0, 10);//带序列号添加元素
        System.out.println(l1);

        //删除元素
        l1.remove((Object)20);//强制转换为包装类
        System.out.println(l1);

        //遍历方法
        System.out.println("for方法遍历");
        for (int i = 0; i < l1.size(); i++) {
            System.out.println(l1.get(i));
        }
        System.out.println("listIterator()列表迭代器遍历");
        ListIterator lit = l1.listIterator();//这是个指针，一开始指向头
        System.out.println("正向遍历");
        while (lit.hasNext()) {//正向遍历结束后指针指向尾
            System.out.println(lit.next());
        }
        System.out.println("反向遍历");
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }

        //获取
        System.out.println(l1.indexOf(30));
        List l2 = l1.subList(1, 2);
        System.out.println(l2);
    }
}

/*
[10, 20, 30]
[10, 30]
for方法遍历
10
30
listIterator()列表迭代器遍历
正向遍历
10
30
反向遍历
30
10
1
[30]
 */

3.1 ArrayList类 【重点】

1. 数组结构实现，必须要连续空间，查询快、增删慢。
2. jdk1.2版本，运行效率块、线程不安全
3. 创建集合：ArrayList arrayList = new ArrayList<>();
4. 常用方法：
   （1）添加元素 arrayList.add();
   （2）删除元素 arrayList.remove(new Student("name", 10));
   需要重写Student类equals(this == obj) 方法。
   （3）判断查找
5. 遍历元素：使用迭代器，列表迭代器
6. ArrayList原码分析【IDEA中按住Ctrl再点击就能打开】
   DEFAULT_CAPACITY = 10; //默认容量
   //注意：如果没有向集合中添加任何元素时，容量0，添加一个后，容量为10
   //每次扩容是原来的1.5倍
   elementData//存放元素的数组
   size//实际元素个数

重写equals(this == obj) 方法（Student类包含两个属性）：

public boolean equals(Object obj){
  //1 判断是不是同一个对象
  if(this == obj){
    return true;
  }
  //2 判断是否为空
  if(obj == null){
    return false;
  }
  //3 判断是否是Student类型
  if(obj instanceof Student){
    Student == (Student)obj;
    //4 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  //5 不满足条件返回false
  return false;
}

3.1 Vector类

1. 数组结构实现，查询快、增删慢
2. jdk1.0版本，运行
3. 创建集合：Vector vector = new Vector<>();
4. 常用方法：
   增加、删除、判断同上
   vector其他方法：firsetElement、 lastElement、elementAt();
5. 遍历：枚举器遍历

枚举器遍历方法：

Enumeration en = vector.elements();
while(en.hasMoreElements()){
  String o = (String)en.nextElement();
  sout(o);
}

3.3 LinkedList类

1. 双向链表结构实现，无需连续空间，增删快，查询慢
2. 创建链表集合：LinkedList li = new LinkedList<>();
3. 常用方法与List一致

3.4 不同结构的实现方式：