LinkedList的基本使用

最新推荐文章于 2024-06-28 18:18:35 发布
最新推荐文章于 2024-06-28 18:18:35 发布
阅读量456 收藏 1
点赞数
分类专栏： java 文章标签： linkedlist

LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList(): ——生成空的链表
2. public LinkedList(Collection col): 复制构造函数
1、获取链表的第一个和最后一个元素
[java] view plaincopy
import java.util.LinkedList;

public class LinkedListTest{
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”); 

System.out.println("链表的第一个元素是 : " + lList.getFirst());  
System.out.println("链表最后一个元素是 : " + lList.getLast());

}
}

2、获取链表元素
[java] view plaincopy
for (String str: lList) {
System.out.println(str);
}
3、从链表生成子表
[java] view plaincopy
List subl = lList.subList(1, 4);
System.out.println(subl);
lst.remove(2);
System.out.println(lst);
System.out.println(lList);
4、添加元素：添加单个元素
如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.
[java] view plaincopy
import java.util.LinkedList;

public class LinkedListTest{
public static void main(String[] a) {
LinkedList list = new LinkedList();
list.add(“A”);
list.add(“B”);
list.add(“C”);
list.add(“D”);
list.addFirst(“X”);
list.addLast(“Z”);
System.out.println(list);
}
}
5、删除元素
[java] view plaincopy
public Object removeFirst()
public Object removeLast()
import java.util.LinkedList;

public class MainClass {
public static void main(String[] a) { 

LinkedList list = new LinkedList();  
list.add("A");  
list.add("B");  
list.add("C");  
list.add("D");  
list.removeFirst();  
list.removeLast();  
System.out.println(list);

}
}
6、使用链表实现栈效果
[java] view plaincopy
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
StackL stack = new StackL();
for (int i = 0; i < 10; i++)
stack.push(i);
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
class StackL {
private LinkedList list = new LinkedList();
public void push(Object v) {
list.addFirst(v);
}
public Object top() {
return list.getFirst();
}
public Object pop() {
return list.removeFirst();
}
}
7、使用链表来实现队列效果
[java] view plaincopy
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
Queue queue = new Queue();
for (int i = 0; i < 10; i++)
queue.put(Integer.toString(i));
while (!queue.isEmpty())
System.out.println(queue.get());
}
}
class Queue {
private LinkedList list = new LinkedList();
public void put(Object v) {
list.addFirst(v);
}
public Object get() {
return list.removeLast();
}
public boolean isEmpty() {
return list.isEmpty();
}
}
8、将LinkedList转换成ArrayList

[java] view plaincopy
ArrayList arrayList = new ArrayList(linkedList);
for (String s : arrayList) {
System.out.println(“s = ” + s);
}
9、删掉所有元素：清空LinkedList
lList.clear();
10、删除列表的首位元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
System.out.println(lList);
//元素在删除的时候，仍然可以获取到元素
Object object = lList.removeFirst();
System.out.println(object + ” has been removed”);
System.out.println(lList);
object = lList.removeLast();
System.out.println(object + ” has been removed”);
System.out.println(lList);
}
}
11、根据范围删除列表元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
System.out.println(lList);
lList.subList(2, 5).clear();
System.out.println(lList);
}
}
12、删除链表的特定元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
System.out.println(lList);
System.out.println(lList.remove(“2”));//删除元素值=2的元素
System.out.println(lList);
Object obj = lList.remove(2); //删除第二个元素
System.out.println(obj + ” 已经从链表删除”);
System.out.println(lList);
}
}
13、将LinkedList转换为数组，数组长度为0
[java] view plaincopy
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List theList = new LinkedList();
theList.add(“A”);
theList.add(“B”);
theList.add(“C”);
theList.add(“D”);
String[] my = theList.toArray(new String[0]);
for (int i = 0; i < my.length; i++) {
System.out.println(my[i]);
}
}
}
14、将LinkedList转换为数组，数组长度为链表长度
[java] view plaincopy
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List theList = new LinkedList();
theList.add(“A”);
theList.add(“B”);
theList.add(“C”);
theList.add(“D”);
String[] my = theList.toArray(new String[theList.size()]);
for (int i = 0; i < my.length; i++) {
System.out.println(my[i]);
}
}
}
15、将LinkedList转换成ArrayList
[java] view plaincopy
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
LinkedList myQueue = new LinkedList();
myQueue.add(“A”);
myQueue.add(“B”);
myQueue.add(“C”);
myQueue.add(“D”);
List myList = new ArrayList(myQueue);
for (Object theFruit : myList)
System.out.println(theFruit);
}
}
16、实现栈
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList stack = new LinkedList();
Object object = “”;
stack.addFirst(object);
Object o = stack.getFirst();
stack = (LinkedList) Collections.synchronizedList(stack);
}
}
17、实现队列
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList queue = new LinkedList();
Object object = “”;
// Add to end of queue
queue.add(object);
// Get head of queue
Object o = queue.removeFirst();
}
}
18 、同步方法
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList queue = new LinkedList();
Object object = “”;
queue.add(object);
Object o = queue.removeFirst();
queue = (LinkedList) Collections.synchronizedList(queue);
}
}
19、查找元素位置
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
lList.add(“2”);
System.out.println(lList.indexOf(“2”));
System.out.println(lList.lastIndexOf(“2”));
}
}
20、替换元素
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
System.out.println(lList);
lList.set(3, “Replaced”);//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值
System.out.println(lList);
}
}
21、链表添加对象
[java] view plaincopy
import java.util.LinkedList;
class Address {
private String name;
private String street;
private String city;
private String state;
private String code;
Address(String n, String s, String c, String st, String cd) {
name = n;
street = s;
city = c;
state = st;
code = cd;
}
public String toString() {
return name + ” ” + street + ” ” + city + ” ” + state + ” ” + code;
}
}

