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("First element of LinkedList is : " + lList.getFirst()); System.out.println("Last element of LinkedList is : " + lList.getLast()); } } 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"); for (String str: lList) { System.out.println(str); } } } import java.util.LinkedList; import java.util.List; 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); List lst = lList.subList(1, 4); System.out.println(lst); lst.remove(2); System.out.println(lst); System.out.println(lList); } } dding the element to the end of the list unless an index is specified.

public boolean add(Object element) public boolean add(int index, Object element) To Treat the linked list as a stack or queue: public boolean addFirst(Object element) public boolean addLast(Object element) The addLast() method is equivalent to call add(), with no index. 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.addFirst("X"); list.addLast("Z"); System.out.println(list); } } 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.addFirst("0"); System.out.println(lList); lList.addLast("6"); System.out.println(lList); } } /* [1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6] */

public Object getFirst() public Object getLast() 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.addFirst("X"); list.addLast("Z"); System.out.println(list); System.out.println(list.getFirst()); System.out.println(list.getLast()); } } 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.addFirst("X"); list.addLast("Z"); System.out.println(list); System.out.println(list.getFirst()); System.out.println(list.getLast()); list.removeFirst(); list.removeLast(); System.out.println(list); } } [X, A, B, C, D, Z] X Z [A, B, C, D]

mport 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(); } } 9 9 9 8 7 9.12.11.Making a queue from a LinkedListPrevious/Next 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(); } } 0 1 2 3 4 5

6 7 8 9

9.12.12.Convert Collection to ArrayListPrevious/Next import java.util.ArrayList; import java.util.LinkedList; public class Main { public static void main(String[] args) { LinkedList<String> linkedList = new LinkedList<String>(); linkedList.push("A"); linkedList.push("B"); linkedList.push("C"); linkedList.push("D"); ArrayList<String> arrayList = new ArrayList<String>(linkedList); for (String s : arrayList) { System.out.println("s = " + s); } } }

Remove all elements or clear LinkedListPrevious/Next 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("LinkedList contains : " + lList); lList.clear(); System.out.println("LinkedList now contains : " + lList); } }

9.12.16.Remove specified element from LinkedListPrevious/Next 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")); System.out.println(lList); Object obj = lList.remove(2); System.out.println(obj + " has been removed from LinkedList"); System.out.println(lList); }

9.12.17.Convert LinkedList to Array with zero length arrayPrevious/Next 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]); } } } /* A B C D */

9.12.19.Convert a LinkedList to ArrayListPrevious/Next 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); } } /* A B C D */

9.12.20.Implementing a StackPrevious/Next 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); } }

9.12.11.Making a queue from a LinkedListPrevious/Next 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(); } } 0 1 2 3 4 5 6 7 8 9

9.12.21.Implementing a Queue with LinkedListPrevious/Next 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(); } }

9.12.23.Search elements of LinkedListPrevious/Next 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")); } }

9.12.24.Replace an Element of LinkedListPrevious/Next

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"); System.out.println(lList); } }

9.12.25.Add object to LinkedListPrevious/Next 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"); } } }

9.12.27.Create an object array from elements of LinkedListPrevious/Next 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"); Object[] objArray = lList.toArray(); for (Object obj: objArray) { System.out.println(obj); } } }

9.12.28.Using a LinkedList in multi-threadPrevious/Next 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(); } }

9.12.29.A basic priority linked list: maintaining an individual LinkedList for e ach priority level.Previous/Next /* * JBoss, Home of Professional Open Source * Copyright 2005, JBoss Inc., and individual contributors as indicated * by the @authors tag. See the copyright.txt in the distribution for a * full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */

import import import import import

java.util.ArrayList; java.util.LinkedList; java.util.List; java.util.ListIterator; java.util.NoSuchElementException;

/** * A basic priority linked list * * It implements this by maintaining an individual LinkedList for each priority * level. * * @author <a href="mailto:tim.fox@jboss.com>Tim Fox</a> * @version <tt>$Revision: 1174 $</tt> * * $Id: BasicPrioritizedDeque.java 1174 2006-08-02 14:14:32Z timfox $ */ 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; // Initially we are just using a simple prioritization algorithm: // Highest priority refs always get returned first. // This could cause starvation of lower priority refs. // TODO - A better prioritization algorithm 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; // Initially we are just using a simple prioritization algorithm: // Lowest priority refs always get returned first. // TODO - A better prioritization algorithm 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; // Initially we are just using a simple prioritization algorithm: // Highest priority refs always get returned first. // This could cause starvation of lower priority refs. // TODO - A better prioritization algorithm 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(); } } } 9.12.30.Helper method for creating listPrevious/Next /** * Copyright (C) 2007 Google Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US A */

import import import import

java.util.ArrayList; java.util.Collections; java.util.LinkedList; java.util.List;

/** * Helper methods related to {@link List}s. * * @author maxr@google.com (Max Ross) */ public class Lists { private Lists() { } /** * Construct a new {@link ArrayList}, taking advantage of type inference to * avoid specifying the type on the rhs. */ public static <E> ArrayList<E> newArrayList() { return new ArrayList<E>(); } /** * Construct a new {@link ArrayList} with the specified capacity, taking advan tage of type inference to * avoid specifying the type on the rhs. */ public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) { return new ArrayList<E>(initialCapacity); } /** * Construct a new {@link ArrayList} with the provided elements, taking advant age of type inference to * avoid specifying the type on the rhs. */ public static <E> ArrayList<E> newArrayList(E... elements) { ArrayList<E> set = newArrayList(); Collections.addAll(set, elements); return set; } /** * Construct a new {@link ArrayList} with the contents of the provided {@link Iterable}, taking advantage of type inference to * avoid specifying the type on the rhs. */ public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) { ArrayList<E> list = newArrayList(); for(E e : elements) { list.add(e); } return list; } /** * Construct a new {@link LinkedList}, taking advantage of type inference to * avoid specifying the type on the rhs. */

public static <E> LinkedList<E> newLinkedList() { return new LinkedList<E>(); } }