List集合方法实例演示

List

概述

List集合接口继承了Collection集合接口，此集合的元素是有序的，且允许重复。

下面示例常用方法

源码解释

/*
	***源码***
*/

public interface List<E> extends Collection<E> {
    // Query Operations（查询操作）

   	//返回此列表中的元素个数。如果此列表包含返回超过int最大值则返回最大值。
    int size();
    
	//如果此列表不包含任何元素则返回true，否则false
    boolean isEmpty();

    //如果此列表包含参数指定的元素则返回true 否则false
    boolean contains(Object o);

  	//以正确的顺序返回此列表中元素的迭代器
    Iterator<E> iterator();

    // 将集合转换为数组，返回为Object数组类型
    Object[] toArray();

    //根据一个数组内容来匹配集合的内容，如果两者内容不一致则按照集合内容输出
    <T> T[] toArray(T[] a);

    /* Modification Operations（修改操作） */

    //将指定元素添加到集合的末尾
    boolean add(E e);

    //根据对象类型移除指定的元素，返回值为布尔类型
    boolean remove(Object o);

    // Bulk Modification Operations

	//如果此列表包含新集合的所有元素，则返回 true 否则false
    boolean containsAll(Collection<?> c);

   	//将其它集合内容批量添加到此集合内
    boolean addAll(Collection<? extends E> c);

   	//在指定位置插入新集合的元素（可选操作）
    boolean addAll(int index, Collection<? extends E> c);

    //根据新集合内的参数批量移除老集合元素
    boolean removeAll(Collection<?> c);

    //仅在列表中保留指定 collection 中所包含的元素，取得两个集合的交集,输出打印相同的数值,如果有相同的值则返回false，否则true
    boolean retainAll(Collection<?> c);

	//用函数接口的返回结果替代原集合中的值.
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
    
    // 对集合进行排序操作
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    //删除此列表中的所有元素（可选操作）。此调用返回后，该列表将为空。
    void clear();

    // Comparison and hashing（比较和哈希）
    
  	//将指定的对象与集合进行相等性比较。
    boolean equals(Object o);

    //打印返回此集合的哈希值
    int hashCode();

    //根据数字索引获取指定的集合元素
    E get(int index);

    //set:将此列表中指定位置的元素替换为指定元素（可选操作）。
    E set(int index, E element);

    //在此列表中的指定位置插入指定元素
    void add(int index, E element);

    //根据数字索引编号移除集合指定元素
    E remove(int index);

    // Search Operations （搜索操作）

   	//根据参数指定元素返回集合元素的索引编号，如果此列表不包含元素，则返回 -1
    int indexOf(Object o);

    //返回指定元素最后一次发生的索引在此列表中，如果此列表不包含元素则返回 -1
    int lastIndexOf(Object o);

    // List Iterators（集合迭代器）

    //返回一个列表迭代器，可用于遍历集合内容
    ListIterator<E> listIterator();

    //返回一个列表迭代器，并指定集合元素的位置
    ListIterator<E> listIterator(int index);

    // View（视图）

    //获取该集合指定区间的元素
    List<E> subList(int fromIndex, int toIndex);

   //用于分割和遍历集合
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

这里使用的是maven，创建maven项目并导入junit测试编写

<!-- junit测试依赖 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
</dependency>

代码示例

size

