Conllection和Map

 

 

 【容器类】/【集合类】

    

            通常,程序总是根据运行时才知道的某些条件去创建新对象,在此之前,

 对象的数量和确切类型都是未知的.

 数组的局限:1.保存类型要明确

     2.容量固定

 容器类的优势:1.保存类型和数量可以更加灵活.

 一.容器的2种大类型:

  单槽类型(接口):Collection  14种方法[add,clear,contains,remove,iterator...]

 

  双槽类型(接口):Map         14种方法[clear,get,put,entrySet.........]

 二.4种基本容器类型(接口):

  

  它们分别遵守各自的原则

  <1>. 【List 】 extends Collection   我的原则是:必须按顺序排

  

        >增加了6种方法  [listIterator,indexOf,get,subList,set,lastIndexOf]

  <2>. 【Set  】 extends Collection   我的原则是:不能有重复

        >方法上没有增加,与父类完全一样

  <3>. 【Queue】 extends Collection   我的原则是:一边进,另一边出

        >增加了4种方法[offer,element,peek,poll]

         <4>. 【Map  】                      我的原则是:成双成对

 三.4种基本类型下细分了6中常用【实现版本】/【实现类】

  

  它们都有自己的特点.

  <1>.ArrayList      implements【List】:易查找 

  

     >增加了2两方法[trimTosize,ensureCapacity]

  

  <2>.LinkedList     implements【List】【Deque】【Queue】:便于删除,插入,性能强大

     >相对List增加了21种方法. 

 

     因为LinkedList里添加了可以作用队列和双端队列的方法所以能够实现它们.

  <3>.HashSet        implements【Set】:不重复无序

      >方法上没有增加

  <4>.LinkedHashSet  extends【HashSet】:不重复有序

       >方法上没有增加

  <5>.HashMap        implements【Map】:散列码快速访问

       >方法上没有增加   

  <6>.LinkedHashMap  extends【HashMap】:散列码快速访问/有序

   

       >方法上没有增加

  

  【类型之间的转换问题】      

   

   向上造型的好处在于代码的重用性好,效率高.但也就意味着可用方法越来越少,操作性能有所下降.

  如果就要用对象的方法怎么办?

  >>>强制转换<<<

  【实现版本的选择是否容易混乱?理不清楚?】

  两个原则: 1. 从上至下排选.

   

     2. 不能跨类比较

 四.泛型<>

  正是容器类保存类型的灵活性的原因,同时带了不利的一点:存放对象时操作不当容易造成类型混搭.

  

  class Apple{

   public int num(){return 10;}  

  }

  class Orange{

  }

  main(){

  ArrayList apples =new ArrayList();

  

   apples.add(new Apple()); //因为add(Object o)方法默认的是Object类型.

      所以相当于Object o=new Apple()        ==apples.get(0);

  apples.add(new Orange());//这步也不会有问题.也相当于Object o=new        Orange()==apples.get(1);

  但是在获取的时候就会出现问题

  问题一:访问异常

   o.num()//编译错误.从这里Object o==apples.get(0) 可以看出o引用无法访问num()方法

  

  解决方法:

   强制转换 (Apple)o.num==(Apple)apples.get(0).num()

  问题二:转换异常

   (Apple)apples.get(1)//编译出错.Orange和Apple没有继承关系,转换错误.

  所以可以简单地理解:泛型<>的出现解决了,容器类的两个问题

   1.把不是同类或者继承关系的对象排除在外

   2.不再需要类型转换.相当于把Object o 换成了 Apple o

 五.迭代器 Iterator 只作用于数组和集合.

  任意的Collection都能生成Iterator对象.

   因为Collection中含有iterator()方法,这个方法的作用是要求集合

   返回一个Iterator类型对象.

    Iterator it=collection.iterator();

    

    it.hasNext();判断序列中是否还有元素.

    it.next();获取序列中下一个元素

    it.remove();删除it.next()所指向的元素,

 六.任意的Collection都可以用add()和addAll()添加元素,remove()删除元素等等

 Queue也同样.

  但是Queue中有自己完整的且有独立功能的方法.所以在创建具有Queue功能实现时,不需要再去使用  Collection中的方法

 七.Map和Collection的关联处

  Map中有三个方法keySet(),values()和entrySet()可以与Collection关联上

  Collection c=map.values(); (得到Collection)

    //把Map中的所有"值",保存到一组集合中.             因为返回的"值"可以重复,所以返回的不是Set

    (方法得到的是父类对象,不能赋给子类引用.)

  Collection cs=map.keySet();   (得到Set)   //把Map中的所有"键",      保存到一组集合中.

       (方法得到的是子类对象,可以赋给己       类或者父类引用)

  Collection/Set set=map.entrySet();(得到Set)   //把Map中的所有"键值      对",保存到一组集合中.

                      (方法得到的是子类对象,可以赋给己       类或者父类引用)

  延伸一下Set<Entry<>> set=map.entrySet()==>><Entry<类型1,类型2>>

  Set set=map.entrySet()

  Map<String,Map<String,String ==>>map= new        HashMap<String,Map<String,String>>()

 【父类对象如何转成子类对象?】

  【复制构造器】List list=new ArrayList(Collction c);

   每个集合的实现版本都允许我们在创建对象的时候传进去一个Collection类型参数.完成转换.

                        可以实现Collection-->List--->ArrayList/LinkedList

                                Collection-->Set--->HashSet/LinkedHashSet

     List<-->Set

     之间的相互转换. 

 【为什么要强调添加泛型?】为了访问不出错.(虽然存储时候不会出错,但是数据不可能只保存不访问.)

 【为什么Map要转换成Collection?】

  因为集合才有迭代器/遍历功能.所以当我们想对Map进行遍历之前必须转成相应的集合.

 

  基本类型-->字符串-->数组-->Collection-->Map