第14章 集合框架-List集合的各种类

Posted 2020-08-20 岑宇

1.概述
1.1.Java集合框架的由来
1.2.什么是集合框架？
1.3.为什么需要集合框架
1.4.常用的框架接口规范
2.Vector类
2.1.存储原理
2.2.构造方法
2.3.常用方法
3.Stack类
3.1.什么是栈
3.2.栈的构造方法和常用方法
4.ArrayList类
5.LinkedList类
5.1定义
5.2.常用方法

 

1.概述

1.1.Java集合框架的由来

刚开始的时候java只有Vetor,Stack,Hashtable这些同容器类用来保存大量的对象。
容器类是可以存储多个数据的类，数组也是一个容器，但是数组有一定的缺陷，所有提出了容器概念
怎么学习集合框架呢？
集合框架是非常简单，但是又非常重要的一个对象。
学习集合框架只要记住：拿来主义

1.2.什么是集合框架？

集合框架是为了表示和操作而规定集合而规定的一种统一的标准的体系结构。
任何集合框架都要包含三大块内容：
对外的接口
接口的实现
对集合应用的算法（底层都对应这一种数据结构的算法）

1.3.为什么需要集合框架

1.提供功能的复用（java.util包）
2.让程序员能专注于开发，而不是数据结构和算法

1.4.常用的框架接口规范

1.集合中存储的对象称之为集合元素
2.常用的集合类
-Set(集)：集合中的对象不按特定方式排序，不允许元素重复
-List（列表）：集合中的元素按照索引位置排序，不允许元素重复
-Map（映射）：集合中的每一个元素都包含一对key和value对象，不允许key对象重复，值对象可以重复

2.Vector类

在Java2.0之前，还没有集合框架的概念，但是要存储多个数据，于是就有了一个Vector类。Vector类底层其实就是一个Object数组，Vector类中的方法是支持同步的。
Vector类提供了实现可增长数组的功能，随着更多元素的加入其中，数组变得更大，在删除一些元素之后，数组就变得小

2.1.存储原理

通过源码分析，发现Vector类中有一个Object[]类型数组，protected Object[] elementData;
1.表面上把数据存储到Vector对象中，其实底层依然是把数据存储到Object数组中的
2.我们发现数组的元素类型是Object类型，意味着集合中能存储任意对象的对象。不要要注意，集合中只能存储对象，不能存储基本数据类型的值。

2.2.构造方法

Vector类提供三种常用构造方法
1.public Vector();

构造一个空向量，默认的数组大小是10

2.public Vector(int Capacity)

用Capacity指定Vector默认容量的大小，由于增加数据导致容量增加时，每次容量会增加一倍

3.public Vector(int Capacity, int capacityIncrement)

Capacity是默认容量大小，capacityIncrement是每次容量增加时的增量值

2.3.常用方法

Vector的常用方法，在其他集合中也大部分是通用的，而常用方法是分成四种的，即：增、删、查、改
1.增加
boolean add(Object e)

将指定元素增加到集合的末尾，等价与addElement()方法

voild add(int index, Object element)

在集合的指定位置插入指定元素

boolean addAll(Collection c)

把一个集合中的元素去全部添加到当前集合中来

注意：add()也可以追加一个集合，但是追加的这个集合是当做一个集合中的一个元素来的，addAll()是把一个集合中的所用元素跟当前集合的所有元素并排，同等位置存放
示例:

 1 import java.util.Vector;
 2 
 3 /**
 4  * 演示Vector类中的增加方法
 5  * Created by cenyu on 16-11-19.
 6  */
 7 public class TestVector {
 8     public static void main(String[] args) {
 9         Vector v = new Vector();
10         v.add("A");
11         v.add("B");
12         v.add("C");
13         System.out.println(v); //[A, B, C]
14         //将指定元素增加到集合的末尾
15         v.add("D");
16         System.out.println(v);//[A, B, C, D]
17         //在集合的指定位置插入指定元素
18         v.add(2,"B");
19         System.out.println(v);//[A, B, B, C, D]
20         //把一个集合中的元素去全部添加到当前集合中来
21         Vector v2 = new Vector();
22         v2.add(1);
23         v2.add(2);
24         v2.add(3);
25         v.addAll(v2);
26         System.out.println(v);//[A, B, B, C, D, 1, 2, 3]
27         v.add(v2);
28         System.out.println(v);//[A, B, B, C, D, 1, 2, 3, [1, 2, 3]]
29     }
30 }

 

2.删除
Object remove(int index)

按下标删除指定位置的元素，返回被删除的那个元素

boolean remove(Object o)

按值删除指定元素

boolean removeAll(Collection c)

从当前集合中移除包含在指定集合 c 中的所有元素

boolean retainAll(Collection c)

在当前集合中只保留和集合c有交集的元素

示例

 1 import java.util.Vector;
 2 
 3 /**
 4  * 演示Vector类中的删除方法
 5  * Created by cenyu on 16-11-19.
 6  */
 7 public class TestVector {
 8     public static void main(String[] args) {
 9         Vector v = new Vector();
10         v.add("A");
11         v.add("B");
12         v.add("C");
13         //在集合的指定位置插入指定元素
14         v.add(2,"B");
15         //把一个集合中的元素去全部添加到当前集合中来
16         Vector v2 = new Vector();
17         v2.add(1);
18         v2.add(2);
19         v2.add(3);
20         v.add(v2);
21         System.out.println(v);//[A, B, B, C, [1, 2, 3]]
22 
23 
24 
25         //按下标删除指定位置的元素，返回被删除的那个元素
26         System.out.println(v.remove(2));//B
27         //按值删除指定元素
28         v.remove("C");
29         System.out.println(v);//[A, B, [1, 2, 3]]
30 //        //在当前集合中只保留和集合v2有交集的元素
31 //        v.remove(v2);
32 //        System.out.println(v);//[A, B]
33         v.add(1);
34         v.add(2);
35         v.retainAll(v2);
36         System.out.println(v);//[1, 2]
37 
38     }
39 }

 

3.查询
int size()

返回当前集合中存储的元素个数

boolean isEmpty()

判断当前集合中元素个数是否为0

Object get(int index)

查询指定索引位置的元素

Object[] toArray()

把集合对象转换为Object数组

4.修改
Object set(int index, Object element)

修改当前集合中指定索引位置的元素，返回被替换的那个旧元素

示例：

 1 import java.util.Arrays;
 2 import java.util.Vector;
 3 
 4 /**
 5  * 演示Vector类中的查询和修改方法
 6  * Created by cenyu on 16-11-19.
 7  */
 8 public class TestVector {
 9     public static void main(String[] args) {
10         Vector v = new Vector();
11         v.add("A");
12         v.add("B");
13         v.add("C");
14 
15         //返回当前集合中存储的元素个数
16         System.out.println(v.size());//3
17         //判断当前集合中元素个数是否为0
18         System.out.println(v.isEmpty());//false
19         //查询指定索引位置的元素
20         System.out.println(v.get(1));//B
21         //修改当前集合中指定索引位置的元素，返回被替换的那个旧元素
22         System.out.println(v.set(0,"B"));//A
23         System.out.println(v);//[B, B, C]
24         //把集合对象转换为Object数组
25         System.out.println(Arrays.toString(v.toArray()));//[B, B, C]
26     }
27 }

 

3.Stack类

3.1.什么是栈

*栈(stack)：数据机构的一种，存储特点是：后进先出，Last In First Out.
stack类表示后进先出(LIFO)的对象栈
栈的思想是规定一个底部，所有的数据从顶部进入，然后从顶部获取数据。
栈结构在生活中的体现：
1、QQ消息，A、B、C先后发来消息，后发的在上面显示
2、手枪弹夹的装弹和发射

要来实现栈的存储，底层可以使用数组来存储，也可以使用链表来存储。
该类继承于java.util.Vector

3.2.栈的构造方法和常用方法

栈是一种比较简单的操作，只有一种构造器方法和五种常用操作方法
1.构造器
Stack()

创建一个空堆栈

2.操作方法
1.boolean empty()

测试堆栈是否为空

2.Object peek()

查看堆栈的顶部对象，只是查看不进行任何操作

3.Object pop()

移除堆栈顶部的对象，并返回移除的这个对象

4.Object push()

把一个元素压入堆栈顶部

5.int search(Object o)

返回对象在堆栈中的位置，以1为基数，后进的为1，先进的往后排

示例

 1 import java.util.Stack;
 2 
 3 /**
 4  * 测试Stack类的方法
 5  * Created by cenyu on 16-11-20.
 6  */
 7 public class TestStack {
 8     public static void main(String[] args) {
 9         //创建一个空堆栈
10         Stack s = new Stack();
11         //测试堆栈是否为空
12         System.out.println(s.empty());  //true
13         //把一个元素压入堆栈顶部
14         s.push("A");
15         s.push("B");
16         s.push("C");//C是最后添加的
17         System.out.println(s.empty());//true
18         //查看堆栈的顶部对象，只是查看不进行任何操作
19         System.out.println(s.peek()); //C
20         //移除堆栈顶部的对象，并返回移除的这个对象
21         System.out.println(s.pop());//C
22         System.out.println(s); //[A, B]
23         //返回对象在堆栈中的位置，以1为基数,后进的为1，先进的往后排
24         System.out.println(s.search("B"));//1
25     }
26 }

 

4.ArrayList类

ArrayList类是Java集合框架出现之后用来取代Vector类的，二者在底层原理上是一模一样的。
区别：
Vector:所有的方法都使用了synchronized修饰符，线程安全但是性能较低，使用与多线程环境
ArrayList：所有的方法都没有synchronized修饰符，线程不安全，但是性能较高
即使在多线程环境下，我们也不使用Vector类：
ArrayList list = Collections.synchronizedList(new ArrayList(……));
常用的方法可以参照Vector

5.LinkedList类

5.1定义

LinkedList类是双向链表，单向队列，双向队列，栈的实现类
LinkedList类实现单向队列和双向队列的接口，自身提供了栈操作的方法，链表的操作方法

5.2.常用方法

在LinkedList类中存在很多方法，但是功能都是相同的，LinkedList表示了很多中数据结构的实现，每一种数据结构的操作名字不同

具体方法转载了一篇文章