Java学习笔记30

LinkedList类是List接口的实现类,它是一个List集合,可以根据索引来随机访问集合元素。除此之外,LinkedList还实


现了Deque接口,因此它可以被当成双端队列来使用,也可以被当成“栈”来使用。LinkedList是基于链的线性表。


以下是官方对LinkedList类的说明:

List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口


外,LinkedList 类还为在列表的开头及结尾 getremoveinsert 元素提供了统一的命名方法。这些操作允许将链接


列表用作堆栈、队列双端队列


此类实现 Deque 接口,为 addpoll 提供先进先出队列操作,以及其他堆栈和双端队列操作。


所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表(从靠近指定索引


的一端)。


注意,此实现不是同步的。如果多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,则


必须 保持外部同步。(结构修改指添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。)这


一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象,则应该使


Collections.synchronizedList方法来“包装”该列表。最好在创建时完成这一操作,以防止对列表进行意外的不同步访


问,如下所示:

   List list = Collections.synchronizedList(new LinkedList(...));


此类的 iteratorlistIterator 方法返回的迭代器是快速失败 的:在迭代器创建之后,如果从结构上对列表进行修改,


除非通过迭代器自身的 removeadd 方法,其他任何时间任何方式的修改,迭代器都将抛出


ConcurrentModificationException。因此,面对并发的修改,迭代器很快就会完全失败,而不冒将来不确定的时间任


意发生不确定行为的风险。


注意,迭代器的快速失败行为不能得到保证,一般来说,存在不同步的并发修改时,不可能作出任何硬性保证。快


速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此,编写依赖于此异常的程序的方式是错误的,


正确做法是:迭代器的快速失败行为应该仅用于检测程序错误。


以下是LinkedList类的绝大部分方法:


