《Java基础：List 各种遍历方式（3种）》

 一、想对你说

（1）之前一直有小伙伴让我总结下Java相关的知识点，这里我针对有一定Java基础的同学做了一个系列的总结，感兴趣的同学可以看看顶部的【Java专栏】希望对大家有所帮助。
（2）要是对您有所帮助的话，可以给 “大大大钢琴” 点个赞，这是我继续下去的动力，谢谢大家了！废话不多说了，直接上干货。

二、List类排序方式

（一）List类介绍

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组。

总结

（1）所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]
（2）所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]
（3）所有的List中可以有null元素，例如[ tom,null,1 ]
（4）基于Array的List（Vector，ArrayList）适合查询，而LinkedList 适合添加，删除操作

以下是list方法的使用、以及调用的方法定义

import java.util.*;

public class test_demo {
    public static void main(String[] args) throws Exception {
        System.out.println("开始：");
        String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";
        List<String> list = new ArrayList<String>();
        list.add(a); // 索引位置为 0
        list.add(repeat); // 索引位置为 1
        list.add(b); // 索引位置为 2
        list.add(repeat); // 索引位置为 3
        list.add(c); // 索引位置为 4
        list.add(repeat); // 索引位置为 5
        list.add(d); // 索引位置为 6
        System.out.println(list.indexOf(repeat));//开始第一个"Repeat"索引
        System.out.println(list.lastIndexOf(repeat));//结尾第一个"Repeat"索引
        System.out.println(list.indexOf(b));//开始第一个"b"索引
        System.out.println(list.lastIndexOf(b));//结尾第一个"b"索引
        System.out.println("结束！");
    }

    void testFunction(){
        List list = new ArrayList();
        list.add("test01");// 向列表的尾部追加指定的元素
        list.add(1, "test01");// 在列表的指定位置插入指定元素
        list.addAll(new ArrayList());// 追加指定 collection 中的所有元素到此列表的结尾
        list.clear(); // 从列表中移除所有元素
        list.contains("test");// 如果列表包含指定的元素,则返回true
        list.containsAll(new ArrayList()); // 如果列表包含指定 collection 的所有元素,则返回 true
        list.equals(new ArrayList());// 比较指定的对象与列表是否相等
        list.get(0); // 返回列表中指定位置的元素
        list.hashCode(); // 返回列表的哈希码值
        list.indexOf("lwc"); // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
        list.lastIndexOf("lwc"); // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
        list.isEmpty();  // 如果列表不包含元素,则返回 true
        list.remove(0); // 移除列表中指定位置的元素
        list.remove("lwc");  // 移除列表中出现的首个指定元素
        list.removeAll(new ArrayList()); // 从列表中移除指定 collection 中包含的所有元素
        list.set(0, "lp"); // 用指定元素替换列表中指定位置的元素
        list.size();  // 返回列表中的元素数
        list.subList(1, 2); // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
        list.toArray(); // 返回以正确顺序包含列表中的所有元素的数组
        list.toArray(new String[] { "a", "b" }); // 返回以正确顺序包含列表中所有元素的数组
    }
}

（二）List 声明（6种）

Java 中初始化 List 的五种方法
(1）构造 List 后使用 List.add 初始化
(2）使用 {{}} 双括号语法
(3）使用 Arrays.asList
(4）使用 Stream (JDK8)
(5）使用 Lists （JDK9）
(6）使用guava包的Lists(推荐使用)

import org.testng.collections.Lists;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class test_demo {
    public static void main(String[] args) {
        //Java 中初始化 List 的五种方法
        //(1）构造 List 后使用 List.add 初始化
        //(2）使用 {{}} 双括号语法
        //(3）使用 Arrays.asList
        //(4）使用 Stream (JDK8)
        //(5）使用 Lists （JDK9）
        //(6）使用guava包的Lists(推荐使用)

        //1、构造 List 后使用 List.add 初始化
        List<String> stringList1 = new LinkedList<>();
        stringList1.add("a");
        stringList1.add("b");
        System.out.println("方法1:" + stringList1);

        //2、使用 {{}} 双括号语法
        List<String> stringList2 = new LinkedList<String>(){{
            add("a");
            add("b");
        }};
        System.out.println("方法2:" + stringList2);

        //3、使用 Arrays.asList
        List<String> stringList3 = Arrays.asList("a", "b", "c");
        System.out.println("方法3:" + stringList3);
        //分步骤（先建数组，再存入list）
        int[] intArray = new int[]{1, 2, 3};
        Integer[] integerArray = new Integer[]{1, 2, 3};
        List<int[] > intArrayList = Arrays.asList(intArray);
        List<Integer> integerList = Arrays.asList(integerArray);
        List<Integer> integerList2 = Arrays.asList(1, 2, 3);

        //4、使用 Stream (JDK8)
        List<String> stringList4 = Stream.of("a", "b","c").collect(Collectors.toList());
        System.out.println("方法4:" + stringList4);

        //5、使用 Lists （JDK9）
        List<String> stringList5 = Lists.newArrayList("a", "b", "c");
        System.out.println("方法5:" + stringList5);

        //6、使用 guava包的Lists
        //使用方法同上，提出这种方法主要是很多项目还是java8，没法直接用java9的List。
        List<Integer> stringList6 = Lists.newArrayList(1, 2, 3);
        System.out.println("方法6:" + stringList6);
    }
}

（三）List 遍历（3种）

方法1：list集合遍历foreach

比Iterator 慢,这种循环方式还有其他限制, 不建议使用它。

方法2：list集合遍历for

内部不锁定, 效率最高, 但是当写多线程时要考虑并发操作的问题。

方法3：Iterator遍历循环

这种方式在循环执行过程中会进行数据锁定, 性能稍差, 同时,如果你想在寻欢过程中去掉某个元素,只能调用it.remove方法, 不能使用list.remove方法, 否则一定出现并发访问的错误.

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

public class test_demo {
    private static List<String> list = new ArrayList<String>();

    public static void main(String[] args) {
        //list的3种遍历方式：10万条数据性能测试
        test_demo mapTest = new test_demo();
        mapTest.initList(list);
        mapTest.foreach(list);
        mapTest.forlist(list);
        mapTest.iteratorList(list);
    }

    //list 集合中添加10万条数据
    public List initList(List<String> list) {
        int i = 0;
        int num = 6000000;
        for (i = 0; i < num; i++) {
            list.add("list" + i);
        }
        return list;
    }

    //方法1：list集合遍历foreach
    public void foreach(List<String> list) {
        long start = System.currentTimeMillis();
        for (String data : list) {
            String value = data;
        }
        long end = System.currentTimeMillis();
        long count = end - start;
        System.out.println("foreach 循环时间" + count);
    }

    //方法2：list集合遍历for
    public void forlist(List<String> list) {
        long start = System.currentTimeMillis();
        int i = 0;
        for (i = 0; i < list.size(); i++) {
            String value = list.get(i);
        }
        long end = System.currentTimeMillis();
        long count = end - start;
        System.out.println("for list.size() 遍历时间" + count);
    }

    //方法3：Iterator遍历循环
    public void iteratorList(List<String> list) {
        long start = System.currentTimeMillis();
        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            String value = it.next();
        }
        long end = System.currentTimeMillis();
        long count = end - start;
        System.out.println("iterator 遍历时间" + count);
    }
}