Java基础十一-List

发表于 | 分类于 | 阅读次数: ℃
字数统计: 1.9k | 阅读时长 ≈ 8
  • List 是元素有序并且可以重复的集合，称为序列
  • List 可以精确的控制每个元素的插入位置，或删除某个位置的元素
  • List 的两个主要实现类，是 ArrayList 和 LinkedList

ArrayList

  • ArrayList 底层是由数组实现的
  • 动态增长，以满足应用程序的需求
  • 在列表尾部插入或删除非常有效
  • 更适合查找和更新元素
  • ArrayList 中的元素可以为 NULL

下面的例子介绍 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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main{
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');
        list.add('e');
        System.out.println("list的长度为:" + list.size());
        System.out.println("输出list中的第二个元素:" + list.get(1));
        System.out.println("遍历list数组:");
        System.out.println("--第一种遍历方法---for循环");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        System.out.println("--第二种遍历方法---foreach循环（修改第三个位置的数据）");
        list.set(2,'z');
        for (Object i :
                list) {
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("--第三种遍历方法---Iterator迭代器（去掉第二个位置的数据）");
        list.remove(1);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next() + " ");
        }
    }
}

运行结果：

list的长度为:5
输出list中的第二个元素:b
遍历list数组:
–第一种遍历方法—for循环
a b c d e
–第二种遍历方法—foreach循环（修改第三个位置的数据）
a b z d e
–第三种遍历方法—Iterator迭代器（去掉第二个位置的数据）
a z d e

LinkedList

  • 与 ArrayList 一样，LinkedList 也按照索引位置排序，但它的元素之间是双向链表的
  • 适合快速地插入和删除元素
  • LinkedList 实现 List 和 Queue 两个接口

案例一：使用 LinkedList 对字符串进行管理

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
import java.util.LinkedList;

public class Main{
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<String>();
        //向链表添加数据
        list.add("apple");
        list.add("pear");
        //将数据插入链表头
        list.addFirst("banana");
        //将数据插入链表的末尾
        list.addLast("grape");
        //在指定位置添加数据
        list.add(2,"orange");
        //显示链表中的所有数据
        System.out.println(list);
        //判断链表中是否包含指定元素
        if (list.contains("Mast")){
            System.out.println("'Mast'存在");
        }else {
            System.out.println("'Mast'不存在");
        }
        //返回位置3的元素
        System.out.println("位置3的元素是：" + list.get(2));
        //返回第一个元素
        System.out.println("第一个元素是：" + list.getFirst());
        //返回最后一个元素
        System.out.println("最后一个元素是：" + list.getLast());
    }
}

运行结果

[banana, apple, orange, pear, grape]
‘Mast’不存在
位置3的元素是：orange
第一个元素是：banana
最后一个元素是：grape

案例二：使用 LinkedList 对自定义类进行管理

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
41
42
43
44
public class Student {
    private Integer stuNum;
    private String stuName;
    private Integer stuAge;

