目录

集合容器

数组（Array）有什么缺点？

ArraysList中的  "E"到底是什么？

双向链表封装类--LinkedList

           增

          删

          查

       数组和链表的区别

 Array和ArrayList的区别是什么？

整理ArrayList的常用方法

整理LinkedList的常用方法

集合容器

数组（Array）有什么缺点？

1.在创建数组的时候，就需要定死长度，在运行过程中，需要判断剩余长度，并动态扩容

2.在中间插入的时候，需要将后面的元素进行后移

3.在中间删除的时候，需要将后面元素进行前移

数组的封装类 - 列表（集合）（ArrayList）是一个封装类：有成员变量，构造方法，成员方法。

数组特点：有序的，不唯一的

   构造方法：先研究如何构造方法

         ArrayList()

        ArrayList(int)

   成员变量：研究构造出来的对象中有什么

      elementDate---Object[]类型

      size---int类型

   成员方法：研究如何操作对象中的成员

      add(int) --在数组尾部的第一个不为空的位置添加

      add(int,E)--在数组中的指定位置插入

      set(int,E)  --修改数组指定位置

      remove(int)---根据数组索引号删除

      remove(Object)--根据指针移除，如果存在多个，只会移除第一个

      get(int)--根据指定的索引号找到某个元素并返回

ArraysList中的  "E"到底是什么？

泛型：用泛型来实现类中用到的数据类型的未知

               --作者在编写的时候用"E"来表达数据类型的未知

               --调用者在使用的时候，可以给出"E"的具体类型，也可以不给出

                           如果给出“E”的具体类型，是在构造ArrayList对象(在声明指针)的时候给出

                           例如：E=String    E=Car     E=Dog

                           不给的话"E"=Object

                           给出E的具体数据类型的语法：

                           ArrayListal1=new ArrayList();

                           ArrayListal2=new ArrayList();

package Charpter12;

import Chapter04汽车租聘系统.Car;

import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) {
        //未指定泛型“E”的具体类型，E=Object
        ArrayList al1=new ArrayList();
        Car car =new Car();
        car.setBrand("玛莎拉蒂");
        al1.add(car);//发生向上转型car添加Object类型的数组中
        //Car car2=al1.get(0);
        Object obj=al1.get(0);
        Car car3=(Car)al1.get(0);
        //指定了E为Car类型
        ArrayListal2=new ArrayList<>();
        al2.add(car);
        Car car4=al2.get(0);
    }
}

（可以是参数类型，可以是返回值类型，可以是任意变量类型，可以是向下转型的类型）

用泛型的好处是，被调用方可以帮调用方写向下转型的代码

双向链表封装类--LinkedList

底层：Node对象

构造方法

成员变量

成员方法

           增

           1.addFrist(E)  在头部添加

           2.addLast(E)  在尾部添加

           3.add(E)         在尾部追加

           4.add(int,E)  在指定指定位置插入

                   链表在中间插入的速度要优于数组，只需要找到插入位置的节点，创建新节点，然后修改指针即可（需要遍历）

                   数组在尾部插入较快，但是在首部或者中间插入，比较慢，因为需要后移（需要遍历）

          删

           1.removeFrist()  删除头部

           2.removeLast()  删除尾部

           3.remove(int)     根据指定位置删除

           4.remove(Object)  根据指定元素删除

           

          查

          数组有索引，不需要遍历

          链表没有索引（链表本身没有索引，只是内部维护了一个size，增的时候size++,减的时候size--，这只是一个序号）所以需要遍历。

           get(int)   链表并没有索引机制，底层通过遍历链表然后通过二分查找法找到指定位置的节点，并返回节点中的item。所以，从查询角度来看，数组的性能远远优于链表。

       数组和链表的区别

中间插入和删除，链表优于数组，因为链表不需要前移和后移。查询和修改，数组优于链表，因为链表没有索引，查询和修改时需要遍历链表