public class Main {
	public static void main(String[] args) {
		LinkedList linkedList=new LinkedList();
		
		/*
		 * boolean add(E e) 
		 * 将指定元素添加到此列表的结尾。 
		 */
		linkedList.add("A");
		//输出:[A]
		System.out.println(linkedList);
		
		/*
		 *  void add(int index, E element) 
		 *   在此列表中指定的位置插入指定的元素。 
		 */
		linkedList.add(1, "B");
		//输出:[A, B]
		System.out.println(linkedList);
		
		
		/*
		 * boolean addAll(Collection<? extends E> c) 
		 * 添加指定 collection 中的所有元素到此列表的结尾,
		 * 顺序是指定  collection 的迭代器返回这些元素的顺序。
		 */
		ArrayList arrayList=new ArrayList();
		arrayList.add("C");
		arrayList.add("D");
		linkedList.addAll(arrayList);
		//输出:[A, B, C, D]
		System.out.println(linkedList);
		
		
		/*
		 *  boolean addAll(int index, Collection<? extends E> c) 
		 *   将指定 collection 中的所有元素从指定位置开始插入此列表。 
		 */
		ArrayList list=new ArrayList();
		list.add("E");
		list.add("F");
		linkedList.addAll(4, list);
		//输出:[A, B, C, D, E, F]
		System.out.println(linkedList);
		
		
		/*
		 *  void addFirst(E e) 
		 *  将指定元素插入此列表的开头。 
		 */
		linkedList.addFirst("First");
		//输出:[First, A, B, C, D, E, F]
		System.out.println(linkedList);
		
		
		/*
		 * void addLast(E e) 
		 * 将指定元素添加到此列表的结尾。 
		 */
		linkedList.addLast("Last");
		//输出:[First, A, B, C, D, E, F, Last]
		System.out.println(linkedList);
		
		
		/*
		 *  Object clone() 
		 *  返回此 LinkedList 的浅表副本。 
		 */
		LinkedList linkedListClone=(LinkedList)linkedList.clone();
		linkedListClone.add("clone");
		//输出:[First, A, B, C, D, E, F, Last, clone]
		System.out.println(linkedListClone);
		//输出:[First, A, B, C, D, E, F, Last]
		System.out.println(linkedList);
		
		
		/*
		 * boolean contains(Object o) 
		 *  如果此列表包含指定元素,则返回 true。  
		 */
		//输出:true
		System.out.println(linkedList.contains("First"));
		
		
		
		/*
		 * Iterator<E> descendingIterator() 
		 *  返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 
		 */
		Iterator iterator=linkedList.descendingIterator();
		//输出:Last F E D C B A First 
		while(iterator.hasNext()){
			System.out.print(iterator.next()+" ");
		}
		System.out.println();
		
		
		
		
		/*
		 *  E element() 
		 *  获取但不移除此列表的头(第一个元素)。 
		 */
		//输出;First
		System.out.println(linkedList.element());
		//输出:[First, A, B, C, D, E, F, Last]
		System.out.println(linkedList);
		
		
		
		/*
		 *  E get(int index) 
		 *  返回此列表中指定位置处的元素。 
		 */
		//输出:A
		System.out.println(linkedList.get(1));
		
		
		
		/*
		 *  E getFirst() 
		 *    返回此列表的第一个元素。 
		 */
		//输出:First
		System.out.println(linkedList.getFirst());
		
		
		
		/*
		 *  E getLast() 
		 *   返回此列表的最后一个元素。 
		 */
		//输出:Last
		System.out.println(linkedList.getLast());
		
		
		
		/*
		 *  int indexOf(Object o) 
		 *  返回此列表中首次出现的指定元素的索引,
		 *  如果此列表中不包含该元素,则返回 -1。 
		 */
		//输出:4
		System.out.println(linkedList.indexOf("D"));
		
		
		/*
		 *  int lastIndexOf(Object o) 
		 * 返回此列表中最后出现的指定元素的索引,
		 * 如果此列表中不包含该元素,则返回 -1。 
		 */
		//输出:6
		System.out.println(linkedList.lastIndexOf("F"));
		
		
		
		/*
		 * ListIterator<E> listIterator(int index) 
		 * 返回此列表中的元素的列表迭代器(按适当顺序),
		 * 从列表中指定位置开始。 
		 */
		ListIterator listIterator=linkedList.listIterator(3);
		//输出:C D E F Last 
		while(listIterator.hasNext()){
			System.out.print(listIterator.next()+" ");
		}
		System.out.println();
		
		
		/*
		 *  boolean offer(E e) 
		 *  将指定元素添加到此列表的末尾(最后一个元素)。 
		 */
		linkedList.offer("offer");
		//输出:[First, A, B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		
		
		/*
		 * boolean offerFirst(E e) 
		 *  在此列表的开头插入指定的元素。 
		 */
		linkedList.offerFirst("offerFirst");
		//输出:[offerFirst, First, A, B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		
		
		/*
		 * boolean offerLast(E e) 
		 *  在此列表末尾插入指定的元素。 
		 */
		linkedList.offerLast("offerLast");
		//输出:[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		
		
		/*
		 * E peek() 
		 * 获取但不移除此列表的头(第一个元素)。 
		 */
		//输出:offerFirst
		System.out.println(linkedList.peek());
		//输出:[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		
		/*
		 *  E peekFirst() 
		 *  获取但不移除此列表的第一个元素;
		 *  如果此列表为空,则返回 null。 
		 */
		//输出:offerFirst
		System.out.println(linkedList.peekFirst());
		//输出:[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		
		
		
		/*
		 *  E peekLast() 
		 *  获取但不移除此列表的最后一个元素;如果此列表为空,
		 *  则返回 null。 
		 */
		//输出:offerLast
		System.out.println(linkedList.peekLast());
		//输出:[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		/*
		 * E poll() 
		 *  获取并移除此列表的头(第一个元素)  
		 */
		//输出:offerFirst
		System.out.println(linkedList.poll());
		//输出:[First, A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		
		
		
		/*
		 *  E pollFirst() 
		 *   获取并移除此列表的第一个元素;如果此列表为空,
		 *   则返回 null。 
		 */
		//输出:First
		System.out.println(linkedList.pollFirst());
		//输出:[A, B, C, D, E, F, Last, offer, offerLast]
		System.out.println(linkedList);
		
		
		/*
		 *  E pollLast() 
		 *   获取并移除此列表的最后一个元素;如果此列表为空,
		 *   则返回 null。 
		 */
		//输出:offerLast
		System.out.println(linkedList.pollLast());
		//输出:[A, B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		/*
		 *  E pop() 
		 *  从此列表所表示的堆栈处弹出一个元素。 
		 */
		//输出:A
		System.out.println(linkedList.pop());
		//输出:[B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		
		/*
		 *  void push(E e) 
		 *  将元素推入此列表所表示的堆栈。 
		 */
		linkedList.push("A");
		//输出:[A, B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		
		
		
		/*
		 *  E remove() 
		 *  获取并移除此列表的头(第一个元素)。 
		 */
		//输出:A
		System.out.println(linkedList.remove());
		//输出:[B, C, D, E, F, Last, offer]
		System.out.println(linkedList);
		
		
		/*
		 *  E remove(int index) 
		 *  移除此列表中指定位置处的元素。 
		 */
		//输出:offer
		System.out.println(linkedList.remove(6));
		//输出:[B, C, D, E, F, Last]
		System.out.println(linkedList);
		
		
		
		
		
		/*
		 * boolean remove(Object o) 
		 * 从此列表中移除首次出现的指定元素(如果存在)。 
		 */
		linkedList.remove("Last");
		//输出:[B, C, D, E, F]
		System.out.println(linkedList);
		
		
		
		/*
		 *  E removeFirst()  
		 *  移除并返回此列表的第一个元素。 
		 */
		//输出:B
		System.out.println(linkedList.removeFirst());
		//输出:[C, D, E, F]
		System.out.println(linkedList);
		
		
		
		/*
		 *  boolean removeFirstOccurrence(Object o) 
		 *  从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)。 
		 */
		linkedList.removeFirstOccurrence("D");
		//输出:[C, E, F]
		System.out.println(linkedList);
		
		
		/*
		 *  E removeLast() 
		 *  移除并返回此列表的最后一个元素。 
		 */
		//输出:F
		System.out.println(linkedList.removeLast());
		//输出:[C, E]
		System.out.println(linkedList);
		
		
		
		/*
		 *  boolean removeLastOccurrence(Object o) 
		 *  从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)。 
		 */
		linkedList.removeLastOccurrence("E");
		//输出:[C]
		System.out.println(linkedList);
		
		
		
		
		/*
		 * E set(int index, E element)
		 *  将此列表中指定位置的元素替换为指定的元素。 
		 */
		//输出:C
		System.out.println(linkedList.set(0, "set"));
		//输出:[set]
		System.out.println(linkedList);
		
		
		
		/*
		 * int size() 
		 * 返回此列表的元素数。 
		 */
		//输出:1
		System.out.println(linkedList.size());
		
		/*
		 *  Object[] toArray() 
		 *  返回以适当顺序(从第一个元素到最后一个元素)
		 *  包含此列表中所有元素的数组。 
		 */
		//输出:[set]
		System.out.println(Arrays.toString(linkedList.toArray()));
		
		
		
		/*
		 * void clear() 
		 * 从此列表中移除所有元素。 
		 */
		linkedList.clear();
		//输出:[]
		System.out.println(linkedList);
		
		
		
		
		
		
		
		
		
		
		
	}
}



转载请注明出处:http://blog.csdn.net/hai_qing_xu_kong/article/details/44134565  情绪控_ 



©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值