持有对象--List

Leefs 2019-11-29 AM 2335℃ 0条

# 持有对象--List

### 前言

本篇将讲述《Java编程思想》第11.5小节：List。本小节虽然内容不多，但是在工作和面试中都非常重要，当然本文只是为了简单的介绍一下List,如果想应对面试的话这一篇还不够。

### 概念

**一、List概念**

List接口是继承Collection接口，所以Collection集合中有的方法，List集合也继承过来。

![List集合01.png][1]

> 1. 1.List集合是有序，可重复的集合
> 2. 2.每个元素都有其对应的顺序索引
> 3. 3.List是Collection的子接口

List新增了一些根据索引操作元素的方法：

> + add():将元素插入到指定位置
> + addAll():将集合所有元素插入到指定位置
> + get():返回索引处元素
> + indexOf(): 第一次出现的索引 
> + lastIndexOf(): 最后一次出现的索引 
> + remove（）：删除并返回指定位置元素 
> +  set（）：指定位置元素替换 
> +  subList(): 截取子集合 
> +  sort(): 根据 Comparator 排序 
> +  replaceAll(): 根据计算规则重新设置List集合所有元素

同时，List判断两个对象相等的标准是根据`equals()`方法返回值。

**二、`ArrayList`和`LinkList`对比**

**相同点：**

**`ArrayList`和`LinkList`都是List接口的子类，都是对List接口的实现**

`ArrayList`和`LinkedList`是两个集合类，用于存储一系列的对象引用(references)

**不同点：**

> 1. 1.`ArrayList`是实现了基于动态数组的数据结构，`LinkedList`基于链表的数据结构 
> 2. 2.对于随机访问get和set，`ArrayList`优于`LinkedList`，因为`ArrayList`可以随机定位，而`LinkedList`要移动指针一步一步的移动到节点处。 
> 3. 3.对于新增和删除操作add和remove，`LinedList`比较占优势，只需要对指针进行修改即可，而`ArrayList`要移动数据来填补被删除的对象的空间。

**三、List集合代码示例**

```java
public class ListFeatures {
    public static void main(String[] args) {
        Random rand = new Random(47);
        List<Pet> pets = Pets.arrayList(7);//取出Pets对象中的前7位元素（0-6）
        System.out.println("1:"+pets);
        Hamster h = new Hamster();
        pets.add(h);
        System.out.println("2:"+pets);
        System.out.println("3:"+pets.contains(h));
        pets.remove(h);
        Pet p = pets.get(2);//获取List集合中第三个元素
        System.out.println("4:"+p+" "+pets.indexOf(p));
        Pet cymric= new Cymric();//向上转型
        System.out.println("5:"+pets.indexOf(cymric));
        System.out.println("6:"+pets.remove(cymric));
        //Must be the exact object
        System.out.println("7:"+pets.remove(p));
        System.out.println("8:"+pets);
        pets.add(3,new Mouse());  //Insert at an index
        System.out.println("9:"+pets);
        List<Pet> sub = pets.subList(1,4);//截取Pet对象集合中1--3的内容
        System.out.println("subList:"+sub);
        System.out.println("10:"+pets.containsAll(sub));
        Collections.sort(sub);  //In-place sort
        System.out.println("sorted subList:"+sub);
        //Order is not important in containsAll()
        System.out.println("11:"+pets.containsAll(sub));
        Collections.shuffle(sub,rand); //Mix it up
        System.out.println("shuffled subList:"+sub);
        System.out.println("12:"+pets.containsAll(sub));
        List<Pet> copy = new ArrayList<Pet>(pets);
        sub = Arrays.asList(pets.get(1),pets.get(4));
        copy.retainAll(sub);//保留交集
        System.out.println("13:"+copy);
        copy = new ArrayList<Pet>(pets);//Get a fresh copy
        copy.remove(2);//Remove by index
        System.out.println("14:"+copy);
        copy.removeAll(sub);//Only removes exact objects
        System.out.println("15:"+copy);
        copy.set(1,new Mouse());//Replace an element
        System.out.println("16:"+copy);
        copy.addAll(2,sub);//Insert a list in the middle
        System.out.println("17:"+copy);
        System.out.println("18:"+pets.isEmpty());
        pets.clear(); // Remove all elements
        System.out.println("19:"+pets);
        System.out.println("20:"+pets.isEmpty());
        pets.addAll(Pets.arrayList(4));
        System.out.println("21:"+pets);
        Object[] o = pets.toArray();
        System.out.println("22:"+o[3]);
        Pet[] pa = pets.toArray(new Pet[0]);
        System.out.println("23:"+pa[3].id());
    }
}
```

> 运行结果

```java
1:[Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug]
2:[Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Hamster]
3:true
4:Cymric 2
5:-1
6:false
7:true
8:[Rat, Manx, Mutt, Pug, Cymric, Pug]
9:[Rat, Manx, Mutt, Mouse, Pug, Cymric, Pug]
subList:[Manx, Mutt, Mouse]
10:true
sorted subList:[Manx, Mouse, Mutt]
11:true
shuffled subList:[Mouse, Manx, Mutt]
12:true
13:[Mouse, Pug]
14:[Rat, Mouse, Mutt, Pug, Cymric, Pug]
15:[Rat, Mutt, Cymric, Pug]
16:[Rat, Mouse, Cymric, Pug]
17:[Rat, Mouse, Mouse, Pug, Cymric, Pug]
18:false
19:[]
20:true
21:[Manx, Cymric, Rat, EgyptianMau]
22:EgyptianMau
23:14
```

> 方法说明

> 1. contains()：方法来确定某个对象是否在列表内
> 2. remove()：移除某个元素（若该元素有多个，移除所有该元素）
> 3. indexOf()：获取对象在List中所处位置（获取第一个出现的位置）
> 4. subList(a,b)：从列表中获得一个片段，左闭右开
> 5. containsAll()：包含该集合的所有元素（Collecions.sort()和Collections.shuffle()（随机排序）不会影响）
> 6. retainAll()：保留了同时在copy和sub中的元素（依赖于equals）
> 7. removeAll()：移除所有元素
> 8. set(),replace()，替换
> 9. addAll()：从制定位置插入一个列表
> 10. toArray()：将Collection转换成一个数组

当确定一个元素是否属于某个List,发现某个元素的索引，以及从某个List中移除一个元素时，都会用到equals()方法（它是根类Object的一部分）。

注意：上方示例代码需要引入`typeinfo-pets.jar`工具包，如果有需要的可以给小编留言

[1]: https://lilinchao.com/usr/uploads/2019/11/2092050579.png

标签: Java, Java编程思想, JavaSE, 持有对象

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/234.html

上一篇 JVM学习（八）--类加载器与类初始化深度剖析

下一篇 JVM学习（九）--不同的类加载器作用与加载动作分析

持有对象--List

评论已关闭

栏目分类

标签云

友情链接申请

持有对象--List

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请