黑马程序员技术交流社区

标题: 新人集合随笔 [打印本页]

作者: heimalipan 时间: 2019-3-30 13:13
标题: 新人集合随笔
集合的概述：
            1.用于存放内容的容器
集合的特点：
               1.长度可变
               2.只能存放引用数据类型
集合的体系
      顶层父类  collection
      Jdk 1.5 以后提供了一个父类 Iterable  --> 目的：使用迭代器进行迭代  (屏蔽底层的不同)
      两个体系的子类
               List
                     1.有序(存进去的和取出来的顺序一致)
                     2.索引 : 底层是数组
                     3.可重复
               Set
                     1.无序(存进去的顺序和取出来的顺序不一致)
                     2.无索引 :底层是哈希表
                     3.不可重复
常用的方法
         add(E e)
            list.add(1)
            list.add(2)
                     经历自动装箱
         remove(E  e)
               list.remove(1)
                     如果删除成功返回 true
                     如果删除失败返回false
         size
               list.size 等同于  int [] arr 中的arr.length
            contains
               list.contains(1)       判断当前集合中是否有 1 这个元素
                     如果有：返回true
                     如果没有：返回false
      clear :清空集合中的元素
               list.clear
                     注意：执行完此方法后，集合还在，但集合中的元素不在了
         isEmpty:判断这个集合是否为空，如果为空，返回true  ，否则返回false

迭代器的使用规则
Jdk 1.5 以后提供了一个父类 Iterable

Iterator it =  list.iterator 方法

while(it.hasNext() ){  it.next       }
hashNext 是判断是否有下一个元素
   hasNext : 判断元素当前这个指针上是否有这个元素

next ：取出下一个元素

      1. 取出元素

                                 2.指针向后移动一位
并发修改异常

在迭代器迭代的过程中，使用集合修改了集合的长度，此时就会抛出并发修改异常
listIterator  来解决以上问题

      ListIterator<String> lit =  coll.listIterator()
      利用迭代器来进行集合长度的改变

  3.增强for 循环
            注意：底层用的  是  迭代器
               使用的语法
                     for(  集合/数组中对应的元素数据类型变量名    : 需要遍历的数组/集合){
                                             sout(变量名)
                     }
               举例：
                     ArrayList<Integer> list = new ArrayList<Integer>()
                     list.add(1);  list.add(2) list.add(3)
                        for(Integer  num  :  list){
                                       sout(num)
                        }
   4. 泛型定义：
            将数据类型灵活的运用到类，方法，接口上，作为参数传递
      泛型确定的时间:创建对象时
      泛型的好处：
               1.数据类型确定，省去了强转的麻烦
               2.将运行时异常转换成编译器异常
      泛型的缺点：
               1.只能操作同一种数据类型
            泛型类：
                        将泛型书写在Class类上
                        书写方式：public class ArrayList<E>
                              1.在创建对象时不写泛型:默认操作就是Object
                              ArrayList list = new ArrayList ();  list.add(Object obj)
                              2.写了泛型 --> 泛型什么就只能操作什么
                              ArrayList<String> list = new ArrayList ();
            泛型方法
                              静态泛型方法       public static <T>  void method1(T t);
                              非静态泛型方法    public <T> void  method2(T t);
            泛型接口
                              1.  直接在接口上定义泛型
                                             public class GenericInterfaceImpl1 implements GenericInterface<String>{}
                              2.public class GenericInterfaceImpl2<I> implements GenericInterface<I>
                                             主要应用到了泛型的传递
            泛型的通配符  ?
            泛型的限定
                              上限（开发中极有可能会使用到一种方式）和下限
                                 上线写法一
                                             public static  void getElement1(Collection<? extends Number> coll){}
                                 上线写法二：
                                             public static<T extends Number> void getElement1(Collection<T> coll){}
                                 下限
                                             public static void getElement2(Collection<? super Number> coll){}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2