Java集合简述

• 集合
  • • 作用：存储同一类型的元素
    • 分类
      • 双列集合（Map接口）
        • 特点:
          • 一个元素由K,V两部分组成
          • K和V可以是任意引用数据类型
          • 一个K值对应一个V值,K不能重复
        • 分类
          • HashMap<E>
            • 底层是哈希表,无序
          • LinkedHashMap<E>
            • 底层是链表+哈希表,有序
          • TreeMap<E>
            • 底层是红黑树,可排序
              • TreeMap在系只能元素的时候,K必须是Comparable类型,如果不是则需要在构造器中,传入一个Comparator<K>对象.
          • Hashtable<E>
            • 和HashMap一样,线程安全,效率低.且不能为null
            • HashMap线程不安全,效率高.K,V可以为null
        • 常用方法:
          • V put(K k,V v);添加一个元素,返回V值,如果K存在,新V替换旧V,如果K不存在,则返回null.
          • V remove(Object obj);根据K值删除整个元素,返回被删除的V
          • V get(Object K);根据K获取V
          • Set<K> KeySet();获取所以的K
          • Collection<V> Values();获取所有的V
          • Set<Entry<K,V>> entrySet();获取K V的单列集合(将K,V封装成一个对象)
            • K getKey();获得K
            • V getValue();获得V
            • for(Entry e:Set){e.getKey();e.getValue();}
          • boolean containsKey(Object k);查询是否包含k
          • boolean containsValue(Object v);查询是否包含value
          • boolean isEmpty();查询集合是否为空
          • void clear();清空集合
          • int size();获取元素的个数
        • 主要事项:
          • HashSet底层是HashMap
          • LinkedHashSet底层是LinkedHashMap
          • TreeSet底层是TreeMap
      • 单列集合（Collection<E>接口）
        • List<E>接口
          • 特点：有序，可以重复，有索引值
          • 分类
            • ArrayList<E>
              • 底层是数组，查询快，增删慢 线程不安全 效率高
            • LinkedList<E>
              • 底层是链表，查询慢增删快
              • 独有的方法:
                • void addFirst(E e);在表头添加一个元素
                • void addLast(E e);在表尾添加一个元素
                • E  removeFirst();删除第一个元素,返回被删除的元素
                • E removeLast();删除最后一个元素,返回被删除的元素
                • E getFirst();获取表头的元素
                • E getLast();获取表尾的元素
            • Vector<E>
              • 和ArrayList类型：线程安全 效率低
          • List<E>的方法:
            • void add(int index,E e);在索引值位置添加元素
            • E remove(int index);删除索引值位置的元素,返回被删除的元素
            • E get(int index);获得索引值位置的值
            • E set(int index,E newe);修改所以索引值位置的值,返回被旧值
            • List<E> subList(int beginIndex,int endIndex);截取索引值begin位置到end位置结束的元素,左闭右开,返回新的集合
            • int IndexOf(Object obj);查询元素第一次出现的位置,如果没有返回-1
            • int LastIndexOf(Object obj);查询元素最后一场出现的位置....
        • Set<E>接口
          • 特点：没有索引值，不可以重复
          • 分类
            • HashSet<E>
              • 没有索引，不可重复，无序。底层是哈希表
                • 新增顺序和获取顺序不一定一致
            • LinkedHashSet<E>
              • 有序，不可重复。底层是链表+哈希表
            • TreeSet<E>
              • 可排序，底层是红黑树
                • 构造方法:
                  • public TreeSet();
                  • public TreeSet(Comparator<> c);
                • 可排序(自定义排序)
                  • 1.实现Comparable<类型名>
                    • 重写public int Compareto方法
                      • 升序:当前对象-参数对象
                      • 降序:参数对象-当前对象
                  • 2.创建Comparator匿名内部类
                    • Comparator<类型名> 变量名=new Comparator<类型名>{重写public int compare(? e1,? e2){return:升序 e1-e2;return:降序 e2-e1;}};
          • 方法
            • Collection<E>接口的所有方法
          • 重点
            • Set的新增过程:
              • 1.计算新增元素的哈希值(十进制的地址值),调用hashCode()方法(Object的);
              • 2.通过哈希值%数组的长度,去确定元素新增的索引值位置
                • 如果该位置没有元素,之间新增
                • 如果该位置有元素:判断这两个元素是否相等
                  • 如果相等:不新增
                  • 如果不相等,挂在这个元素的下面(链表)
              • 判断的标准: 比较哈希值&&(地址值相同||equals相同)
              • 如果自定义的对象,我们希望添加的到HashSet集合中,我们认为成员变量的值是相同,就为一个元素.则需要覆盖重写hashCode和equals方法.
        • Collection<E>方法
          • boolean add(E e)；添加元素
          • boolean remove(Object obj)；删除元素
          • boolean contains(Object obj)；是否包含元素
          • boolean isEmpty()；判断集合是否为空
          • int size()；获取元素的个数
          • void clear()；清空集合
          • Objec[] toArray();将集合变为Object数组
          • Iterator<E> iterator();获得迭代器
            • Iterator<E>接口;
              • 方法
                • boolean hasNext()；判断是否还有元素
                • E next();获得当前元素
                • void remove();删除元素（获取谁删除谁）
              • eg：while(iterator.hasNext()){iterator.next();}
              • 注意事项：通过迭代器遍历的机会的时候，不能通过集合的对象增删元素。可以通过迭代器对象删除元素。
            • 增强for（底层也是迭代器）
              • for（E e：List）{sout（e);}
    • 泛型
      • 定义：位置的一种引用数据类型
      • 含有泛型的类：public calss 类名<E>{}
        • 类中方法的参数和返回值可以是泛型类型
        • 类中的成员变量类型也可以是泛型
        • 如果创建对象的时候，没有指明泛型的类型，则泛型是object类型
      • 含有泛型的接口：public interface 接口名<E>{}
        • 方法的参数和返回值类型可以是泛型，静态方法的参数和返回值除外
        • 静态常量的不能是因为常量必须赋值
        • 类实现接口出来泛型的两种方式
          • public class 类名 implements 接口名<明确的泛型类型>{}
          • public class 类名<E>implements 接口名<E>
      • 含有泛型的方法：方法的参数和返回值可以是泛型类型，或者是泛型数组集合
        • 修饰符 <T> 返回值类型 方法名(T t){}
      • 通配符:?
        • 上限
          • <? super T>只有T的父类和T本身类型可以使用;eg:<? super String> 只有 String和Object可以使用
        • 下限
          • <? extends T>只有T本身和继承它的子类可以使用;eg:<? extends Number> 只有Number和Integer Double Character...的可以使用
    • 数据结构
      • 栈:先进后出,后进先出
      • 队列:先进先出
      • 数组:查询快,增删慢
      • 链表:查询慢,增删快
      • 红黑树:查询,增删都比较快
    • Collections工具类
      • static <T> boolean addAll(Colleaction<T> c,T... array);一次给集合添加多个元素
      • static void shuffle(List<? list>);打乱集合内的元素位置
      • static <T  extends Comparable<T>> void sort(List<T>);给集合排序,须集合实现Comparable接口
      • static <T> void sort(List<T> list,Comparator<T> c);给集合排序,需放入Comparator的匿名内部类对象
    • 可变参数
      • 语法:方法名(数据类型... 参数名)
      • 在方法中把可变参数看做数组来处理
        • 方法名(对象类型的多个值);
        • 方法名(对象类型的数组);
        • 方法名();
      • 注意事项:
        • 一个方法中只能有一个可变参数
        • 如果有多个参数,可变参数必须写在最后