2021.07.19 Java学习笔记之List

Collection 

        集合的上层接口，用来存储单个数据之，多个元素的集合

        遍历方式

                foreach 

                迭代器Iterator

        map 多个元素的集合，每个元素由键值对组成

List 接口

        特点：有序，可以重复

        新增方法：一些根据索引操作的方法

                        可以添加Null元素

List 容器

        泛型：规定集合存储的数据的类型 | 规定数据的类型

                表示：<数据类型> 数据类型只能为引用数据类型

                位置：定义在数据类型的后面

                优点：帮助增强程序的稳定性与可读性

        ist<String> list = new ArrayList();
        //List<Integer> list2 = new ArrayList();

        list.add(null);
        list.add(null);
        list.add("abc");
        list.add("cde");
        list.add("mnb");

        System.out.println(list);

        //新增方法
        //void add(int index, E element) 将指定元素插入此列表中的指定位置（可选操作）。
        list.add(1,"你好");
        System.out.println(list);

        //E get(int index) 返回此列表中指定位置的元素。
        System.out.println(list.get(3));;

        //int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
        //int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.lastIndexOf(null));

        //static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
        List<Integer> list1 = List.of(1,2,3,4,5);
        System.out.println(list1);

        //E remove(int index) 删除此列表中指定位置的元素（可选操作）。
        System.out.println(list.remove(2));
        System.out.println(list);

        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。
        System.out.println(list.set(4,"nb"));
        System.out.println(list);

        //List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
        System.out.println(list.subList(1,3));
        System.out.println(list);

        //Object[] toArray()
        System.out.println(Arrays.toString(list.toArray()));

/*
    有序:  存放的顺序与内部真实存储的顺序相同
    注意: 存储的数据为整数的时候,默认以索引优先

 */
public class Class002_List {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(3);
        list.add(1);
        list.add(2);
        list.add(5);

        list.add(4);

        List<Boolean> list2 = new ArrayList<>();
        list2.add(false);
        list2.add(true);
        list2.add(false);
        list2.add(true);
        System.out.println(list2);

        //删除
        list.remove(3);
        System.out.println(list);
        /*移出第一个数据*/
        list2.remove(false);
        System.out.println(list2);
    }
}

定义: 一个list集合,存储你喜欢的漫威英雄人物
         如果包含灭霸,就向集合中添加一个惊奇队长 

/*
    List集合遍历方式:
        1.普通for循环
        2.增强for循环
        3.iterator迭代器
        4.listIterator 列表迭代器
 */
public class Class003_List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("钢铁侠");
        list.add("美国队长");
        list.add("黑寡妇");
        list.add("灭霸");
        list.add("毒液");
        System.out.println(list);


        //1. contains
        /*if(list.contains("灭霸")){
            list.add("惊奇队长");
        }
        System.out.println(list);*/

        //2.for
       /* for(int i=0;i<list.size();i++){
            if("灭霸".equals(list.get(i))){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //3.foreach
        //ConcurrentModificationException 当不允许这样的修改时，检测到对象的并发修改的方法可能抛出此异常。
      /*  for(String str : list){
            if("灭霸".equals(str)){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //4.迭代器 iterator
        /*for(Iterator<String> it =  list.iterator();it.hasNext();){
            if("灭霸".equals( it.next())){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //5.列表迭代器
        //1)获取列表迭代器对象
      /*  ListIterator<String> it2 =  list.listIterator();
        //2)判断是否存在下一个|上一个元素
        //正向遍历
        while(it2.hasNext()){
            //3)获取上一个或者下一个元素 | 操作集合
            System.out.println(it2.nextIndex());
            System.out.println(it2.next());
            *//*if("灭霸".equals( it2.next())){
                it2.add("惊奇队长");
            }*//*
        }
        System.out.println(list);*/


        //反向遍历
        ListIterator<String> it3 = list.listIterator(4);
        while(it3.hasPrevious()){
            System.out.println(it3.previousIndex()+"-->"+it3.previous());
        }
    }
}

