Java List 常用整理

---

前言

本文主要对于Java中List的一些常用方法，以及开发过程中的一些小技巧的整理记录。

一、List

扩展Collection接口的接口，是一个有序的集合。

二、基本特性

• 允许添加重复的元素
• 可以添加null元素
• 索引下标从0开始
• 支持泛型

三、常用方法

• int size（）：获取列表中元素的数量
• boolean isEmpty（）：检查列表是否为空
• boolean contains（Object o）：如果此列表包含指定的元素，则返回true
• Iterator iterator（）：以适当的顺序返回此列表中元素的迭代器
• Object [] toArray（）：以适当的顺序返回包含此列表中所有元素的数组
• boolean add（E e）：将指定的元素追加到此列表的末尾 java.lang.UnsupportedOperationException（具体实现类操作e:ArrayList）
• boolean retainAll（Collection <？> c）: 两个集合的交集
• void clear（）：从列表中删除所有元素
• E get（int index）：返回列表中指定位置的元素
• E set（int index，E element）**：用指定的元素替换列表中指定位置的元素
• ListIterator listIterator（）：返回列表中元素的列表迭代器
• List subList（int fromIndex，int toIndex）：返回指定fromIndex（包含）和toIndex（不包括）之间的此列表部分数据
• addAll([index],Collection<? extends E> c) : 两个List合并
• replaceAll(UnaryOperator operator) ：对List的中每一个元素进行操作 一元运算
• list5.sort((a,b) -> a-b); //升序 || b-a降序

四、案例代码

package demo;

import java.util.*;
import java.util.function.Consumer;

/**
 * @program:
 * @description: List 常用方法
 *
 * Iterable
 *      Collection
 *          list
 *              CopyOnWriteArrayList
 *              LinkedList
 *              AbstractList
 *                  Vector
 *                      Stack
 *                  ArrayList
 *
 * @author: dingwen
 * @create: 2021/2/3 15:22
 **/
public class    ListDemo {
    public static void main(String[] args) {
       /*
       * 允许添加重复元素
       * 元素允许为null
       * 列表索引从0开始
       * 支持泛型
       * */
       String str = "t a l k i s c h e a p s h o w m e t h e c o d e";

       // String -> Array ->  List
       List<String> list1 = Arrays.asList(str.split(" "));
        System.out.println(list1);

        //集合中元素数量
        System.out.println(list1.size());

        //是=是否为空
        System.out.println(list1.isEmpty());

        //是否包含某一元素
        System.out.println(list1.contains("a"));


        //以适当的顺序返回包含此列表中所有元素的数组
        // list1.toArray();


        //一下操作必须是实现类
        list1 = new ArrayList<>(list1);
        list1.add("**");


        list1.add(6,"dingwen");
        //java.lang.UnsupportedOperationException

        //从此列表中删除指定元素的第一个匹配项
        System.out.println(list1.remove("t"));




        //求两个集合的交集
        List<String> list2 = new ArrayList<>();
        list2.add("dingwen");
        list2.add("t");
        list1.retainAll(list2);

        //删除所有的元素
		//list2.clear();

        // 以适当的顺序返回此列表中元素的迭代器
        Consumer<String> stringConsumer = System.out::print;

        //返回列表中元素的列表迭代器 迭代元素
        list2.listIterator(2).forEachRemaining(stringConsumer);
        System.out.println();
        list2.iterator().forEachRemaining(stringConsumer);

        //get set
        list2.set(1,"000");
        System.out.println(list2.get(1));

        // list1.iterator().forEachRemaining(stringConsumer);
        //返回指定fromIndex（包含）和toIndex（不包括）之间的此列表部分的视图
        list1.subList(1,1).iterator().forEachRemaining(stringConsumer);

        //两个List合并 可选择从何处开始合并
        list1.addAll(2,list2);


        List<Integer> list3= new ArrayList<>();
        list3.add(1);
        list3.add(2);
        list3.add(3);

        list3.replaceAll(num -> num * 100);

        //此处演示迭代器使用
        Iterator<Integer> iterator = list3.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


        //sort

        List<Integer> list5 = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            list5.add(random.nextInt(1000));
        }
        Consumer<Integer> integerConsumer = System.out::print;
        list5.iterator().forEachRemaining(integerConsumer);
        //升序
        list5.sort((a,b) -> a-b);
        //降序
        //list5.sort((a,b) -> b-a);
        list5.iterator().forEachRemaining(integerConsumer);
        System.out.println();
        list5.forEach(num -> System.out.print("  "+ num));
    }

}

五、浅拷贝 & 深拷贝

1.浅拷贝

List 本质是数组，以地址的形式进行存储。浅拷贝是改变地址的引用，这样就导致了改变内容时会相互受到影响。

public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        //浅拷贝方式1
        List<Integer> list2 = new ArrayList<>();
        list1.set(1,100);

        Consumer<Integer> consumer = list2::add;
        list1.forEach(consumer);

        Consumer<Integer> print = System.out::print;

        list2.forEach(print);

        //浅拷贝方式2
        List<Integer> list3 = new ArrayList<Integer>(list1);

        //浅拷贝方式3
        List<Integer> list4 = new ArrayList<>();
        list4.addAll(list1);

        //浅拷贝方式4
        System.arraycopy(list1,0,list2,0,list1.size());
    }

2.深拷贝

在赋值内容的时候同时创建新的地址指向当前的内容，操作之后互不影响，占用独立的内存空间。

• 使用序列化方法

public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {  
   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
   ObjectOutputStream out = new ObjectOutputStream(byteOut);  
   out.writeObject(src);  

   ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());  
   ObjectInputStream in = new ObjectInputStream(byteIn);  
   @SuppressWarnings("unchecked")  
   List<T> dest = (List<T>) in.readObject();  
   return dest;  
}  

• clone方法

public class Test implements Cloneable {   
   public String name[];   

   public Test(){   
       name=new String[2];   
   }   

   public Object clone() {   
       Test o = null;   
       try {   
           o = (Test) super.clone();   
       } catch (CloneNotSupportedException e) {   
           e.printStackTrace();   
       }   
       return o;   
   }   
}  
for(int i=0;i<n;i+=){
   copy.add((Test)src.get(i).clone());
}