LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList(): ——生成空的链表
2. public LinkedList(Collection col): 复制构造函数
1、获取链表的第一个和最后一个元素
2、获取链表元素
3、从链表生成子表
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()方法实现的效果一样.
5、删除元素
6、使用链表实现栈效果
7、使用链表来实现队列效果
lList.clear();
10、删除列表的首位元素
11、根据范围删除列表元素
12、删除链表的特定元素
13、将LinkedList转换为数组,数组长度为0
14、将LinkedList转换为数组,数组长度为链表长度
15、将LinkedList转换成ArrayList
16、实现栈
17、实现队列
18 、同步方法
19、查找元素位置
20、替换元素
21、链表添加对象
22、确认链表是否存在特定元素
23、根据链表元素生成对象数组
24、链表多线程
25、优先级链表(来自JBOSS)
26、生成list的帮助类(来自google)
LinkedList的构造函数如下
1. public LinkedList(): ——生成空的链表
2. public LinkedList(Collection col): 复制构造函数
1、获取链表的第一个和最后一个元素
- import java.util.LinkedList;
- public class LinkedListTest{
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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、获取链表元素
- for (String str: lList) {
- System.out.println(str);
- }
- List subl = lList.subList(1, 4);
- System.out.println(subl);
- lst.remove(2);
- System.out.println(lst);
- System.out.println(lList);
如果不指定索引的话,元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.
- 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);
- }
- }
- 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);
- }
- }
- 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();
- }
- }
- 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
- ArrayList<String> arrayList = new ArrayList<String>(linkedList);
- for (String s : arrayList) {
- System.out.println("s = " + s);
- }
9、删掉所有元素:清空LinkedList
lList.clear();
10、删除列表的首位元素
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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);
- }
- }
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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);
- }
- }
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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);
- }
- }
- import java.util.LinkedList;
- import java.util.List;
- public class Main {
- public static void main(String[] args) {
- List<String> theList = new LinkedList<String>();
- 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]);
- }
- }
- }
- import java.util.LinkedList;
- import java.util.List;
- public class Main {
- public static void main(String[] args) {
- List<String> theList = new LinkedList<String>();
- 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]);
- }
- }
- }
- import java.util.ArrayList;
- import java.util.LinkedList;
- import java.util.List;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> myQueue = new LinkedList<String>();
- myQueue.add("A");
- myQueue.add("B");
- myQueue.add("C");
- myQueue.add("D");
- List<String> myList = new ArrayList<String>(myQueue);
- for (Object theFruit : myList)
- System.out.println(theFruit);
- }
- }
- 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);
- }
- }
- 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();
- }
- }
- 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);
- }
- }
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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"));
- }
- }
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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);
- }
- }
- 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<Address> ml = new LinkedList<Address>();
- 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");
- }
- }
- import java.util.LinkedList;
- public class Main {
- public static void main(String[] args) {
- LinkedList<String> lList = new LinkedList<String>();
- 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");
- }
- }
- }
- Object[] objArray = lList.toArray();
- for (Object obj: objArray) {
- System.out.println(obj);
- }
- import java.util.Collections;
- import java.util.LinkedList;
- import java.util.List;
- class PrepareProduction implements Runnable {
- private final List<String> queue;
- PrepareProduction(List<String> q) {
- queue = q;
- }
- public void run() {
- queue.add("1");
- queue.add("done");
- }
- }
- class DoProduction implements Runnable {
- private final List<String> queue;
- DoProduction(List<String> 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<String>());
- Thread p1 = new Thread(new PrepareProduction(q));
- Thread c1 = new Thread(new DoProduction(q));
- p1.start();
- c1.start();
- p1.join();
- c1.join();
- }
- }
- 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();
- }
- }
- }
- import java.util.ArrayList;
- import java.util.Collections;
- import java.util.LinkedList;
- import java.util.List;
- public class Lists {
- private Lists() { }
- public static <E> ArrayList<E> newArrayList() {
- return new ArrayList<E>();
- }
- public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) {
- return new ArrayList<E>(initialCapacity);
- }
- public static <E> ArrayList<E> newArrayList(E... elements) {
- ArrayList<E> set = newArrayList();
- Collections.addAll(set, elements);
- return set;
- }
- public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {
- ArrayList<E> list = newArrayList();
- for(E e : elements) {
- list.add(e);
- }
- return list;
- }
- public static <E> LinkedList<E> newLinkedList() {
- return new LinkedList<E>();
- }
- }
相关推荐
Java不同数据存储类型使用不同遍历方法效率研究 GitHub代码仓库 数据存储类型 ArrayList HashSet HashMap LinkedList 遍历方法 传统遍历方法 for(int i=0;i<list.size();i++) { String str = list.get(i); ... ...
ClassRosterList 基本的LinkedList程序添加和删除元素,使用增强的for循环和排序方法。
使用Python编程链表数据结构,可以使用类来实现单链表的基本操作,如下所示: # 这个程序定义了两个类:Node和LinkedList。 # Node类用于表示单链表中的每个节点,包含数据和指向下一个节点的指针。 # LinkedList类...
本文详细介绍了 Java 基本操作的相关知识点,包括变量和数据类型、运算符、字符串操作、数组和集合、控制流语句、方法和函数、异常处理等。这些知识点是每个 Java 开发者都需要掌握的基本技能。
4.4.7 尽量不要使用finalize方法 4.4.8 考虑使用SoftReference 4.5 小结 第5课 表达式中的陷阱 5.1 关于字符串的陷阱 5.1.1 JVM对字符串的处理 5.1.2 不可变的字符串 5.1.3 字符串比较 5.2 表达式类型的...
用户也可以使用调试方法打印出整个链表。 输入字符串的当前限制少于 11 个字符。 这可以根据新节点的空间分配轻松更改(即使这也意味着更改许多过程的偏移量)。 我遇到的问题是这种链表实现存在内存泄漏。 如果用...
在使用散列的数据结构(HashSet、HashMap、LinkedHashSet 或者 LinkedHashMap)时,最好先覆盖 hashCode() 和 equals(),因为从 Object 继承下来的 hashCode() 方法默认是使用对象的地址计算散列值。 hashCode 对于...
2、编写程序练习List集合的基本使用: 1) 创建一个只能容纳String对象名为names的ArrayList集合; 2)按顺序往集合中添加5个字符串对象:"张三"、"李四"、"王五"、"马六"、"赵七"; 3)对集合进行遍历,分别打印...
2、多次使用的相同变量最好归纳成常量,3、尽量少的在循环中执行方法调用,4、常量的定义可以放到接口中,5、ArrayList和LinkedList的选择, 6、String,StringBuffer和StringBuilder, 7、包装类和基本类型的选择...
Collection接口提供了一个iterator()方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中的每一个元素。典型的用法如下: Iterator it = collection.iterator(); // 获得一个迭代子 while(it....
概述 该存储库存储短代码段(<1k行),用于简单的编码实践和个人使用。 这里的大多数代码(当前全部)都是用Java编写...该代码以Java语言编写,是LinkedList的简单实现,具有创建,删除或反转LinkedList的基本方法。
1 面向对象的特征有哪些方面 ...通常性能上较ArrayList差,而LinkedList使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。
java线程中容器使用技术,比如List接口是在Collection的基础上添加了大量方法,有两种基本类型:ArrayList,它擅⻓于随机访问元素,但是List中间插入或移除元 素时较慢;LinkedList,它和ArrayList的特性正好相反。...
如果不断改变基本功能并且使用接口,那么就需要改变所有实现了该接口的类。 List、Set、Map的区别 1. List 可存储重复对象; 是一个有序集合,保存了每一个元素的插入顺序,输出顺序就是插入顺序; 常见的实现类有...
ArrayList 的默认大小为 10,添加元素时使用 ensureCapacityInternal() 方法来保证容量足够,如果不够时,需要使用 grow() 方法进行扩容,新容量的大小为 oldCapacity + (oldCapacity >> 1) ,也就是旧容量的 1.5 倍...
Java集合详解1:一文读懂ArrayList,Vector与Stack使用方法和实现原理 Java集合详解2:Queue和LinkedList Java集合详解3:Iterator,fail-fast机制与比较器 Java集合详解4:HashMap和HashTable Java集合详解5:深入...
3.八种基本数据类型的大小,以及他们的封装类 4.标识符的命名规则 5.instanceof 关键字的作用 6.Java自动装箱与拆箱 7.重载和重写的区别 8.equals与==的区别 9.Hashcode的作用 10.String、String StringBuffer 和 ...
JNA:演示了JNA的基本用法,使用Java调用C++代码。 博客目录 Java基础 Java基础学习(1)——引用 Java基础学习(2)——注解 Java基础学习(3)——泛型 Java基础学习(4)——动态代理 《Java多线程核心技术》读书笔记 ...
Java集合详解:一文读懂ArrayList,Vector与Stack使用方法和实现原理 Java集合详解:Queue和LinkedList Java集合详解:迭代器,快速失败机制与比较器 Java集合详解:HashMap和HashTable Java集合详解:深入理解...