脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java集合List接口

Java集合操作之List接口及其实现方法详解

 更新时间：2020年04月23日 14:51:39   作者：陈树义  
这篇文章主要介绍了Java集合操作之List接口及其实现方法,详细分析了Java集合操作中List接口原理、功能、用法及操作注意事项,需要的朋友可以参考下

在介绍List接口之前，我们先来看看 Collection 接口，因为Collection接口是 List / Set / Queue 接口的父接口，List / Set / Queue 的实现类中很多的操作方法其实还是调用Collection类定义的方法。

一、Collection接口

在Collection接口中，定义了如下的方法：

其中方法可以分为以下几类：

数据操作类方法：add/addAll/remove/removeAll/clear/retainAll/iterator

判断类方法：contains/containsAll/equals/hashcode/isEmpty/size

所有继承 Collection 接口的集合都可以用 Collection 中的方法进行元素操作，而具体的集合类有根据其特性增加了一些其特有的方法。

1、数据操作类方法：add/addAll/remove/removeAll/clear/retainAll/iterator

Collection接口-数据操作类方法MARK

2、判断类方法：contains/containsAll/equals/hashcode/isEmpty/size

package com.chanshuyi.collection;

import java.util.ArrayList;
import java.util.Collection;

/**
 * Collection接口-判断类方法
 * contains/containsAll/equals/hashcode/isEmpty/size
 * @author Administrator
 *
 */
public class CollectionTest2 {

  public static void main(String[] args) {
    Collection<String> listCol = new ArrayList<String>();
    listCol.add("1"); 
    listCol.add("2");
    listCol.add("3");
    Collection<String> addCol = new ArrayList<String>();
    addCol.add("4");  
    addCol.add("5");
    addCol.add("6");
    
    //1.是否包含 contains()  //true
    System.out.println("listCol是否包含1：" + listCol.contains("1"));
    //2.是否包含集合中所有元素 containAlls() //false
    System.out.println("listCol是否包含addCol中所有元素：" + listCol.containsAll(addCol));  
    //3.listCol与addCol是否相等 equals()  //false
    System.out.println("listCol与addCol是否相等：" + listCol.equals(addCol));
    //4.listCol与addCol的哈希码是否相等 hashcode()  //78481,81460
    System.out.println("listCol与addCol的哈希码是否相等：" + listCol.hashCode() + "," + addCol.hashCode()); 
    //5.listCol是否为空 isEmpty()  //false
    System.out.println("listCol是否为空：" + listCol.isEmpty()); 
    //6.listCol的大小 size()  //3
    System.out.println("listCol大小：" + listCol.size()); 
    System.out.println("=====================================");
    
    addCol.clear();
    addCol.add("1");  
    addCol.add("2");
    addCol.add("3");
    //true
    System.out.println("listCol是否包含1：" + listCol.contains("1"));    
    //true
    System.out.println("listCol是否包含addCol中所有元素：" + listCol.containsAll(addCol));  
    //true
    System.out.println("listCol与addCol是否相等：" + listCol.equals(addCol)); 
    //78481,78481
    System.out.println("listCol与addCol的哈希码是否相等：" + listCol.hashCode() + "," + addCol.hashCode()); 
    //false
    System.out.println("listCol是否为空：" + listCol.isEmpty()); 
    //3
    System.out.println("listCol大小：" + listCol.size()); 
    System.out.println("=====================================");
  }
}

Collection接口-判断类方法

二、List接口

List接口在Collection接口的基础上拓展了一些方法，增加了一些自己独有的方法，主要是增加了这样的几类方法：

1、在 add / remove / addAll 中增加了 index 参数，使其可以在任意位置插入删除

add(int index, E element) / addAll(int index, E element)

可以在特定位置插入删除元素，而不只是插入集合末尾

remove(int index)　　

删除集合中特定下标的元素（removeAll() 是移除集合所有元素，暂时没有移除一个区间的元素的 API。但 ArrayList 类实现了，对应的方法是： removeRange(int fromIndex, int toIndex) ）

package com.chanshuyi.collection.list;

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

public class ListTest1 {

