认识Java中的列表结构

作者: 王一萍o叩丁狼教育 | 来源:发表于2018-09-13 18:33 被阅读0次

1. 集合框架体系

集合是Java中提供的一种容器，可以用来存储多个数据，根据不同存储方式形成的体系结构，就叫做集合框架体系（掌握）。

image.png

每一种容器类底层拥有不同的底层算法。

既然数组可以存储多个数据，为什么要出现集合？

数组的长度是固定的，集合的长度是可变的。
使用Java类封装出一个个容器类，开发者只需要直接调用即可，不用再手动创建容器类。

集合中存储的数据，叫做元素，元素只能是对象（引用类型）。

1.1. 容器的分类（掌握）

根据容器的存储特点的不同，可以分成三种情况：

image.png

List(列表)：允许记录添加顺序，允许元素重复。
Set(集合)：不记录添加顺序，不允许元素重复。
Map(映射)：容器中每一个元素都包含一对key和value，key不允许重复，value可以重复。严格上说，并不是容器（集合），是两个容器中元素映射关系。

注意：List和Set接口继承于Collection接口，Map接口不继承Collection接口。

image.png

Collection接口：泛指广义上集合，主要表示List和Set两种存储方式。
List接口：表示列表，规定了允许记录添加顺序，允许元素重复的规范。
Set接口：表示狭义上集合，规定了不记录添加顺序，不允许元素重复的规范。
Map接口：表示映射关系，规定了两个集合映射关系的规范。

注意：我们使用的容器接口或类都处于java.util包中。

1.2. List接口（重点）

List接口是Collection接口子接口，List接口定义了一种规范，要求该容器允许记录元素的添加顺序，也允许元素重复。那么List接口的实现类都会遵循这一种规范。

List集合存储特点：

允许元素重复
允许记录元素的添加先后顺序

该接口常用的实现类有：

ArrayList类：数组列表，表示数组结构，采用数组实现，开发中使用对多的实现类，重点。
LinkedList类：链表，表示双向列表和双向队列结构，采用链表实现，使用不多。
Stack类：栈，表示栈结构，采用数组实现，使用不多。
Vector类：向量，其实就是古老的ArrayList，采用数组实现，使用不多。

1.2.1. List常用API方法（必须记住）

添加操作

boolean add(Object e)：将元素添加到列表的末尾
void add(int index, Object element)：在列表的指定位置插入指定的元素
boolean addAll(Collection c)：把c列表中的所有元素添加到当前列表中

删除操作

Object remove(int index)：从列表中删除指定索引位置的元素,并返回被删除的元素
boolean removeAll(Collection c)：从此列表中移除c列表中的所有元素

修改操作

Object set(int index, Object ele)：修改列表中指定索引位置的元素，返回被替换的旧元素

查询操作

int size()：返回当前列表中元素个数
boolean isEmpty()：判断当前列表中元素个数是否为0
Object get(int index)：查询列表中指定索引位置对应的元素
Object[] toArray()：把列表对象转换为Object数组
boolean contains(Object o):判断列表是否存在指定对象

注意，标红的是重度使用的方法。

1.2.2. ArrayList类（重点）

ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组。

需求1：操作List接口常用方法

public class ArrayListDemo1 {

    public static void main(String[] args) {

        //创建一个默认长度的列表对象

        List list = new ArrayList();

        //打印集合中元素的个数

        System.out.println("元素数量："+list.size());//0

        //添加操作：向列表中添加4个元素

        list.add("Will");

        list.add(100);

        list.add(true);

        list.add("Lucy");

        //查询操作:

        System.out.println("列表中所有元素："+list);//输出:[Will, 100, true, Lucy]

        System.out.println("元素数量："+list.size());//4

        System.out.println("第一个元素："+list.get(0));//Will

        //修改操作：把索引为2的元素，替换为wolfcode

        list.set(2, "wolfcode");

        System.out.println("修改后："+list);//输出:[Will, 100, wolfcode, Lucy]

        //删除操作：删除索引为1的元素

        list.remove(1);

        System.out.println("删除后："+list);//输出:[Will, wolfcode, Lucy]

    }

}

需求2：创建四个User对象，存储在List中，分析内存图。

public class User {

    private String name;

    private int age;

     //省略两个参数构造器、getter/setter方法、toString方法

}

public class ArrayListDemo2 {

    public static void main(String[] args) {

        List girls = new ArrayList();

        User u1 = new User("西施", 18);

        girls.add(u1);

        girls.add(new User("王昭君",19));

        girls.add(new User("貂蝉",20));

        girls.add(new User("杨玉环",21));

        System.out.println(girls);

        //修改u1对象的名字和年龄

        u1.setName("小施");

        u1.setAge(17);

        System.out.println(girls);

    }

}

运行结果（观察变化）：

[User [name=西施, age=18], User [name=王昭君, age=19], User [name=貂蝉, age=20], User [name=杨玉环, age=21]]

[User [name=小施, age=17], User [name=王昭君, age=19], User [name=貂蝉, age=20], User [name=杨玉环, age=21]]

内存分析，解释原因：

image.png

结论：集合类中存储的对象,都存储的是对象的引用,而不是对象本身。

1.2.3. LinkedList类（了解）

ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组。

LinkedList类，底层采用链表算法，实现了链表，队列，栈的数据结构。无论是链表还是队列主要操作的都是头和尾的元素，因此在LinkedList类中除了List接口的方法，还有很多操作头尾的方法。