	@Test
    public void size(){
        //size:返回此列表中的元素个数
        ArrayList<Object> list = new ArrayList<Object>();
        System.out.println(list.size()); //没有数据则结果为0
        list.add("Hello,World"); //添加一个数据
        System.out.println(list.size()); //打印结果为1
    }
   

isEmpty

@Test
public void isEmpty(){
    //isEmpty:判断集合是否为空
    List<Object> list = new ArrayList<Object>();
    System.out.println(list.isEmpty()); //没有数据则返回true
    list.add("Hello,Bear");
    System.out.println(list.isEmpty()); //有数据则返回false
}

contains

@Test
public void contains() {
    //contains:判断是否包含指定的字符串，存在为true，不存在为false
    List<Object> list = new ArrayList<Object>();
    System.out.println(list.contains("bear"));//不包含此字符串，为false
    list.add("cat");
    System.out.println(list.contains("cat")); //包含此字符串，为true
}

iterator

@Test
public void iterator() {
    //iterator:返回一个迭代器接口，可用于遍历集合
    List<Object> list = new ArrayList<Object>();
    list.add(1);   
    list.add(2);   
    list.add(3); //往集合添加值
    Iterator<Object> iterator = list.iterator();
    while (iterator.hasNext()) { //使用迭代器接口遍历集合
        Object next = iterator.next();
        System.out.println(next);//打印结果为1，2，3
    }
    System.out.println(list); 
}

toArray

@Test
public void toArray() {
    //toArray: 将集合转换为数组类型
    List<Object> list = new ArrayList<Object>();
    list.add(18); 
    list.add(19); //添加值
    Object[] objects = list.toArray();
    System.out.println(objects[0]); //打印数组第一号元素
    
    for (Object object : objects) { //使用增强for循环遍历数组内容
        System.out.println(object);
    }
}

toArray(有参)

@Test
public void toArrayArgs() {
    //toArray(有参):根据数组内容匹配集合参数,打印结果按照集合元素输出
    List<Object> list = new ArrayList<Object>();
    list.add(1); list.add(2);
    Object[] objects = list.toArray(new Object[]{1,2,3}); //创建一个object数组作为条件匹配
    for (Object object : objects) {
        System.out.println(object); //第三个值会输出null
    }
}

add

@Test
public void add() {
    //add:往集合里添加数据
    List<Object> list = new ArrayList<Object>();
    list.add("向集合中添加内容");
    list.add("向集合中添加内容");
    System.out.println(list); //打印集合内容
}

remove

@Test
public void remove() {
    //remove: 移除集合指定元素
    List<Object> list = new ArrayList<Object>();
    list.add("bear");
    boolean a = list.remove("bear"); //移除集合里的字段bear
    System.out.println(a); //打印为true
}

containsAll

@Test
public void containsAll() {
    //containsAll: 根据其它集合的内容作为筛选条件，返回值为布尔类型
    List<Object> list = new ArrayList<Object>();
    list.add(123);
    Collection<Object> collection = new ArrayList<Object>(); //创建一个新集合
    collection.add(123); //添加筛选条件
    boolean containsAll = list.containsAll(collection); //参数为新集合的筛选条件
    System.out.println(containsAll);//两个集合都有相同的元素，打印为true
}

addAll(collection参数)

@Test
public void addAll() {
    //addAll：根据其它集合批量添加数据
    List<Object> list = new ArrayList<Object>();
    list.add("老集合元素");
    Collection<Object> collection = new ArrayList<Object>(); //创建一个新集合
    collection.add("新集合元素");
    
    boolean addAll = list.addAll(collection); //调用addAll方法
    System.out.println(addAll); //打印为true
    System.out.println(list); //打印结果包含新集合的内容
}

addAll(有参)

@Test
public void addAllTwo() {
    //addAll(有参):根据其它集合参数在指定位置添加数据
    List<Object> list = new ArrayList<Object>();
    list.add("老集合元素");
    Collection<Object> collection = new ArrayList<Object>(); //创建一个新集合
    collection.add("新集合元素");
    System.out.println(list.addAll(0,collection)); //在0号元素位置插入新集合的内容
    System.out.println(list); //打印集合结果
}

removeAll

@Test
public void removeAll() {
    //removeAll:根据其它集合元素批量删除
    List<Object> list = new ArrayList<Object>();
    list.add(1);
    Collection<Object> collection = new ArrayList<Object>(); //创建一个新集合
    collection.add(1); //添加移除的内容
    boolean removeAll = list.removeAll(collection); //放入集合参数
    System.out.println(removeAll); //移除了旧集合元素为1的内容，打印为true
}

retainAll

@Test
public void retainAll() {
    //retainAll: 匹配其它集合元素，输出不相同的值，如果相同返回false，否则true
    List<Object> list = new ArrayList<Object>();
    list.add("保留的内容");
    Collection<Object> collection = new ArrayList<Object>(); //创建一个新集合
    collection.add("保留的内容");
    
    boolean retainAll = list.retainAll(collection); //取得两个集合的交集,输出打印相同的数值
    System.out.println(retainAll); //有相同的值打印为false，没有则为true
    
    System.out.println(list); //打印集合内容
}

replaceAll

@Test
public void replaceAll() {
    //replaceAll: 返回一个UnaryOperator接口，可用于计算数据
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    //使用lambda表达式写法将元素数值+1
    list.replaceAll(t -> t + 1); //集合中每个值都+1
    list.forEach(System.out :: println);//结果显示为：2、3、4
}

sort

@Test
public void sort() {
    //sort: 返回一个Comparator接口，可用于排序
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.sort((o1, o2) -> o2-o1); //使用lambda表达式写法，使集合倒序排列
    for (Integer sort : list) {
        System.out.println(sort);//遍历集合结果
    }
}

clear

@Test
public void clear() {
    //clear: 清除集合内的所有内容
    List<String> list = new ArrayList<>();
    list.add("hello");
    System.out.println(list);//可以获取集合元素
    list.clear();
    System.out.println(list);//上面使用了clear方法，所以访问不到集合的元素
}

equals

@Test
public void equals() {
    //equals: 比较两个对象的哈希值是否相等
    List<String> list = new ArrayList<>();
    list.add("this is a Collection");
    
    boolean equals = list.equals(list); //和自己比较
    System.out.println(equals);//打印为true
    
    String str = "hello"; 
    System.out.println(list.equals(str)); //和字符串比较不是同一个对象，打印为false
}

HashCode

@Test
public void HashCode(){
    //hashCode:打印返回此集合的哈希值
    List<String> list = new ArrayList<>();
    int hashCode = list.hashCode();
    System.out.println(hashCode);
}

get

@Test
public void get() {
    //get: 根据数字索引获取集合的数据
    List<String> list = new ArrayList<>();
    list.add("Hello,World");
    list.add("Hello,China");
    String get = list.get(0); //获取对应Hello,World值
    String get2 = list.get(1); //获取对应Hello,China值
    System.out.println(get);
    System.out.println(get2); //打印结果
}

set

@Test
public void set() {
    //set:将此列表中指定位置的元素替换为指定元素（可选操作）。
    List<String> list = new ArrayList<>();
    list.add("This is a set method");
    System.out.println(list); //打印原始数据
    
    list.set(0, "This is not set method"); //使用set方法替换0号索引数据
    System.out.println(list);
}

add(有参)

@Test
public void addArgs() {
   //addArgs: 在此列表中的指定位置插入指定元素
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add(0,"hello"); //在0号索引位置插入hello字段
    System.out.println(list);
}

remove(有参)

@Test
public void removeInt() {
    //remove: 根据索引编号移除集合指定位置的元素
    List<String> list = new ArrayList<>();
    list.add("This is a remove method");
    String remove = list.remove(0); //移除集合第0号元素
    System.out.println(remove); //打印被移除的元素
    System.out.println(list); //此时打印集合为空
}

indexOf

@Test
public void indexOf() {
    //indexOf:根据参数指定元素返回集合元素的索引编号
    List<String> list = new ArrayList<>();
    list.add("This is a indexOf method");
    int i = list.indexOf("This is a indexOf method"); //设置指定参数
    System.out.println(i); //返回该元素的索引位置，打印为0号
}

lastIndexOf

//此方法和indexOf雷同
@Test
public void lastIndexOf() {
    //lastIndexOf:返回指定元素最后一次发生的索引在此列表中，如果此列表不包含元素，则为 -1
    List<String> list = new ArrayList<>();
    list.add("This is a lastIndexOf method");
    int lastIndexOf = list.lastIndexOf("This is a lastIndexOf method");
    System.out.println(lastIndexOf);
}

listIterator(无参)

@Test
public void listIteratorNoArgs() {
    //返回一个列表迭代器，可用于遍历集合内容
    List<String> list = new ArrayList<>();
    list.add("This is a listIterator method");
    
    ListIterator<String> listIterator = list.listIterator();
    while (listIterator.hasNext()) { //如果有元素
        String next = listIterator.next(); //遍历这个集合
        System.out.println(next);
    }
}

listIterator(有参)方法

@Test
public void listIteratorArgs() {
    //返回一个列表迭代器，并指定集合元素的位置
    List<String> list = new ArrayList<>();
    list.add("This is a listIterator(int index) method");
    
    ListIterator<String> listIterator = list.listIterator(0); //参数是集合第0号元素,如果没有元素遍历则为空
    while (listIterator.hasNext()) { //使用迭代器遍历集合
        String next = listIterator.next();
        System.out.println(next);
    }

subList

@Test
public void subList() {
    //subList:返回此集合在指定区间位置的元素
    List<String> list = new ArrayList<>();
    list.add("-------------------------");
    list.add("This is a subList method");
    list.add("This is a list Collection");
    list.add("-------------------------");
    List<String> subList = list.subList(1, 3); //获取1-3号索引区间的值
    System.out.println(subList);
}

spliterator

@Test
public void spliterator() {
    //spliterator:用于分割和遍历集合
    List<String> list = new ArrayList<>();
    list.add("This is a spliterator method");
    Spliterator<String> spliterator = list.spliterator();
    spliterator.forEachRemaining(System.out :: println); //调用Spliterator接口的方法遍历集合数据
}

本文地址：https://blog.csdn.net/weixin_44863459/article/details/107092945