ArraysList

        顶层实现：可变数组

        特点：有序 可重复

                根据索引做查询效率高

                增删效率低，设计到新数组的创建，数组的拷贝问题

        应用场景：

                大量做查询少量做增删的时候适合使用ArrayList

        扩容：

                int newCapacity = oldCapacity + (oldCapacity >> 1); 通过Arrays.copyOf方法实现扩容,每次扩容原容量的1.5倍
                第一次添加数据内部构建数组的初始容量为10

        新增内容：

                 void forEach(Consumer<? super E> action) 对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。

        遍历方式：

                 1.普通for
                 2.增强for
                 3.iterator迭代器
                 4.listIterator迭代器

Vector 向量 

         有序，可重复

        底层结构： 数组

Vector与 ArrayList之间的区别: 

        1.同步问题

                ArrayList 线程不安全 | 不同步 ，相对效率高

                Vector     线程安全 | 同步

        2.扩容问题

                ArrayList 每次扩容原容量的1.5倍，更有利于节约内存

                Vector     每次扩容原容量的2倍

                注意:
                            使用集合存储自定义引用数据类型数据时候,需要重写equals方法,使用indexOf,constains()..,默认使用equals的返回值决定是否存在,包含,相等
               可以实现比较对象的内容,而非地址 

LinkedList 

        有序，可重复

        底层结构：双向链表 

        特点 ： 

                根据索引查询效率低

                做增删效率高

        应用场景：

                大量做增删，少量做查询的时候适合使用

        新增功能：

                新增了一些可以直接操作头尾的方法

public static void main(String[] args) {
        //链表结构
        LinkedList<Double> linked = new LinkedList<>();

      /*  linked.add(1.1);
        linked.add(2.1);
        linked.add(3.1);
        linked.add(4.1);

        System.out.println(linked);

        linked.addFirst(0.1);
        linked.addLast(5.1);
        System.out.println(linked);

        System.out.println(linked.removeFirst());*/
        System.out.println(linked);
    }

 

/*
    手写LinkedList --> 扩容
        通过单向链表简单实现
 */
public class Class006_MyLinkedList {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        System.out.println(list.size());
        list.add("0");
        System.out.println(list.size());
        list.add("1");
        System.out.println(list.size());
        list.add("2");
        list.add("3");
        list.delete(3);
        System.out.println(list);
    }
}

//自定义的链表
class MyLinkedList {
    //记录链表头节点
    private Node head;
    private int size;

    public MyLinkedList() {
    }

    /**
     * 在链表结构的最后添加一个数据
     *
     * @param value 要添加的数据
     */
    public void add(Object value) {
        //1.创建新节点
        Node node = new Node(value, null);

        //2.判断是否为第一个节点,作为链表头节点
        if (head == null && size == 0) {
            head = node;
            //长度+1
            size++;
            return;
        }

        //3.存在原链表.遍历原链表,找到原链表的最后一个节点,新节点挂上去
        //定义一个临时变量,指向首节点
        Node temp = head;

        while (temp.getNext() != null) {
            //指向下一个节点
            temp = temp.getNext();
        }

        //新节点地址挂在原链表的最后
        temp.setNext(node);

        //4.长度+1
        size++;
    }

    //size()
    public int size() {
        return this.size;
    }

    //toString()
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        //临时变量用于遍历这个链表
        Node temp = head;
        //遍历链表结构
        while (temp != null) {
            // 获取到每一个节点的数据值,拼接到字符串中
            sb.append(temp.getData() + ", ");
            //temp指向下一个节点
            temp = temp.getNext();
        }
        String str = sb.toString();
        //判断字符串是否以, 结尾,如果是去掉,
        if (str.endsWith(", ")) {
            str = str.substring(0, str.length() - 2);
        }

        return str + "]";
    }

    public void delete(int i) {
        if (i < 0 && i > size) {
            System.out.println("请确定");
        } else {
            // 临时
            Node temp = head;
            int size = 0;
            //遍历到要删除的链表节点
            while (!(size == i - 1)) {
                temp = temp.getNext();
                size++;
            }
//           这时候的temp地址指向的是要删除的数据
            //判断是否还有数据
            if (this.size == i) {
                temp.setNext(null);
                this.size--;
            } else {
                //定义一个变量 来接收删除变量所指向的下个地址
                Node temp1 = temp.getNext();
                temp.setNext(temp1.getNext());
                this.size--;
            }

        }
    }
}

//链表中的节点
class Node {
    private Object data;
    private Node next;  //Node next = new Node();

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}