  public static void main(String[] args) {
    Collection<String> addCol = new ArrayList<String>();
    addCol.add("4");  
    addCol.add("5");
    addCol.add("6");
    
    List<String> strList = new ArrayList<String>();
    strList.add("1");
    strList.add("3");
    
    //1.在特定位置插入删除元素 add(int index, E element)
    strList.add(1, "2"); //在index前加而不是后
    printCol(strList);  //1 2 3 
    strList.remove(0);
    printCol(strList);  //2 3
    
    //2.在特定位置插入删除集合 addAll(int index, E element) 
    strList.addAll(addCol);
    printCol(strList);  //2 3 4 5 6 
    
    //3.删除集合中特定下标的元素 remove(int index)　　
    strList.remove(0);
    printCol(strList);  //3 4 5 6
        
    //4.获取（更新）特定位置上的元素 get(int index)
    System.out.println("第一个元素：" + strList.get(0));  //第一个元素：3
    strList.set(0, "1");  //5.设置特定位置元素的值 set(int index,Element e)
    printCol(strList);  //1 4 5 6
    
    //获取子集合
    List<String> subList = strList.subList(1, strList.size());
    printCol(subList);  //4 5 6
    
    //获取特定元素下标 indexOf()
    //5的下标是：2
    System.out.println("5的下标是：" + strList.indexOf("5"));
    //获取元素最后一次出现的下标 lastIndexOf()
    //5的下标是：2
    System.out.println("5的下标是：" + strList.lastIndexOf("5"));
    printCol(strList);  //1 4 5 6
    
    //获取一个ListIterator对象 listIterator()
    /*没有前一个值 本对象是：1
    前一个对象值：1 本对象是：4
    前一个对象值：4 本对象是：5
    前一个对象值：5 本对象是：6*/
    System.out.println("======================================");
    ListIterator<String> it = strList.listIterator();
    while(it.hasNext()){
      if(it.hasPrevious()){
        System.out.print("前一个对象值：" + it.previous());
        it.next();
      }else{
        System.out.print("没有前一个值");
      }
      System.out.print(" 本对象是：" + it.next() + "\n");
    }
    System.out.println("======================================");
    
    //获取一个ListIterator对象 listIterator(int index)
    /*
     * 前一个对象值：1 本对象是：4
        前一个对象值：4 本对象是：5
              前一个对象值：5 本对象是：6
     */
    it = strList.listIterator(1); //从第一个开始迭代遍历
    while(it.hasNext()){
      if(it.hasPrevious()){
        System.out.print("前一个对象值：" + it.previous());
        it.next();
      }else{
        System.out.print("没有前一个值");
      }
      System.out.print(" 本对象是：" + it.next() + "\n");
    }
  }
  
  public static <E> void printCol(Collection<E> col){
    Iterator<E> it = col.iterator();
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}

2、增加了获取元素以及设置元素值的方法

get(int index) / set(int index, E element)  　　　　

可以获取（设置）特定位置上的元素

package com.chanshuyi.collection.list;

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

public class ListTest2 {

  public static void main(String[] args) {
    Collection<String> addCol = new ArrayList<String>();
    addCol.add("4");  
    addCol.add("5");
    addCol.add("6");
    
    List<String> strList = new ArrayList<String>();
    strList.add("1");
    strList.add("3");
        
    //4.获取（更新）特定位置上的元素 get(int index)
    System.out.println("第一个元素：" + strList.get(0));  //第一个元素：3
    strList.set(0, "1");  //5.设置特定位置元素的值 set(int index,Element e)
    printCol(strList);  //1 4 5 6
  }
  public static <E> void printCol(Collection<E> col){
    Iterator<E> it = col.iterator();
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}

3、其他方法

  • subList(int fromIndex, int toIndex)　　获取子集合
  • indexOf(Object o) / lastIndexOf(Object o)　　获取特定元素下标
  • listIterator() / listIterator(int index)　　获取一个ListIterator对象（ListIterator对象具有比Iterator更强大的遍历集合功能。Iterator只能向后遍历，但ListIterator扩展了Iterator接口，不仅可以向后遍历也可以向前遍历）
package com.chanshuyi.collection.list;

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

public class ListTest3 {

  public static void main(String[] args) {
    Collection<String> addCol = new ArrayList<String>();
    addCol.add("4");  
    addCol.add("5");
    addCol.add("6");
    
    List<String> strList = new ArrayList<String>();
    strList.add("1");
    strList.add("3");
        
    //5.获取子集合
    List<String> subList = strList.subList(1, strList.size());
    printCol(subList);  //4 5 6
    
    //6.获取特定元素下标 indexOf()
    System.out.println("5的下标是：" + strList.indexOf("5")); //2
    //7.获取元素最后一次出现的下标 lastIndexOf()
    System.out.println("5的下标是：" + strList.lastIndexOf("5")); //2
    printCol(strList);  //1 4 5 6
    
    //8.获取一个ListIterator对象 listIterator()
    /*没有前一个值 本对象是：1
    前一个对象值：1 本对象是：4
    前一个对象值：4 本对象是：5
    前一个对象值：5 本对象是：6*/
    System.out.println("======================================");
    ListIterator<String> it = strList.listIterator();
    while(it.hasNext()){
      if(it.hasPrevious()){
        System.out.print("前一个对象值：" + it.previous());
        it.next();
      }else{
        System.out.print("没有前一个值");
      }
      System.out.print(" 本对象是：" + it.next() + "\n");
    }
    System.out.println("======================================");
    
    //9.获取一个ListIterator对象 listIterator(int index)
    /*
     * 前一个对象值：1 本对象是：4
        前一个对象值：4 本对象是：5
              前一个对象值：5 本对象是：6
     */
    it = strList.listIterator(1); //从第一个开始迭代遍历
    while(it.hasNext()){
      if(it.hasPrevious()){
        System.out.print("前一个对象值：" + it.previous());
        it.next();
      }else{
        System.out.print("没有前一个值");
      }
      System.out.print(" 本对象是：" + it.next() + "\n");
    }
  }
  public static <E> void printCol(Collection<E> col){
    Iterator<E> it = col.iterator();
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}

