您的位置:365bet体育备用网址器 > 应用 > 关于可迭代接口(Iterable)

关于可迭代接口(Iterable)

2019-11-03 17:38

java SE基础(Collection接口概述)

Collection接口相关集成关系如下图

365bet在线官网 1

1。关于可迭代接口(Iterable)
可迭代接口仅包含一个方法,返回一个在一组T类型元素上进行迭代的迭代器:

public abstract Iterator iterator();

 

迭代器Iterator接口的方法声明如下:

 

public interface Iterator{
    public abstract boolean hasNext();        //如果仍有元素可以迭代,则返回 true
    public abstract E        next();            //返回迭代的下一个元素
}

2。关于Collection接口
所有通用的 Collection 实现类提供两个构造方法:
(1)无参数构造方法,用于创建空 collection;
(2)带有Collection 类型单参数的构造方法,用于创建一个具有与其参数相同元素新的 collection。
3。关于List接口
(1)有序的 collection(也称为序列),此接口的用户可以对列表中每个元素的插入位置进行精确地控制
(2)列表通常允许重复的元素,如果列表本身允许 null 元素的话,通常它们允许多个 null 元素
(3)List接口提供了特殊的迭代器ListIterator,除了允许 Iterator 接口提供的正常操作外,还允许元素插入和替换,以及双向访问
(4)List部分方法

public interface List extends Collection{
 Iterator iterator();      //返回按适当顺序在列表的元素上进行迭代的迭代器
 ListIterator listIterator();    //返回此列表元素的列表迭代器(按适当顺序)。
 ListIterator listIterator(int index); //返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始
 E set(int index, E element);    //用指定元素替换列表中指定位置的元素(可选操作
 E get(int index);       //返回列表中指定位置的元素
 void add(int index, E element);    //在列表的指定位置插入指定元素(可选操作)
 List subList(int fromIndex, int toIndex) //返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
}

4。关于ListIterator接口
(1)列表迭代器,允许按任一方向遍历列表、迭代期间修改列表,并获得迭代器在列表中的当前位置。
(2)ListIterator没有当前元素;它的光标位置始终位于调用previous()所返回的元素和调用next()所返回的元素之间。
Element(0) Element(1) Element(2) ... Element(n-1)
cursor positions: ^ ^ ^ ^ ^ ^
(3)remove()和set(Object)方法不是根据光标位置定义的;它们是根据对调用next()或previous()所返回的最后一个元素的操作定义的
(4)ListIterator部分方法

public interface ListIterator extends Iterator{
 boolean hasNext();    //以正向遍历列表时,如果列表迭代器有多个元素,则返回 true
 boolean hasPrevious();   //如果以逆向遍历列表,列表迭代器有多个元素,则返回 true 

 E next();      //返回列表中的下一个元素
 E previous();     //返回列表中的前一个元素

 int nextIndex();    //返回对 next 的后续调用所返回元素的索引
 int previousIndex();   //返回对 previous 的后续调用所返回元素的索引

 void add(E e);     //新元素被插入到隐式光标前:该元素直接插入到 next 返回的下一个元素的前面,或者 previous 返回的下一个元素之后,
         //不影响对 next 的后续调用,并且对 previous 的后续调用会返回此新元素

 void set(E e);     //用指定元素替换 next 或 previous 返回的最后一个元素
 void remove();     //从列表中移除由 next 或 previous 返回的最后一个元素
}

5。关于ArrayList类
(1)可包含重复元素、值允许为null、线程不同步
(2)每个 ArrayList 实例都有一个容量,随着向 ArrayList 中不断添加元素,其容量也自动增长。
在添加大量元素前,应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
(3)ArrayList实例的线程同步一般通过对封装该列表的对象进行同步操作来完成;
如果不存在这样的对象,则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。
List list = Collections.synchronizedList(new ArrayList(...));
(4)ArrayList部分方法

 

 

public void ensureCapacity(int minCapacity){}  //增加此ArrayList实例的容量,以确保它至少能够容纳minCapacity所指定的元素数。
public void add(int index, E element){}    //将指定的元素插入此列表中的指定位置
public int indexOf(Object o){}      //返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1
protected  void removeRange(int from, int to){}  //移除列表中索引在 fromIndex(包括)和 toIndex(不包括)之间的所有元素
public void trimToSize(){}       //将此 ArrayList 实例的容量调整为列表的当前大小。此操作用来最小化 ArrayList 实例的存储量

