【零基础学Java】第二十一篇 集合1（Collection，ArrayList，LinkedList，Vector)

📄个人简介
🔔作者简介：大家好，我是小学生！！🙈大三学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
📝个人主页：小学生！！
📖系列专栏
🌕阶段一：Java基础编程
💦目前已原创21篇

🌕阶段二：数据结构与算法
🌕阶段三：操作系统
🌕阶段四：计算机网络

1.集合体系图

2.Collection接口

1.Collection接口实现类的特点

public interface Collection extends Iterable

1. collection实现子类可以存放多个元素，,每个元素可以是Object。
2. 有些Collection的实现类,可以存放重复的元素，有些不可以。
3. 有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)4) Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的其他的方法，老师就不说,使用的时候，自己查看API使用即可。

2.Collection的常见方法

1. add：添加单个元素
2. remove：删除指定元素
3. contains：查找元素是否存在
4. size：获取元素个数
5. isEmpty：判断是否为空
6. clear：清空
7. addAll：添加多个元素
8. containsAll：查找多个元素是否都存在
9. removeAll：删除多个元素

public class CollectionMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
//        add:添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10))
        list.add(true);
        System.out.println("list=" + list);
//        remove:删除指定元素
        //list.remove(0);//删除第一个元素
        list.remove(true);//指定删除某个元素
        System.out.println("list=" + list);
//        contains:查找元素是否存在
        System.out.println(list.contains("jack"));//T
//        size:获取元素个数
        System.out.println(list.size());//2
//        isEmpty:判断是否为空
        System.out.println(list.isEmpty());//F
//        clear:清空
        list.clear();
        System.out.println("list=" + list);
//        addAll:添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
//        containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
//        removeAll：删除多个元素
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);//[聊斋]
//        说明：以ArrayList实现类来演示.

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

3.Collection接口遍历元素的方式

1.使用迭代器

快捷键为itit

1)基本介绍
java.util
接口lterator所有已知子接口:
ListIterator，XMLEventReader
所有已知实现类:
BeanContextSupport.BCSIterator，EventReaderDelegate，Scanner

1.terator对象称为迭代器，主要用于遍历Collection集合中的元素。

2.所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象，即可以返回一个迭代器。

3.Iterator仅用于遍历集合,Iterator本身并不存放对象。

2)迭代器的执行原理
lterator iterator = coll.iterator();1/得到一个集合的迭代器
/hasNext():判断是否还有下一个元素while(iterator.hasNext(0){
/next():①指针下移②将下移以后集合位置上的元素返回
System.out.println(iterator.next(0));}

public class CollectionIterator {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {

        Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));

        //System.out.println("col=" + col);
       
        //1. 先得到 col 对应的 迭代器
        Iterator iterator = col.iterator();
        //2. 使用while循环遍历
//        while (iterator.hasNext()) {//判断是否还有数据
//            //返回下一个元素，类型是Object
//            Object obj = iterator.next();
//            System.out.println("obj=" + obj);
//        }
        //一个快捷键，快速生成 while => itit
        //显示所有的快捷键的的快捷键 ctrl + j
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);

        }
        //3. 当退出while循环后 , 这时iterator迭代器，指向最后的元素
        //   iterator.next();//NoSuchElementException
        //4. 如果希望再次遍历，需要重置我们的迭代器
        iterator = col.iterator();
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);

        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2.增强for循环

快捷键为I

增强for循环，可以代替iterator迭代器。特点：简化版iterator，本质一样。只能用于遍历集合或数组。

基本语法
for(元素类型元素名:集合名或数组名){访问元素}

public class CollectionFor {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));

        //1. 使用增强for, 在Collection集合
        //2. 增强for， 底层仍然是迭代器
        //3. 增强for可以理解成就是简化版本的 迭代器遍历
        //4. 快捷键方式 I
//        for (Object book : col) {
//            System.out.println("book=" + book);
//        }
        for (Object o : col) {
            System.out.println("book=" + o);
        }

        //增强for，也可以直接在数组使用
//        int[] nums = {1, 8, 10, 90};
//        for (int i : nums) {
//            System.out.println("i=" + i);
//        }


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.List接口

1.基本介绍

List接口是Collection 接口的子接口

1. List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复

2. List集合中的每个元素都有其对应的顺序索引，即支持索引。

3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。List list = new ArrayList0;

4. JDK API中List接口的实现类有:
   java. util
   接口List
   所有超级接口:
   Collection,Iterable
   所有已知实现类:
   AbstractList，AbstractSequentialList，ArrayList，AttributeList，CopyOrllriteArrayList，LinkedList，RoleList，RoleUnresolvedList，Stack，Vector。

   常用的有:ArrayList、LinkedList和Vector。

