java集合复习总结（Hash扩容机制，集合遍历排序降序升序，匿名类的使用结合Comparator）

 

目录

List、Set、Map基本特点：

ArrayList和LinkedList最主要的区别：

关于默认初始容量：

集合遍历的三种方式:

--集合排序：

关于HashMap扩容机制:

---

List、Set、Map基本特点：

List:存放重复，有顺序的数据

Set：存放不可重复、无序的数据

HashSet：底层是哈希表，无序不可重复

TreeSet：底层是二叉树，不可重复，有序（对于实现了Comparable的类（如8种大基本类型））

List、Set继承Collection（单列集合），Map不是。

 

Map<Key,Value>：双列型集合，存放的是一对键值,Key 不可以重复，Value可以且数据无序

HashMap底层是哈希表（没有下标），无序，key不可以重复

TreeMap底层是二叉树，有序（对于实现了Comparable的类（如8种大基本类型），可以根据key进行排序。

 

ArrayList和LinkedList最主要的区别：

底层实现不同，arrayList采用的是数组（方便查询）,LinkedList采用的是链表（方便增删);

 

关于默认初始容量：

arrayList 的默认构造容量是10，超过10，扩大两倍+1；

HashSet是：16 负载因子：0.75 即达到12就进行扩展，扩充倍数为两倍。

HashMap ：16 负载因子：0.75 即达到12就进行扩展，扩充倍数为两倍。

Hashtable 初始容量是11 ，扩容 方式为2N+1;

集合遍历的三种方式:

List list;

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

for(Object o :list){}

只适用于集合，不能在数组中使用： list.foreach(temp->{});  

HashMap： hm.foreach((k,v)->{System.out.println(k+"="+v)}); 直接打印hashmap对象是打印哈希值，但是hashmap底层实现了toString。则打印toString内容。

--集合排序：

Comparable与Comparable的区别：https://www.cnblogs.com/skywang12345/p/3324788.html；

1）升序：直接使用Collections.sort(ls);

2）降序或者对特定字段： Collections.reverse(ls);//这是翻转不是倒序,

Collections.sort(ls,Collections.reverseOrder());     ---关于数组排序函数:Arrays.sort(array);Arrays.sort(array,Collections.reverseOrder()) 注意这个地方的array不能是int[] 必须要对象类型 Integer[]

public static void main(String[] args) throws Exception {
 List<Integer> ls = new ArrayList();
 ls.add(89);
 ls.add(66);
 ls.add(22);
 ls.add(41);
 ls.add(99);
 ls.sort(new CompareInt());
 ls.forEach(temp->{
     System.out.println(temp);
 });
}
class CompareInt implements Comparator<Integer>{
    @Override
    public int compare(Integer o1,Integer o2) {
        return o2 -o1;
    }
}

 

 public static void main(String[] args) throws Exception {
  List<Integer> ls = new ArrayList();
  ls.add(89);
  ls.add(66);
  ls.add(22);
  ls.add(41);
  ls.add(99);
Collections.sort(ls, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
});
  ls.forEach(temp->{
      System.out.println(temp);
  });
 }

 

 

关于HashMap扩容机制:

 

总结:

HashMap默认加载因子为什么选择0.75？(阿里) - aspirant - 博客园 (cnblogs.com)

提高空间利用率和减少查询成本的折中(空间利用率和查询效率的平衡)

由泊松分布得出加载因子在0.6~0.8范围比较好 （0.75*2n刚好为整数）

加载因子过高，例如为1，虽然减少了空间开销，提高了空间利用率，但是导致碰撞可能增加，也就增加了查询时间成本；

加载因子过低，例如0.5，虽然可以减少查询时间成本，但是空间利用率很低，同时提高了resize操作的次数。（这个操作十分消耗性能即资源)（加载因子低影响空间和性能资源）

 

resize：最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize

扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。比如说，我们有1000个元素new HashMap(1000), 但是理论上来讲new HashMap(1024)更合适，不过上面annegu已经说过，即使是1000，hashmap也自动会将其设置为1024。 但是new HashMap(1024)还不是更合适的，因为0.75*1000 < 1000, 也就是说为了让0.75 * size > 1000, 我们必须这样new HashMap(2048)才最合适，既考虑了&的问题，也避免了resize的问题。 

1）结构：（可以说是散列表）

2）数组长度为什么是16（或者是2的幂次方）：

hash算法：

1. static int indexFor(int h, int length) {  
2.        return h & (length-1);  
3.    }  

为什么用与呢？
所以我们首先想到的就是把hashcode对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，“模”运算的消耗还是比较大的，能不能找一种更快速，消耗更小的方式那？java中时这样做的，

位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。

         看上图，左边两组是数组长度为16（2的4次方），右边两组是数组长度为15。两组的hashcode均为8和9，但是很明显，当它们和1110“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到同一个链表上，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hashcode的值会与14（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！ 

    数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。 

转至：https://www.cnblogs.com/williamjie/p/9358291.html