void addFirst(Object e) 将指定元素插入此列表的开头。
void addLast(Object e) 将指定元素添加到此列表的结尾。
Object getFirst() 返回此列表的第一个元素。
Object getLast() 返回此列表的最后一个元素。
Object removeFirst() 移除并返回此列表的第一个元素。
Object removeLast() 移除并返回此列表的最后一个元素。
boolean offerFirst(Object e) 在此列表的开头插入指定的元素。
boolean offerLast(Object e) 在此列表末尾插入指定的元素。
Object peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
Object peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
Object pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
Object pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
void push(Object e) 将元素推入此列表所表示的栈。
Object pop() 从此列表所表示的栈处弹出一个元素。
Object peek() 获取但不移除此列表的头（第一个元素）。

LinkedList之所以有这么多方法，是因为自身实现了多种数据结构，而不同的数据结构的操作方法名称不同，在开发中LinkedList使用不是很多，知道存储特点就可以了。

public class LinkedListDemo {

    public static void main(String[] args) {

        LinkedList list = new LinkedList();

        //添加元素

        list.addFirst("A");

        list.addFirst("B");

        System.out.println(list);

        list.addFirst("C");

        System.out.println(list);

        list.addLast("D");

        System.out.println(list);

        //获取元素

        System.out.println("获取第一个元素：" + list.getFirst());//C

        System.out.println("获取最后一个元素：" + list.getLast());//D

        //删除元素

        list.removeFirst();

        System.out.println("删除第一个元素后：" + list);//[B, A, D]

        list.removeLast();

        System.out.println("删除最后一个元素后：" + list);//[B, A]

    }

}

程序运行结果：

[B, A]

[C, B, A]

[C, B, A, D]

获取第一个元素：C

获取最后一个元素：D

删除第一个元素后：[B, A, D]

删除最后一个元素后：[B, A]

1.2.4. Stack和Vector类（了解）

Vector类：基于数组算法实现的列表，其实就是ArrayList类的前身。和ArrayList的区别在于方法使用synchronized修饰，所以相对于ArrayList来说，线程安全，但是效率就低了点。

Stack类：表示栈，是Vector类的子类，具有后进先出(LIFO)的特点，拥有push（入栈），pop（出栈）方法。

1.3. 泛型（会用即可）

1.3.1. 什么是泛型（了解）

其实就是一种类型参数，主要用于某个类或接口中数据类型不确定时，可以使用一个标识符来表示未知的数据类型，然后在使用该类或方法时指定该未知类型的真实类型。

泛型可用到的接口、类、方法中，将数据类型作为参数传递，其实更像是一个数据类型模板。

如果不使用泛型，从容器中获取出元素，需要做类型强转，也不能限制容器只能存储相同类型的元素。

List list = new ArrayList();

list.add("A");

list.add("B");

String ele = (String) list.get(0);

1.4. 自定义和使用泛型（了解）

定义泛型：使用一个标识符，比如T在类中表示一种未知的数据类型。

使用泛型：一般在创建对象时，给未知的类型设置一个具体的类型，当没有指定泛型时，默认类型为Object类型。

需求：定义一个类Point，x和y表示横纵坐标，分别使用String、Integer、Double表示坐标类型。

如果没有泛型需要设计三个类，如下：

image.png

定义泛型：

//在类上声明使用符号T,表示未知的类型

public class Point<T> {

    private T x;

    private T y;

    //省略getter/setter

}

使用泛型：

//没有使用泛型，默认类型是Object

Point p1 = new Point();

Object x1 = p1.getX();

//使用String作为泛型类型

Point<String> p2 = new Point<String>();

String x2 = p2.getX();

//使用Integer作为泛型类型

Point<Integer> p3 = new Point<Integer>();

Integer x3 = p3.getX();

画图分析：

image.png

注意：这里仅仅是演示泛型类是怎么回事，并不是要求定义类都要使用泛型。

1.5. 在集合框架中使用泛型（掌握）

拿List接口和ArrayList类举例。

class ArrayList<E>{

    public boolean add(E e){ }

    public E get(int index){  }

}

此时的E也仅仅是一个占位符，表示元素（Element）的类型，那么当使用容器时给出泛型就表示该容器只能存储某种类型的数据。

//只能存储String类型的集合

List<String> list1 = new ArrayList<String>();

list1.add("A");

list1.add("B");

//只能存储Integer类型的集合

List<Integer> list2 = new ArrayList<Integer>();

list2.add(11);

list2.add(22);

因为前后两个泛型类型相同（也必须相同），泛型类型推断：

List<String> list1 = new ArrayList<String>();

可以简写为

List<String> list1 = new ArrayList<>();

通过反编译工具，会发现泛型其实是语法糖，也就是说编译之后，泛型就不存在了。

注意：泛型必须是引用类型，不能是基本数据类型（错误如下）：

List<int> list = new ArrayList<int>();

泛型不存在继承的关系（错误如下）：

List<Object> list = new ArrayList<String>();  //错误的

若要获得最好的学习效果，需要配合对应教学视频一起学习。需要完整教学视频，请参看https://ke.qq.com/course/272077。

认识Java中的列表结构

1. 集合框架体系

1.1. 容器的分类（掌握）

1.2. List接口（重点）

1.2.1. List常用API方法（必须记住）

1.2.2. ArrayList类（重点）

1.2.3. LinkedList类（了解）

1.2.4. Stack和Vector类（了解）

1.3. 泛型（会用即可）

1.3.1. 什么是泛型（了解）

1.4. 自定义和使用泛型（了解）

1.5. 在集合框架中使用泛型（掌握）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读