(5)例如:

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class MyArrayList {

 public static void main(String[] args) {
  ArrayList< Integer> arraylist = new ArrayList(); //创建ArrayList对象,默认容量为10
  for(int i = 0 ; i < 15 ; i++){        //初始化数组列表内容
   arraylist.add(i);
  }

  Object[] arr =arraylist.toArray();       //获取arraylist内容,存放在数组中
  for (Object object : arr) {         //遍历数组,输出
   System.out.print( (int)object +"t");
  }
  System.out.println();

  System.out.println(arraylist.size());      //查询此时arraylist元素个数

  System.out.println(arraylist.contains(15));     //查询是否包含某一元素
  arraylist.add(5, -1);          //指定位置插入元素
  arraylist.add(15);           //末尾插入元素
  System.out.println(arraylist.contains(15));     //查询是否包含某一元素

  arr =arraylist.toArray();         //获取arraylist内容,存放在数组中
  for (Object object : arr) {         //遍历数组,输出
   System.out.print( (int)object +"t");
  }
  System.out.println();

  arraylist.set(5, 1);          //改变指定位置的元素
  arraylist.remove(16);          //移除指定位置的元素
  arraylist.remove(15); 
  arraylist.remove(arraylist.lastIndexOf(1));

  Iterator iterator = arraylist.iterator();   //迭代器遍历
  while(iterator.hasNext()){
   System.out.print(iterator.next()+"t");
  }
  System.out.println();

  arraylist.trimToSize();          //将此 ArrayList 实例的容量调整为列表的当前大小

  ListIterator listiterator = arraylist.listIterator(); //使用ListIterator遍历元素
  System.out.println(listiterator.hasPrevious());
  while(listiterator.hasNext()){
   System.out.print( listiterator.next()+"t" );
  }
  System.out.println();
  while(listiterator.hasPrevious()){
   System.out.print( listiterator.previous()+"t" );
  }
  System.out.println();

  listiterator.next();          //替换元素
  listiterator.next();
  listiterator.set(-1);

  while(listiterator.hasPrevious())       //指针回到列表头
   listiterator.previous();

  while(listiterator.hasNext())        //遍历
   System.out.print( listiterator.next()+"t" );
  System.out.println();
 }
}

6。LinkedList类
(1)可包含重复元素、值允许为null、线程不同步
(2)除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。
这些操作允许将链接列表用作堆栈、队列或双端队列
(3)此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的:在迭代器创建之后,如果从结构上对列表进行修改,
除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改,迭代器都将抛出 ConcurrentModificationException
(4)LinkedList部分方法

 

 

public void addFirst(E e){}    //将指定元素插入此列表的开头。
public void addLast(E e){}    //将指定元素添加到此列表的结尾

public E getFirst(){}     //返回此列表的第一个元素
public E getLast(){}     //返回此列表的最后一个元素

public E removeFirst(){}    //移除并返回此列表的第一个元素
public E removeLast(){}     //移除并返回此列表的最后一个元素

public ListIterator listIterator(int index){} //返回此列表中的元素的列表迭代器,从列表中指定位置开始
public Iterator descendingIterator(){}   //返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个到第一个的顺序返回

(5)例如:

 

import java.util.Iterator;
import java.util.LinkedList;

public class MyLinkedList {

 public static void main(String[] args) {
  LinkedList linkedlist = new LinkedList();//创建链接列表对象

  for(int i =0 ; i < 15 ; i++){       //初始化
   linkedlist.add(i);
  }

  Iterator iterator = linkedlist.iterator();//获取迭代器,遍历链接列表
  while(iterator.hasNext()){
   System.out.print( iterator.next()+"t" );
  }
  System.out.println();

  linkedlist.addFirst(15);//开头添加元素
  System.out.println( linkedlist.removeLast() );//末尾删除元素

  iterator = linkedlist.iterator();//获取迭代器,遍历链接列表
  while(iterator.hasNext()){
   System.out.print( iterator.next()+"t" );
  }
  System.out.println();

  Iterator descendingiterator = linkedlist.descendingIterator(); //获取逆向迭代器
  while(descendingiterator.hasNext())
   System.out.print( descendingiterator.next()+"t" );
  System.out.println();
 }
}    

7。Set接口
(1)不包含重复元素、最多包含一个null
(2)接口声明(部分):

 

