①. List集合的概述

• ①. 元素都带有索引

• ②. List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引

1. 有序:储存和取出的元素顺序一致
2. 可重复:储存元素可以重复

②. 并发修改异常

• ①. 需求:

我有一个集合: List<String> list=new ArrayList<>();
里面有三个元素:list.add("hello");list.add("world");list.add("java");
遍历集合,得到每一个元素,看有没有 " world "这个元素,如果有,我就添加一个" javaEE" 元素
1
2
3

• ②. 异常的原因:迭代器遍历的过程中,通过集合对象修改了集合中的元素,造成了迭代器获取元素中判断预期修改值和实际修改值不一致

• ③. 解决方案:使用for循环进行遍历,list中的get方法不会对expectedModCount = modCount进行判断,可以添加成功

	@Test
    public void fun5(){
	     List<String> list=new ArrayList<>();
	
	     list.add("hello");
	     list.add("world");
	     list.add("java");
	
	     Iterator<String> iterator=list.iterator();
	
	        for (int i = 0; i < list.size(); i++) {
	             String s=list.get(i);
	             if(s.equals("world")){
	                 list.add("javaEE");
	             }
	        }
	    /* while(iterator.hasNext()){
	         String s=iterator.next();
	         if(s.equals("world")){
	             list.add("javaEE"); //遍历的同时在修改元素,并发修改ConCurrentModificationException
	         }
	     }*/
	        System.out.println(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

③. 列表迭代器ListIterator

• ①. ListIterator的概述

1. 通过list集合的 listIterator()方法得到,所以说它是list集合中特有的迭代器
2. 用于允许程序员沿任一方向遍历列表的迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置

• ②. ListIterator中的常用方法

1. E next():返回迭代中的下一个元素
2. boolean hasNext():如果迭代具有更多的元素,则返回true
3. E previous()`:返回列表中的上一个元素
4. bloolean hasPrevious(): 如果此列表迭代器在相反方向遍历列表时具有更多的元素,则返回true
5. void add(E e):`将制定的元素插入列表

• ③. 逆向遍历,必须要有正向遍历在前面才能遍历出来；要是没有正向遍历,直接逆向遍历,逆向遍历的指针从0索引开始,这个时候向后遍历便没有要遍历的元素

    @Test
    public void fun6(){
     List<String>list=new ArrayList<>();

     list.add("hello");
     list.add("world");
     list.add("javeEE");

     //通过list集合的listItrator()方法得到
     ListIterator<String> lit=list.listIterator();
        System.out.println("正向遍历:");
     while(lit.hasNext()){
         String s=lit.next();
         System.out.print(s+"\t");//hello	world	javeEE
     }
        System.out.println();
        System.out.println("逆向遍历:");//一般很少运用
        while(lit.hasPrevious()){
            String s=lit.previous();
            //要是没有正向遍历直接逆向遍历,指针在0的位置,向上找没有元素,所以出打印空
            System.out.print(s+"\t");//javeEE	world	hello
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

④. 什么是ArrayList

• ①. ArrayList:在所有E的地方我们使用引用数据类型替换即可(举例:ArrayList、ArrayList)

• ②. 可调节大小的数组实现,< E >: 是一种特殊的数据类型,范型

• ③. ArrayList构造和增删改查

1. public ArrayList():创建一个空的集合对象
2. public boolean add(E e):将指定的元素追加到此集合的末尾
3. public void add(int index , E element):在此集合中指定位置插入指定的元素
4. public boolean remove(Objec o):删除指定的元素,返回删除是否成功[重写了equals方法]
5. public E remove(int index):删除指定索引处的元素,返回被删除的元素[ <> 返回的是什么,E就是什么类型]
6. public E set(int index , E element) :修改指定索引处的元素,返回被修改的元素
7. public E get(int index):返回指定索引处的元素
8. public int size() :返回集合中的元素的个数

		//ArrayList array=new ArrayList<>();
		ArrayList<String> array = new ArrayList<String>();
		//public boolean add(E e)
		array.add("AAA");
		array.add("BBB");
		array.add("CCC");
		//public void add(int index,E element)
		array.add(0,"BeforeAAA");
		System.out.println(array);
1
2
3
4
5
6
7
8
9

• ④. 遍历集合

    @Test
    public void fun8(){
        List<String>list=new ArrayList<>();

        list.add("hello");
        list.add("world");
        list.add("xiaozhi");

        //遍历集合的通用格式
        //E get(int i)
        for(int i=0;i<list.size();i++){
            String s=list.get(i);
            System.out.print(s+"\t");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

⑤. List三个子类对比

• ①. ArrayList

1. 底层数据结构是数组,查询快,增删慢
2. 线程不安全,效率高
   

• ②. Vector

1. 底层数据结构是数组,查询快,增删慢
2. 线程安全,效率低

• ③. LinkedList

1. 底层数据结构是链表,查询慢,增删快
2. 查修慢的原因是:链表的底层会从两端往中间查询；增删快的原因是:只在一个链表中发生,增加和删除会断开两个地址值,然后指向要添加的元素
3. 线程不安全,效率高

• ④. 面试题目

1.Vector 和 ArrayList 的区别
Vector 是线程安全的,效率低
ArrayList 是现成不安全的,效率高
共同点:都是数组实现的,增删慢,改查快
2.ArrayList 和 LinkedList的区别
ArrayList 底层是数组结果,查询和修改快
linkedList 底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
1
2
3
4
5
6
7
8

• ⑤. List有三个儿子,我们到底使用谁呢？

1. 查询多用:ArrayList
2. 增删多用:LinkedList
3. 如果都多:ArrayList