2017 - 10 -21 集合框架 Collection 迭代器 List

1 将对象存储到数组中
    需求： 
      将5个学生信息存储到数组中，并遍历数组，获得每一个学生信息
          学生：Student 
          成员变量：name，age 
          构造方法：无参，带参
          成员方法：getXxx()/setXxx()
    //创建学生数组      
    Studnet[] student = new Student[5];
    //创建5个学生对象
    Student s1 = new Student("学生1",15);   
    Student s2 = new Student("学生2",16); 
    Student s3 = new Student("学生3",17); 
    Student s4 = new Student("学生4",18); 
    Student s5 = new Student("学生5",19);
    //把对象放入数组
    Student[0] = s1;
    Student[1] = s2;
    Student[2] = s3;
    Student[3] = s4;
    Student[4] = s5;
    //遍历  
    for(int x=0;x<student.length;x++){
        // System.out.println("student[x]");  // 修改了toString方法
          Student s = student[x];
          System.out.println(s.getName()+"---"+s.getAge());//这种方式更灵活一些   

    }

2  集合
 集合的由来：
   我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。
   而想要存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢？
   数组和StringBuffer，但是，StringBuffer的结果是一个字符串，不一定满足我们的需求，所以我们只能选择数组，这就是对象数组。
   而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，java就提供了集合类提供我们使用。
   数组和集合的区别？
    A:长度区别
         数组的长度固定
         集合长度可变
    B:内容不同
         数组存储的是同一种类型的元素
         而集合可以存储不同类型的对象
    C:元素的数据类型问题
         数组可以存储基本数据类型，也可以存储引用数据类型
         而集合只能存储引用类型

    刚才说过，集合是存储多个元素的，但是，存储多个元素我们也是有不同需求的，比如说，我要这多个元素中不能有相同的元素，再比如说，我要这多个元素按照某种规则排序一下。
    针对不同的需求，java就提供了不同的集合类 ，这样呢，java就提供了很多个集合类，这些集合类的数据结构不同。
    而且这些集合类是有共性的，我们把这些集合类的共性向上提取，这样就能得到一个集合的继承体系结构图。
    这个体系的老大是：Collection
----------------------------------------------------------
                                       Collection 
                      List                                     Set
 ArrayList Vector LinkedList       HashSet     TreeSet
----------------------------------------------------------
 学习过程：先学习Collecton父类，再学习子类

3 Collection
    是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的(等等，后面慢慢讲解)
  Collection的功能描述：
   1：添加功能
       boolean add(Object obj):添加一个元素
       boolean addAll(Collection):添加一个集合的元素
   2：删除功能
       void clear():移除所有元素
       boolean remove(Object o):移除一个元素
       boolean removeAll(Collction o)：移除一个集合的元素
   3：判断功能
       boolean contains(Object o):判断集合中是否包含指定的元素
       boolean containsAll(Collection c)：判断集合中是否包含指定集合元素
       boolean isEmpty():判断集合是否为空
   4：获取功能
       Iterator<E> iterator():(重点)
   5：长度功能
       int size():元素的个数
---------------------------------------
***面试题：数组有没有length()方法呢?字符串有没有length()方法呢？集合有没有length()方法呢？
      回答：数组有，字符串有，集合的叫做size()。。。
---------------------------------------
   6：交集功能
       boolean retainAll(Collection c):两个集合都有的元素？思考元素去哪了，返回的boolean又是什么意思呢？
   7：把集合转换为数组
       Object[] toArray()

4 测试
A:测试不带ALL的方法    
  //创建集合对象
  //Collection c = new Collection();//错误，因为接口不能实例化
    Collection c = new ArrayList();
  //重写了toString方法
    System.out.println("add:"+c.add("hello"));
    System.out.println("c:"+c);
  //输出： add:true 
                 c:[hello]
  // public boolean add(Object obj)  return true  永远成功

(1) 添加 删除
     c.add("hello");
     c.add("world");
     c.add("java");//输出：[hello,world,java]
     //c.clear();//输出：[]
     c.remove("hello");//输出[world,java]
(2)判断
     System.out.println("contains:"+c.contains("hello"));//输出：contains true 
(3)长度
     System.out.println("size:"+c.size()); //输出：size:3      
       