public interface Setextends Collection{
  Iterator iterator();  //返回在此 set 中的元素上进行迭代的迭代器
  int size();     //返回 set 中的元素数
}

8。HashSet类
(1)不包含重复元素、允许一个null、线程不同步
(2)此类由HashMap实例支持,不保证迭代顺序恒久不变
(3)部分方法

public boolean add(E e){}   //如果此 set 中尚未包含指定元素,则添加指定元素
public Iterator iterator(){}  //返回对此 set 中元素进行迭代的迭代器
public boolean remove(Object o){} //如果指定元素存在于此 set 中,则将其移除

 

(4)例如

import java.util.HashSet;
import java.util.Iterator;

public class MyHashSet {

 public static void main(String[] args) {
  HashSet hashset = new HashSet();     //创建散列集合类对象

  for(int i =0 ; i < 15 ; i++)          //添加元素
   hashset.add(i);
  hashset.add(null);

  Iterator iterator = hashset.iterator();        //获取迭代器,遍历hashset
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();

  System.out.println( hashset.size() );         //返回集合中的元素个数
  System.out.println( hashset.contains(10) );       //测试集合
  System.out.println( hashset.add(10) );        //添加重复元素
  System.out.println( hashset.add(15) );        //添加不重复元素
  System.out.println( hashset.remove(0) );       //移除已有元素
  System.out.println( hashset.remove(0) );       //移除不存在元素

  iterator = hashset.iterator();          //获取迭代器,遍历hashset
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();


  System.out.println( hashset.isEmpty() );
  hashset.clear();             //清空集合
  System.out.println( hashset.isEmpty() );
 }
}

9。SortedSet接口
(1)元素不允许为null
(2)元素使用其自然顺序进行排序,或者根据在创建有序set时提供的Comparator进行排序;该set的迭代器将按元素升序遍历set
(3)插入有序set的所有元素都必须实现Comparable接口,所有这些元素都必须是可互相比较的
(4)所有有序set实现类都应该提供4个构造方法:
1)无参数构造方法,它创建一个空的有序set,按照元素的自然顺序进行排序
2)带有一个Comparator类型参数的构造方法,它创建一个空的有序set,根据指定的比较器进行排序
3)带有一个Collection类型参数的构造方法,它创建一个新的有序set,其元素与参数相同,按照元素的自然顺序进行排序
4)带有一个SortedSet类型参数的构造方法,它创建一个新的有序set,其元素和排序方法与输入的有序set相同
(5)部分方法

Comparator comparator();   //返回对此set中的元素进行排序的比较器;如果此set使用其元素的自然顺序,则返回null
E first();         //返回此 set 中当前第一个(最低)元素
E last();         //返回此 set 中当前最后一个(最高)元素
SortedSet subSet(E from, E to);   //返回此 set 的部分视图,其元素从 from(包括)到 to(不包括)
SortedSet headSet(E toElement);   //返回此 set 的部分视图,其元素严格小于 toElement
SortedSet tailSet(E fromElement);  //返回此 set 的部分视图,其元素大于等于 fromElement

10。TreeSet类
(1)不包含重复元素、不允许null、线程不同步
(2)使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法,元素必须是可比较的
(3)此实现为基本操作(add、remove 和 contains)提供受保证的 log(n) 时间开销
(4)部分方法

public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable{
 public TreeSet(){}         //构造一个新的空set,该set根据其元素的自然顺序进行排序
 public TreeSet(Comparator comparator){} //构造一个新的空 TreeSet,它根据指定比较器进行排序
 public TreeSet(Collection c){}   //构造一个包含指定 collection 元素的新 TreeSet,它按照其元素的自然顺序进行排序
 public TreeSet(SortedSet s){}     //构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet

 E ceiling(E e){}         //返回此set中 >=e 的最小元素;如果不存在这样的元素,则返回 null
 E floor(E e){}          //返回此set中 <=e 的最大元素;如果不存在这样的元素,则返回 null
 E higher(E e){}          //返回此set中 >e 的最小元素;如果不存在这样的元素,则返回 null
 E lower(E e){}          //返回此set中  comparator(){}    //返回对此set中的元素进行排序的比较器;如果此set使用其元素的自然顺序,则返回 null

 Iterator iterator(){}       //返回在此 set 中的元素上按升序进行迭代的迭代器
 Iterator descendingIterator(){}     //返回在此 set 元素上按降序进行迭代的迭代器
}

