Java-List集合

1.List类型的集合

1.1概述：Collection下的子接口：List

特点：

• 1、有序集合（也称为序列 ）。(有序指的是存储和取出的顺序一致)
• 2、，List通常允许重复的元素。且有下标

创建对象格式：List list = new ArrayList();

List继承了collection父类，但是除了父类的，它还有自己集合的特有方法：

List集合特有的功能：

• 该界面的用户可以精确控制列表中每个元素的插入位置。
  用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素因为List集合拥有下标索引的特点，所以根据这个下标索引衍生出了很多特有的方法

• 添加功能：++根据索引将元素插入指定位置++
  void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。

• 删除功能：++删除指定索引元素，并返回object=删除元素++
  Object remove(int index) 删除该列表中指定位置的元素（可选操作）。

• 获取功能；++根据索引找到，并返回Object= 查找的元素++
  Object get(int index) 返回此列表中指定位置的元素。

• 修改功能：++返回被修改的 object = 被修改元素++
  Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。

1.2遍历List集合的三种方式：

一：List集合特有迭代器：

    ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。

使用while循环根据listiterator.hasnext()判断是否为最后一个。根据listiterator.next()遍历；

list还可以反向遍历：前提是已经进行过正向遍历（因为集合中只有一个指针）然后使用hasprevious,进行判断；

二：增强for循环

三：通过size()和ger()方法

代码如下

1

package com.bigdat.java.day19;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
        Collection下的子接口：List
            1、有序集合（也称为序列 ）。(有序指的是存储和取出的顺序一致)
            2、与Collection不同，List通常允许重复的元素。
 */
public class ListDemo1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("java");
        list.add("hello");
        list.add("hadoop");
        list.add("look");
        list.add("hive");
        list.add("hive");
        list.add("hive");
        System.out.println(list);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            String s = (String) obj;
            System.out.println("元素为："+s+"长度为："+s.length());
        }
    }
}

2

import java.util.ArrayList;
import java.util.List;
/*
    List集合特有的功能：
        该界面的用户可以精确控制列表中每个元素的插入位置。
        用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素
        因为List集合拥有下标索引的特点，所以根据这个下标索引衍生出了很多特有的方法
    添加功能：
        void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。
    删除功能：
        Object remove(int index) 删除该列表中指定位置的元素（可选操作）。
    获取功能：
        Object get(int index) 返回此列表中指定位置的元素。
    修改功能：
        Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
    List集合特有迭代器：
        ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。
 */
public class ListDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //    添加功能：
        //        void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。
        list.add("武松");
        list.add("李逵");
        list.add("卢俊义");
        list.add("鲁智深");
        list.add("宋江");
        System.out.println(list);
        //在下标为 2 的位置插上字符串
        list.add(2,"扈三娘");
        System.out.println(list);
        // list.add(8,"时迁");//索引越界异常 IndexOutOfBoundsException
        System.out.println(list);
        System.out.println("=======================================");
        //删除功能：
        //Object remove(int index) 删除该列表中指定位置的元素（可选操作）。
        Object remove = list.remove(5);
        System.out.println(remove);//返回被移除的值
        System.out.println(list);
        // 获取功能：
        // Object get(int index) 返回此列表中指定位置的元素。
        Object o = list.get(3);//返回的是索引为3的值
        System.out.println(o);
        System.out.println(list);
        //修改功能：
        //Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
        Object b = list.set(3, "白虎堂");
        System.out.println(b);//返回的是被替换的值
        System.out.println(list);
    }
}

3

package com.bigdat.java.day19;
import com.sun.corba.se.impl.oa.poa.AOMEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*   List集合特有迭代器：
            ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。
  */
public class ListDemo3 {
     public static void main(String[] args) {
         List l = new ArrayList();
         l.add("娃哈哈");
         l.add("软绵绵");
         l.add("美羊羊");
         l.add("金灿灿");
         l.add("美滋滋");
         l.add("喜洋洋");
         ListIterator listIterator = l.listIterator();
         while (listIterator.hasNext()) {
             Object obj = listIterator.next();
             String s = (String) obj;
             System.out.println("名字为："+s+"的长度为："+s.length());
         }
         System.out.println("===============================================");
         //当指针指向最后一个时，调用 hasPrevious 方法可以反向遍历集合；
         while(listIterator.hasPrevious()){
             Object obj1 = listIterator.previous();
             String s1 = (String)obj1;
             System.out.println("名字为："+s1+"的长度为："+s1.length());
         }
     }
}

size（）和get（）方法：

package com.shujia.wyh.day19;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
### 通过List集合中的get()和size()方法来遍历我们的集合
 */
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();

        //向集合中添加元素
        list.add("hello");
        list.add("world");
        list.add("hello");
        list.add("java");
        list.add("hadoop");

        //遍历集合
        //方式1：迭代器遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            String s = (String) next;
            System.out.println(s + "字符串的长度为：" + s.length());
        }

        System.out.println("============================");
        //方式2：普通for循环遍历（暂时只针对List集合有效）
        for(int i=0;i<list.size();i++){
            Object o = list.get(i);
            String s = (String)o;
            System.out.println(s + "字符串的长度为：" + s.length());
        }
    }
}

## 并发修改异常问题：
==创建List集合并向集合中添加不同类型的元素
        需求：遍历集合，如果集合中存在字符串java,就往集合添加一个新的字符串"spark"==
>- 结果：        按照我们分析的思路去编写后发现，报错了ConcurrentModificationException，这是为什么呢？
        ConcurrentModificationException：并发修改异常
### 原因及解决办法：
**       分析原因：因为迭代器是依赖于集合而产生的，我们在做这道题的时候，按照思路获取该集合的迭代器对象
        然后去遍历迭代器，但是呢，你在遍历的过程中，还使用了集合本身的方法让集合中的元素发生了改变，但是集合改变了
        迭代器它并不知道元素已经发生修改，所以会报错。

        如何解决呢？
            1、迭代器遍历迭代器修改
            2、集合遍历集合修改**
            
##### 通过查找API发现list 集合有特有的 迭代器 listiterator  其中有add() 方法

    //通过查找API发现list 集合有特有的 迭代器 listiterator  其中有add() 方法
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        String s = (String)listIterator.next();
        if("java".contains(s)){
            listIterator.add("spark");
        }
    }
            //listiterator 中有可以反向遍历的方法previousIndex()  返回由后续调用 previous()返回的元素的索引
    while (listIterator.hasPrevious()){
        String s1 = (String)listIterator.previous();
        System.out.println(s1+" 的长度为："+s1.length());
    }

##### 二：通过for循环添加

    System.out.println("=============================================");
    //第二种方法：for循环遍历 for循环修改
    for (int i = 0; i < list.size(); i++) {
        String s2 = (String)list.get(i);
        if("java".contains(s2)){
            list.add("spark");
        }
    }
    System.out.println(list);

}