Go语言视频零基础入门到精通

admin

一、前言　　现笔者打算做关于java集合框架的教程，具体是打算分析Java源码，因为平时在写程序的过程中用Java集合特别频繁，但是对于里面一些具体的原理还没有进行很好的梳理，所以拟从源码的角度去熟悉梳理具体类的原理和其中的数据结构。分析源码的好处总结如下三条：　　1. 提升自身代码水平及写代码能力。　　2. 可以顺带温习数据结构知识点。　　3. 以后写代码遇到问题时能够找到最佳的解决办法二、集合框架图　　做一件事情时，首先一定要有做事情的总体方法，然后再去抠细节。我们肯定要来看看集合的总体框架图，也好对集合框架有一个很感性的认识。下图展示了Java整个集合框架（没有包括并发），如果不出意外的话，以后也会出并发方面的专题分析，我们从表及里，由浅入深，慢慢来。　　　　说明：对于以上的框架图有如下几点说明　　1. 集合接口：6个接口（短虚线表示），表示不同集合类型，是集合框架的基础。
　　2. 抽象类：5个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。
　　3. 实现类：8个实现类（实线表示），对接口的具体实现。
　　4. Collection 接口是一组允许重复的对象。
　　5. Set 接口继承 Collection，集合元素不重复。
　　6. List 接口继承 Collection，允许重复，维护元素插入顺序。
　　7. Map接口是键－值对象，与Collection接口没有什么关系。三、接口说明　　3.1. Collection接口　　除了Map接口，其他集合都是Collection的子类，并且在我们的实际编程中，由于多态的原因，我们一般都会使用这个的编码方式，如：Inter i1 = new ImplementInter();(其中，Inter表示一个接口，ImplementInter表示对此接口的实现)，此时i1调用的方法只能是Inter接口中的方法，无法调用ImplementInter中新增的方法（除非进行向下类型转化）。所以，很有必要了解一下Collection根接口中都有哪些方法。

1. public interface Collection<E> extends Iterable<E> {
2.     int size();
3.     boolean isEmpty();
4.     boolean contains(Object o);
5.     Iterator<E> iterator();
6.     Object[] toArray();
7.     <T> T[] toArray(T[] a);
8.     boolean add(E e);
9.     boolean remove(Object o);
10.     boolean containsAll(Collection<?> c);
11.     boolean addAll(Collection<? extends E> c);
12.     boolean removeAll(Collection<?> c);
13.     boolean retainAll(Collection<?> c);
14.     void clear();
15.     boolean equals(Object o);
16.     int hashCode();
18.     // jdk1.8添加的方法
19.     default boolean removeIf(Predicate<? super E> filter) {
20.         Objects.requireNonNull(filter);
21.         boolean removed = false;
22.         final Iterator<E> each = iterator();
23.         while (each.hasNext()) {
24.             if (filter.test(each.next())) {
25.                 each.remove();
26.                 removed = true;
27.             }
28.         }
29.         return removed;
30.     }
31.     @Override
32.     default Spliterator<E> spliterator() {
33.         return Spliterators.spliterator(this, 0);
34.     }
35.     default Stream<E> stream() {
36.         return StreamSupport.stream(spliterator(), false);
37.     }
38.     default Stream<E> parallelStream() {
39.         return StreamSupport.stream(spliterator(), true);
40.     }
41. }

复制代码

View Code说明：　　1. 其中在jdk1.8后添加的方法对我们的分析不会产生影响，添加的方法有关键字default修饰，为缺省方法，是一个新特性。　　2. 对集合而言，都会包含添加、删除、判断、清空、大小等基本操作。　　3.2. Map接口　　对于Map接口而言，是键值对集合，特别适用于那种情形，一个主属性，另外一个副属性（如：姓名，性别；leesf,男），添加元素时，若存在相同的键，则会用新值代替旧值。方法如下　