链表不存在扩容和转移，数组需要

    遍历ArrayList和LinkedList的几种方式

       1.普通for循环

    public static void main(String[] args) {
        ArrayListlist=new ArrayList<>();
        list.add("张飞");
        list.add("赵云");
        list.add("马超");
        list.add("关羽");
        list.add("刘备");
        System.out.println("遍历方式1：for循环");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

       2.增强型for循环

   System.out.println("遍历方式2：增强for循环");
        //1.增强型for循环不需要写循环四要素
        //2.不需要手动执行list.get()操作了
        //冒号的左边是一个临时变量String item，这个临时变量的数据类型与list的泛型必须保持一至
        //冒号右边的是被遍历的list
        //每循环一次会自动从list中取出一个元素付给item，直到没有下一个元素，循环自动退出
        for (String item : list) {
            System.out.println(item);
        }

       3.forEach循环

   System.out.println("遍历方式3：forEach循环");
        //先写出list.forEach(),在括号里再写一个小括号，在小括号里写一个item，再写一个->,再写个{}，
        // 最后鼠标放在{}，点回车
        //用list调用forEach函数
        //forEach函数的参数是一个箭头函数
        //箭头函数的语法（参数名）->{}
        list.forEach((item)->{
            System.out.println(item);
        });

       4.迭代器

    System.out.println("遍历方式4：迭代器");
        //调用iterator()方法，返回一个迭代器对象
        //使用iterator类，声明一个迭代器指针，迭代器的泛型必须和list的泛型保持一样
        Iterator iterator = list.iterator();
        //迭代器的hasNext()方法可以判断是否还有下一个元素
        while (iterator.hasNext()){
        //迭代器的next（）方法可以取出下一个元素
        String item= iterator.next();
            System.out.println(item);
        }

 Array和ArrayList的区别是什么？

   1.Array是数组，ArrayList是类

   2.Array是定长的（需要手动扩容），ArrayList长度可变（使用过程中自动扩容）

   3.ArrayList的底层是Array

ArrayList和LinkedList的区别是什么？

1.底层数据结构实现：ArrayList底层数据结构是动态数组，而LinkedList的底层数据结构是双向链表。

2.随机访问（即读）效率：ArrayList比LinkedList在随机访问的时候效率要高，因为ArrayList底层是数组，可以通过索引号快速访问，LinkedList是通过二分查找法遍历链表节点进行查找的。

3.增加和删除效率：在非首尾的增加和删除操作，LinkedList要比ArrayList效率更高，因为ArrayList增删操作需要大量的前移或后移，这个过程涉及到大量的赋值操作比较消耗时间，LinkedList只需要修改节点对象的左右指针即可。

4.内存空间暂用：LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。

5.综合来说，在需要频繁读取集中的元素时，更推荐使用ArrayList，而在插入和删除操作较多时，更推荐使用LinkedList。

整理ArrayList的常用方法

序号	方法名	参数说明	返回值说明	方法功能说明
1	size()		int类型,集合的元素个数	获取数组中的元素个数;
2	add(E )	E  泛型类型的元素	返回一个boolean类型。添加成功返回turn,添加失败返回false	在数组尾部的第一个不为空的位置添加
3	add（int，E）	int 指定增加元素的下标；E 增加的元素		在指定位置插入一个元素，后面的元素后移
4	①addAll(Collection) ②addAll（int ,Collection）	①需要添加的集合;②int  下标位置，需要添加的集合;	boolean类型值	给数组添加数组 ①默认添加到末尾
5	set(int,E)	int 指定元素的下标；E  修改成功的元素	返回被修改的元素	修改数组指定位置（注意：不允许在size之前修改，可修改的下标不能大于size）
6	remove(Object)	Object 类型的指针	移除成功返回true，否则返回false。指定元素输出返回ture	根据指针移除，如果存在多个，只会移除第一个
7	remove(int)	int 指定元素下标	返回被删除的元素	根据数组索引号删除，后面的元素前移
8	clear()			从列表中移除所有元素
9	subList(int ,int)	开始下标, 结束下标	新的子数组	在原数组中截取子数组
10	get(int）	int 指定元素的下标	返回指定索引号的元素	根据指定的索引号找到某个元素并返回
11	indexOf(Object)	需要查找的元素	int类型(找到返回下标,未找到返回-1)	查找数组内的元素;

常用方法对应的程序及结果

1， ①addAll(Collection)（给数组添加数组）

      ②addAll（int ,Collection）

public class Demo05 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add("str1");
        list1.add("str2");
        ArrayList list2 = new ArrayList();
        list2.add("str01");
        list2.add("str02");
        list1.addAll(list2);
        System.out.println(list1);
    }
}

public class Demo05 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add("str1");
        list1.add("str2");
        ArrayList list2 = new ArrayList();
        list2.add("str01");
        list2.add("str02");
        list1.add(1,list2);
        System.out.println(list1);
    }
}

2， set(int,E) 

public class Demo05 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("str1");
        list.add("str2");
        list.add("str3");
        list.add("str4");
        System.out.println(list);
        System.out.println(list.set(1,"str5"));
        System.out.println(list);
    }
}

3，clear() （从列表中移除所有元素）

public class Demo05 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("str1");
        list.add("str2");
        System.out.println(list);
        list.clear();
        System.out.println(list);
    }
}

4， subList(int ,int)  （在原数组中截取子数组）

• fromIndex - 截取元素的起始位置，包含该索引位置元素
• toIndex - 截取元素的结束位置，不包含该索引位置元素

• 返回给定的动态数组截取的部分。

• 如果fromIndex 小于 0 或大于数组的长度，则抛出 IndexOutOfBoundsException（索引超出边界异常） 的异常

• 如果 fromIndex 大于 toIndex 的值则抛出 IllegalArgumentException （不合法的参数异常）异常。

import java.util.ArrayList;
public class Demo05 {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList sites = new ArrayList<>();
        sites.add("str1");
        sites.add("str2");
        sites.add("str3");
        sites.add("str4");
        System.out.println(sites);
        // 元素位置为1到3
        System.out.println(sites.subList(1, 3));
    }
}

5，indexOf(Object) （查找数组内的元素;）

public class Demo05 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("str1");
        list.add("str2");
        list.add("str3");
        list.add("str4");
        System.out.println(list.indexOf("str2"));
        System.out.println(list.indexOf("str5"));
    }
}

 整理LinkedList的常用方法

序号	方法名	参数说明	返回值说明	方法功能说明
1	addFrist(E)   addLast(E)   add(E)     add(int,E)			在头部添加 在尾部添加  在尾部追加 在指定指定位置插入
2	removeFrist()  removeLast()  remove(int)      remove(Object)		返回此列表中的第一个元素 返回此列表中的最后一个元素	删除头部 删除尾部 根据指定位置删除 根据指定元素删除
3	get() getFirst() getLast()	int index	返回此列表中的第一个元素 返回此列表中的最后一个元素	按照下边获取元素 获取第一个元素 获取最后一个元素
4	peek() peekLast() peekFirst()		返回这个列表的头部	检索第一个元素（但不删除）  返回列表的最后一个元素。 返回列表的第一个元素。
5	set(int index,E element)			用指定元素替换此列表中指定位置的元素
6	offer(E e) offerFirst(E e)  offerLast(E e)			将指定的元素添加到列表的尾部（最后一个元素） 在列表的前面插入指定的元素。 在列表的结尾插入指定的元素。