(5)例如

 

/*例一*/
import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;

public class MyTreeSet {

 public static void main(String[] args) {
  TreeSet treeset = new TreeSet();   //创建树集合对象

  Random r = new Random();
  for(int i =0 ; i < 15 ; i++)        //添加元素
   treeset.add( r.nextInt(50) );

  Iterator iterator = treeset.iterator();   //获取迭代器,正向遍历元素
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();

  Iterator desciterator = treeset.descendingIterator();//获取迭代器,逆向遍历元素
  while(desciterator.hasNext())
   System.out.print( desciterator.next()+"t" );
  System.out.println();
 }
}

/*例二*/
public class Person{
 private int number = 0;
 private int age = 0;

 public Person(int number , int age) {
  this.number = number;
  this.age = age;
 }

 public int getAge() {
  return age;
 }
 public int getNumber() {
  return number;
 }

 @Override
 public String toString() {
  return "["+this.number+","+this.age+"]";
 }
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.Random;

public class TreeSetCom implements Comparator{

 public static void main(String[] args) {
  TreeSet treeset = new TreeSet(new TreeSetCom()); //创建树集合

  Random age = new Random();
  Random num = new Random();

  for(int i  = 0 ; i < 15 ; i++)          //添加元素
   treeset.add(new Person(num.nextInt(30), age.nextInt(20)));

  Iterator iterator = treeset.iterator();      //获取迭代器,遍历元素
  while(iterator.hasNext())
   System.out.print( iterator.next().toString()+"--" );
  System.out.println();
 }

 @Override
 public int compare(Person arg0, Person arg1) {
  return arg0.getAge() - arg1.getAge();
 }

/* @Override
 public int compare(Person arg0, Person arg1) {
  return arg0.getNumber() - arg1.getNumber();
 }*/
}

11。Vector类
(1)允许重复、允许null、线程同步
(2)基于数组
(3)Vector 的 elements 方法返回的 Enumeration 不是 快速失败的
(4)如果容量的增量小于等于零,则每次需要增大容量时,向量的容量将增大一倍
(5)部分方法

public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable{
 public Vector(){}      //构造一个空向量,使其内部数据数组的大小为 10,其标准容量增量为零   
 public Vector(int initialCapacity){} //使用指定的初始容量和等于零的容量增量构造一个空向量
 public Vector(int initialCapacity,int capacityIncrement){} //使用指定的初始容量和容量增量构造一个空的向量

 public void ensureCapacity(int minCapacity){}  //增加此向量的容量,以确保其至少能够保存最小容量参数指定的组件数
 public void setSize(int newSize){} //设置此向量的大小。如果新大小大于当前大小,则会在向量的末尾添加相应数量的 null 项;
          //如果新大小小于当前大小,则丢弃索引 newSize 处及其之后的所有项
 public Enumeration elements(){} //返回此向量的组件的枚举。返回的Enumeration对象将生成此向量中的所有项,第一项为索引0处的项,然后是索引1处的项...
 public void addElement(E obj){}  //将指定的组件添加到此向量的末尾,将其大小增加 1。如果向量的大小比容量大,则增大其容量

 public E get(int index){}   //返回向量中指定位置的元素
 public E set(int index,E element) //用指定的元素替换此向量中指定位置处的元素
 protected void removeRange(int from,int to){} //从此 List 中移除其索引位于from(包括)与to(不包括)之间的所有元素
}

(6)例如

 

import java.util.Enumeration;
import java.util.Vector;
import java.util.Iterator;
import java.util.Random;

public class MyVector {
 public static void main(String[] args) {

  Vector vector = new Vector();   //创建无参向量对象

  Random r = new Random();           //初始化向量对象
  for(int i = 0 ; i < 9 ; i++)
   vector.add( r.nextInt(30) );

  Iterator iterator = vector.iterator();     //获取迭代器,遍历向量
  while(iterator.hasNext())
   System.out.print(iterator.next()+"t");
  System.out.println();

  Enumeration enumeration = vector.elements(); //获取向量组件的枚举,遍历向量
  while( enumeration.hasMoreElements() )
   System.out.print( enumeration.nextElement()+"t" );
  System.out.println();

  System.out.println( vector.size() );         //对向量容量的操作
  System.out.println( vector.capacity() );
  vector.setSize(12);
  System.out.println(vector.size());
  vector.trimToSize();
  System.out.println(vector.capacity());

  vector.addElement(null);
  vector.add(10, 9);
  vector.add(13);
  iterator = vector.iterator();     //获取迭代器,遍历向量
  while(iterator.hasNext())
   System.out.print(iterator.next()+"t");
  System.out.println();

  System.out.println(vector.capacity());
  System.out.println(vector.size());
 }
}    

12。Stack类
(1)Stack类表示堆栈,对类Vector进行了扩展,提供了push、pop操作
(2)部分方法

public class Stack extends Vector{
 public Stack(){}   //创建一个空堆栈

