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中List集合及其实现类的方法详解
List集合_List接口介绍 特点 1).有序的: 2).可以存储重复元素: 3).可以通过索引访问: List<String> list = new ArrayList<>(); list.add("张无忌"); list.add("张三丰"); list.add("章子怡"); list.add("章子怡");//OK的,可以添加 for(String s : list){ System.out.
-
java中List接口与实现类介绍
目录 List接口介绍-ArrayList ArrayList源码结论 ArrayList源码分析 总结 List接口介绍-ArrayList 有序.可重复 线程不安全,因为没有synchronized修饰 ArrayList源码结论 ArrayList中维护了一个Object类型的数组elementData. transient Object[] elementData; // transient 表示该属性不会被序列化 当创建ArrayList对象时,如果使用的是无参构造器,则初始eleme
-
Java中的List接口实现类解析
目录 Java的List接口实现类 实现类ArrayList 实现类LinkedList 实现类Vector List三个实现类 Java的List接口实现类 实现类ArrayList ArrayList类相当于一个容量可变的动态数组,当超过了他的大小时,类集自动增加,当对象被删除后,数组就可以缩小. import java.util.*; public class ListDemo { public static void main(String args[]){ Collection c1
-
Java集合操作之List接口及其实现方法详解
在介绍List接口之前,我们先来看看 Collection 接口,因为Collection接口是 List / Set / Queue 接口的父接口,List / Set / Queue 的实现类中很多的操作方法其实还是调用Collection类定义的方法. 一.Collection接口 在Collection接口中,定义了如下的方法: 其中方法可以分为以下几类: 数据操作类方法:add/addAll/remove/removeAll/clear/retainAll/iterator 判断类方法
-
基于java集合中的一些易混淆的知识点(详解)
(一) collection和collections 这两者均位于java.util包下,不同的是: collection是一个集合接口,有ListSet等常见的子接口,是集合框架图的第一个节点,,提供了对集合对象进行基本操作的一系列方法. 常见的方法有: boolean add(E e) 往容器中添加元素:int size() 返回collection的元素数:boolean isEmpty() 判断此容器是否为空: boolean contains(Object o) 如果此collecti
-
java面向对象设计原则之接口隔离原则示例详解
目录 概念 实现 拓展 概念 小接口原则,即每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分.如下图所示定义了一个接口,包含了5个方法,实现类A用到了3个方法.实现类B用到了3个方法,类图如下: 类A没有方法4.方法5,却要实现它:类B没有方法2.方法3,但还是要实现这两个方法,不符合接口隔离原则.改造为将其拆分为三个接口,实现方式改为下图所示,符合接口隔离原则: 实现 面向对象机制中一个类可以实现多个接口,通过多重继承分离,通过接口多继承(实现)来实现客户的需求,代码更加清
-
Java操作Excel文件解析与读写方法详解
目录 一.概述 二.Apache POI 三.XSSF解析Excel文件 1.Workbook(Excel文件) 2.Sheet(工作簿) 3.Row(数据行) 4.Cell(单元格) 四.超大Excel文件读写 1.使用POI写入 2.使用EasyExcel 一.概述 在应用程序的开发过程中,经常需要使用 Excel 文件来进行数据的导入或导出.所以,在通过Java语言实现此 类需求的时候,往往会面临着Excel文件的解析(导入)或生成(导出). 在Java技术生态圈中,可以进行Excel文件
-
java中的抽象类和接口定义与用法详解
目录 一.抽象类 1.什么叫抽象类? 2.抽象类的特点: 3.成员特点: 二.接口 1.接口是什么? 2.接口的特点 3.接口的组成成员 4.类与抽象的关系: 5.抽象类与接口的区别: 一.抽象类 1.什么叫抽象类? 例如在生活中我们都把狗和猫归为动物着一类中,但当只说动物时,我们是不知道是猫还是狗还是其他的.所以动物就是所谓的抽象类,猫和狗则是具体的类了.因此在Java中,一个没有方法体的方法应该定义为抽象类,而类中有抽象方法,则必须为抽象类. 2.抽象类的特点: 抽象类与抽象方法必须用abs
-
java并发编程_线程池的使用方法(详解)
一.任务和执行策略之间的隐性耦合 Executor可以将任务的提交和任务的执行策略解耦 只有任务是同类型的且执行时间差别不大,才能发挥最大性能,否则,如将一些耗时长的任务和耗时短的任务放在一个线程池,除非线程池很大,否则会造成死锁等问题 1.线程饥饿死锁 类似于:将两个任务提交给一个单线程池,且两个任务之间相互依赖,一个任务等待另一个任务,则会发生死锁:表现为池不够 定义:某个任务必须等待池中其他任务的运行结果,有可能发生饥饿死锁 2.线程池大小 注意:线程池的大小还受其他的限制,如其他资源池:
-
Java语言中flush()函数作用及使用方法详解
最近在学习io流,发现每次都会出现flush()函数,查了一下其作用,起作用主要如下 //------–flush()的作用--------– 笼统且错误的回答: 缓冲区中的数据保存直到缓冲区满后才写出,也可以使用flush方法将缓冲区中的数据强制写出或使用close()方法关闭流,关闭流之前,缓冲输出流将缓冲区数据一次性写出.flash()和close()都使数据强制写出,所以两种结果是一样的,如果都不写的话,会发现不能成功写出 针对上述回答,给出了精准的回答 FileOutPutStream
-
default怎么修饰接口中的方法详解
一.default修饰接口中的方法 在实现HandlerInterceptor接口时,我发现不实现HandlerInterceptor接口的方法也不会报错 仔细想来,还是我对接口的理解不清晰. 打开源码发现HandlerInterceptor接口中的方法都是default 在以前的接口编写中,我总是省略权限修饰符,因为在接口中的方法中默认是public abstract. 那么再来对接口进行总结. 那么也就是说,实现类要覆盖接口中的抽象方法就能实例化,而HandlerInterceptor接口中
-
Java为实体类动态添加属性的方法详解
目录 添加依赖 代码 测试 可以给已有实体类动态的添加字段并返回新的实体对象,不影响原来的实体对象结构. 添加依赖 <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>commons
-
Java实现添加条形码到PDF表格的方法详解
目录 程序环境 代码示例 条码的应用已深入生活和工作的方方面面.在处理条码时,常需要和各种文档格式相结合.当需要在文档中插入.编辑或者删除条码时,可借助于一些专业的类库工具来实现.本文,以操作PDF文件为例,介绍如何在编辑表格时,向单元格中添加条形码. 程序环境 本次功能测试中,使用 Free Spire.PDF for Java. 实现功能的大致思路:生成条形码,将条形码保存为图片,然后在PDF中的表格单元格中插入条码图片. Spire.PDF for Java 中的Spire.Pdf.Bar