List 接口,List容器,泛型,List集合遍历方式,ArrayList,Vector与 ArrayList之间的区别,LinkedList 链表

Collection 集合上层接口
    存储单个数据值,多个元素的集合
    常用方法
    遍历方式
        foreach
        迭代器Iterator
Map 多个元素的集合,每个元素由键值对组成

List 接口
    有序可重复
    新增 : 一些根据索引操作的方法
    添加null元素

//List容器
/*
    泛型: 规定集合存储数据的类型 | 规定数据的类型
    表示 : <数据类型>  数据类型只能为引用数据类型
    位置 : 定义在数据类型的后面
    优点 : 帮助增强程序的稳定性与可读性
 */

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

public class Class001_List {
    public static void main(String[] args) {
        //List容器
        /*
            泛型: 规定集合存储数据的类型 | 规定数据的类型
            表示 : <数据类型>  数据类型只能为引用数据类型
            位置 : 定义在数据类型的后面
            优点 : 帮助增强程序的稳定性与可读性
         */

        List<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()));

    }
}

 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());
        }
    }
}

List 接口的实现类 : 有序 可重复
ArrayList
    底层实现: 可变数组
    特点:
        优点：根据索引做查询效率高
        缺点：增删效率低,设计到新数组的创建,数据的拷贝等问题
    应用场景: 大量做查询,少量做增删的时候适合使用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迭代器

定义ArrayList,存储自定义的javabean类型学生类型数据,简单操作

Vector 向量
    有序 可重复
    底层结构: 数组
    与ArrayList很像

Vector与 ArrayList之间的区别:
    1.同步问题
        ArrayList 线程不安全|不同步,相对效率高
        Vector    线程安全|同步
    2.扩容问题
        ArrayList 每次扩容原容量的1.5倍,更有利于节约内存
        Vector    每次扩容原容量的2倍

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

public class Class004_List{
    public static void main(String[] args) {
        //ArrayList() 构造一个初始容量为10的空列表。
        List<String> list = new ArrayList<>();

        //ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
        //ArrayList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

        //添加
        list.add("haha");
        list.add("hehe");
        System.out.println(list);

        //遍历输出每一个元素
        list.forEach(System.out::println);

    }
}

LinkedList :
    有序 可重复

    底层结构: 双向链表
    特点:
        根据索引查询效率低
        做增删效率高
    应用场景:
        大量做增删少量做查询的时候适合使用
    新增功能:
        新增了一些可以直接操作头尾的方法

public class Class005_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("haha");
        System.out.println(list.size());
        //list.add("haha");
        System.out.println(list.size());

        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+"]";
    }
}

//链表中的节点
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 +
                '}';
    }
}