LinkedList链式集合
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
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);
- }
3、从链表生成子表
- 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()方法实现的效果一样.
- 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、删除元素
- 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、使用链表实现栈效果
- 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、使用链表来实现队列效果
- 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);
- }
- }
11、根据范围删除列表元素
- 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);
- }
- }
12、删除链表的特定元素
- 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);
- }
- }
13、将LinkedList转换为数组,数组长度为0
- 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]);
- }
- }
- }
14、将LinkedList转换为数组,数组长度为链表长度
- 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]);
- }
- }
- }
15、将LinkedList转换成ArrayList
- 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);
- }
- }
16、实现栈
- 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、实现队列
- 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 、同步方法
- 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、查找元素位置
- 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"));
- }
- }
20、替换元素
- 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);
- }
- }
21、链表添加对象
- 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");
- }
- }
22、确认链表是否存在特定元素
- 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");
- }
- }
- }
23、根据链表元素生成对象数组
- Object[] objArray = lList.toArray();
- for (Object obj: objArray) {
- System.out.println(obj);
- }
24、链表多线程
- 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();
- }
- }
25、优先级链表(来自JBOSS)
- 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)
- 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>();
- }
- }
LinkedList链式集合的更多相关文章
- Java实现链式存储的二叉查找树(递归方法)
二叉查找树的定义: 二叉查找树或者是一颗空树,或者是一颗具有以下特性的非空二叉树: 1. 若左子树非空,则左子树上所有节点关键字值均小于根节点的关键字: 2. 若右子树非空,则右子树上所有节点关键字值 ...
- 如何写 JS 的链式调用 ---》JS 设计模式《----方法的链式调用
1.以$ 函数为例.通常返回一个HTML元素或一个元素集合. 代码如下: function $(){ var elements = []; ;i<arguments.length;i++){ v ...
- C#中扩展StringBuilder支持链式方法
本篇体验扩展StringBuilder使之支持链式方法. 这里有一个根据键值集合生成select元素的方法. private static string BuilderSelectBox(IDicti ...
- 数据结构Java实现07----队列:顺序队列&顺序循环队列、链式队列、顺序优先队列
一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其 ...
- 数据结构Java实现05----栈:顺序栈和链式堆栈
一.堆栈的基本概念: 堆栈(也简称作栈)是一种特殊的线性表,堆栈的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置进行插入和删除操作,而堆栈只允许在固定一端进行插入和删除 ...
- 单元最短路径算法模板汇总(Dijkstra, BF,SPFA),附链式前向星模板
一:dijkstra算法时间复杂度,用优先级队列优化的话,O((M+N)logN)求单源最短路径,要求所有边的权值非负.若图中出现权值为负的边,Dijkstra算法就会失效,求出的最短路径就可能是错的 ...
- jQuery编程基础精华01(jQuery简介,顶级对象$,jQuery对象、Dom对象,链式编程,选择器)
jQuery简介 什么是jQuery? jQuery就是一个JavaScript函数库,没什么特别的.(开源)联想SQLHelper类 jQuery能做什么?jQuery是做什么的? jQuery本身 ...
- [置顶] ※数据结构※→☆线性表结构(queue)☆============优先队列 链式存储结构(queue priority list)(十二)
优先队列(priority queue) 普通的队列是一种先进先出的数据结构,元素在队列尾追加,而从队列头删除.在优先队列中,元素被赋予优先级.当访问元素时,具有最高优先级的元素最先删除.优先队列具有 ...
- jQuery链式编程
链式编程 多行代码合并成一行代码,前提要认清此行代码返回的是不是对象.是对象才能进行链式编程 .html(‘val’).text(‘val’).css()链式编程,隐式迭代 链式编程注意:$(‘div ...
随机推荐
- datagridview的数据存取
这里主要是复习DataSet等数据或ADO.NET方面的知识.下面是一个简单的数据存储(在DataGridView上增加一行然后并存储到数据库的过程): private void button1_Cl ...
- Sharepoint学习笔记—习题系列--70-576习题解析 -(Q19-Q20)
Question 19 You are designing a custom SharePoint 2010 solution package. It will include a feature t ...
- oracle应该安装在什么版本的linux下
今天想在我的ubuntu上安装oracle 11g r2,在网上所有了一些教程,然后找到了oracle官网网站的Operating System Requirements,内容如下: Operatin ...
- c#程序打包大全
c#程序打包现在分为两种,一种是VS自带的打包方式,还有一种是第三方的打包方式,在VS2013里面是没有自带打包安装部署的,只有第三方的创建. 第三方打包方式很简单,百度Installshield下载 ...
- Java和Android Http连接程序:使用java.net.URL 下载服务器图片到客户端
Java和Android Http连接程序:使用java.net.URL 下载服务器图片到客户端 本博客前面博文中利用org.apache.http包中API进行Android客户端HTTP连接的例子 ...
- PCM(Pulse-code modulation)脉冲编码调制
在音频处理中,我们会经常听到PCM数据,那么什么是PCM数据呢? PCM数据就是模拟信号经过PCM以后的数字信号,PCM就是把音频信号由模拟信号(时间连续,取值连续)转为数字信号(时间离散,取值离散) ...
- C语言中的数组的一些笔记
C语言是面向过程的语言. 计算数组长度: Int count =sizeof(ages)/sizeof(int); C语言里面输出字符串,必须以'\0'结束,如果没有则一直执行下去. Char nam ...
- 【代码笔记】iOS-显示图片的各种方式
代码: - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view. UI ...
- iOS开发之 用第三方类库实现轮播图
在github上面有很多的第三方类库,大大节约了大家的开发时间 下载地址:https://github.com/gsdios/SDCycleScrollView 现已支持cocoapods导入:pod ...
- 初学svn对版本进行控制 用post- commit钩子实现代码同步到web目录
这里只是一个记录,原文摘抄svn利用钩子实现代码同步到web目录 思路: 找 到SVN Server中的仓库(Repositories)文件夹的位置,在相应的项目文件夹中找到hooks文件夹.在该文件 ...