 public E push(E item){}  //把项压入堆栈顶部
 public E pop(){}   //移除堆栈顶部的对象,并作为此函数的值返回该对象

 public E peek(){}   //查看堆栈顶部的对象,但不从堆栈中移除它

 public int search(Object o){} //对象到堆栈顶部的位置,以 1 为基数;返回值 -1 表示此对象不在堆栈中

 public boolean empty(){} //测试堆栈是否为空
}

(3)例如

 

import java.util.Stack;
import java.util.Iterator;

public class MyStack {
 public static void main(String[] args) {
  Stack stack = new Stack();    //创建栈

  for(int i = 0 ; i < 11 ; i++)            //初始化栈
   stack.add(i);

  Iterator iterator = stack.iterator();         //获取迭代器,遍历栈
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();

  System.out.println( stack.search(4) );         //查询元素到栈顶的距离
  System.out.println( stack.search(15) );

  System.out.println( stack.capacity() );
  System.out.println( stack.size() );

  System.out.println( stack.push(10) );//push and pop
  System.out.println( stack.push(11) );

  iterator = stack.iterator();         //获取迭代器,遍历栈
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();

  System.out.println( stack.peek() );
  System.out.println( stack.pop() );

  iterator = stack.iterator();         //获取迭代器,遍历栈
  while(iterator.hasNext())
   System.out.print( iterator.next()+"t" );
  System.out.println();

  while( !stack.isEmpty() )//依次出栈
   System.out.print( stack.pop()+"t" );
  System.out.println();
 }
}

SE基础(Collection接口概述) Collection接口相关集成关系如下图 1。关于可迭代接口(Iterable) 可迭代接口仅包含一个方法,返回一个在一组T类型...

JAVA 集合类介绍和使用

类关系示意图
Iterable(接口)
    │
    └--Collection (接口)
        ├-List(接口)
        │ ├-LinkedList  不同步  (构造同步:List list = Collections.synchronizedList(new LinkedList(...));)
        │ ├-ArrayList   不同步 
        │ └-Vector      同步
365bet在线官网,        │ └--Stack     同步
        └-Set
            ├--EnumSet
            ├--HashSet --LinkedHashSet
            └--TreeSet

Map
├--Hashtable
├--HashMap --LinkedHashMap
└--WeakHashMap

Map接口:
    |
    + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map。在 WeakHashMap 中,当某个键不再正常使用时,将自动移除其条目。更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃,这就使该键成为可终止的,被终止,然后被回收。丢弃某个键时,其条目从映射中有效地移除,因此,该类的行为与其他的 Map 实现有所不同。此实现不是同步的。
    |
    + -- TreeMap:该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。此实现不是同步的。
    |
    + -- HashMap:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序,特别是它不保证该顺序恒久不变。此实现不是同步的。
    |
    +-- SortedMap: 进一步提供关于键的总体排序 的 Map。该映射是根据其键的自然顺序进行排序的,或者根据通常在创建有序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图(由 entrySet、keySet 和 values 方法返回)进行迭代时,此顺序就会反映出来。要采用此排序方式,还需要提供一些其他操作(此接口是 SortedSet 的对应射)。

Collection接口:
    |
    + -- Set接口:一个不包含重复元素的 collection。更正式地说,set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素。正如其名称所暗示的,此接口模仿了数学上的 set 抽象。
    |      |
    |      + -- HashSet:此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。此类为基本操作提供了稳定性能,此实现不是同步的。
    |      |
    |      + -- LinkedHashSet:具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,即按照将元素插入到 set中的顺序(插入顺序)进行迭代。注意,插入顺序不 受在 set 中重新插入的 元素的影响。此实现不是同步的。
    |      |
    |      + -- TreeSet:基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。此实现为基本操作(add、remove 和 contains)提供受保证的 log(n) 时间开销。此实现不是同步的。
    |
    + -- List接口:有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。
           |
           + -- ArrayList:List 接口的大小可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。(此类大致上等同于Vector 类,除了此类是不同步的。)每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素,其容量也自动增长。并未指定增长策略的细节,因为这不只是添加元素会带来分摊固定时间开销那样简单。此实现不是同步的。
           |
           + -- LinkedList:List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。提供先进先出队列操作(FIFO)。此实现不是同步的。
           |
           + -- Vector:Vector 类可以实现可增长的对象数组。与数组一样,它包含可以使用整数索引进行访问的组件。但是,Vector 的大小可以根据需要增大或缩小,以适应创建 Vector 后进行添加或移除项的操作。此实现是同步的.

Collection接口
  Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
  所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
  如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下:
    Iterator it = collection.iterator(); // 获得一个迭代子
    while(it.hasNext()) {
      Object obj = it.next(); // 得到下一个元素
    }
  由Collection接口派生的两个接口是List和Set。
List接口
  List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
和下面要提到的Set不同,List允许有相同的元素。
  除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个 ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。
  实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

LinkedList类
  LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
  注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
    List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
  ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
  每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
  和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

Vector类
  Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

Stack 类
  Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