1. public interface Map<K,V> {
2.     int size();
3.     boolean isEmpty();
4.     boolean containsKey(Object key);
5.     boolean containsValue(Object value);
6.     V get(Object key);
7.     V put(K key, V value);
8.     V remove(Object key);
9.     void putAll(Map<? extends K, ? extends V> m);
10.     void clear();
11.     Set<K> keySet();
12.     Collection<V> values();
13.     Set<Map.Entry<K, V>> entrySet();
14.     interface Entry<K,V> {
15.         K getKey();
16.         V getValue();
17.         V setValue(V value);
18.         boolean equals(Object o);
19.         int hashCode();
20.    
21.         // jdk1.8 后添加的方法
22.         public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
23.             return (Comparator<Map.Entry<K, V>> & Serializable)
24.                 (c1, c2) -> c1.getKey().compareTo(c2.getKey());
25.         }
26.         public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
27.             return (Comparator<Map.Entry<K, V>> & Serializable)
28.                 (c1, c2) -> c1.getValue().compareTo(c2.getValue());
29.         }
30.         public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
31.             Objects.requireNonNull(cmp);
32.             return (Comparator<Map.Entry<K, V>> & Serializable)
33.                 (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
34.         }
35.         public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
36.             Objects.requireNonNull(cmp);
37.             return (Comparator<Map.Entry<K, V>> & Serializable)
38.                 (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
39.         }
40.     }
41.     boolean equals(Object o);
42.     int hashCode();
44.     default V getOrDefault(Object key, V defaultValue) {
45.         V v;
46.         return (((v = get(key)) != null) || containsKey(key))? v: defaultValue;
47.     }
48.    
49.     default void forEach(BiConsumer<? super K, ? super V> action) {
50.         Objects.requireNonNull(action);
51.         for (Map.Entry<K, V> entry : entrySet()) {
52.             K k;
53.             V v;
54.             try {
55.                 k = entry.getKey();
56.                 v = entry.getValue();
57.             } catch(IllegalStateException ise) {
58.                 // this usually means the entry is no longer in the map.
59.                 throw new ConcurrentModificationException(ise);
60.             }
61.             action.accept(k, v);
62.         }
63.     }
64.     default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
65.         Objects.requireNonNull(function);
66.         for (Map.Entry<K, V> entry : entrySet()) {
67.             K k;
68.             V v;
69.             try {
70.                 k = entry.getKey();
71.                 v = entry.getValue();
72.             } catch(IllegalStateException ise) {
73.                 // this usually means the entry is no longer in the map.
74.                 throw new ConcurrentModificationException(ise);
75.             }
77.             // ise thrown from function is not a cme.
78.             v = function.apply(k, v);
80.             try {
81.                 entry.setValue(v);
82.             } catch(IllegalStateException ise) {
83.                 // this usually means the entry is no longer in the map.
84.                 throw new ConcurrentModificationException(ise);
85.             }
86.         }
87.     }
88.     default V putIfAbsent(K key, V value) {
89.         V v = get(key);
90.         if (v == null) {
91.             v = put(key, value);
92.         }
94.         return v;
95.     }
96.     default boolean remove(Object key, Object value) {
97.         Object curValue = get(key);
98.         if (!Objects.equals(curValue, value) ||
99.             (curValue == null && !containsKey(key))) {
100.             return false;
101.         }
102.         remove(key);
103.         return true;
104.     }
105.     default boolean replace(K key, V oldValue, V newValue) {
106.         Object curValue = get(key);
107.         if (!Objects.equals(curValue, oldValue) ||
108.             (curValue == null && !containsKey(key))) {
109.             return false;
110.         }
111.         put(key, newValue);
112.         return true;
113.     }
114.     default V replace(K key, V value) {
115.         V curValue;
116.         if (((curValue = get(key)) != null) || containsKey(key)) {
117.             curValue = put(key, value);
118.         }
119.         return curValue;
120.     }
121.     default V computeIfAbsent(K key,
122.             Function<? super K, ? extends V> mappingFunction) {
123.         Objects.requireNonNull(mappingFunction);
124.         V v;
125.         if ((v = get(key)) == null) {
126.             V newValue;
127.             if ((newValue = mappingFunction.apply(key)) != null) {
128.                 put(key, newValue);
129.                 return newValue;
130.             }
131.         }
133.         return v;
134.     }
135.     default V computeIfPresent(K key,
136.             BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
137.         Objects.requireNonNull(remappingFunction);
138.         V oldValue;
139.         if ((oldValue = get(key)) != null) {
140.             V newValue = remappingFunction.apply(key, oldValue);
141.             if (newValue != null) {
142.                 put(key, newValue);
143.                 return newValue;
144.             } else {
145.                 remove(key);
146.                 return null;
147.             }
148.         } else {
149.             return null;
150.         }
151.     }
152.     default V compute(K key,
153.             BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
154.         Objects.requireNonNull(remappingFunction);
155.         V oldValue = get(key);
157.         V newValue = remappingFunction.apply(key, oldValue);
158.         if (newValue == null) {
159.             // delete mapping
160.             if (oldValue != null || containsKey(key)) {
161.                 // something to remove
162.                 remove(key);
163.                 return null;
164.             } else {
165.                 // nothing to do. Leave things as they were.
166.                 return null;
167.             }
168.         } else {
169.             // add or replace old mapping
170.             put(key, newValue);
171.             return newValue;
172.         }
173.     }
174.     default V merge(K key, V value,
175.             BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
176.         Objects.requireNonNull(remappingFunction);
177.         Objects.requireNonNull(value);
178.         V oldValue = get(key);
179.         V newValue = (oldValue == null) ? value :
180.                    remappingFunction.apply(oldValue, value);
181.         if(newValue == null) {
182.             remove(key);
183.         } else {
184.             put(key, newValue);
185.         }
186.         return newValue;
187.     }
188. }