    public Student(Integer stuNum, String stuName, Integer stuAge) {
        this.stuNum = stuNum;
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public Integer getStuNum() {
        return stuNum;
    }

    public void setStuNum(Integer stuNum) {
        this.stuNum = stuNum;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Integer getStuAge() {
        return stuAge;
    }

    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNum=" + stuNum +
                ", stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }
}
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
import java.util.LinkedList;

public class Main{
    public static void main(String[] args) {
        LinkedList<Student> stulist = new LinkedList<Student>();
        Student s1 = new Student(0001,"Jack",18);
        Student s2 = new Student(0002,"Mike",20);
        Student s3 = new Student(0003,"Lucy",19);
        //将学生添加到链表，使用push完成
        //LinkedList 实现 List 接口的同时，也实现了 Queue 接口
        //push 和 pop 就是针对 Queue 进行添加和取出数据的操作
        stulist.push(s1);
        stulist.push(s2);
        stulist.push(s3);
        System.out.println("链表为：" + stulist);
        //弹出一个元素，这里可以把链表看成一个容器，先加入链表里的元素后弹出
        //依据先进后出的原则
        System.out.println("弹出的数据为：" + stulist.pop());
        System.out.println("调用 pop() 方法后的链表为：" + stulist);
        //peek() 方法获取并不移除元素
        System.out.println("调用 peek() 方法的数据为：" + stulist.peek());
        System.out.println("调用 peek() 方法后的链表为：" + stulist);
        //再次调用 pop() 方法，发现调用 pop() 方法后，数据从链表中移除了而 peek() 方法不会
        System.out.println("弹出的数据为：" + stulist.pop());
        System.out.println("调用 pop() 方法后的链表为：" + stulist);
        //重新添加元素
        stulist.push(s2);
        stulist.push(s3);
        System.out.println("重新添加元素后的链表为：" + stulist);
        //调用 poll() 方法
        System.out.println("调用 poll() 方法的数据为：" + stulist.poll());
        //调用 poll() 方法在获取了元素的同时删除了链表中的元素
        System.out.println("调用 poll() 方法后的链表为：" + stulist);
    }
}

运行结果

链表为：[Student{stuNum=3, stuName=’Lucy’, stuAge=19}, Student{stuNum=2, stuName=’Mike’, stuAge=20}, Student{stuNum=1, stuName=’Jack’, stuAge=18}]
弹出的数据为：Student{stuNum=3, stuName=’Lucy’, stuAge=19}
调用 pop() 方法后的链表为：[Student{stuNum=2, stuName=’Mike’, stuAge=20}, Student{stuNum=1, stuName=’Jack’, stuAge=18}]
调用 peek() 方法的数据为：Student{stuNum=2, stuName=’Mike’, stuAge=20}
调用 peek() 方法后的链表为：[Student{stuNum=2, stuName=’Mike’, stuAge=20}, Student{stuNum=1, stuName=’Jack’, stuAge=18}]
弹出的数据为：Student{stuNum=2, stuName=’Mike’, stuAge=20}
调用 pop() 方法后的链表为：[Student{stuNum=1, stuName=’Jack’, stuAge=18}]
重新添加元素后的链表为：[Student{stuNum=3, stuName=’Lucy’, stuAge=19}, Student{stuNum=2, stuName=’Mike’, stuAge=20}, Student{stuNum=1, stuName=’Jack’, stuAge=18}]
调用 poll() 方法的数据为：Student{stuNum=3, stuName=’Lucy’, stuAge=19}
调用 poll() 方法后的链表为：[Student{stuNum=2, stuName=’Mike’, stuAge=20}, Student{stuNum=1, stuName=’Jack’, stuAge=18}]

我们在这里发现，好像 pop() 和 poll() 的作用是一样的。

pop() 和 poll() 的区别

poll是队列数据结构实现类的方法，从队首获取元素，同时获取的这个元素将从原队列删除；

pop是栈结构的实现类的方法，表示返回栈顶的元素，同时该元素从栈中删除，当栈中没有元素时，调用该方法会发生异常

其实，这两个函数的代码实现是基本一致的，如果一定要说区别那么就是当头结点为空的时候，两个函数的处理方式不同：poll()选择返回null，pop()选择抛出异常。

ArrayList 和 LinkedList 的区别

  • ArrayList 和 LinkedLis t可想从名字分析，它们一个是 Array（动态数组）的数据结构，一个是 Link（链表）的数据结构，此外，它们两个都是对 List 接口的实现。

    前者是数组队列，相当于动态数组；后者为双向链表结构，也可当作堆栈、队列、双端队列

  • 当随机访问 List 时（ get 和 set 操作），ArrayList 比 LinkedList 的效率更高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。

  • 当对数据进行增加和删除的操作时( add 和 remove 操作)，LinkedList 比 ArrayList 的效率更高，因为ArrayList 是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。

  • 从利用效率来看，ArrayList 自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而 LinkedList 自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。

  • 线程都不安全

-------------本文结束感谢您的阅读-------------

本文标题:Java基础十一-List

文章作者:Cui Zhe

发布时间:2018年11月08日 - 23:11

最后更新:2018年11月08日 - 23:11

原始链接:https://cuizhe1023.github.io/2018/11/08/Java基础十一-List/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。