2.常用方法

List 集合里添加了一些根据索引来操作集合元素的方法

1. void add(int index, Object ele)：在index位置插入ele元素。

2. boolean addAll(int index,Collection eles)：从index位置开始将eles中的所有元素添加进来。

3. Object get(int index)：获取指定index位置的元素。

4. int indexOf(Object obj)：返回obj在集合中首次出现的位置。

5. int lastlndexOf(Object obj)：返回obj在当前集合中末次出现的位置。

6. Object remove(int index)：移除指定index位置的元素,并返回此元素。

7. Object set(int index, Object ele)：设置指定index位置的元素为ele ,相当于是替换。

8. List subList(int fromlndex, int tolndex)：返回从fromIndex到tolndex位置的子集合。

   public class ListMethod {
       @SuppressWarnings({"all"})
       public static void main(String[] args) {
           List list = new ArrayList();
           list.add("张三丰");
           list.add("贾宝玉");
   //        void add(int index, Object ele):在index位置插入ele元素
           //在index = 1的位置插入一个对象
           list.add(1, "hsp");
           System.out.println("list=" + list);
   //        boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
           List list2 = new ArrayList();
           list2.add("jack");
           list2.add("tom");
           list.addAll(1, list2);
           System.out.println("list=" + list);
   //        Object get(int index):获取指定index位置的元素
           //说过
   //        int indexOf(Object obj):返回obj在集合中首次出现的位置
           System.out.println(list.indexOf("tom"));//2
   //        int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
           list.add("hsp");
           System.out.println("list=" + list);
           System.out.println(list.lastIndexOf("hsp"));
   //        Object remove(int index):移除指定index位置的元素，并返回此元素
           list.remove(0);
           System.out.println("list=" + list);
   //        Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
           list.set(1, "玛丽");
           System.out.println("list=" + list);
   //        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
           // 注意返回的子集合 fromIndex <= subList < toIndex
           List returnlist = list.subList(0, 2);
           System.out.println("returnlist=" + returnlist);
   
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37

3.List的三种遍历方式[ArrayList,LinkedList,Vector]

1)方式一︰使用iterator
lterator iter = col.iterator);while(iter.hasNext(){
Object o = iter.next();}
2)方式二:使用增强forfor(Object o:col){
}
3)方式三:使用普通for
for(int i=0;i List list = new LinkedListO;
System.out.println(object);
说明:使用LinkedList完成使用方式和ArrayList一样

public class ListFor {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {

        //List 接口的实现子类 Vector LinkedList
        //List list = new ArrayList();
        //List list = new Vector();
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("鱼香肉丝");
        list.add("北京烤鸭子");

        //遍历
        //1. 迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println(obj);

        }

        System.out.println("=====增强for=====");
        //2. 增强for
        for (Object o : list) {
            System.out.println("o=" + o);
        }

        System.out.println("=====普通for====");
        //3. 使用普通for
        for (int i = 0; i < list.size(); i++) {
            System.out.println("对象=" + list.get(i));
        }


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

4.ArrayList的底层操作机制分析(重点，难点)

1. ArrayList中维护了一个0bject类型的数组elementData.transient Object[] elementData; //transient表示瞬间,短暂的,表示该属性不会被序列号
2. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容,则直接扩容elementData为1.5倍。

5.Vector的基本介绍

1. Vector类的定义说明
   public class vectorextends AbstractListimplements List，RandomAccess，cloneable，Serializable
2. Vector底层也是一个对象数组,protected Object[] elementData;
3. Vector是线程同步的，即线程安全, Vector类的操作方法带有synchronized
   public synchronized E get(int index){
   if (index >= elementCount)
   throw new ArraylndexOutOfBoundsException(index);return elementData(index);
4. 在开发中，需要线程同步安全时，考虑使用Vector

6.LinkedList底层结构

1.LinkedList的介绍

1. LinkedList实现了双向链表和双端队列特点。
2. 可以添加任意元素(元素可以重复)，包括null。
3. 线程不安全，没有实现同步。

2.LinkedList的底层操作机制

1. LinkedList底层维护了一个双向链表。

2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点。

3. 每个节点(Node对象),里面又维护了prev、next、item三个属性,其中通过prev指向前一个,通过next指向后一个节点。最终实现双向链表。

4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

7.ArrayList与Vector的比较

8.ArrayList与LinkedList的比较

1. 如果我们改查的操作多，选择ArrayList。
2. 如果我们增删的操作多，选择LinkedList。
3. 一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList。
4. 在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList,另外一个模块是LinkedList。