您的位置:1010cc时时彩经典版 > 1010cc时时彩经典版 > 1010cc时时彩经典版java集结全部,Java集结知识点总

1010cc时时彩经典版java集结全部,Java集结知识点总

发布时间:2019-08-15 22:57编辑:1010cc时时彩经典版浏览(162)

    java集合你了解多少?,java集合了解

    用了java集合这么久,还没有系统的研究过java的集合结构,今天亲自画了下类图,总算有所收获。

     

    1010cc时时彩经典版 1

    一、所有集合都实现了Iterable接口。

        Iterable接口中包含一个抽象方法:Iterator<T> iterator();每个实现了这个方法的集合都会返回一个Iterator对象。

        Iterator:它包含三个方法,hashNext(),next(),remove()三种方法,通过它们可以实现集合的遍历和元素删除,例如:

        Collection<String> list = new ArrayList<String>();

       list.add("a");   

       list.add("b");  

        list.add("c");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {  

             String element = iterator.next();

              System.out.println(element);//a b c

        }  

        System.out.println(list);//[a, b, c]      iterator = list.iterator();    iterator.next();

        iterator.remove();

        System.out.println(list);//[b, c]

        ps:为什么不直接实现Iterator接口呢?因为:Iterator会携带当前集合的位置信息,下次使用再使用的时候就非从0开始了;而Iterable接口每次都返回一个Iterator对象(通过内部类实现Iterator),各个迭代器之间互不影响。

     

    二、ListIterator

     

        从AbstractList起封装了public ListIterator<E> listIterator()方法,返回一个ListIterator,它在Iterator的基础上增加了add(),previous(),hasPrevious()等方法,可以实现双向遍历。

    AbstractList<String> list = new ArrayList<String>();

    list.add("a");

    list.add("b");

    list.add("c");

    ListIterator<String> iterator = list.listIterator(3);

    while (iterator.hasPrevious()) {

    String element = iterator.previous();

    System.out.println(element);//c,b,a

    }

     

    三、比较

        ArrayList:允许存放重复元素,且元素是有序的,随机访问比较方便。

        LinkedList:链表实现,插入和删除时更优于ArrayList。

        HashSet:不允许重复元素且无序(散列函数对元素进行排序,可快速查询),允许null值。

        TreeSet:红黑树排序,可进行排序,包含的元素要实现Comparable接口并定义compareTo方法,不允许null值。

        HashMap:线程不安全,key和值都允许null,判断是否包含key要使用containsKey()方法,不允许重复key,hash数组的默认大小是16,而且一定是2的指数,重新计算hash值。

        HashTable:线程安全,key和value都不允许出现null值,不允许重复key,数组默认大小是11,增加的方式是 old*2 1,使用包含对象的hash值。

     

    四、Collections和Arrays

        Collections:java.util下的一个专用类,它包含有各种有关集合操作的静态方法,可实现对各种集合的搜索、排序、线程安全化等操作。

        Arrays:java.util下的一个专用类,用来操作array ,提供搜索、排序、复制,转换等静态方法。

     

    关注老姜谈技术,微信号:helojava,或者扫描下面二维码。

    1010cc时时彩经典版 2
    每日一帖,技术鸡汤。

    用了java集合这么久,还没有系统的研究过java的集合结构,今天亲自画了下类图,总算有所收获。 一、...

    Java集合知识点总结——博客园:执、著,java知识点

    数组与集合的区别:

    Java中的数组是存放同一类型数据的集合。数组可以存放基本数据类型的数据,也可以存放引用数据类型的数据,但数组的长度是固定的。

    集合只能存放引用数据类型的数据,不能存放基本数据类型的数据,但集合的数目是可变的。

    1010cc时时彩经典版 3

     

    所有的集合类都存放在java.util包中

     List接口是元素有序,可重复的集合,添加自定义类时需要重写equals()方法

    ArrayList集合中,插入一个元素时,列表需要将插入点后面的所有元素向后移动,而在删除(remove())一个元素时,需要将被删除元素后面的所有元素向前移动

    ArrayList集合允许所有的元素,包括null

    例1:ArrayList的一些基本方法

    public class ArrayListText{

      public static void main(String[] args){

        Collection<String> collection=new ArrayList<String>();

        List<String> list=new ArrayList<String>();

        collection.add("1");

        collection.add("2");

        collection.add("3");

        list.add("A");

        list.add("B");

        list.add("C");

        list.addAll(0,collection);//向指定位置添加一个集合的所有元素

        System.out.println("list集合:" list);

        List<String> subList=list.subList(1,5);

        System.out.println("subList集合:" subList);

        System.out.println("设置list集合元素前::" list.get(3));

        list.set(3,"Set");

        System.out.println("设置list集合元素后::" list.get(3));

        System.out.println("list集合中,元素3的位置:" list.indexOf("3") ",元素D的位置:" list.indexOf("D"));//获取指定元素在集合中的索引位置,若不存在则返回-1

        String arrString[]=list.toArray(new String[]{});//将集合转为字符串数组

        for(String str:arrString){

          System.out.print(str " ");

        }

        System.out.println("nlist集合是否为空:" list.isEmpty());

        list.clear();

        System.out.println("nlist集合是否为空:" list.isEmpty());

      }

    }

    结果:

    list集合:[1,2,3,A,B,C]

    subList集合:[2,3,A,B]

    设置list集合元素前::A

    设置list集合元素后::Set

    list集合中,元素3的位置:2,元素D的位置:-1

    1  2  3  Set  B  C

    list集合是否为空:false

    list集合是否为空:true

    将数组转换为ArrayList集合

    String[] str={"W","E","C","O","M","E"};

    List<String> list=Arrays.asList(str);

    ArrayList<String> arrList=new ArrayList<String>();

    arrList.addAll(list);

    LinkedList是链表类,链表结构的优点是便于向集合插入和删除元素。因为在插入或删除元素时,不需要移动任何元素,LinkedList也可以存在null元素

    获取表头的方法:

    getFirst():仅仅是获取表头     element():获取但不移除此链表头   peek():获取但不移除此链表头    poll():获取并移除此链表头  pop():获取并移除此链表头

    例2:LinkedList获取链表头

    public class LinkedListText{

      public static void main(String[] args){

        LinkedList<String> link=new LinkedList<String>();

        link.add("1");

        link.add("2");

        link.add("3");

        link.addFirst("F");

        link.addLast("L");

        LinkedList<String> newLink=new LinkedList<String>(link);

        System.out.println("添加元素后:nt" link);

        System.out.println("get()方法获取表头:" link.getFirst());

        System.out.println("使用get()方法后:nt" link);

        System.out.println("element()方法获取表头:" link.element());

        System.out.println("使用element()方法后:nt" link);

        System.out.println("peek()方法获取表头:" link.peek());

        System.out.println("使用peek()方法后:nt" link);

        System.out.println("poll()方法获取表头:" link.poll());

        System.out.println("使用poll()方法后:nt" link);

        System.out.println("pop()方法获取表头:" link.pop());

        System.out.println("使用pop()方法后:nt" link);

        System.out.println("******使用链表的先进先出*******");

        int  len=newLink.size();

        for(int i=0;i<len;i ){

          System.out.print(newLink.poll() " ");

        }

      }

    }

    结果:

    添加元素后:

    [F,1,2,3,L]

    get()方法获取表头:F

    使用get()方法后:

    [F,1,2,3,L]

    element()方法获取表头:F

    使用element()方法后:

    [F,1,2,3,L]

    peek()方法获取表头:F

    使用peek()方法后:

    [F,1,2,3,L]

    poll()方法获取表头:F

    使用poll()方法后:

    [1,2,3,L]

    pop()方法获取表头:1

    使用pop()方法后:

    [2,3,L]

    *****使用链表的先进先出*****

    F 1 2 3 L

     Set集合是元素无序,不可重复的集合,允许包含null元素,添加自定义类一定要重写equals()和hashcode()方法

    HashSet类可以快速地定位一个元素,但放到HashSet集合中的元素需要重写equals()和hashcode()方法,而TreeSet集合将放进其中的元素按序存放

    HashSet是按哈希算法来存放集合中的元素的,使用哈希算法可以提高存取的效率

    HashSet集合的特点:1.不能保证元素的排列顺序,集合中元素的顺序随时有可能发生改变  2.集合中最多允许存在一个null元素  3.HashSet集合不是线程同步的

    LinkedHashSet插入性能略低于HashSet,但在迭代访问Set里的全部元素时有很好的性能,LinkedHashSet()使用链表维护了一个添加进集合中的顺序,导致当我们遍历LinkedHashSet集合元素时是按添加进去的顺序遍历的,但不能说明它是有序的!

    TreeSet类实现了java.util包中的Set接口和SortedSet接口,TreeSet集合中的元素在默认情况下是升序排序

    TreeSet集合的特点:1.向TreeSet中添加的元素必须是同一个类的  2.从小到大遍历   3.自定义类没有实现Comparable接口时,当向TreeSet中添加此对象时,报错

    例2:自定义类实现Comparable接口

    class Person implements Comparable{

      private String name;

      private String age;

      public Person(){

      }

      public Person(String name,int age){

        this.name=name;

        this.age=age;

      }

      public int compareTo(Person per){

        if(this.age>per.age){

          return 1;

        }else if(this.age<per.age){

          return -1;

        }else{

          return this.name.compareTo(per.name);

        }

      }

      public String toString(){

        return ("姓名:" name ",年龄:" age "n");

      }

    }

    public class TreeSetDemo{

      public static void main(String[] args){

        Set<Person> tset=new TreeSet<Person>();

        tset.add(new Person("小强",21));

        tset.add(new Person("小伟",23));

        tset.add(new Person("小强",21));

        tset.add(new Person("小强",21));

        tset.add(new Person("小琴",20));

        tset.add(new Person("小婷",20));

        System.out.println(tset);

      }

    }

    结果:

    [姓名:小婷,年龄:20

    ,姓名:小琴,年龄:20

    ,姓名:小强,年龄:21

    ,姓名:小伟,年龄:23

    ]

    集合的输出:1.Iterator:迭代器输出(提供遍历各种集合类型的迭代器)   2.foreach:JDK1.5新增的输出

    迭代删除:

    Iterator<String> it=link.iterator();

    while(it.hasNext){

      it.next();

      it.remove();

    }

    注释:在调用remove()方法前需要使用next()方法指定要删除的元素,否则运行时将产生IllegalStateException异常

     Map接口提供的是key-value的映射,其中key不允许重复,每一个key只能映射一个value,常用String类作为Map的键

    一个key-value对是一个Entry,所有的Entry是用Set存放的,不可重复。key是用Set来存放的,不可重复,value是用Collection存放的,可重复

    Map.Entry接口是静态的,所以可以直接使用”外部类.内部类“的形式调用

    HashMap类是实现Map集合,对于元素的添加和删除有着较高的效率。HashMap类提供所有可选的映射操作,并允许使用null值和null键,但必须保证键是唯一的,HashMap是非同步的,也不保证映射顺序

    例3:获取Map集合中的全部key和value

    public class HashMapDemo{

      public static void main(String[] arg){

        Map<Integer,String> map=new HashMap<Integet,String>();

        map.put(1,"清华大学");

        map.put(2,"北京大学");

        map.put(3,"复旦大学");

        map.put(4,"武汉大学");

        map.put(5,"中国科技大学");

        map.put(6,"中国矿业大学");

        Set<Integer> set=map.keySet();

        Iterator<Integet> itKey=set.iterator();

        System.out.println("Map集合中全部的key:");

        while(itKey.hasNext()){

          System.out.print(itKey.next() " ");

        }

        System.out.println();

        Collection<String> c=map.values();

        Iterator<String> itValue=c.iterator();

        System.out.println("Map集合中全部的value:");

        while(itValue.hasNext()){

          System.out.print(itValue.next() " ");

        }

      }

    }

    结果:

    Map集合中全部的key:

    1 2 3 4 5 6

    Map集合中全部的value:

    清华大学 北京大学 复旦大学 武汉大学 中国科技大学 中国矿工大学

    例4:使用Iterator输出Map集合

    public class hashMapDemo{

      public static void main(String[] args){

        Map<Integer,String> map=new HashMap<Integet,String>();

        map.put(1,"清华大学");

        map.put(2,"北京大学");

        map.put(3,"复旦大学");

        map.put(4,"武汉大学");

        map.put(5,"中国科技大学");

        map.put(6,"中国矿业大学");

        Set<Map.Entry<Integer,String>> set=map.entrySet();

        Iterator<Map.Entry<Integet,String>> it=set.iterator();

        System.out.println("Key--------Value");

        while(it.hasNext()){

          Map.Entry<Integer,String> mapEntry=it.next();

          System.out.println("" mapEntry.getKey() "-------" mapEntry.getValue());

        }

      }

    }

    结果:

    key------value

    1-----清华大学

    2-----北京大学

    3-----复旦大学

    4-----武汉大学

    5-----中国科技大学

    6-----中国矿业大学

    使用foreach输出:

    for(Map.Entry<Integet,String> mapEntry:map.entryKey()){

      System.out.println("" mapEntry.getKey() "-------" mapEntry.getValue());

    }

    TreeMap类不但实现了Map接口,还实现了SortedMap接口,因此,TreeMap集合中的映射关系具有一定的顺序性。与HashMap相比,TreeMap集合对元素的添加、删除和定位映射性能较低

    Collections类可以对集合的元素进行排序、反序、去极值、循环移位、查询和修改等功能,还可以将集合对象设置不可变、对集合对象实现同步控制等方法。

    Collections类所提供的方法均为静态方法,可以直接通过“类名.方法()"的形式调用

    Collections常用方法:addAll(Collection c,T...elements)--Collections.addAll(list,"1","2","3")  binarySearch(List list,T key)-使用此方法前必须先使用sort(List list,Comparator c)方法进行排序  copy(List dest,List src)//将src集合中的所有元素复制到dest集合中  fill(List list,T obj)//使用指定元素替换指定集合中的所有元素  max(Collection coll) max(Collection coll,Comparator c)  replaceAll(List list,T oldVal,T newVal)//使用另一个元素替代集合中指定的所有元素  reverse(List list) 

    Stack-栈是一种特殊的线性表,它仅限于在表尾进行元素的添加与删除操作。栈的表尾成为栈顶,表头成为栈底。栈是采用“先进后出”的数据存储方式,若栈中没有任何元素,则成为空栈。栈是Vector的子类

    empty()//判断该栈是否为空,若为空返回true  peek()//获取栈顶元素,但不删除它  pop()//获取栈顶元素,并删除它  push()//将元素添加到栈顶中  search()、、查找指定元素在栈中位置,起始位置为1,不是0

    Hashtable类是Map的子类,是JDK1.0是出现的,Hashtable类是同步的,线程安全的,不允许存放null键和null值,其他功能与HashMap类似

    数组与集合的区别: Java中的数组是存放同一类型数据的集合。数组可以存放基本数据...

    Java集合:整体结构,java集合整体

    一、Java中集合

      Java中集合类是Java编程中使用最频繁、最方便的类。集合类作为容器类可以存储任何类型的数据,当然也可以结合泛型存储指定的类型(不过泛型仅仅在编译期有效,运行时是会被擦除的)。集合类中存储的仅仅是对象的引用,并不存储对象本身。集合类的容量可以在运行期间进行动态扩展,并且还提供很多很方便的方法,如求集合的并集、交集等。

    二、集合类结构

      Java中的集合包含多种数据结构,如链表、队列、哈希表等。从类的继承结构来说,可以分为两大类,一类是继承自Collection接口,这类集合包含List、Set和Queue等集合类。另一类是继承自Map接口,这主要包含了哈希表相关的集合类。下面我们看一下这两大类的继承结构图:

    1、List、Set和Queue

    1 package com.paddx.test.collection; 2 3 import java.util.ArrayList; 4 import java.util.LinkedList; 5 6 public class ListTest { 7 public static void main(String[] args) { 8 for(int i=0;i<10000;i ){ 9 10 } 11 long start = System.currentTimeMillis(); 12 13 LinkedList<Integer> linkedList = new LinkedList<Integer>(); 14 for(int i=0;i<100000;i ){ 15 linkedList.add(0,i); 16 } 17 18 long end = System.currentTimeMillis(); 19 System.out.println(end - start); 20 21 ArrayList<Integer> arrayList = new ArrayList<Integer>(); 22 for(int i=0;i<100000;i ){ 23 arrayList.add(0,i); 24 } 25 26 System.out.println(System.currentTimeMillis() - end); 27 } 28 }

    下面是本地执行的结果:

    23
    1227
    

      可以看出,在这种情况下,LinkedList的插入效率远远高于ArrayList,当然这是一种比较极端的情况。我们再来比较一下两者随机访问的效率:

     1 package com.paddx.test.collection;
     2 
     3 import java.util.ArrayList;
     4 import java.util.LinkedList;
     5 import java.util.Random;
     6 
     7 public class ListTest {
     8     public static void main(String[] args) {
     9 
    10         Random random = new Random();
    11 
    12         for(int i=0;i<10000;i  ){
    13 
    14         }
    15         LinkedList<Integer> linkedList = new LinkedList<Integer>();
    16         for(int i=0;i<100000;i  ){
    17             linkedList.add(i);
    18         }
    19 
    20         ArrayList<Integer> arrayList = new ArrayList<Integer>();
    21         for(int i=0;i<100000;i  ){
    22             arrayList.add(i);
    23         }
    24 
    25         long start = System.currentTimeMillis();
    26 
    27 
    28         for(int i=0;i<100000;i  ){
    29             int j = random.nextInt(i 1);
    30             int k = linkedList.get(j);
    31         }
    32 
    33         long end = System.currentTimeMillis();
    34         System.out.println(end - start);
    35 
    36         for(int i=0;i<100000;i  ){
    37             int j = random.nextInt(i 1);
    38             int k = arrayList.get(j);
    39         }
    40 
    41         System.out.println(System.currentTimeMillis() - end);
    42     }
    43 }
    

    下面是我本机执行的结果:

    5277
    6
    

      很明显可以看出,ArrayList的随机访问效率比LinkedList高出好几个数量级。通过这两段代码,我们应该能够比较清楚的知道LinkedList和ArrayList的区别和适应的场景。至于Vector,它是ArrayList的线程安全版本,而Stack则对应栈数据结构,这两者用的比较少,这里就不举例了。

      (2)Queue:一般可以直接使用LinkedList完成,从上述类图也可以看出,LinkedList继承自Deque,所以LinkedList具有双端队列的功能。PriorityQueue的特点是为每个元素提供一个优先级,优先级高的元素会优先出队列。

      (3)Set:Set与List的主要区别是Set是不允许元素重复的,而List则可以允许元素重复的。判断元素的重复需要根据对象的hash方法和equals方法来决定。这也是我们通常要为集合中的元素类重写hashCode方法和equals方法的原因。我们还是通过一个例子来看一下Set和List的区别,以及hashcode方法和equals方法的作用:

    package com.paddx.test.collection;
    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.Set;
    
    public class SetTest {
    
        public static void main(String[] args) {
            Person p1 = new Person("lxp",10);
            Person p2 = new Person("lxp",10);
            Person p3 = new Person("lxp",20);
    
            ArrayList<Person> list = new ArrayList<Person>();
            list.add(p1);
            System.out.println("---------");
            list.add(p2);
            System.out.println("---------");
            list.add(p3);
            System.out.println("List size="   list.size());
    
            System.out.println("----分割线-----");
    
            Set<Person> set = new HashSet<Person>();
            set.add(p1);
            System.out.println("---------");
            set.add(p2);
            System.out.println("---------");
            set.add(p3);
            System.out.println("Set size=" set.size());
        }
    
    
        static class Person{
            private String name;
            private int age;
    
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }
    
            @Override
            public boolean equals(Object o) {
                System.out.println("Call equals();name=" name);
                if (this == o) return true;
                if (o == null || getClass() != o.getClass()) return false;
    
                Person person = (Person) o;
    
                return name.equals(person.name);
    
            }
    
            @Override
            public int hashCode() {
                System.out.println("Call hashCode(),age=" age);
                return age;
            }
        }
    }
    

      上述代码的执行结果如下:

    ---------
    ---------
    List size=3
    ----分割线-----
    Call hashCode(),age=10
    ---------
    Call hashCode(),age=10
    Call equals();name=lxp
    ---------
    Call hashCode(),age=20
    Set size=2
    

      从结果看出,元素加入List的时候,不执行额外的操作,并且可以重复。而加入Set之前需要先执行hashCode方法,如果返回的值在集合中已存在,则要继续执行equals方法,如果equals方法返回的结果也为真,则证明该元素已经存在,会将新的元素覆盖老的元素,如果返回hashCode值不同,则直接加入集合。这里记住一点,对于集合中元素,hashCode值不同的元素一定不相等,但是不相等的元素,hashCode值可能相同。

      HashSet和LinkedHashSet的区别在于后者可以保证元素插入集合的元素顺序与输出顺序保持一致。而TresSet的区别在于其排序是按照Comparator来进行排序的,默认情况下按照字符的自然顺序进行升序排列。

      (4)Iterable:从这个图里面可以看到Collection类继承自Iterable,该接口的作用是提供元素遍历的功能,也就是说所有的集合类(除Map相关的类)都提供元素遍历的功能。Iterable里面包含了Iterator的迭代器,其源码如下,大家如果熟悉迭代器模式的话,应该很容易理解。

    1 public interface Iterator<E> {
    2 
    3     boolean hasNext();
    4 
    5     E next();
    6 
    7     void remove();
    8 }
    

    2、Map:

    package com.paddx.test.collection; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.TreeMap; public class MapTest { public static void main(String[] args) { Map<String,String> treeMap = new TreeMap<String,String>(); Map<String,String> linkedMap = new LinkedHashMap<String, String>(); treeMap.put("b",null); treeMap.put("c",null); treeMap.put("a",null); for (Iterator<String> iter = treeMap.keySet().iterator();iter.hasNext();){ System.out.println("TreeMap=" iter.next()); } System.out.println("----------分割线---------"); linkedMap.put("b",null); linkedMap.put("c",null); linkedMap.put("a",null); for (Iterator<String> iter = linkedMap.keySet().iterator();iter.hasNext();){ System.out.println("LinkedHashMap=" iter.next()); } } }

    运行上述代码,执行结果如下:

    TreeMap=a
    TreeMap=b
    TreeMap=c
    ----------分割线---------
    LinkedHashMap=b
    LinkedHashMap=c
    LinkedHashMap=a
    

      从运行结果可以很明显的看出这TreeMap和LinkedHashMap的区别,前者是按字符串排序进行输出的,而后者是根据插入顺序进行输出的。细心的读者可以发现,HashMap与TreeMap的区别,与之前提到的HashSet与TreeSet的区别是一致的,在后续进行源码分析的时候,我们可以看到HashSet和TreeSet本质上分别是通过HashMap和TreeMap来实现的,所以它们的区别自然也是相同的。HashTable现在已经很少使用了,与HashMap的主要区别是HashTable是线程安全的,不过由于其效率比较低,所以通常使用HashMap,在多线程环境下,通常用CurrentHashMap来代替。

    三、总结

      本文只是从整体上介绍了Java集合框架及其继承关系。除了上述类,集合还提供Collections和Arrays两个工具类,此外,集合中排序跟Comparable和Comparator紧密相关。在之后的文章中将对上述提的类在JDK中实现源码进行详细分析。

    一、Java中集合 Java中集合类是Java编程中使用最频繁、最方便的类。集合类作为容器类可以存储任何类型的...

    紧接上文中我们谈到的Java框架中的Collection接口,接下来我们一起再去看看Java框架中的其他组成部分吧:

    引用自:

    四、Map接口

    Collection层次结构

    1010cc时时彩经典版 4

    Map与List、Set接口不同,它是由一系列键值对组成的集合,提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value,所以它不能存在相同的key值,当然value值可以相同。

    Collection

    子接口  

    1. Set,List  
    2. 集合中只能放置对象的引用,不能放置原生数据类型,  
    3. 我们需要使用原生数据类型的封装类才能加入到集合中  

    1.HashMap

    Ordered与Sorted接口

    1. Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的  
    2. Sorted排序,按照天然顺序进行排序,是先天指定的  

    以哈希表数据结构实现,查找对象时通过哈希函数计算其位置,它是为快速查询而设计的,其内部定义了一个hash表数组(Entry[] table),元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引,如果有冲突,则使用散列链表的形式将所有相同哈希地址的元素串起来,可能通过查看HashMap.Entry的源码它是一个单链表结构。

    List

    1. 实现类包括  
    2.     LinkedList,Vector,ArrayList  
    3. 列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection  
    4.     具有列表的功能,元素顺序均是按添加的先后进行排列的,  
    5.     允许重复的元素,允许多个null元素

    2.LinkedHashMap

    List常用方法

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5.   
    6. public class Test {  
    7.     public static void main(String[] args) {  
    8.         List list = new ArrayList();  
    9.         // 向列表的尾部追加指定的元素  
    10.         list.add("lwc");  
    11.         // 在列表的指定位置插入指定元素  
    12.         list.add(1, "nxj");  
    13.         // 追加指定 collection 中的所有元素到此列表的结尾  
    14.         list.addAll(new ArrayList());  
    15.         // 从列表中移除所有元素  
    16.         list.clear();  
    17.         // 如果列表包含指定的元素,则返回true  
    18.         list.contains("nxj");  
    19.         // 如果列表包含指定 collection 的所有元素,则返回 true  
    20.         list.containsAll(new ArrayList());  
    21.         // 比较指定的对象与列表是否相等  
    22.         list.equals(new ArrayList());  
    23.         // 返回列表中指定位置的元素  
    24.         list.get(0);  
    25.         // 返回列表的哈希码值  
    26.         list.hashCode();  
    27.         // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1  
    28.         list.indexOf("lwc");  
    29.         // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1  
    30.         list.lastIndexOf("lwc");  
    31.         // 如果列表不包含元素,则返回 true  
    32.         list.isEmpty();  
    33.         // 移除列表中指定位置的元素  
    34.         list.remove(0);  
    35.         // 移除列表中出现的首个指定元素  
    36.         list.remove("lwc");  
    37.         // 从列表中移除指定 collection 中包含的所有元素  
    38.         list.removeAll(new ArrayList());  
    39.         // 用指定元素替换列表中指定位置的元素  
    40.         list.set(0, "lp");  
    41.         // 返回列表中的元素数  
    42.         list.size();  
    43.         // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图  
    44.         list.subList(1, 2);  
    45.         // 返回以正确顺序包含列表中的所有元素的数组  
    46.         list.toArray();  
    47.         // 返回以正确顺序包含列表中所有元素的数组  
    48.         list.toArray(new String[] { "a", "b" });  
    49.     }  
    50. }  

    LinkedHashMap是HashMap的一个子类,它保留插入的顺序,如果需要输出的顺序和输入时的相同,那么就选用LinkedHashMap。

    ArrayList

    [plain] view plain copy

    1. 构造方法  
    2.     public ArrayList()  
    3.     public ArrayList(int initialCapacity)  
    4.     public ArrayList(Collection c)  
    5. ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组  
    6.     当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍 1,  
    7.     然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,  
    8.     当新数组无法容纳增加的元素,重复该过程  
    9. ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,  
    10.     因为操作之后后续元素需要移动  

    LinkedHashMap是Map接口的哈希表和链接列表实现,具有可预知的迭代顺序。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变

    遍历ArrayList

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.Iterator;  
    5. import java.util.List;  
    6.   
    7. public class Test {  
    8.     public static void main(String[] args) {  
    9.         List<String> list = new ArrayList<String>();  
    10.         list.add("lwc");  
    11.         list.add("nxj");  
    12.         // 方法一  
    13.         Iterator<String> ite1 = list.iterator();  
    14.         while (ite1.hasNext()) {  
    15.             String str = ite1.next();  
    16.             System.out.println(str);  
    17.         }  
    18.         System.out.println("---------------------");  
    19.         // 方法二(方法一的变形)  
    20.         for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {  
    21.             String str = ite2.next();  
    22.             System.out.println(str);  
    23.         }  
    24.         System.out.println("---------------------");  
    25.         // 方法三  
    26.         for(String s : list){  
    27.             System.out.println(s);  
    28.         }  
    29.     }  
    30. }  
    31. /* 
    32. 打印结果: 
    33.     lwc 
    34.     nxj 
    35.     --------------------- 
    36.     lwc 
    37.     nxj 
    38.     --------------------- 
    39.     lwc 
    40.     nxj 
    41. */  

    LinkedHashMap实现与HashMap的不同之处在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,该迭代顺序可以是插入顺序或者是访问顺序

    Vector

    [plain] view plain copy

    1. 向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,  
    2.     不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList  
    3. 构造方法  
    4.     public Vector()  
    5.     public Vector(int initialCapacity)  
    6.     public Vector(int initialCapacity,int capacityIncrement)  
    7.         第一个参数是初始容量,第二个参数是当Vector满时的增量  
    8.     public Vector(Collection c)  
    9. Vector也是依赖数组实现的  

    案例

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.Enumeration;  
    4. import java.util.Vector;  
    5.   
    6. public class Test {  
    7.     public static void main(String[] args) {  
    8.         Vector v = new Vector();  
    9.         v.add("123");  
    10.         v.add("lwc");  
    11.         v.add("你好");  
    12.         // Vector转换为枚举  
    13.         Enumeration e = v.elements();  
    14.         while (e.hasMoreElements()) {  
    15.             System.out.println(e.nextElement());  
    16.         }  
    17.     }  
    18. }  

    根据链表中元素的顺序可以分为:按插入顺序的链表,和按访问顺序的链表。默认是按插入顺序排序,如果指定按访问顺序排序,那么调用get方法后,会将这次访问的元素移至链表尾部,不断访问可以形成按访问顺序排序的链表。

    Stack

    [java] view plain copy

    1. Vector的子类  

    案例

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.Enumeration;  
    4. import java.util.Stack;  
    5.   
    6. public class Test {  
    7.     public static void main(String[] args) {  
    8.         Stack stack = new Stack();  
    9.         // 向栈里面压一个整数  
    10.         stack.push(new Integer(123));  
    11.         stack.push("lwc");  
    12.         stack.push(new Double(88.88));  
    13.         // 遍历  
    14.         Enumeration items = stack.elements();  
    15.         while (items.hasMoreElements()) {  
    16.             System.out.print(items.nextElement()   " ");  
    17.         }  
    18.         System.out.println();  
    19.         // 出栈  
    20.         while (stack.size() != 0) {  
    21.             System.out.print(stack.pop()   " ");  
    22.         }  
    23.     }  
    24. }  
    25. /* 
    26. 打印结果: 
    27.     123 lwc 88.88  
    28.     88.88 lwc 123 
    29. */  

    注意,此实现不是同步的。如果多个线程同时访问链接的哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须保持外部同步。

    LinkedList

    [plain] view plain copy

    1. LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,  
    2.     因此有很好的插入和删除性能,但随机访问元素的性能很差  
    3. 构造方法  
    4.     public LinkedList()  
    5.     public LinkedList(Collection c)  
    6. LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据  
    7.     header.next = header.previous = header;  

    由于LinkedHashMap需要维护元素的插入顺序,因此性能略低于HashMap的性能,但在迭代访问Map里的全部元素时将有很好的性能,因为它以链表来维护内部顺序。

    遍历LinkedList

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.LinkedList;  
    4. import java.util.List;  
    5. import java.util.ListIterator;  
    6.   
    7. public class Test {  
    8.     public static void main(String[] args) {  
    9.         List link = new LinkedList();  
    10.         link.add(123);  
    11.         link.add("lwc");  
    12.         link.add(8.8);  
    13.         link.add("nxj");  
    14.         link.add(520);  
    15.         printList(link);  
    16.         printReversedList(link);  
    17.     }  
    18.   
    19.     private static void printList(List link) {  
    20.         System.out.println("正序链表中的元素");  
    21.         // 的到链表的迭代器,位置指向链头  
    22.         ListIterator li = link.listIterator();  
    23.         // 判断迭代器中是否有下一个元素  
    24.         while (li.hasNext()) {  
    25.             // 返回下个元素  
    26.             System.out.print(li.next()   " ");  
    27.         }  
    28.         System.out.println();  
    29.     }  
    30.   
    31.     private static void printReversedList(List link) {  
    32.         System.out.println("逆向链表中的元素");  
    33.         // 的到链表的迭代器,位置指向link.size()结尾  
    34.         ListIterator li = link.listIterator(link.size());  
    35.         // 判断迭代器中是否有前一个元素  
    36.         while (li.hasPrevious()) {  
    37.             // 返回前一个元素  
    38.             System.out.print(li.previous()   " ");  
    39.         }  
    40.         System.out.println();  
    41.     }  
    42. }  
    43. /* 
    44. 打印结果: 
    45.     正序链表中的元素 
    46.     123 lwc 8.8 nxj 520  
    47.     逆向链表中的元素 
    48.     520 nxj 8.8 lwc 123  
    49. */  

    3.TreeMap

    自定义LinkedList结构

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. class Node {  
    4.     Node previous;// 前驱  
    5.     String data;// 数据  
    6.     Node next;// 后驱  
    7.   
    8.     public Node(String data) {  
    9.         this.data = data;  
    10.     }  
    11. }  
    12.   
    13. public class Test {  
    14.     public static void main(String[] args) {  
    15.         Node node1 = new Node("node1");  
    16.         Node node2 = new Node("node2");  
    17.         Node node3 = new Node("node3");  
    18.         node1.next = node2;  
    19.         node2.previous = node1;  
    20.         node2.next = node3;  
    21.         node3.previous = node2;  
    22.         node3.next = node1;  
    23.         node1.previous = node3;  
    24.   
    25.         // 增加node4  
    26.         Node node4 = new Node("node4");  
    27.         node1.next = node4;  
    28.         node4.previous = node1;  
    29.         node4.next = node2;  
    30.         node2.previous = node4;  
    31.         // 删除node4  
    32.         node1.next = node2;  
    33.         node2.previous = node1;  
    34.         node4.previous = null;  
    35.         node4.next = null;  
    36.   
    37.     }  
    38. }  

    TreeMap 是一个有序的key-value集合,非同步基于红黑树(Red-Black tree)实现,每一个key-value节点作为红黑树的一个节点。TreeMap存储时会进行排序的,会根据key来对key-value键值对进行排序,其中排序方式也是分为两种,一种是自然排序,一种是定制排序,具体取决于使用的构造方法。

    依赖倒置原理

    [plain] view plain copy

    1. 依赖应该尽量在抽象层进行,避免在具体层进行,  
    2.     在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用  

    案例

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.LinkedList;  
    4. import java.util.List;  
    5.   
    6. public class Test {  
    7.     //如果我们需要传入参数是ArrayList就需要改动代码  
    8.     public void printLinkedList(LinkedList ll){  
    9.         System.out.println(ll);  
    10.     }  
    11.     //如果我们传入参数是List的子类,我们不需要改动代码,灵活性大  
    12.     public void printList(List l){  
    13.         System.out.println(l);  
    14.     }  
    15. }  

    自然排序:TreeMap中所有的key必须实现Comparable接口,并且所有的key都应该是同一个类的对象,否则会报ClassCastException异常。

    将数组转换为列表

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.Arrays;  
    4. import java.util.List;  
    5.   
    6. public class Test {  
    7.     public static void main(String[] args) {  
    8.         String[] str = { "l", "w", "c" };  
    9.         //使用Java类库中java.util.Arrays类的静态方法asList()  
    10.         List l = Arrays.asList(str);  
    11.         System.out.println(str);  
    12.     }  
    13.   
    14. }  
    15. /* 
    16. 打印结果: 
    17.     [l, w, c] 
    18. */  

    定制排序:定义TreeMap时,创建一个comparator对象,该对象对所有的treeMap中所有的key值进行排序,采用定制排序的时候不需要TreeMap中所有的key必须实现Comparable接口。

    ArrayList VS LinkedList

    [plain] view plain copy

    1. ArrayList底层采用数组实现,LinkedList底层采用双链表实现  
    2. 如果为列表增加对象  
    3.     ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的  
    4.     LinkedList底层Entry结构  
    5.         Entry{  
    6.             Entry previous;  
    7.             Object element;  
    8.             Entry next;  
    9.         }  
    10.         其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中  
    11. 插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好  

    TreeMap判断两个元素相等的标准:两个key通过compareTo()方法返回0,则认为这两个key相等。

    List<Map>遍历

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.HashMap;  
    5. import java.util.Iterator;  
    6. import java.util.List;  
    7. import java.util.Map;  
    8.   
    9. public class Test {  
    10.     public static void main(String[] args) {  
    11.         Map<Integer, String> map1 = new HashMap<Integer, String>();  
    12.         map1.put(new Integer(1), "lwc");  
    13.         map1.put(new Integer(2), "nxj");  
    14.         Map<Integer, String> map2 = new HashMap<Integer, String>();  
    15.         map2.put(new Integer(3), "tom");  
    16.         map2.put(new Integer(4), "cat");  
    17.         List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();  
    18.         list.add(map1);  
    19.         list.add(map2);  
    20.         // 方法一  
    21.         Iterator<Map<Integer, String>> ite1 = list.iterator();  
    22.         while (ite1.hasNext()) {  
    23.             Map<Integer, String> m = ite1.next();  
    24.             System.out.println(m);  
    25.         }  
    26.         System.out.println("-----------------------------");  
    27.         // 方法二(方法一的变形)  
    28.         for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {  
    29.             Map<Integer, String> m = ite2.next();  
    30.             System.out.println(m);  
    31.         }  
    32.         System.out.println("-----------------------------");  
    33.         // 方法三:  
    34.         for (Map<Integer, String> m : list) {  
    35.             System.out.println(m);  
    36.         }  
    37.     }  
    38. }  
    39. /*  
    40. 打印结果:  
    41.     {1=lwc, 2=nxj} 
    42.     {3=tom, 4=cat} 
    43.     ----------------------------- 
    44.     {1=lwc, 2=nxj} 
    45.     {3=tom, 4=cat} 
    46.     ----------------------------- 
    47.     {1=lwc, 2=nxj} 
    48.     {3=tom, 4=cat} 
    49. */  

    如果使用自定义的类来作为TreeMap中的key值,且想让TreeMap能够良好的工作,则必须重写自定义类中的equals()方法,TreeMap中判断相等的标准是:两个key通过equals()方法返回为true,并且通过compareTo()方法比较应该返回为0。

    Set

    [plain] view plain copy

    1. 实现类  
    2.     HashSet,LinkedHashSet  
    3. 子接口  
    4.     SortSet  
    5.     实现类  
    6.         TreeSet  
    7. 不包含重复元素,最多包含一个null,元素没有顺序  

    1010cc时时彩经典版 5

    HashSet

    [plain] view plain copy

    1. HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,  
    2.     HashSet中是否存在一个对象是通过equals()和hashCode()协同判断  
    3. 不保证顺序  
    4. 构造方法  
    5.     public HashSet()    
    6.     public HashSet(int initialCapacity)    
    7.     public HashSet(Collection c)  
    8. HashSet底层是使用HashMap实现的  
    9. HashSet的add()方法详解:  
    10.     判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致  
    11.     如果不一致,直接加进去  
    12.     如果一致,再进行equals()比较  
    13.         如果equals()返回true,对象已经存在不增加进去  
    14.         如果equals()返回false,把对象增加进去  

    五、Iterator 与 ListIterator详解

    LinkedHashSet

    [plain] view plain copy

    1. LinkedHashSet是Ordered,采用双链表实现的  
    2. 有固定顺序,也就是插入顺序  
    3. LinkedHashSet底层是使用LinkedHashMap实现的  
    4. 构造方法  
    5.     public LinkedHashSet()    
    6.     public LinkedHashSet(int initialCapacity)    
    7.     public LinkedHashSet(Collection c)  

    1.Iterator

    SortedSet接口

    [plain] view plain copy

    1. 保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序  
    2. 常用方法  
    3.     Object first()  
    4.          返回此有序集合中当前第一个(最小的)元素  
    5.     Object last()  
    6.         返回此有序集合中最后一个(最大的)元素  
    7.     SortedSet headSet(Object toElement)  
    8.         返回此有序集合的部分视图,其元素严格小于toElement  
    9.     SortedSet tailSet(Object fromElement)  
    10.         返回此有序集合的部分视图,其元素大于或等于fromElement  
    11.     SortedSet subSet(Object fromElement,Object toElement)  
    12.         返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)  
    13.     Comparator comparator()  
    14.         返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null  

    Iterator的定义如下:

    TreeSet

    [java] view plain copy

    1. TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历  
    2. TreeSet底层是使用TreeMap实现的  
    3. 构造方法  
    4.     public TreeSet()  
    5.     public TreeSet(SortedSet s)    
    6.     public TreeSet(int initialCapacity)  
    7.     public TreeSet(Comparator<? super E>)  
    8.     public TreeSet(Collection c)  
    9. 因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则  

    public interface Iterator {

    TreeSet排序规则Comparator案例

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.Comparator;  
    4. import java.util.Iterator;  
    5. import java.util.TreeSet;  
    6.   
    7. public class Test {  
    8.     public static void main(String[] args) {  
    9.         TreeSet set = new TreeSet(new PersonComparator());  
    10.         set.add(new Person("lwc", 80));  
    11.         set.add(new Person("nxj", 70));  
    12.         set.add(new Person("lp", 60));  
    13.         set.add(new Person("fy", 75));  
    14.         Iterator ite = set.iterator();  
    15.         while (ite.hasNext()) {  
    16.             Person p = (Person)ite.next();  
    17.             System.out.println(p.name);  
    18.         }  
    19.     }  
    20. }  
    21.   
    22. class Person {  
    23.     String name;  
    24.     int score;  
    25.   
    26.     public Person(String name, int score) {  
    27.         this.name = name;  
    28.         this.score = score;  
    29.     }  
    30. }  
    31.   
    32. class PersonComparator implements Comparator {  
    33.     public int compare(Object o1, Object o2) {  
    34.         Person p1 = (Person) o1;  
    35.         Person p2 = (Person) o2;  
    36.         return p1.score - p2.score;  
    37.     }  
    38. }  

    }

    Collections

    [plain] view plain copy

    1. 操作Collection类的工具类,类中方法都是静态的  

    Iterator是一个接口,它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。Iterator提供的API接口如下:

    Collections常用方法

    [java] view plain copy

    1. package com.itlwc;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.Collections;  
    5. import java.util.Comparator;  
    6.   
    7. public class Test {  
    8.     public static void main(String[] args) {  
    9.         // 将所有元素从一个列表复制到另一个列表  
    10.         Collections.copy(new ArrayList(), new ArrayList());  
    11.         // 如果两个指定collection中没有相同的元素,则返回 true  
    12.         Collections.disjoint(new ArrayList(), new ArrayList());  
    13.         // 使用指定元素替换指定列表中的所有元素  
    14.         Collections.fill(new ArrayList(), new Object());  
    15.         // 返回指定 collection 中等于指定对象的元素数  
    16.         Collections.frequency(new ArrayList(), new Object());  
    17.         // 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1  
    18.         Collections.indexOfSubList(new ArrayList(), new ArrayList());  
    19.         // 根据元素的自然顺序,返回给定 collection 的最大元素  
    20.         Collections.max(new ArrayList());  
    21.         // //根据元素的自然顺序,返回给定 collection 的最大元素  
    22.         Collections.min(new ArrayList());  
    23.         // 使用另一个值替换列表中出现的所有某一指定值  
    24.         Collections.replaceAll(new ArrayList(), "oldVal", "newVal");  
    25.         // 反转指定列表中元素的顺序  
    26.         Collections.reverse(new ArrayList());  
    27.         // 返回一个比较器,它强行反转  
    28.         Collections.reverseOrder();  
    29.         // 返回一个比较器,它强行反转指定比较器的顺序  
    30.         Collections.reverseOrder(new Comparator() {  
    31.             @Override  
    32.             public int compare(Object o1, Object o2) {  
    33.                 return 0;  
    34.             }  
    35.         });  
    36.         // 使用默认随机源随机更改指定列表的序列  
    37.         Collections.shuffle(new ArrayList());  
    38.         // 根据元素的自然顺序对指定列表按升序进行排序  
    39.         Collections.sort(new ArrayList());  
    40.         // 根据元素的自然顺序对指定列表按降序进行排序  
    41.         Collections.sort(new ArrayList(), Collections.reverseOrder());  
    42.         // 在指定列表的指定位置处交换元素  
    43.         Collections.swap(new ArrayList(), 1, 2);  
    44.   
    45.     }  

    boolean hasNext():判断集合里是否存在下一个元素。如果有,hasNext()方法返回 true。

    Object next():返回集合里下一个元素。

    void remove():删除集合里上一次next方法返回的元素。

    使用示例:

    public class IteratorExample {

    public static void main(String[] args) {

    ArrayList a = new ArrayList();

    a.add;

    a.add;

    a.add;

    System.out.println("Before iterate : " a);

    Iterator it = a.iterator();

    while (it.hasNext {

    String t = it.next();

    if ("bbb".equals {

    it.remove();

    }

    }

    System.out.println("After iterate : " a);

    }

    }

    输出结果如下:

    Before iterate : [aaa, bbb, ccc]

    After iterate : [aaa, ccc]

    注意:

    Iterator只能单向移动。

    Iterator.remove()是唯一安全的方式来在迭代过程中修改集合;如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。而且每调用一次next()方法,remove()方法只能被调用一次,如果违反这个规则将抛出一个异常。

    2.ListIterator

    ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator方法创建一个一开始就指向列表索引为n的元素处的ListIterator.

    ListIterator接口定义如下:

    public interface ListIterator extends Iterator {

    boolean hasNext();

    E next();

    boolean hasPrevious();

    E previous();

    本文由1010cc时时彩经典版发布于1010cc时时彩经典版,转载请注明出处:1010cc时时彩经典版java集结全部,Java集结知识点总

    关键词: