集合总结

集合（collection）有两个主要的子接口List和Set.

Iterable是collection的父接口，不是map的，所有map不能直接用增强for，要用key。。。。

集合（接口）只能存储引用类型，并且是单个字符。并且可以动态改变大小。

collection是iterator接口和iterable接口的实现类。

集合分为：

1. 1. 单纯存元素的集合。
   2. 表示映射关系的集合。
2. Iterator和iterable都可实现迭代功能。
3. 泛型：本质是参数化类型，声明，相当于一个形参，指定存的集合的元素的类 型。Collection<Integer> b=new ArrayList<Integer>();

new的collection的子接口。声明初始化了一个集合。

1. 1. 1. 1. 泛型两个特点：自动检查类型 自动转换类型（向上转型 向下转型）
         2. 泛型是一种编译器现象，自动装箱和拆箱和增强for循环也是编译器现象。
2. JDK中的集合类一般都实现了iterable接口不直接实现iterator接口。（可百度）
3. 这两个接口JDK中的定义：
   1. iterable 可以for each
      package java.lang; 
      import java.util.Iterator; 
      public interface Iterable<T> { 
           Iterator<T> iterator(); 
      } 
   2. iterator
      package java.util; 
      public interface Iterator<E> { 
            boolean hasNext(); 
           E next(); 
           void remove(); 
      }
   3. Iterator的迭代过程 
      1. 1. 1. Iterator获取迭代器对象
            2. While hasNext()
            3. .next()//
               1. 取出元素
               2. i++

1. List(接口)有三个子类：ArrayList、LinkedList、Vector.
   1. list的三种遍历方式：

Eg:List<String> list=new ArrayList<String>();

           list.add(“aaa”);

       list.add(“bbb”);

   list.add(“ccc”);

方法一：增强for遍历（最优）

格式：for（数组名 ： 数组或者实现了iterable（具有迭代功能的）的类或者子类的对象）{}

for(string a: list){

System.out.println(a);

}

方法二：对于ArrayList来说速度比较快，用for循环，以size（）为条件遍历

    for(int i=0;i<list.size();i++){

System.out.println(list.get(i));

}

方法三：集合类的通用遍历方式，用迭代器迭代（最low）。

Iterator it=list.iterator();

While(it.hashNext()){

System.out.println(it.next);

1. 1. List
      • List.set(index,value);根据索引（下标）更改数据（覆盖原来此位置的数据）。
      • List.add(index,value);根据索引添加数据。
      • List的两个子类：ArrayList和LinkedLlist用法和区别
        1. arraylist用的时候当做数组：数组是为了批量处理同一类型的数据
        2. linkedlist用的时候当做队列
           1. 1. Offer是从队列后面加。
              2. poll是从队列前面拉出来。
        3. arraylist和linkedlist的区别：
           1. arraylist底层是数组（用下标访问内存空间）要求存储空间连续。访问效率高，速度快。添加慢，删除慢（因为要依次去移动相应的元素）
           2. linkedlist底层是链表（把内存空间的格子拆了，一半存地址，一半存数据）不要求连续，可连续也可不连续。访问效率低，速度慢。更充分的使用了内存，但是没下标。如果想从A指向C，要从A到B再到C。添加快，删除快（因为只需要修改两个指针的指向就可以了）。
   2. ArrayList：
      • .size():判断存储元素的个数。
      • .add():添加数据。
      • .contains():
        1. 1. 1. 是一个Boolean的判断语句，重写hashcode和equals方法会输出true。否则输出false。
              2. 层次调用：必须重写student(引用类型)的tostring方法。否则如果syso(c)输出的是地址，不是存储的数据。
      • Collections.sort(list);不去重，会按照数字、字母本身顺序存储。
      • Collections.sort(list,MyComparator);不去重，不更改会按照输入顺序排序。
      • comparable是一个泛型的接口
        1. Comparable<T>它里面的方法是compareTo（T other）
        2. Comparator<T>它里面的方法是compare（T o1, T o2）

A.Comparable<T>必须和实体类耦合（也就是说必须implements Comparable），一旦实现后，只能有一种排序规则。

B.Comparator<T>无需和实体类耦合，可以根据具体场景实现不同的排序规则。

• • • 如果一个类既实现了comparable又实现了comparator,  comparator优先

(人工干预的是comparator)

1. 1. ArrayList和vector对比：
      1. 1. Vector线程安全(和arrayList一样，底层都是数组实现)。
         2. arraylist线程不安全
2. Set(接口)均能去重：
   • • HashSet
     • SortedSet--->TreeSet--->二叉树

1. list特点，add的顺序，决定了输出的顺序，“add”有序。add元素可重复
2. Set的add的顺序决定不了输出的顺序“add不一定序”。add元素不重复，可用 来去重
3. set排序只有TreeSet。（排序用treeset，去重用hashset）。

 

1. HashSet和TreeSet
   • • Treeset会按照字母、数字的本身顺序存储（非添加顺序），可去重

• • • Hashset添加无序，可去重
    • TreeSet不能乱用，排序的时候会去重。！

3.list和set的排序方式

1) ArraList两种方式

