Java：List中常见的方法和五种遍历方式

1.List集合的特点：

有序：存和取的元素顺序一致

有索引：可以通过索引操作元素

可重复：存储的元素可以重复

2.List集合的特有方法

Collection的方法List都继承了

List集合因为有索引，所以多了很多索引操作的方法

方法：

void add(int index,E element)----------->在此集合中的指定插入指定的元素

E remove(int index)----------->删除指定索引处的元素，返回被删除的元素

E set(int index,E element)----------->修改指定索引处的元素，返回被修改的元素

E get(int index)----------->返回指定索引处的元素

代码运行：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
    public static void main(String[] args) {
        //1.创建一个集合
        List<String> list=new ArrayList<>();
        //2.添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        System.out.println(list);//[aaa, bbb, ccc]
//        //在此集合的指定位置插入指定元素
//        //细节：原来索引上的元素会一次往后移
//        list.add(1,"qqq");//[aaa, qqq, bbb, ccc]
//        System.out.println(list);
//        //删除指定索引的元素，返回被删除的元素
//        String remove = list.remove(0);
//        System.out.println(remove);//aaa

        //set方法:返回被修改的元素
//        String result = list.set(0, "hhh");
//        System.out.println(result);//aaa
//        System.out.println(list);//[hhh, bbb, ccc]

        //get方法：
        String s = list.get(0);
        System.out.println(s);//aaa
    }
}

运行结果：

List删除元素的两种方法：

//1.直接删除元素
//2.通过索引进行删除

注意点：默认通过索引删除因为在调用方法时，如果方法出现了重载现象：优先调用实参跟形参类型一致的那个方法，如果想直接删除元素要手动装箱

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.List;

public class ListDemo2 {
    public static void main(String[] args) {
        //List系列集合中的两种删除的方法
        //1.直接删除元素
        //2.通过索引进行删除

        //1.创建集合并添加元素：
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //2.删除元素
        //list.remove(1);//[1, 3]
        //此时的1是删除1索引上的元素
        //因为在调用方法时，如果方法出现了重载现象：优先调用实参跟形参类型一致的那个方法

        //若要删除元素1：
        //需要手动装箱，手动把基本数据类型的1变成Integer类型
        Integer i=Integer.valueOf(1);
        list.remove(i);
        System.out.println(list);//[2, 3]
    }
}

运行结果：

 

3.List集合的遍历方式

（1）迭代器遍历

在遍历的过程中需要删除元素，使用迭代器

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo3 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
    }
}

运行结果：

 

（2）列表迭代器遍历

在遍历的过程中需要添加元素，使用列表迭代器

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Consumer;

public class ListDemo3 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");


        //列表迭代器：
        //获取一个列表迭代器的对象，里面的指针也是默认指向0索引
        //额外添加了一个方法：在遍历过程中可以添加元素
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()){
            String str = it.next();
            if("bbb".equals(str)){
                it.add("qqq");
            }
           
        }
        System.out.println(list);
    }
}

运行结果：

 

（3）增强for循环遍历

仅仅想遍历，用增强for或lambda表达式

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo3 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");


        //增强for的遍历方式
        //s就是一个第三方变量
        //在循环过程中依次表示集合中的每一个元素
        for (String s : list) {
            System.out.println(s);
        }
    }
}

运行结果：

 

（4）Lambda表达式遍历

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

public class ListDemo3 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");


        //lambda表达式
        //forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
        //并把每一个元素传递给下面的accept方法
        //accept方法的形参s 依次表示集合中的每一个元素
//        list.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        list.forEach( s -> System.out.println(s));
    }
}

运行结果：

 

（5）普通for循环（因为List集合存在索引）

如果在遍历时想操作索引，可以用普通for

代码演示：

package a04mylistdemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

public class ListDemo3 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

       //普通for
        for (int i = 0; i < list.size(); i++) {
            //i就是集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

运行结果：