【集合框架】Java集合框架综述

一、前言

　　现笔者打算做关于Java集合框架的教程，具体是打算分析Java源码，因为平时在写程序的过程中用Java集合特别频繁，但是对于里面一些具体的原理还没有进行很好的梳理，所以拟从源码的角度去熟悉梳理具体类的原理和其中的数据结构。分析源码的好处总结如下三条：

　　1. 提升自身代码水平及写代码能力。

　　2. 可以顺带温习数据结构知识点。

　　3. 以后写代码遇到问题时能够找到最佳的解决办法

二、集合框架图

　　做一件事情时，首先一定要有做事情的总体方法，然后再去抠细节。我们肯定要来看看集合的总体框架图，也好对集合框架有一个很感性的认识。下图展示了Java整个集合框架（没有包括并发），如果不出意外的话，以后也会出并发方面的专题分析，我们从表及里，由浅入深，慢慢来。

　　

public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);

// jdk1.8 后的方法
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}

default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}

default <U> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
return thenComparing(comparing(keyExtractor, keyComparator));
}

default <U extends Comparable<? super U>> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor)
{
return thenComparing(comparing(keyExtractor));
}

default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
return thenComparing(comparingInt(keyExtractor));
}

default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
return thenComparing(comparingLong(keyExtractor));
}

default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
return thenComparing(comparingDouble(keyExtractor));
}

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
return Collections.reverseOrder();
}

@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}

public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(true, comparator);
}

public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(false, comparator);
}

public static <T, U> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
Objects.requireNonNull(keyExtractor);
Objects.requireNonNull(keyComparator);
return (Comparator<T> & Serializable)
(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
keyExtractor.apply(c2));
}

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}

public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
}

public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}
}

View Code
　　我们在compare方法实现我们的比较逻辑，就可以实现各种各样的排序。

四、工具类Collections && Arrays

　　Collections与Arrays工具类提供了很多操作集合的方法，具体的我们可以去查看API，总有一款你想要的。

五、equals && hashCode

　　equals方法与hashCode方法在集合中显得尤为重要，所以，在这里我们也好好的理解一下，为后边的分析打下好的基础。 在每一个覆盖了equals方法的类中，也必须覆盖hashCode方法，因为这样会才能使得基于散列的集合正常运作。

　　Object规范规定：

　　1. 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次hashCode方法都必须始终如一的返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。

　　2. 如果两个对象根据equals方法比较是相等的，那么调用者两个对象中的任意一个对象的hashCode方法都必须产生同样的整数结果。

　　3. 如果两个对象根据equals方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定产生不同的整数结果。

　　相等的对象必须拥有相等的散列码。即equals相等，则hashcode相等，equals不相等，则hashcode不一定相等。一个好的hashCode函数倾向于为不相等的对象产生不相等的散列码，从而提升性能，不好的hashCode函数会让散列表退化成链表，性能急剧下降。

六、总结

　　集合的开篇之作就到这里了，之后会不定期的进行更新，尽请期待，谢谢各位园友观看~