 三、ArrayList实现类

在ArayList实现类中，我们通常用Collection接口提供的add/addAll/remove/removeAll/iterator方法进行数据的增删改查：

package com.chanshuyi.collection.list;

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

public class ArrayListTest1 {

  public static void main(String[] args) {
    //增加
    ArrayList<String> listCol = new ArrayList<String>();
    listCol.add("1"); 
    listCol.add("2");
    listCol.add("3");
    //删除
    listCol.remove("1");
    //修改 List接口方法
    //迭代
    Iterator<String> it = listCol.iterator();  
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}

然而ArrayList实现类比起List接口，ArrayList实现类拥有了以下几个特有的方法：

  • clone()  复制一个集合实例
  • removeRange(int fromIndex, int toIndex)   移除指定范围内的元素
  • ensureCapacity(int minCapacity)   扩大集合大小，使其至少容纳minCpacity个元素
  • trimToSize()   缩小集合大小到其现在的大小
package com.chanshuyi.collection.list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * ArrayList 有序允许重复 非线程同步
 * @author Administrator
 */
public class ArrayListTest{

  public static void main(String[] args) {
    //增加
    ArrayList<String> nameList = new ArrayList<String>();
    nameList.add("Tom");
    nameList.add("Marry");
    nameList.add("Henry");
    nameList.add("Jensus");
    
    //1.复制集合
    @SuppressWarnings("unchecked")
    ArrayList<String> copyList = (ArrayList<String>) nameList.clone();  
    //Tom Marry Henry Jensus 
    printCol(nameList); 
    //Tom Marry Henry Jensus 
    printCol(copyList); 
    
    //2.扩大集合大小
    nameList.ensureCapacity(8);
    
    //3.缩小集合大小
    //集合大小：4
    System.out.println("集合大小：" + nameList.size());
    nameList.trimToSize();
    //集合大小：4
    System.out.println("集合大小：" + nameList.size());
  }
  
  public static <E> void printCol(Collection<E> col){
    Iterator<E> it = col.iterator(); 
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}
  • removeRange(int fromIndex, int toIndex) 方法是protected方法，只能在包内或子类中使用，因此如果要使用removeRange方法，只能用继承ArrayList类的方法构造一个类，然后用这个类去调用removeRange()方法，如：
package com.chanshuyi.collection.list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

@SuppressWarnings("serial")
public class ArrayListTest2<E> extends ArrayList<E> {

  public static void main(String[] args) {
    ArrayListTest2<String> list = new ArrayListTest2<String>();
    list.add("1");
    list.add("2");
    list.add("3");
    
    list.removeRange(1, 2);
    printCol(list);  //1 3
  }
  public static <E> void printCol(Collection<E> col){
    Iterator<E> it = col.iterator(); 
    while(it.hasNext()){
      System.out.print(it.next().toString() + " ");
    }
    System.out.println();
  }
}

四、LinkedList实现类

LinkedList同样实现了Collection和List接口，所以同样可以用这两个接口中的方法进行数据操作：

package com.chanshuyi.collection.list;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class LinkedListTest {

  public static void main(String[] args) {
    //增加
    List<String> linkedList = new LinkedList<String>();
    linkedList.add("one");
    linkedList.add("two");
    linkedList.add("three");
    linkedList.add("four");
    linkedList.add("five");
    linkedList.add(0, "Middle");
    
    //删除
    linkedList.remove(4);  
    linkedList.remove("five");
    
    //修改
    linkedList.set(1, "1");
    
    //查询
    System.out.println(linkedList.get(0));  //Middle
    
    //迭代1
    //Middle 1 two three
    for(String numStr : linkedList){
      System.out.print(numStr + " ");
    }
    System.out.println();
    
    //迭代2
    //Middle 1 two three
    Iterator<String> it = linkedList.iterator();
    while(it.hasNext()){
      System.out.print(it.next() + " ");
    }
  }
}

但其实LinkedList类也实现了DQueue接口，所以LinkedList也可以使用push/pop等方法进行堆栈结构的操作，但这不属于Collection和List的范围，因此我们将在Queue接口时进行介绍。

五、Vector实现类

Vector实现类与ArrayList实现类的区别就是Vector是线程安全的，而ArrayList是线程不安全的，因此Vector效率较低。因此在非多线程的情况下推荐用ArrayList，而在多线程环境下适合用Vector。

一般操作Vector时也是使用Collection接口和List接口提供的方法：

package com.chanshuyi.collection.list;

import java.util.Iterator;
import java.util.Vector;

public class VectorTest {

