第三章 数据结构（掌握）

3.1 数据结构介绍

数据结构 : 数据用什么样的方式组合在一起。

科班出身的同学我想你对数据结构一点也不陌生，不知道你记不记得，当时学习数据结构的逻辑结构中的集合时，只是简单了解它，并没有实际用到它，现在你通过上面的学习学习了集合的一些使用，我想你对数据结构中的集合肯定有更深的理解。

3.2 常见数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树。我们分别来了解一下：

栈

• 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

简单的说：采用该结构的集合，对元素的存取有如下的特点

• 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

• 栈的入口、出口的都是栈的顶端位置。

这里两个名词需要注意：

• 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

• 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

 递归、函数调用都用到了栈！

队列

• 队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。

• 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

操作系统的缓冲区、图的广度优先遍历都用到了队列。

数组

• 数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

简单的说,采用该结构的集合，对元素的存取有如下的特点：

• 查找元素快：通过索引，可以快速访问指定位置的元素

• 

• 增删元素慢

• 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

• 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

链表

• 链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。

• 

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

• 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

• 增删元素快：

• 

  树数据结构

第四章 List接口（掌握）

我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？

接下来，我们一起学习Collection中的常用几个子类（java.util.List集合、java.util.Set集合）。

4.1 List接口介绍

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

看完API，我们总结一下：

List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。

2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义。

4.2 List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

• public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。

• public E get(int index):返回集合中指定位置的元素。

• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

• public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法都是跟索引相关，我们在基础班都学习过。

tips:我们之前学习Colletion体系的时候，发现List集合下有很多集合，它们的存储结构不同，这样就导致了这些集合它们有各自的特点，供我们在不同的环境下使用，那么常见的数据结构有哪些呢？在下一章我们来介绍：

代码示例：

public class Demo6 {
    public static void main(String[] args) {
        //1.创建集合
        List<String> list = new ArrayList<>();
        //2.添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
​
        //3.利用带有索引的方法添加元素
        //原本0索引上的数据，往后移动了一个位置
        //list.add(0,"QQQ");
​
        //通过索引删除，返回的是被删除的元素
        //System.out.println(list.remove(1));
​
        //修改执行索引上的元素
        //把被覆盖的元素给返回。
        //System.out.println(list.set(0, "QQQ"));
​
​
        //System.out.println(list.get(1));
        //我们可以通过get和size方法相结合，去利用普通for循环遍历集合。
​
        System.out.println(list);
    }
}
​

扩展点：

1，List接口中，有通过对象删除的方法，也有通过索引删除的方法，到底调用哪个，需要看不同的情况。

代码示例：

//1.创建集合
ArrayList <Integer> list = new ArrayList<>();
//添加数据
list.add(1);
list.add(2);
list.add(3);
list.add(4); 
list.add(5);
​
//2.删除
//请问，是删除1这个元素，还是把1索引上的元素进行删除
//在删除的时候，不会自动装箱
//如果写数字，那么就是通过索引进行删除
list.remove(1);
​
//就是想删除1这个对象,可以自己封装成一个Integer对象再进行删除
list.remove(Integer.valueOf(1));
​
System.out.println(list);

运行结果：

其实可以转到定义下看该方法，就知道是通过索引删除还是通过元素删除。

2，再看

//1.创建集合
//在Collection中，删除方法只有通过对象删除的方法
//多态方式创建对象。
//在调用方法的时候：编译看左边，运行看右边
//而左边的父接口中，只有通过对象删除的方法
//所以，在实际运行的时候，运行的还是子类中通过对象删除的方法
Collection<Integer> list = new ArrayList<>();
//添加数据
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
​
//此时是通过对象进行删除。
list.remove(1);
​
System.out.println(list);

运行结果：

4.3 List系列集合的遍历方式

① 普通for循环（因为List集合存在索引，后面学的set系列集合是没有索引的，只能通过下面三种方式来遍历）

② 迭代器

③ 增强for循环

④ Lambda表达式

4.4 ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

ArrayList初始长度为10，当集合满了，就会扩容到它的1.5倍，每次满了都会扩容1.5倍，扩容是有很大代价的。因此ArrayList增加元素是不方便的。但是有索引，索引查询很快。

4.5 LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

 

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

• public void addFirst(E e):将指定元素插入此列表的开头。

• public void addLast(E e):将指定元素添加到此列表的结尾。

• public E getFirst():返回此列表的第一个元素。

• public E getLast():返回此列表的最后一个元素。

• public E removeFirst():移除并返回此列表的第一个元素。

• public E removeLast():移除并返回此列表的最后一个元素。

• public E pop():从此列表所表示的堆栈处弹出一个元素。

• public void push(E e):将元素推入此列表所表示的堆栈。

