Java——集合之List、ArrayList、LinkedList_java.util.arraylist 跟 list

一、List集合的概述和特点

List集合的概述

• List集合是一个有序集合（也称为序列），用户可以精确的控制列表中每个元素的插入位置，还可以通过整数索引访问元素，并搜索列表中的元素
• 与Set集合不同，列表通常允许重复的元素

List集合的特点

• 有序：存储和取出的元素顺序一致
• 可重复：存储的元素可以重复

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

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("world");//可重复

        //输出
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二、List集合的特有方法

List集合有Collection集合的方法，同时还有一些自己的特有方法：

• void add(int index,E element)：在集合中的指定位置插入指定的元素
• E remove(int index)：删除指定索引处的元素，返回被删除的元素
• E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
• E get(int index)：返回指定索引处的元素

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

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("world");//可重复
        System.out.println(list);

        //删除元素
        list.remove(1);
        System.out.println(list);

        //修改元素
        list.set(1, "java");
        System.out.println(list);

        //返回指定索引处的元素
        System.out.println(list.get(0));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三、列表迭代器ListIterator

• 列表迭代器通过list集合的listIterator()方法得到，是List集合特有的迭代器
• 用户允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中的常用方法

• E next()：返回迭代的下一个元素
• boolean hasNext()：如果迭代具有更多的元素，则返回true
• E previous()：返回列表中的上一个元素
• boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
• void add(E e)：将指定的元素插入列表

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

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);

        ListIterator<String> lit = list.listIterator();

        //使用列表迭代器正向遍历
        while (lit.hasNext()) {
            System.out.println(lit.next());
        }
        System.out.println("-----------");

        //使用列表迭代器反向遍历
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }
        System.out.println("-----------");

        //使用列表迭代器向列表中添加元素
        while (lit.hasNext()) {
            if (lit.next().equals("world")) {
                lit.add("javvvv");
            }
        }
        System.out.println(list);
    }
}
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

四、列表迭代器遍历的三种方法

1. 迭代器

public class DemoIterator {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        Iterator<String> lit = list.iterator();
        while (lit.hasNext()) {
            System.out.println(lit.next());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2. 普通for

public class DemoFor {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        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

3. 增强for
   格式：for(元素数据类型 变量名:数组或者Collection集合){}

public class DemoFor2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for (String s : list) {
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

五、List集合的常用子类ArrayList、LinkedList

List集合的常用子类：ArrayList、LinkedList

• ArrayList：底层数据结构时数组，查询快，增删慢
• LinkedList：层层数据结构时链表，查询慢，增删快

六、LinkedList集合的特有功能

• public void addFirst(E e)：在该列表开头插入指定的元素
• public void addLast(E e)：在该列表末尾插入指定的元素
• public E getFirst()：返回该列表中的第一个元素
• public E getLast()：返回该列表中的最后一个元素
• public E removeFirst()：删除并返回第一个元素
• public E removeLast()：删除并返回最后一个元素

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> l = new LinkedList<String>();
        l.add("hello");
        System.out.println(l);

        //在列表开头插入元素
        l.addFirst("world");
        System.out.println(l);

        //在列表末尾插入元素
        l.addLast("java");
        System.out.println(l);

        //返回列表第一个元素
        System.out.println(l.getFirst());

        //返回列表最后一个元素
        System.out.println(l.getLast());

        //删除第一个元素
        l.removeFirst();
        System.out.println(l);

        //删除最后一个元素
        l.removeLast();
        System.out.println(l);
    }
}
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