欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

List集合方法实例演示

程序员文章站 2023-11-12 17:29:16
List概述List集合接口继承了Collection集合接口,此集合的元素是有序的,且允许重复。下面示例常用方法源码解释/****源码****/public interface List extends Collection { // Query Operations(查询操作) //返回此列表中的元素个数。如果此列表包含返回超过int最大值则返回最大值。 int size(); //如果此列表不包含任何元素则返...

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