Java基础——集合(二)——迭代器、Map集合

       接上篇,《Java基础——集合(一)——集合体系和Collection

四.迭代器的使用

使用步骤:

         1、通过集合对象获取迭代器对象。

         2、通过迭代器对象判断。

         3、通过迭代器对象获取。

迭代器原理

         由于多种集合的数据结构不同,所以存储方式不同,所以,取出方式也不同。

         这个时候,我们就把判断和获取功能定义在了一个接口中,将来,遍历哪种集合的时候,只要该集合内部实现这个接口即可。

迭代器源码

          

[java] view plain copy
  1. public interface Iterator  
  2.                       {  
  3.                                public abstract boolean hasNext();  
  4.                                public abstract Object next();  
  5.                       }  
  6.   
  7.                       public interface Collection  
  8.                       {  
  9.                                public abstract Iterator iterator();  
  10.                       }  
  11.   
  12.                       public interface List extends Collection  
  13.                       {  
  14.                                ...  
  15.                       }  
  16.                        
  17.                       public class ArrayList implements List  
  18.                       {  
  19.                                public Iterator iterator()  
  20.                                {  
  21.                                          returnnew Itr();  
  22.                                }  
  23.   
  24.                                private class Itr implements Iterator  
  25.                                {  
  26.                                          publicboolean hasNext(){...}  
  27.                                          publicObject next(){...}  
  28.                                }  
  29.                       }  

Collection存储字符串和自定义对象并通过迭代器遍历

                   1、存储字符串

[java] view plain copy
  1. Collection c = new ArrayList();  
  2. c.add("hello");  
  3. c.add("world");  
  4. c.add("java");  
  5.   
  6. Iterator it = c.iterator();  
  7. while(it.hasNext())  
  8. {  
  9.          String s = (String)it.next();  
  10.          System.out.println(s);  
  11. }  

                   2、存储自定义对象(Student类的代码省略)

[java] view plain copy
  1.  Collection c=new ArrayList();  
  2.  Student s1=new Student("林青霞",26);            
  3. c.add("s1");  
  4.   
  5.  Iterator it=c.iterator();  
  6. while(it.hasNext())  
  7.    {  
  8.      String s=(String)it.next();  
  9.     System.out.println(s);  
  10.    }  

ListIterator迭代器是Iterator的子接口

            所以List的遍历方式共有三种

                   1、Iterator迭代器

                   2、ListIterator迭代器

                   3、普通for+get()

五.Map

map是一个键值对形式的集合。它的元素都是有键和值组成。Map的键(key)是唯一的,(value)可以重复。


Map的功能:

                   A:添加功能

                                     V put(K key ,V value) :当key在集合中不存在是,添加元素;当key存在时替换元素

                   B:判断功能

                                     boolean containsKey (Object key) :判断指定的键是否在集合中存在

                                     Boolean containsValue(Object value):判断指定的值是否在集合中存在

                                     Boolean isEmpty() :判断集合是否为空

                   C:删除功能

                                     Void clear():清除所有键值对数据

                   D:获取功能

                                     Object get (Object key) :根据键获取值

                                     Set<K> keyset(): 所有键的集合

                                     Collection<V>values() :所有值的集合

                  E:长度功能

                                     Int size()

 

Map包括HashMap、HashTable和TreeMap。其中,HashTable已基本被HashMap取代,这里不做讨论。

         (注:HashMap支持null , HashTable不支持null )

Map遍历的两种方式:(导图上面已有,这里直接上代码了)

键找值:

[java] view plain copy
  1. public static void main(String[] args) {  
  2.          Map<String,Integer> map = new HashMap<String,Integer>();  
  3.          map.put("二阳",23);  
  4.          map.put("二峥",24);  
  5.          map.put("二光",25);  
  6.          Set<String> keys=map.keySet();              //把键其中起来,存入到set集合中.  
  7.          for(String key:keys){                            //遍历键集合,获取每一个键。增强for  
  8.                    Integer value=map.get(key);            //让键去找值 get(Object key)  
  9.                    System.out.println(key+"***"+value);  
  10.          }  
  11. }  

键值对:

[java] view plain copy
  1. public static void main(String[] args) {  
  2.          Map<String,Integer> map = new HashMap<String,Integer>();  
  3.          map.put("二阳",23);  
  4.          map.put("二峥",24);  
  5.          map.put("二光",25);  
  6.           
  7.          Set<Map.Entry<String,Integer>> set=map.entrySet(); //获取键值对集合。Set<> entrySet()  
  8.          for(Map.Entry<String,Integer> me:set){                       //遍历键值对集合,获取到每一个键值对。增强for,迭代器  
  9.                    String key=me.getKey();                            //通过键值对获取键getKey()  
  10.                    Integer value=me.getValue();                       //通过键值对获取值getValue()  
  11.                    System.out.println(key+"***"+value);  
  12.          }  
  13. }  

             

            未完待续,下篇为泛型+增强for+工具类

猜你喜欢

转载自blog.csdn.net/jason201710/article/details/80496691