day15Java-常用对象Collection-List集合

常用对象Collection-List集合

博客名称	链接
day16Java-常用对象总结	https://blog.csdn.net/qq_40332952/article/details/104805557

集合继承的体系图解

List集合特点
有序(存储和取出的元素一致)，可重复的。

public class ListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		List list = new ArrayList();

		// 存储元素
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("javaee");
		list.add("android");
		list.add("javaee");
		list.add("android");

		// 遍历集合
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
	}
}

结果:

hello
world
java
javaee
android
javaee
android

List:(面试题List的子类特点)
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

List有三个儿子，我们到底使用谁呢?
	看需求(情况)。
	
要安全吗?
	要：Vector(即使要安全，也不用这个了，后面有替代的)
	不要：ArrayList或者LinkedList
		查询多：ArrayList
		增删多：LinkedList
如果你什么都不懂，就用ArrayList。

List集合-List集合的特有成员方法

A:添加功能
void add(int index,Object element):在指定位置添加元素1
B:获取功能
Object get(int index):获取指定位置的元素1
C:列表迭代器
ListIterator listIterator()：List集合特有的迭代器2
该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
D:删除功能
Object remove(int index)：根据索引删除元素,返回被删除的元素1
E:修改功能
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素1
F:特有功能：
Object previous():获取上一个元素2
boolean hasPrevious():判断是否有元素2

代码演示1
void add(int index,Object element):在指定位置添加元素1
Object get(int index):获取指定位置的元素1
Object remove(int index)：根据索引删除元素,返回被删1除的元素1
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素1

public class CollectionDemo5 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

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

        //void add(int index,Object element):在指定位置添加元素
        list.add(1,"android");//没有问题
        list.add(3,"last");//没有问题
        //list.add(6,"hiahia");//有问题:IndexOutOfBoundsException
        System.out.println("list--"+list);

        System.out.println("---------------------------");
        // 创建集合对象
        List list2 = new ArrayList();

        list2.add("hello");
        list2.add("world");
        list2.add("java");
        //Object get(int index):获取指定位置的元素
        System.out.println("list2.get(0)--"+list2.get(0)); //没问题
        //System.out.println("list2.get(11)--"+list2.get(11));//有问题:IndexOutOfBoundsException
        System.out.println("list2--"+list2);


        System.out.println("---------------------------");
        // 创建集合对象
        List list3 = new ArrayList();

        list3.add("hello");
        list3.add("world");
        list3.add("java");
        //Object remove(int index)：根据索引删除元素,返回被删除的元素
        System.out.println("list3.remove(1)--"+list3.remove(1));//没问题
        //System.out.println("list3.remove(1)--"+list3.remove(10));//有问题:IndexOutOfBoundsException
        System.out.println("list3--"+list3);
        
        System.out.println("---------------------------");
        // 创建集合对象
        List list4 = new ArrayList();

        list4.add("hello");
        list4.add("world");
        list4.add("java");
        //Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
        System.out.println("list4.set(2,javaee)--"+list4.set(2,"javaee"));
        System.out.println("list4--"+list4);
    }
}

结果

list--[hello, android, world, last, java]
---------------------------
list2.get(0)--hello
list2--[hello, world, java]
---------------------------
list3.remove(1)--world
list3--[hello, java]
---------------------------
list4.set(2,javaee)--java
list4--[hello, world, javaee]

代码演示2
ListIterator listIterator()：List集合特有的迭代器2
该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
Object previous():获取上一个元素2
boolean hasPrevious():判断是否有元素2
注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

public class CollectionDemo6 {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        //正向遍历
        //ListIterator listIterator()：List集合特有的迭代器2
        ListIterator listIterator = list.listIterator();//继承了Iterator
        while (listIterator.hasNext()) {
            String s = (String) listIterator.next();
            System.out.println(s);
        }
        //String previous = (String) listIterator.previous();
        //System.out.println(previous);//java
        System.out.println("---------------------------------");
        //方向遍历(只有先正向遍历才能反向遍历)
        //Object previous():获取上一个元素2
        //boolean hasPrevious():判断是否有元素2
        while (listIterator.hasPrevious()) {
            String s = (String) listIterator.previous();
            System.out.println(s);
        }
        
       /* Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
            System.out.println(s);
        }*/
    }
}

结果:

hello
world
java
---------------------------------
java
world
hello

List集合的特有遍历功能

代码演示1
size()和get()方法结合使用

public class CollectionDemo6 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        //将字符串添加到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        
        //遍历集合
        for (int x = 0; x <list.size() ; x++) {
           String s = (String) list.get(x);
            System.out.println(s);
        }
    }
}

结果:

hello
world
java

代码演示2
存储自定义对象并遍历,用普通for循环。(size()和get()结合)
使用for循环和迭代器测试

public class CollectionDemo6 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        //将对象添加到集合中
        Student s1 = new Student("林黛玉", 18);
        Student s2 = new Student("刘姥姥", 88);
        Student s3 = new Student("王熙凤", 38);
        //将独享添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        Iterator iterator = list.iterator();
        //迭代器遍历
        while (iterator.hasNext()) {
            Student s = (Student) iterator.next();
            System.out.println(s.getName()+"----"+s.getAge());
        }
        System.out.println("----------------------");
        //for循环遍历集合
        for (int x = 0; x < list.size(); x++) {
            Student s = (Student) list.get(x);
            System.out.println(s.getName()+"----"+s.getAge());
        }
    }
}

结果:

林黛玉----18
刘姥姥----88
王熙凤----38
----------------------
林黛玉----18
刘姥姥----88
王熙凤----38

迭代器的并发修改异常

问题?
我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
产生的原因：
迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
如何解决呢?
A:迭代器迭代元素，迭代器修改元素
元素是跟在刚才迭代的元素后面的。
B:集合遍历元素，集合修改元素(普通for)
元素在最后添加的。

代码并发修改异常演示1

public class CollectionDemo6 {
    public static void main(String[] args) {
        //创建list集合
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //获取迭代器
        Iterator iterator = list.iterator();
        //遍历集合
        while (iterator.hasNext()){
          String s = (String) iterator.next();
            if(list.contains("world")){
                list.add("javaee");
            }
        }
    }
}

结果: 报错并发修改异常

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:939)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:893)
	at com.ginger.collectiondemo.CollectionDemo6.main(CollectionDemo6.java:25)

解决并发修改异常代码演示
A:迭代器迭代元素，迭代器修改元素
元素是跟在刚才迭代的元素后面的。
B:集合遍历元素，集合修改元素(普通for)
元素在最后添加的。

public class CollectionDemo6 {
    public static void main(String[] args) {
        //创建list集合
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //A:迭代器迭代元素，迭代器修改元素
        //而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            if("world".equals(s)){
                listIterator.add("javaee");
            }
        }
        System.out.println("list--"+list);//list--[hello, world, javaee, java]


        System.out.println("--------------------");
        //创建list集合
        List list2 = new ArrayList();
        //添加元素
        list2.add("hello");
        list2.add("world");
        list2.add("java");

        //B:集合遍历元素，集合修改元素(普通for)
        for (int x = 0; x <list2.size() ; x++) {
            String s = (String) list2.get(x);
            if("world".equals(s)){
                list2.add("javaee");
            }
        }
        System.out.println("list2--"+list2);//list2--[hello, world, java, javaee]
    }
}

结果:
注意:
A:迭代器迭代元素，迭代器修改元素
元素是跟在刚才迭代的元素后面的,从结果可以看出来。
B:集合遍历元素，集合修改元素(普通for)
元素在最后添加的。

list--[hello, world, javaee, java]
--------------------
list2--[hello, world, java, javaee]