B:测试带ALL的方法
   //创建集合1
   Collection c1 = new ArrayList();
   c1.add("abc1");   
   c1.add("abc2");  
   c1.add("abc3");  
   c1.add("abc4");  
   //创建集合2
   Collection c2 = new ArrayList();
   //c2.add("abc4")
   c2.add("abc5"); 
   c2.add("abc6"); 
   c2.add("abc7"); 

(1)增加
   System.out.println("addAll:"c1.addAll(c2));
   //输出：[abc1,abc2,abc3,abc4,abc5,abc6,abc7]
   //如果C2.add("abc4")   重复的也能进去
   //输出：[abc1,abc2,abc3,abc4,abc4,abc5,abc6,abc7]
(2)移除  
    System.out.println("removeAll:"+c1.removeAll(c2));
   //原来是[abc1,abc2,abc3,abc4,abc4,abc5,abc6,abc7]
   //输出：[abc1,abc2,abc3]  
   //一个被移除了就返回true
(3)包含
    System.out.println("containsAll:"+c1.containsAll(c2));
   // 返回false
   // 只有包含所有的元素，才叫包含
(4)交集
   //两个集合都有的元素？思考元素去哪了，返回的boolean又是什么意思呢？
    System.out.println("retainAll:"+c1.retainAll(c2))
   //输出 true  c1：[abc4] c2:[abc4,abc5,abc6,abc7]

   //若 c1[abc1,abc2,abc3,abc4] c2[abc5,abc6,abc7]
   //输出 true  c1[]  c2[abc5,abc6,abc7]
--------------------------------
   假设有两个集合A、B
   A对B做交集，最终的结果保存在A中，B不变
***返回值表示的是A是否发生过改变
--------------------------------
5 集合的遍历---集合转数组遍历
  集合的遍历：其实就是依次获取集合中的每一个元素
  Object[] toArray():把集合转成数组，就可以实现集合的遍历
  //创建集合对象
  Collectin c = new ArrayList();
  //添加元素
  c.add("hello");
  c.add("world");
  c.add("java");
  //遍历
  Object[] objs = c.toArray();
  for(int x=0;x<objs.length;x++){
     System.out.println(objs[x]);
     //我知道元素是字符串，我再获取元素的同时，还想知道元素的长度。
     //System.out.println(objs[x]+"---"+objs[x].length());
     //上面的实现不了，原因是Object中没有length()方法
     //我们要想使用字符串的方法，就必须把元素还远成字符串
     //向下转型
     String s =(String)objs[x];
     System.out.println(s+"---"+s.length());
     //输出 hello---5
               world---5
                java---4

6 练习
  用集合存储5个学生对象，并把学生对象进行遍历
  //创建集合对象
    Collection c = new ArrayList();
  //创建学生对象
    Student s1 = new Student("学生1",15);   
    Student s2 = new Student("学生2",16); 
    Student s3 = new Student("学生3",17); 
    Student s4 = new Student("学生4",18); 
    Student s5 = new Student("学生5",19);
  //把学生添加到集合
    c.add(s1);
    c.add(s2);
    c.add(s3);
    c.add(s4);
    c.add(s5);
  //把集合转成数组
    Object[]  objs = c.toArray();
  //遍历数组
    for(int x = 0;x<objs.length;x++){
         Student s =(Student)objs[x];
         System.out.println(s.getName()+"---"+s.getAge());
      }
   //输出：
          学生1---15
          学生2---16
          学生3---17
          学生4---18
          学生5---19
          
7 集合遍历---迭代器遍历
Iterator iterator()：迭代器，集合的专用遍历方式
Object next()：获取元素，并移动到下一个位置
boolean hasNext():
  //创建集合对象
  Collectin c = new ArrayList();
  //添加元素
  c.add("hello");
  c.add("world");
  c.add("java");
  //Iterator iterator():迭代器，集合的专用遍历方式
  Iterator it = c.iterator();//实际返回的肯定是子类对象，这里是多态
  System.out.println(c.next());
  //输出 hello
  System.out.println(c.next());
  //输出 world
  System.out.println(c.next());
  //输出 java
  //System.out.println(c.next());//会报错，没有数据了
  //最后一个不应该写，所以，我们应该在每次获取前，如果有一个判断就好了 
  //判断是否有以一个元素，有就获取，没有就不继续
  while(it.hasNext()){
       // System.out.println(c.next());
       String s = (String)it.next();
       System.out.println(s);
  }
  
8 练习2
      用集合存储5个学生对象，并把学生对象进行遍历
  //创建集合对象
    Collection c = new ArrayList();
  //创建学生对象
    Student s1 = new Student("学生1",15);   
    Student s2 = new Student("学生2",16); 
    Student s3 = new Student("学生3",17); 
    Student s4 = new Student("学生4",18); 
    Student s5 = new Student("学生5",19);
  //把学生添加到集合
    c.add(s1);
    c.add(s2);
    c.add(s3);
    c.add(s4);
    c.add(s5);
  //遍历
    Iterator it = c.iterator();
    while(it.hasNext()){
       // System.out.println(c.next());
       Student s = (Student)it.next();
       System.out.println(s.getName()+"---"+s.getAge());
  }


9 集合的使用步骤
  迭代器：是遍历集合的一种方式
    迭代器是依赖于集合而存在的。
  我有一个集合：Collection c = new ArrayList();
  我们给集合中添加元素：c.add("hello")  c.add("world");c.add("java");
  通过集合获取迭代器对象： Iterator it = c.iterator();
  while(it.hasNext()){
       // System.out.println(c.next());
       String s = (String)it.next();
       System.out.println(s);
  }

***集合的使用步骤：
     A:创建集合对象
     B:创建元素对象
     C:把元素添加到集合
     D:遍历集合
          a:通过集合对象获得迭代器对象
          b:通过迭代器的hasNext()方法判断是否有元素
          c:通过迭代器对象的next()方法获取元素并移动到一下位置

10 迭代器的原理及源码解析
   迭代器为什么不定义成一个类，而是一个接口呢？
   假设迭代器定义的是一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历。但是呢！我们想想，java中提供了很多的集合类，而这些集合类的数据结构是不同，所以，存储的方式和遍历的方式应该是不同的，进而它们的遍历方式也应该不是一样的，最终，就没有定义迭代器类。
   而无论你是哪种集合，都应该具备获取元素的操作，并且，最好在辅助于判断功能，这样，在获取前，先判断，这样就更不容易出错，也就是说，判断功能和获取功能应该是一个集合遍历所具备的，而每种集合的方式又不太一样，所以我们把两个功能给提取出来，并不提供具体实现，这种方式是接口。
    那么，真正的具体的实现类在哪里？
    在真正的具体子类中，以内部类的方式体现的。

11 List
(1) 使用步骤
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");
  Iterator it = list.iterator();
  while(it.hasNext()){
       String s = (String)it.next();
       System.out.println(s);
  }

(2)List的特点
     有序（存储和取出的元素一致）,可重复的。
  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");
  list.add("world");
  list.add("java");
  Iterator it = list.iterator();
  while(it.hasNext()){
       String s = (String)it.next();
       System.out.println(s);
  }
  //输出： hello   
           world 
           java
           world
           java

(3)List集合的特有功能
 A:添加功能
    public void add(int index,Object element):在指定位置添加元素
 B:获取功能
    Object get(int index):获取指定位置的元素
 C:列表迭代器
    ListIterator listIterator():List集合特有的迭代器
 D:删除功能
    Object remove(int index):根据索引删除元素，返回被删除的元素
 E:修改功能
    Object set(int index,Object element):根据索引修改元素，返回被修饰的元素 

  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");
  list.add(3,"javaee");
  //list.add(13,"javaee");  会报错
 
(4)List集合的特有遍历功能
    size()和get()方法结合
   
  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");
  for(int x = 0;x<list.size();x++){
    String s =(String)list.get(x);
    System.out.println(s);
   }
   
(5)列表迭代器 
    ListIterator listIterator():List集合特有的迭代器
    该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法
-----------------
特有功能：
     Object previous():获取上一个元素
     boolean hasPrevious()：判断是否有元素
   注意：ListIterator 可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
 
  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");
  ListIterator  lit = list.listIterator(); 
  lit.next();
  lit.next();
  lit.next();
  while(lit.hasPrevious()){
            String s = (String)lit.previous();
            System.out.println(s);
  }
  //输出： java 
           world
           hello
    
12 List的三个子类的特点(面试题)
   ArrayList：
     底层数据结构是数组，查询快，增删慢。
     线程不安全，则效率高
   Vector：
     底层数据结构是数组，查询块，增删慢。
     线程安全，效率低
   LinkedList：
     底层数据结构是链表，查询慢，增删快。
     线程不安全，效率高。