复制代码

View Code说明：　　1. Map接口有一个内部接口Entry,对集合中的元素定义了一组通用的操作，维护这键值对，可以对键值对进行相应的操作，通过Map接口的entrySet可以返回集合对象的视图集，方便对集合对象进行遍历等操作。　　2. 对Map而言，也会包含添加、删除、判断、清空、大小等基本操作。　　3.3. Comparable接口 && Comparator接口　　此接口的作用是对集合中的元素进行排序，如Integer类型默认实现了Comparable<Integer>，String类型默认实现了Comprable<String>接口，Integer与String实现了这个接口有什么作用呢？就是当集合中的元素类型为Integer或者是String类型时，我们可以直接进行排序，就可以返回自然排序后的集合。　　对于Comparable接口而言，只有一个方法。　

1. public interface Comparable<T> {
2.     public int compareTo(T o);
3. }

复制代码

View Code　　我们在compareTo方法中实现我们的逻辑，就可以实现各种各样的排序。　　对于Comparator接口而言，比Comparable接口类似，用作排序元素，主要的方法如下

1. public interface Comparator<T> {
2.     int compare(T o1, T o2);
3.     boolean equals(Object obj);
4.    
5.     // jdk1.8 后的方法
6.     default Comparator<T> reversed() {
7.         return Collections.reverseOrder(this);
8.     }
10.     default Comparator<T> thenComparing(Comparator<? super T> other) {
11.         Objects.requireNonNull(other);
12.         return (Comparator<T> & Serializable) (c1, c2) -> {
13.             int res = compare(c1, c2);
14.             return (res != 0) ? res : other.compare(c1, c2);
15.         };
16.     }
18.     default <U> Comparator<T> thenComparing(
19.             Function<? super T, ? extends U> keyExtractor,
20.             Comparator<? super U> keyComparator)
21.     {
22.         return thenComparing(comparing(keyExtractor, keyComparator));
23.     }
25.     default <U extends Comparable<? super U>> Comparator<T> thenComparing(
26.             Function<? super T, ? extends U> keyExtractor)
27.     {
28.         return thenComparing(comparing(keyExtractor));
29.     }
31.     default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
32.         return thenComparing(comparingInt(keyExtractor));
33.     }
35.     default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
36.         return thenComparing(comparingLong(keyExtractor));
37.     }
39.     default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
40.         return thenComparing(comparingDouble(keyExtractor));
41.     }
43.     public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
44.         return Collections.reverseOrder();
45.     }
47.     @SuppressWarnings("unchecked")
48.     public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
49.         return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
50.     }
52.     public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
53.         return new Comparators.NullComparator<>(true, comparator);
54.     }
56.     public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
57.         return new Comparators.NullComparator<>(false, comparator);
58.     }
60.     public static <T, U> Comparator<T> comparing(
61.             Function<? super T, ? extends U> keyExtractor,
62.             Comparator<? super U> keyComparator)
63.     {
64.         Objects.requireNonNull(keyExtractor);
65.         Objects.requireNonNull(keyComparator);
66.         return (Comparator<T> & Serializable)
67.             (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
68.                                               keyExtractor.apply(c2));
69.     }
71.     public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
72.             Function<? super T, ? extends U> keyExtractor)
73.     {
74.         Objects.requireNonNull(keyExtractor);
75.         return (Comparator<T> & Serializable)
76.             (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
77.     }
79.     public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
80.         Objects.requireNonNull(keyExtractor);
81.         return (Comparator<T> & Serializable)
82.             (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
83.     }
85.     public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
86.         Objects.requireNonNull(keyExtractor);
87.         return (Comparator<T> & Serializable)
88.             (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
89.     }
91.     public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
92.         Objects.requireNonNull(keyExtractor);
93.         return (Comparator<T> & Serializable)
94.             (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
95.     }
96. }

复制代码

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函数会让散列表退化成链表，性能急剧下降。
六、总结　　集合的开篇之作就到这里了，之后会不定期的进行更新，尽请期待，谢谢各位园友观看~