ArrayList与LinkedList

最新推荐文章于 2025-06-03 15:09:44 发布

原创最新推荐文章于 2025-06-03 15:09:44 发布 · 126 阅读

0 ·

CC 4.0 BY-SA版权

JavaSE 专栏收录该内容

34 篇文章

订阅专栏

本文探讨了ArrayList和LinkedList两种Java集合实现的区别。ArrayList基于数组，适合快速随机访问但删除或插入操作效率较低，而LinkedList采用链表结构，插入和删除效率高但访问效率低。文中还详细介绍了如何去除ArrayList中的重复元素，并提到了LinkedList在实现栈和队列数据结构中的优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、ArrayList

ArrayList实现了List接口,它是以数组的方式来实现的,数组的特性是可以使用索引的方式来快速定位对象的位置,因此对于快速的随机取得对象的需求,使用ArrayList实现执行效率上会比较好.

1.去除ArrayList中重复字符串元素方式

需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路：创建新集合方式

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

@SuppressWarnings({ "rawtypes", "unchecked" })
//上述注解是javase提供的注解。作用是屏蔽一些无关紧要的警告
//使开发者能看到一些他们真正关心的警告。从而提高开发者的效率
public class Demo1_ArrayList {
public static void main(String[] args) {
	ArrayList list = new ArrayList();
	list.add("a");
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("c");
	list.add("c");
	list.add("c");
	
	ArrayList newList = getSingle(list);
	System.out.println(newList);
}

/*
 * 创建新集合将重复元素去掉
 * 1,明确返回值类型,返回ArrayList
 * 2,明确参数列表ArrayList
 * 
 * 分析:
 * 1,创建新集合
 * 2,根据传入的集合(老集合)获取迭代器
 * 3,遍历老集合
 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
 */
public static ArrayList getSingle(ArrayList list) {
	//1,创建新集合
	ArrayList newList = new ArrayList<>();					
	//2,根据传入的集合(老集合)获取迭代器
	Iterator it = list.iterator();							
	//3,遍历老集合
	while(it.hasNext()) {		
	//记录住每一个元素							
		Object obj = it.next();	
		//如果新集合中不包含老集合中的元素							
		if(!newList.contains(obj)) {	
		//将该元素添加					
			newList.add(obj);								
		}
	}	
	return newList;
}
}

2.去除ArrayList中重复自定义对象元素

A:案例演示
- 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
- 重写equals()方法的
  contains方法判断是否包含,底层依赖的是equals方法
  remove方法判断是否删除,底层依赖的是equals方法

import java.util.ArrayList;
import java.util.Iterator;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_ArrayList {
public static void main(String[] args) {
   //创建集合对象
	ArrayList list = new ArrayList();				
	list.add(new Person("张三", 23));
	list.add(new Person("张三", 23));
	list.add(new Person("李四", 24));
	list.add(new Person("李四", 24));
	list.add(new Person("李四", 24));
	list.add(new Person("李四", 24));
	//调用方法去除重复
	//ArrayList newList = getSingle(list);			
	//System.out.println(newList);
	list.remove(new Person("张三", 23));
	System.out.println(list);
}

/*
 * 创建新集合将重复元素去掉
 * 1,明确返回值类型,返回ArrayList
 * 2,明确参数列表ArrayList
 * 
 * 分析:
 * 1,创建新集合
 * 2,根据传入的集合(老集合)获取迭代器
 * 3,遍历老集合
 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
 */
public static ArrayList getSingle(ArrayList list) {
	ArrayList newList = new ArrayList<>();	//1,创建新集合				
	Iterator it = list.iterator();	//2,根据传入的集合(老集合)获取迭代器						
	
	while(it.hasNext()) {		//3,遍历老集合							
		Object obj = it.next();		//记录住每一个元素						
		if(!newList.contains(obj)) { //如果新集合中不包含老集合中的元素				
			newList.add(obj);	//将该元素添加							
		}
	}	
	return newList;
}
}

二、LinkedList

LinkedList是采用链表的方式来实现List接口的,它本身有自己特定的方法，如: addFirst(),addLast(),getFirst(),removeFirst()等. 由于是采用链表实现的,因此在进行insert和remove动作时在效率上要比ArrayList要好得多!适合用来实现Stack(堆栈)与Queue(队列),前者先进后出，后者是先进先出.
Linkedlist基于链表的动态数组，数据添加删除效率高，只需要改变指针指向即可，但是访问数据的平均效率低，需要对链表进行遍历。

3.LinkedList的特有功能

public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
public E get(int index)

import java.util.LinkedList;
public class Demo3_LinkedList {
public static void main(String[] args) {
	LinkedList list = new LinkedList();
	list.addFirst("a");
	list.addFirst("b");
	list.addFirst("c");
	list.addFirst("d");
	list.addLast("e");
	
	//System.out.println(list.getFirst());
	//System.out.println(list.getLast());
	//System.out.println(list.removeFirst());
	//System.out.println(list.removeLast());
	
	System.out.println(list.get(1));
	System.out.println(list);
}
}

4.栈和队列数据结构

栈
- 先进后出
队列
- 先进先出

5.用LinkedList模拟栈结构

import java.util.LinkedList;
public class Demo4_LinkedList {

public static void main(String[] args) {
	//demo1();
	Stack s = new Stack();
	//进栈
	s.in("a");	
	s.in("b");
	s.in("c");
	s.in("d");
	//判断栈结构是否为空
	while(!s.isEmpty()) {	
	  //弹栈				
	System.out.println(s.out());		
	}
}

public static void demo1() {
   //创建集合对象
	LinkedList list = new LinkedList();					
	list.addLast("a");
	list.addLast("b");
	list.addLast("c");
	list.addLast("d");
	
	/*
	System.out.println(list.removeLast());
	System.out.println(list.removeLast());
	System.out.println(list.removeLast());
	System.out.println(list.removeLast());
	*/
	
	while(!list.isEmpty()) {
		System.out.println(list.removeLast());
	}
}
}

6.stack栈的操作

import java.util.LinkedList;
public class Stack {
private LinkedList list = new LinkedList();
//模拟进栈方法
public void in(Object obj) {
	list.addLast(obj);
}

// 模拟出栈
public Object out() {
	return list.removeLast();
}

//模拟栈结构是否为空
public boolean isEmpty() {
	return list.isEmpty();
}
}

面试题：在删除可插入对象的动作时，为什么ArrayList的效率会比较低呢?

解析: 因为ArrayList是使用数组实现的,若要从数组中删除或插入某一个对象，需要移动后段的数组元素，从而会重新调整索引顺序,调整索引顺序会消耗一定的时间，所以速度上就会比LinkedList要慢许多. 相反,LinkedList是使用链表实现的,若要从链表中删除或插入某一个对象,只需要改变前后对象的引用即可!