class MailList {
public static void main(String args[]) {
LinkedList

ml = new LinkedList
();
ml.add(new Address(“A”, “11 Ave”, “U”, “IL”, “11111”));
ml.add(new Address(“R”, “11 Lane”, “M”, “IL”, “22222”));
ml.add(new Address(“T”, “8 St”, “C”, “IL”, “33333”));
for (Address element : ml)
System.out.println(element + “\n”);
}
}
22、确认链表是否存在特定元素
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList lList = new LinkedList();
lList.add(“1”);
lList.add(“2”);
lList.add(“3”);
lList.add(“4”);
lList.add(“5”);
if (lList.contains(“4”)) {
System.out.println(“LinkedList contains 4”);
} else {
System.out.println(“LinkedList does not contain 4”);
}
}
}
23、根据链表元素生成对象数组
[java] view plaincopy
Object[] objArray = lList.toArray();
for (Object obj: objArray) {
System.out.println(obj);
}
24、链表多线程
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
class PrepareProduction implements Runnable {
private final List queue;
PrepareProduction(List q) {
queue = q;
}
public void run() {
queue.add(“1”);
queue.add(“done”);
}
}
class DoProduction implements Runnable {
private final List queue;
DoProduction(List q) {
queue = q;
}
public void run() {
String value = queue.remove(0);
while (!value.equals(“*”)) {
System.out.println(value);
value = queue.remove(0);
}
}
}
public class Main {
public static void main(String[] args) throws Exception {
List q = Collections.synchronizedList(new LinkedList());
Thread p1 = new Thread(new PrepareProduction(q));
Thread c1 = new Thread(new DoProduction(q));
p1.start();
c1.start();
p1.join();
c1.join();
}
}
25、优先级链表（来自JBOSS）
[java] view plaincopy
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class BasicPriorityLinkedList {

protected LinkedList[] linkedLists;
protected int priorities;
protected int size;

public BasicPriorityLinkedList(int priorities) {
this.priorities = priorities;
initDeques();
}
public void addFirst(Object obj, int priority) {
linkedLists[priority].addFirst(obj);
size++;
}
public void addLast(Object obj, int priority) {
linkedLists[priority].addLast(obj);
size++;
}
public Object removeFirst() {
Object obj = null;
for (int i = priorities - 1; i >= 0; i–) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.removeFirst();
break;
}
}
if (obj != null) {
size–;
}
return obj;
}
public Object removeLast() {
Object obj = null;
for (int i = 0; i < priorities; i++) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.removeLast();
}
if (obj != null) {
break;
}
}
if (obj != null) {
size–;
}
return obj;
}

public Object peekFirst() {
Object obj = null;
for (int i = priorities - 1; i >= 0; i–) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.getFirst();
}
if (obj != null) {
break;
}
}
return obj;
}

public List getAll() {
List all = new ArrayList();
for (int i = priorities - 1; i >= 0; i–) {
LinkedList deque = linkedLists[i];
all.addAll(deque);
}
return all;
}

public void clear() {
initDeques();
}

public int size() {
return size;
}

public boolean isEmpty() {
return size == 0;
}

public ListIterator iterator() {
return new PriorityLinkedListIterator(linkedLists);
}