• public boolean isEmpty()：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

public class Demo04LinkedList {
    public static void main(String[] args) {
        method4();
    }
    /*
     *  void push(E e)： 压入。把元素添加到集合的第一个位置。
     *  E pop()： 弹出。把第一个元素删除，然后返回这个元素。
     */
    public static void method4() {
        //创建LinkedList对象
        LinkedList<String> list = new LinkedList<>();
        //添加元素
        list.add("达尔文");
        list.add("达芬奇");
        list.add("达尔优");
        System.out.println("list:" + list);
        //调用push在集合的第一个位置添加元素
        //list.push("爱迪生");
        //System.out.println("list:" + list);//[爱迪生, 达尔文, 达芬奇, 达尔优]
        
        //E pop()： 弹出。把第一个元素删除，然后返回这个元素。
        String value = list.pop();
        System.out.println("value:" + value);//达尔文
        System.out.println("list:" + list);//[达芬奇，达尔优]
    }
    
    /*
     * E removeFirst()：删除第一个元素
     * E removeLast()：删除最后一个元素。
     */
    public static void method3() {
        //创建LinkedList对象
        LinkedList<String> list = new LinkedList<>();
        //添加元素
        list.add("达尔文");
        list.add("达芬奇");
        list.add("达尔优");
        //删除集合的第一个元素
//      String value = list.removeFirst();
//      System.out.println("value:" + value);//达尔文
//      System.out.println("list:" + list);//[达芬奇，达尔优]
        
        //删除最后一个元素
        String value = list.removeLast();
        System.out.println("value:" + value);//达尔优
        System.out.println("list:" + list);//[达尔文， 达芬奇]
    }
    
    /*
     * E getFirst()： 获取集合中的第一个元素
     * E getLast()： 获取集合中的最后一个元素
     */
    public static void method2() {
        //创建LinkedList对象
        LinkedList<String> list = new LinkedList<>();
        //添加元素
        list.add("达尔文");
        list.add("达芬奇");
        list.add("达尔优");
        
        System.out.println("list:" + list);
        //获取集合中的第一个元素
        System.out.println("第一个元素是：" + list.getFirst());
        //获取集合中的最后一个元素怒
        System.out.println("最后一个元素是：" + list.getLast());
    } 
    
    
    /*
     * void addFirst(E e)： 在集合的开头位置添加元素。
     * void addLast(E e)： 在集合的尾部添加元素。
     */
    public static void method1() {
        //创建LinkedList对象
        LinkedList<String> list = new LinkedList<>();
        //添加元素
        list.add("达尔文");
        list.add("达芬奇");
        list.add("达尔优");
        //打印这个集合
        System.out.println("list:" + list);//[达尔文, 达芬奇, 达尔优]
        //调用addFirst添加元素
        list.addFirst("曹操");
        System.out.println("list:" + list);//[曹操, 达尔文, 达芬奇, 达尔优]
        //调用addLast方法添加元素
        list.addLast("大乔");
        System.out.println("list:" + list);//[曹操, 达尔文, 达芬奇, 达尔优, 大乔]
        
    }
}

扩展点1：

利用迭代器删除元素

ArrayList<String> list = new ArrayList<>();
​
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
​
//利用迭代器方法进行遍历
//细节：如果利用迭代器遍历集合，想要删除元素，需要用迭代器里面的方法进行删除，不能用ArrayList里的remove方法进行删除，否则会报并发修改异常。
Iterator<String> it = list.iterator();
while(it.hasNext()){
    String str = it.next();
    if("b".equals(str)){
        it.remove();//迭代器里的删除和添加指针都是很智能的，删除它能自动减1，添加指针能自动加1
    }
}
​
System.out.println(list);

扩展点2：

利用列表迭代器添加数据

package com.itheima.a03arraylistdemo;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
​
/*
*
*   并发修改异常出现的原因：
*       在利用迭代器遍历集合的过程中，利用集合的方法，对集合发生了改变（add，remove）。
*       会报并发修改异常
*
*   解决：
*       1.删除
*           利用迭代器的remove方法进行删除。
*       2.添加（了解）
*           在List接口中，还有一个叫做列表迭代器
*           可以利用它来添加数据
*
* */
public class Demo12 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
​
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
​
        //利用迭代器删除元素和添加元素用的迭代器不一样。添加元素得用列表迭代器，否则会抛出并发修改异常。
        /* Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            if("b".equals(str)){
                list.add("QQQ");
            }
        }*/
​
        ListIterator<String> lit = list.listIterator();//列表迭代器
        while(lit.hasNext()){
            String str = lit.next();
            if("b".equals(str)){
                lit.add("QQQ");
            }
        }
​
        System.out.println(list);
    }
}
​