JAVA自学教程之（常用对象API） —迭代器



JAVA自学教程之（常用对象API） —迭代器。

数字有很多用数组存，对象有很多就要用集合存

但是数组是固定长度的，集合是可变长度的

集合的由来：

对象用来封装特有数据，对象多了需要存储，如果对象个数不确定，就需要使用集合容器来存储

集合的特点：

1.用于存储对象的容器

2.长度可变

3.集合中不可存储基本数据类型

对于集合体系，的最顶层存储的是该体系中所有的共性内容，Collection，同继承一样，看顶层，用底层

java.uitil包中的Cellection


集合容器因为内部的数据不同，有多种具体容器，不断向上抽取，就形成了集合框架

整个框架的顶层就是Cellection接口

Cellection的常见方法（必须掌握）：

 

  1. 1.添加
  2.     boolean add(Object e)//添加一个
  3.     boolean addAll(Collection e)//添加一堆
  4. 2.删除
  5.     boolean remove(Object e)//删除一个
  6.     boolean removeAll(Collection e)//删除一些
  7.     void clear();//全部删除
  8. 3.判断
  9.     boolean contains(object obj)//是否包含一个
  10.     boolean containsAll(Cellection e)
  11.     boolean isEmpty()//判断集合是否有元素
  12. 4.获取
  13.     int size()//返回此 collection 中的元素数。
  14.     Iterator <E>  iterator()//迭代器取出集合中元素的方式
  15. 5.其他方法
  16.     boolean RetainAll(Collect e)//取交集
  17.     Object[] toArray()//将集合转成数组

方法演示：


 

 

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  5. public class Main
  6. {
  7.     public static void main(String[] args)
  8.     {
  9.         Collection e = new ArrayList();
  10.         Collection f = new ArrayList();
  11.         //show(e);
  12.         show(e,f);
  13.     }
  14.     public static void show(Collection e,Collection f)//演示xxxAll
  15.     {
  16.         e.add(“a1″); e.add(“a2″);
  17.         e.add(“a3″); e.add(“a4″);
  18.         f.add(“a2″); f.add(“a5″);
  19.         f.add(“a6″); f.add(“a7″);
  20.         //addAll
  21.         //e.addAll(f);
  22.         //System.out.println(“e = ”+e);
  23.         //removeAll
  24.         //e.removeAll(f);//删除e容器中所有和f相同的元素
  25.         //System.out.println(“e = ”+e);
  26.         //containsAll
  27.         //boolean flag = e.containsAll(f);
  28.         //System.out.println(flag);//e中是否包含f
  29.         //retainAll
  30.         System.out.println(e.retainAll(f));//和removeAll功能相反，保存相同，删除不同
  31.         System.out.println(e);
  33.     }
  34.     public static void show(Collection e)//ctrl+shirt+o,导入包
  35.     {
  36.         //添加 。add
  37.         e.add(“asd1″);
  38.         e.add(“asd2″);
  39.         e.add(“asd3″);
  40.         System.out.println(e);
  41.         //删除
  42.         e.remove(“asd2″);//会改变长度
  43.         //e.clear();//清空
  45.         System.out.println(e);
  46.     }
  47. }

迭代器的使用

 

 

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Iterator;
  5. public class Main
  6. {
  7.     public static void main(String[] args)
  8.     {
  9.         Collection e = new ArrayList();//随便new一个Collection的子类
  10.         e.add(“a1″);    e.add(“a2″);    e.add(“a3″);    e.add(“a4″);
  11.         System.out.println(e);
  12.         //调用Collection中的iterator()方法   ->   调用集合中的迭代器方法，是为了获取集合中的迭代器对象
  13.     /*  Iterator it = e.iterator();
  15.         while(it.hasNext())//it.hasNext()：如果仍有元素可以迭代，则返回 true。
  16.         {
  17.             System.out.println(it.next());//返回迭代的下一个元素。
  18.             it.remove();//删除：从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
  19.         }*/
  20.         for(Iterator it = e.iterator();it.hasNext();)//写for循环，循环局部代码块一结束，it就删除了，开发用for：省内存
  21.         {
  22.             System.out.println(it.next());
  23.         }
  24.         System.out.println(e);
  25.     }
  26. }

 

迭代器原理：

迭代器本身是内部类，迭代器要想访问集合中的元素，就必须知道集合中元素的存放结构，所以迭代器只有定义在内部才能获取集合中的内容，至于怎么取是容器自己实现的，因为存放方式是容器自身决定的

Iterator接口是最终的，所有容器公共的取出方式，只要找到这个接口，就没有必要面对每一个对象，只要找到接口就可以实现对每一个容器进行取出动作，也就符合接口的特点：降低了容器和取出方式的耦合性

我们只需要使用公共的访问方式即可，至于内部怎么取，不需要知道，所以迭代器就不用new对象

总结：

Iterator it = e.iterator();//找到e容器的公共取出方法即可

该对象（it）必须依赖于容器，才能进行元素的取出，因为每个容器的数据结构不同，所以迭代器对象必须唉容器内部实现，对于使用容器者而言，具体实现不重要，只要通过容器获取到该实现的迭代器的对象即可

也就是iterator方法

Iterator接口是所有Collection容器进行元素取出的公共接口

详细看API中Iterator接口的代码