protected void initDeques() {
linkedLists = new LinkedList[priorities];
for (int i = 0; i < priorities; i++) {
linkedLists[i] = new LinkedList();
}
size = 0;
}

class PriorityLinkedListIterator implements ListIterator {
private LinkedList[] lists;
private int index;
private ListIterator currentIter;
PriorityLinkedListIterator(LinkedList[] lists) {
this.lists = lists;
index = lists.length - 1;
currentIter = lists[index].listIterator();
} 

public void add(Object arg0) {  
  throw new UnsupportedOperationException();  
}  


public boolean hasNext() {  
  if (currentIter.hasNext()) {  
    return true;  
  }  
  while (index >= 0) {  
    if (index == 0 || currentIter.hasNext()) {  
      break;  
    }  
    index--;  
    currentIter = lists[index].listIterator();  
  }  
  return currentIter.hasNext();  
}  


public boolean hasPrevious() {  
  throw new UnsupportedOperationException();  
}  


public Object next() {  
  if (!hasNext()) {  
    throw new NoSuchElementException();  
  }  
  return currentIter.next();  
}  


public int nextIndex() {  
  throw new UnsupportedOperationException();  
}  


public Object previous() {  
  throw new UnsupportedOperationException();  
}  


public int previousIndex() {  
  throw new UnsupportedOperationException();  
}  


public void remove() {  
  currentIter.remove();  
  size--;  
}  


public void set(Object obj) {  
  throw new UnsupportedOperationException();  
}

}

}
26、生成list的帮助类（来自google）
[java] view plaincopy
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Lists {
private Lists() { }
public static ArrayList newArrayList() {
return new ArrayList();
}
public static ArrayList newArrayListWithCapacity(int initialCapacity) {
return new ArrayList(initialCapacity);
}
public static ArrayList newArrayList(E… elements) {
ArrayList set = newArrayList();
Collections.addAll(set, elements);
return set;
}
public static ArrayList newArrayList(Iterable

四角天空
关注
专栏目录
java linkedlist用法_Java linkedList详细介绍及使用示例
weixin_30456719的博客
02-12 1437
①LinkedList简单介绍是一个继承于AbstractSequentialList的双向链表。它可以被当成堆栈、队列或双端队列进行操作。实现了List接口，能对它进行队列操作。实现了Deque接口，能当作双端队列使用。实现了Cloneable接口，覆盖了clone(),能克隆。实现了java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。是非同...
LinkedList基本用法
hanmengyucsdn的博客
02-11 493
LinkedList基本用法 LinkedList是Collection下的一个list实现，就像ArrayList一样。 和ArrayList不同的是它是链表结构，而ArrayList是顺序结构。我们平常使用的list是一样的，理论上来说一种list就可以完成我们所有的需求。但是它们在运行过程中有区别的，完成需求所需要的资源也不相同，至于什么情况下使用哪种list就看需求和当前情况了。 LinkedList的本质是双向链表 LinkedList继承于AbstractSequentialList，并且实现了
Unity 自定义同时具有LinkedList和Dictionary的数据结构
qq_41916689的博客
06-28 206
一个同时具有key-value、频繁删除新增、栈等特性的数据结构
Java中LinkedList用法
FLY_THINK2012的博客
03-29 110
LinkedList的使用例子： import java.util.*; public class LinkedListDemo { public static void main(String []args){ LinkedList list = new LinkedList(); ...
Java集合-List接口-LinkedList
baidu_38126306的博客
09-20 1114
Java集合——LinkedList 1. Java LinkedList 特性 LinkedList（链表）底层是用双向链表实现的存储。是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZNePWKr-1600610375482)(D:\JavaAno\pictures\单向链表&双向链表示例.png)] 与 A
JAVA-LinkedList常用方法汇总
zhhxlj的博客
01-12 466
JAVA-Deque学习笔记及应用
简单了解java集合框架LinkedList使用方法
08-18
"Java集合框架LinkedList使用方法" Java集合框架中的LinkedList是一个双向链表，具有链表底层实现的特点，查询速度慢，增删速度快。LinkedList是Java集合框架中的一个重要组件，广泛应用于各种软件系统中。本文将...
java：LinkedList的基本使用、特征、源码的解读
qq_59168360的博客
02-09 398
LinkedList的基本使用 LinkedList是 Java 集合中比较常用的数据结构，与 ArrayList 一样，实现了 List 接口，只不过 ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。所以 LinkedList 插入和删除方面要优于 ArrayList，而随机访问上则 ArrayList 性能更好。 常用方法： public boolean add(Object element) 向链表末尾添加一个新节点，该节点中的数据是参数element指定的.
使用LinkedList模拟堆栈
11-09
本文将详细讲解如何使用Java中的LinkedList类来模拟这两种数据结构，并实现其基本操作。 堆栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循“先进后出”的原则。常见的堆栈操作有压栈...
LinkedList:使用 Java 实现链表
06-13
本篇文章将深入探讨如何使用Java实现链表，以及`LinkedList`类的相关特性和操作。 首先，链表不同于数组，它不连续存储数据。每个元素（节点）包含两部分：数据和指向下一个节点的引用。在Java的`LinkedList`中，每...
Java LinkedList类基本用法
bcbobo21cn的专栏
06-21 291
LinkedList 实现了一个双端队列（Deque），具有队列的一些特有方法： 1）addFirst（）从集合列表开头插入元素 2）addLast（）从集合列表结尾插入元素（等效于add（）） 3）getFirst（）拿到第一个元素，返回这个元素 4）getLast（）拿到最后一个元素，返回这个元素 5）removeFirst（）移除第一个元素，返回这个元素 6）removeLast（）移除最后一个元素，返回这个元素 （如果列表中没有元素，那么：3到6方法抛 空元素异常） 注： 在1.6版本以后，新添
Java中链表（Linked list）用法（单链表，双链表）
Sueko的博客
03-07 7013
Java中链表的用法1.链表的概念2.链表的操作3.Java中链表的使用
java中linkedlist的用法_Java中LinkedList用法
weixin_29619665的博客
02-19 880
LinkedList是Queue的实现类，是双向链表。决定了LinkedList的节点都包含了对前一个和后一个节点的引用。构造函数public LinkedList(); ——生成一个空的链表public LinkedList(Collection extends E> c); ——复制构造函数常用方法及举例添加元素：boolean add(Object element) —— 将元素添加在...
java linkedlist 用法_java中linkedlist的介绍和用法
weixin_34119722的博客
02-12 1234
Linkedlist是线性数据结构，其中元素不存储在连续的位置，每个元素都是具有数据部分和地址部分的独立对象。元素使用指针和地址进行链接。每个元素被称为节点。由于插入和删除的动态性和易用性，它们优于阵列。它也有一些缺点，比如节点不能直接访问，我们需要从头开始，然后通过链接到达我们希望访问的节点。为了将元素存储在链表中，我们使用一个双向链表，它提供了一个线性数据结构，并且还用于继承一个抽象类并实现l...
Java中LinkedList类的常用方法
tanxinji的博客
02-07 7084
 LinkedList类有很多方法，可以模拟栈，队列，链表功能。 一、队列  1.入队 add(E e );将e插入队列末尾。  2.出队删除队首 poll() ; 取出队首元素，并且在队列中删除队首。队首为空返回null。  3.出队删除队首 remove(); 取出队首元素，并且在队列中删除队首。队首为空报错。  4.出队不删除队首 peek(); 只返回队首元素，不删除。为空则返回null。  5.出队不删除队首 element(); 只返回队首元素，不删除。为空则报错。 二、栈  1.入栈 push
JAVA中實現鏈表--LinkedList的使用
热门推荐
冯立彬的博客
04-23 2万+
import java.util.LinkedList;import java.util.Vector;/** * Java中的鏈表，SUN公司已經為我們做好了，我們只需要簡單的使用就可以了 * 當沒有要求的時候，就可以不用自己去實現。 * 如果確實有要求要自己實現，那么也自己實現也是一樣的道理，只需要像 * LinkedList中一樣，實現向個接口方法，同樣可以做到。 * 這里是一個簡單的例
java LinkedList的用法
mimenglove的专栏
07-02 517
总结下，LinkedList的两个remove方法，remove(Object)和remove(int)的时间复杂度都是O(n)，在链表元素很多 并且没有索引可用的情况下，LinkedList也并不适合做随机增删元素。在对性能特别敏感的场景下，还是需要自己实现专用的双向链表结构，真正实现 O(1)级别的随机增删。更进一步，jdk5引入的ConcurrentLinkedQueue是一个非阻塞的线程安
Java LinkedList基本用法
qq_43685172的博客
01-27 182
Java LinkedList基本用法
理解LinkedList基本操作，了解泛型的使用方法
最新发布
09-08
泛型在集合框架中尤其重要，比如LinkedList就可以使用泛型来声明存储的元素类型： ```java LinkedList<String> list = new LinkedList(); list.add("Hello"); list.add("World"); String firstElement = list.get(0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值