 */

package myapp.data;
import myapp.model.Article;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.*;
import java.util.Map.Entry;

public class CollectionMethodTest {
    
    private static List<Article> list=new ArrayList<Article>(6);
    
    public static void initialize() throws ParseException{
         
         DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.FRANCE);
         list.add(new Article(1,"NBA1","Carl1","NBA Start1",df.parse("2010-01-1"),1));
         list.add(new Article(2,"NBA2","Carl2","NBA Start2",df.parse("2010-01-2"),2));
         list.add(new Article(3,"NBA3","Carl3","NBA Start3",df.parse("2010-01-3"),3));
         list.add(new Article(4,"NBA4","Carl4","NBA Start4",df.parse("2010-01-4"),4));
         list.add(new Article(5,"NBA5","Carl5","NBA Start5",df.parse("2010-01-5"),5));
         list.add(new Article(6,"NBA6","Carl6","NBA Start6",df.parse("2010-01-6"),6));
     }
    
    
     //列表通常允许重复的元素 ,允许NULL元素,有序
     //原型:public interface List<E> extends Collection<E>
     //常用实现类:    AbstractList, ArrayList, LinkedList, Stack, Vector
     public void listTest(){
         
     }
     
    //HashMap:允许使用 null 值和 null 键,不同步,实现了Map接口和AbstractMap抽象类
    //原型:public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
     public void hashMapTest(){
         System.out.println("--------HashMap遍历------");
         
         Map<Integer, String> map=new HashMap<Integer,String>();
         for(Article a : list){
             map.put(a.getId(), a.getTitle()+a.getContent());
         }
        //得到map的所有的键
         Set<Integer> keys=map.keySet();
        //得到map的所有的值
         Collection<String> values=map.values();
        //返回包含在此映射中的映射关系的 Set 视图。
        Set<Map.Entry<Integer, String>> setEntry=map.entrySet();
        //使用Iterator遍历器遍历
        System.out.println("--------使用Iterator遍历器遍历------");
        Iterator<Entry<Integer,String>> it = setEntry.iterator();
        while(it.hasNext()){
            Entry<Integer,String> e = it.next();
            System.out.println("Id:"+e.getKey()+" Description:"+e.getValue());
        }
        //使用for遍历
        System.out.println("--------使用for遍历------");
        for(Entry<Integer,String> e:setEntry){
            System.out.println("Id:"+e.getKey()+" Description:"+e.getValue());
        }
     }
     
     //Set:一个不包含重复元素的 collection。更正式地说,set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素
     //原型:public interface Set<E> extends Collection<E>
     //实现类:    AbstractSet, EnumSet, HashSet, LinkedHashSet, TreeSet、 JobStateReasons,CopyOnWriteArraySet
     public void setTest(){
         Set<String> set=new HashSet<String>();
         set.add("No1");
         set.add("No2");
         set.add("No3");
     }
}

本文由365bet体育备用网址器发布于应用,转载请注明出处:关于可迭代接口(Iterable)

关键词: