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:
     底层数据结构是链表,查询慢,增删快。
     线程不安全,效率高。


  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值