科技行者

行者学院 转型私董会 科技行者专题报道 网红大战科技行者

知识库

知识库 安全导航

至顶网软件频道使用Lists

使用Lists

  • 扫一扫
    分享文章到微信

  • 扫一扫
    关注官方公众号
    至顶头条

     List(接口) 顺序是List最重要的特性;它可保证元素按照规定的顺序排列。List为Collection添加了大量方法,以便我们在List中部插入和删除元素(只推荐对LinkedList这样做)。

作者:中国IT实验室 来源:中国IT实验室 2007年9月25日

关键字: 编程 java

  • 评论
  • 分享微博
  • 分享邮件

  

  List(接口) 顺序是List最重要的特性;它可保证元素按照规定的顺序排列。List为Collection添加了大量方法,以便我们在List中部插入和删除元素(只推荐对LinkedList这样做)。List也会生成一个ListIterator(列表反复器),利用它可在一个列表里朝两个方向遍历,同时插入和删除位于列表中部的元素(同样地,只建议对LinkedList这样做)
  ArrayList* 由一个数组后推得到的List。作为一个常规用途的对象容器使用,用于替换原先的Vector。允许我们快速访问元素,但在从列表中部插入和删除元素时,速度却嫌稍慢。一般只应该用ListIterator对一个ArrayList进行向前和向后遍历,不要用它删除和插入元素;与LinkedList相比,它的效率要低许多
  LinkedList 提供优化的顺序访问性能,同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访问时,速度却相当慢,此时应换用ArrayList。也提供了addFirst(),addLast(),getFirst(),getLast(),removeFirst()以及removeLast()(未在任何接口或基础类中定义),以便将其作为一个规格、队列以及一个双向队列使用
  
  下面这个例子中的方法每个都覆盖了一组不同的行为:每个列表都能做的事情(basicTest()),通过一个反复器遍历(iterMotion())、用一个反复器改变某些东西(iterManipulation())、体验列表处理的效果(testVisual())以及只有LinkedList才能做的事情等:
  
  //: List1.java
  // Things you can do with Lists
  package c08.newcollections;
  import java.util.*;
  
  public class List1 {
   // Wrap Collection1.fill() for convenience:
   public static List fill(List a) {
  return (List)Collection1.fill(a);
   }
   // You can use an Iterator, just as with a
   // Collection, but you can also use random
   // access with get():
   public static void print(List a) {
  for(int i = 0; i < a.size(); i++)
   System.out.print(a.get(i) + " ");
  System.out.println();
   }
   static boolean b;
   static Object o;
   static int i;
   static Iterator it;
   static ListIterator lit;
   public static void basicTest(List a) {
  a.add(1, "x"); // Add at location 1
  a.add("x"); // Add at end
  // Add a collection:
  a.addAll(fill(new ArrayList()));
  // Add a collection starting at location 3:
  a.addAll(3, fill(new ArrayList()));
  b = a.contains("1"); // Is it in there?
  // Is the entire collection in there?
  b = a.containsAll(fill(new ArrayList()));
  // Lists allow random access, which is cheap
  // for ArrayList, expensive for LinkedList:
  o = a.get(1); // Get object at location 1
  i = a.indexOf("1"); // Tell index of object
  // indexOf, starting search at location 2:
  i = a.indexOf("1", 2);
  b = a.isEmpty(); // Any elements inside?
  it = a.iterator(); // Ordinary Iterator
  lit = a.listIterator(); // ListIterator
  lit = a.listIterator(3); // Start at loc 3
  i = a.lastIndexOf("1"); // Last match
  i = a.lastIndexOf("1", 2); // ...after loc 2
  a.remove(1); // Remove location 1
  a.remove("3"); // Remove this object
  a.set(1, "y"); // Set location 1 to "y"
  // Keep everything that's in the argument
  // (the intersection of the two sets):
  a.retainAll(fill(new ArrayList()));
  // Remove elements in this range:
  a.removeRange(0, 2);
  // Remove everything that's in the argument:
  a.removeAll(fill(new ArrayList()));
  i = a.size(); // How big is it?
  a.clear(); // Remove all elements
   }
   public static void iterMotion(List a) {
  ListIterator it = a.listIterator();
  b = it.hasNext();
  b = it.hasPrevious();
  o = it.next();
  i = it.nextIndex();
  o = it.previous();
  i = it.previousIndex();
   }
   public static void iterManipulation(List a) {
  ListIterator it = a.listIterator();
  it.add("47");
  // Must move to an element after add():
  it.next();
  // Remove the element that was just produced:
  it.remove();
  // Must move to an element after remove():
  it.next();
  // Change the element that was just produced:
  it.set("47");
   }
   public static void testVisual(List a) {
  print(a);
  List b = new ArrayList();
  fill(b);
  System.out.print("b = ");
  print(b);
  a.addAll(b);
  a.addAll(fill(new ArrayList()));
  print(a);
  // Shrink the list by removing all the
  // elements beyond the first 1/2 of the list
  System.out.println(a.size());
  System.out.println(a.size()/2);
  a.removeRange(a.size()/2, a.size()/2 + 2);
  print(a);
  // Insert, remove, and replace elements
  // using a ListIterator:
  ListIterator x = a.listIterator(a.size()/2);
  x.add("one");
  print(a);
  System.out.println(x.next());
  x.remove();
  System.out.println(x.next());
  x.set("47");
  print(a);
  // Traverse the list backwards:
  x = a.listIterator(a.size());
  while(x.hasPrevious())
   System.out.print(x.previous() + " ");
  System.out.println();
  System.out.println("testVisual finished");
   }
   // There are some things that only
   // LinkedLists can do:
   public static void testLinkedList() {
  LinkedList ll = new LinkedList();
  Collection1.fill(ll, 5);
  print(ll);
  // Treat it like a stack, pushing:
  ll.addFirst("one");
  ll.addFirst("two");
  print(ll);
  // Like "peeking" at the top of a stack:
  System.out.println(ll.getFirst());
  // Like popping a stack:
  System.out.println(ll.removeFirst());
  System.out.println(ll.removeFirst());
  // Treat it like a queue, pulling elements
  // off the tail end:
  System.out.println(ll.removeLast());
  // With the above operations, it's a dequeue!
  print(ll);
   }
   public static void main(String args[]) {
  // Make and fill a new list each time:
  basicTest(fill(new LinkedList()));
  basicTest(fill(new ArrayList()));
  iterMotion(fill(new LinkedList()));
  iterMotion(fill(new ArrayList()));
  iterManipulation(fill(new LinkedList()));
  iterManipulation(fill(new ArrayList()));
  testVisual(fill(new LinkedList()));
  testLinkedList();
   }
  } ///:~
  
  在basicTest()和iterMotiion()中,只是简单地发出调用,以便揭示出正确的语法。而且尽管捕获了返回值,但是并未使用它。在某些情况下,之所以不捕获返回值,是由于它们没有什么特别的用处。在正式使用它们前,应仔细研究一下自己的联机文档,掌握这些方法完整、正确的用法。

查看本文来源

    • 评论
    • 分享微博
    • 分享邮件