• • Compareable ：通过Collections.sort(list);调用，实体类实现comparable接口，并重写compare方法，根据需要排序。
  • Comparator ：通过collections.sort(list,MyComparator);调用，定义新类MyComparator,实现Comparator接口，并重写compareTo方法，根据需要排序。

2) TreeSet两种方式

• • • Comparable：直接在实体类implements Comparable接口，并重写compare方法，根据需要排序。
    • Comparator：在new TreeSet对象的时候，传进去MyComparator()，定义一个MyComparator()实现Comparator接口。

Map(接口)：

此接口实现的Key到Value的映射，一个Map中不能包含相同的Key，每个Key只能映射一个Value。

1. • • hashMap（去重）
     • sortedMap----->NavigableMap------>TreeMap（排序）
2. Map的常用方法
   • • Map的常用方法
       1. .size();：指有多少个键值对（映射关系）
       2. containsKey();  和  containsValue(); 比较key和value值。
       3. get.(v);找映射中对应的元素key,返回对应的value.(只能通过key找value)
       4. put(k,v); ：存入数据。
       5. Remove(object);：只能成对除去。
       6. putAll合并，把Map2数据合并到Map1数据中。
       7. Clear();清除。
       8. KeySet();：key不可以重复，但是value可以重复，返回值是关于key的set。
       9. Values();：根据填入顺序的逆顺序输出所有的value值。
       10. EntrySet();：返回的是键值对的set。

1. 1. 1. Map的tostring是搭架子{}
      2. Map的遍历：
         1. 通过keySet：
            1. eg: Map<String, String> map=new HashMap<String, String>();

 Set<String> k=map.keySet();

1. 1. 1. 1. Values(无法通过value找key):只能逆序输出所有的value值。
         2. （最常用）entrySet：

Map<String, String> map=getMap();

Set<Entry<String,String>> eSet=map.entrySet();

for(Entry<String,String> entry:eSet)

{

String k=entry.getKey();

String v=entry.getValue();

System.out.println(k+"="+v);

}

（把一个hashmap封装的键值对传进set里，遍历set。分别获取key 和value）。

1. HashMap
   1. 1. 1. HashMap(hashset底层封装的就是hashmap，hashset的性质都是由hashmap决定的，hashset只用了hashmap的key值，没用value)。
         2. Hashmap用contains不用map.get()方法判断是否含有某数据，因为用map.get()即使查找的数不是null也会返回true。
         3. HashMap去重（HashMap的key不能重复，所以HashSet也不能重复）。需要去掉什么重复数据，就重写对应属性的hashcode和equals。
            1. 因为eques比hashcode优先执行，eques如果返回false，hashcode就不会调用。说明已经判断没有重复的。结果可能有重复。eques如果返回true，hashcode还会去重，结果不会有重复。
2. TreeMap
   • • TreeMap只能根据key排序，不能根据value排序。
     • TreeMap同TreeSet一样都可以进行排序，通过key排序。TreeSet去重，是用compare的方法，来达到去重。
3. HashMap和Hashtable的用法和区别：
   • • Hashtable不允许出现null值，而HashMap允许。

• • • Hashtable比hashMap要早出现，但是他是线程安全的，现在已经不再使用hashtable了，
    • 和HashMap一样，底层都是hash表。