Java学习笔记22（List接口）

List接口继承自Collection接口，自身具有三大特点：

1.有序集合：存入和取出的顺序一致；

2.此接口的用户可以对每个元素插入位置进行精确控制：可以通过索引操作元素

3.可以存储重复元素

List接口的特有方法：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*List接口的特有方法：
*   1）add（）添加元素
*   2）remove（）删除元素
*   3）get（）获得元素
*   4）set（） 修改元素
*   5) listIterator（）迭代器*/
public class Demo3 {
    public static void main(String[] args) {
        addfun();
        removefun();
        getfun();
        setfun();
        listiteratorfun();
    }

    private static void listiteratorfun() {
        List<String> list = fun();
        ListIterator<String> it =list.listIterator(1);//从列表的指定位置开始迭代;
        while (it.hasNext()) {
            String next =  it.next();
            System.out.println(next);
            /*world
              love
              java*/
        }
    }

    private static void setfun() {
        List<String> list = fun();
        System.out.println(list);//[hello, world, love, java]
        list.set(1,"abc");//用指定的元素“abc”替换列表中指定位置的元素
        System.out.println(list);//[hello, abc, love, java]
    }

    private static void getfun() {
        List<String> list = fun();
        System.out.println(list);//[hello, world, love, java]
        String s = list.get(3);//get()获得指定下标位置的元素
        System.out.println(s);//java
    }

    private static void removefun() {
        List<String> list = fun();
        System.out.println(list);//[hello, world, love, java]
        list.remove(1);//remove()删除列表中指定位置的元素
        System.out.println(list);//[hello, love, java]
    }

    private static void addfun() {
        List<String> list=fun();
        System.out.println(list);//[hello, world, love, java]
        list.add(1,"abc");//add();插入一个元素到指定位置
        System.out.println(list);//[hello, world, love, java]
    }

    private static List<String> fun() {
        //创建新建集合方法，，返回集合对象
        List<String> li=new ArrayList<>();//List是接口，所以只能通过子类创建对象，这里使用ArrayList类创建
        li.add("hello");
        li.add("world");
        li.add("love");
        li.add("java");
        return li;
    }
}

List集合遍历有三种遍历方式：迭代器遍历；普通for循环遍历，增强for循环遍历；

List接口的数据存储结构：List的众多子类数据元素所采用的结构方式是不一样的，

　　数据存储通常结构有：堆栈，队列，数组，链表；

堆栈：先进后出     就像一个死胡同，后面进来的人先出去，先进来的人最后出去，

队列：先进先出     就像一个胡同，两边都通，只能从一边进，另一边出，先进去的人先出去，后边的人才能出去；

链表：（链表分为单链表和双链表，这里用单链表举例）链表中的数据是以节点来表示的，每一个节点由两部分组成，一部分存指针，另一部分存储数据，指针指向上一个节点的地址。查找的时候速度慢，增删的时候，直接操作地址，速度块

数组：通过索引查找，长度固定，增删慢

List接口由两个子类，分别是LinkedList类，ArrayList类，

ArrayList类采用数组结构存储方式，有索引，所以查找快，增删慢，线程不安全，运行速度快；

ArrayList方法前面已经写过了，这里主要写LinkedList的方法；

LinkedList类采用双向循环链表存储结构，没有索引，查找慢，增删快，线程不安全，运行速度快；

LinkedList特有方法：

package com.zs.Demo;

import java.util.LinkedList;

/*LinkedList中由大量首尾操作的方法
* 1）添加元素:addFirst()  将指定元素插入此列表的开头
*           addLast()   将指定元素插入此列表的结尾
*           offerFirst（）  在此列表的开头插入指定的元素
*           offerLast（）  在此列表的结尾插入指定的元素
* 2）增删元素:removeFirst（）  移除并返回此列表的第一个元素
*           removeLast（）   移除并返回此列表的最后一个元素
*           pollFirst（）    获取并移除此列表的第一个元素；如果列表为空，则返回null。
*           pollLast（）     获取并移除此列表的最后一个元素；如果此列表为空，则返回null。
* 3）获取元素:getFirst()     返回此列表的第一个元素
*           getLast（）       返回此列表的最后一个元素
*           pollFirst（）    获取并移除此列表的第一个元素；如果列表为空，则返回null。
*           pollLast（）     获取并移除此列表的最后一个元素；如果此列表为空，则返回null。
* 4）栈操作： push（）         将元素推入此列表表示的堆栈。
*           pop（）           从此列表表示的堆栈出弹出一个元素。
*           peek（）          获取但不移除此列表的头（第一个元素）*/
public class LinkedListDemo {
    public static void main(String[] args) {
        //添加方法
        addDemo();
        //增删元素
        insertAndDelete();
        //获取元素
        getDemo();
        //栈操作
        StackDemo();
    }

    private static void StackDemo() {
        LinkedList<String> li=new LinkedList<>();
        li.push("a");//push()方法将一个元素推入堆栈
        System.out.println(li);//[a]
        li.push("b");
        li.push("c");
        li.push("d");
        System.out.println(li);//[d, c, b, a]a最先进来，排在最后面
        // 可以看出堆栈中元素，push把元素不断往后推，进来越早越往后，这就是堆栈的先入后出
        String s1 = li.pop();//弹出堆栈中最后进去的元素（先入后出，后入先出）
        System.out.println(s1);//d
        System.out.println(li);//[c, b, a] 可以看出d被弹出堆栈
        String s2 = li.peek();//获取但不移除此列表的头
        System.out.println(s2);//c
        System.out.println(li);//[c, b, a] 列表头没有被移除
    }

    private static void getDemo() {
        LinkedList<String> li=new LinkedList<>();
        li.add("a");
        li.add("b");
        li.add("c");
        System.out.println(li);//[a, b, c]
        String s = li.getFirst();
        System.out.println(s);//a
        String last = li.getLast();
        System.out.println(last);//c
        //   pollFirst/Last()在增删方法中测试
    }

    private static void insertAndDelete() {
        LinkedList<String> li=new LinkedList<>();
        li.add("a");
        li.add("b");
        li.add("c");
        li.add("d");
        System.out.println(li);//[a, b, c, d]
        String s = li.removeFirst();//删除并返回头元素给s
        System.out.println(s);//a
        System.out.println(li);//[b, c, d]
        String s1 = li.removeLast();
        System.out.println(s1);//d
        System.out.println(li);//[b, c]
        String s2 = li.pollFirst();
        System.out.println(s2);//b
        System.out.println(li);//[c]
        String s3 = li.pollLast();
        System.out.println(s3);//d
        System.out.println(li);//[]为空
        String s4 = li.pollFirst();
        System.out.println(s4);//null
    }

    private static void addDemo() {
        LinkedList<String> li=new LinkedList<>();
        li.add("b");
        System.out.println(li);//[b]
        li.addFirst("a");//添加头元素
        li.addLast("c");//尾部添加元素
        System.out.println(li);//[a, b, c]
        li.offerFirst("Z");//头部添加元素
        li.offerLast("d");//尾部添加元素
        System.out.println(li);//[Z, a, b, c, d]
    }
}