  public static void main(String[] args) {
    //增加 add()
    Vector<String> vector = new Vector<String>();
    vector.add("Tom");
    vector.add("Marry");
    vector.add("Jesus");
    vector.add("Json");
    
    //删除 remove()
    vector.remove(0);
    vector.remove("Marry");
    
    //修改
    vector.set(0, "JesusCopy");
    
    //查询 get()
    System.out.println(vector.get(0));
    
    //迭代1
    for(String name : vector){
      System.out.print(name + " ");
    }
    
    System.out.println();
    
    //迭代2
    Iterator<String> it = vector.iterator();
    while(it.hasNext()){
      System.out.print(it.next() + " ");
    }
  }
}

六、Stack实现类

Stack类是Vector类的子类，因此它也可以用Collection和List接口提供的add/remove等方法。

Stack类是堆栈结构的一个模拟，实现了自己独有的进栈、出栈等方法。

package com.chanshuyi.collection.list;

import java.util.Stack;

public class StackTest {

  public static void main(String[] args) {
    //入栈 push()
    Stack<String> stack = new Stack<String>();
    stack.push("1");
    stack.push("2");
    stack.push("3");
    
    //出栈 pop()
    stack.pop(); 
    
    //取得栈顶元素 peek()
    System.out.println(stack.peek());
    
    //通过堆栈是否为空来迭代 isEmpty()
    while(!stack.isEmpty()){
      System.out.print(stack.pop() + " ");
    }  
  }
}
您可能感兴趣的文章:

相关文章

  • 浅谈Java中对类的主动引用和被动引用

    浅谈Java中对类的主动引用和被动引用

    这篇文章主要介绍了浅谈Java中对类的主动引用和被动引用，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
    2018-02-02
  • java通过方向键控制小球移动的小游戏

    java通过方向键控制小球移动的小游戏

    这篇文章主要为大家详细介绍了java通过方向键控制小球移动的小游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-10-10
  • 解析java中的condition

    解析java中的condition

    Condition 将 Object 监视器方法(wait()、notify()和notifyAll()）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）
    2021-06-06
  • 深入理解Java遗传算法

    深入理解Java遗传算法

    这篇文章主要为大家详细介绍了Java遗传算法，本文对基因的编码采用二进制规则，分享了对Java遗传算法的理解，感兴趣的小伙伴们可以参考一下
    2016-02-02
  • springboot集成mybatisplus的详细步骤

    springboot集成mybatisplus的详细步骤

    MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生，这篇文章主要介绍了springboot四步集成mybatisplus,需要的朋友可以参考下
    2022-10-10
  • Java中如何快速构建项目脚手架的实现

    Java中如何快速构建项目脚手架的实现

    这篇文章主要介绍了Java中如何快速构建项目脚手架，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-05-05
  • SpringBoot+Logback实现一个简单的链路追踪功能

    SpringBoot+Logback实现一个简单的链路追踪功能

    Spring Boot默认使用LogBack日志系统，并且已经引入了相关的jar包，所以我们无需任何配置便可以使用LogBack打印日志。这篇文章主要介绍了SpringBoot+Logback实现一个简单的链路追踪功能,需要的朋友可以参考下
    2019-10-10
  • Java 使用Calendar计算时间的示例代码

    Java 使用Calendar计算时间的示例代码

    这篇文章主要介绍了Java 使用Calendar计算时间的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-10-10
  • Java连接MongoDB的常用方法详解

    Java连接MongoDB的常用方法详解

    这篇文章主要为大家详细介绍一下Java语言连接MongoDB的常用方法以及实现增删改查功能的示例代码，感兴趣的小伙伴可以跟随小编一起了解一下
    2022-07-07
  • 简单分析Java的求值策略原理

    简单分析Java的求值策略原理

    在本篇文章里小编给大家整理的是一篇关于简单分析Java的求值策略原理内容，有需要的朋友们可以学习下。
    2021-06-06

最新评论