Collection

发表于 | 分类于
Collection

List,Set

  1. ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会在底层生成一个长度为10的Object类型数组
  2. 如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。当心数组无法容纳增加的元素时，重复该过程。
  3. 对于ArrayList元素的删除操作，需要将删除元素的后续元素向前移动，代价比较高。
  4. 集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加入到集合中。
  5. 集合当中放置的都是Object类型，因此取出来的也是Object类型，那么必须要使用强制类型转换将其转换为真正的类型（放置进去的类型）。
  6. 关于ArrayList与LinkedList的比较分析
    a) ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。
    b) 当执行插入或者删除操作时，采用LinkedList比较好。
    c) 当执行搜索操作时，采用ArrayList比较好。
  7. 当向ArrayList添加一个对象时，实际上就是将该对象放置到了ArrayList底层所维护的数组当中；当向LinkedList中添加一个对象时，实际上LinkedList内部会生成一个Entry对象，该Entry对象的结构为：
    Entry{
    Entry previous;
    Object element;
    Entry next;
    }
    其中的Object类型的元素element就是我们向LinkedList中所添加的元素，然后Entry又构造好了向前向后的引用previous、next，最后将生成的这个Entry对象加入到了链表当中。换句话说，LinkedList中所维护的是一个个的Entry对象。
  8. 关于Object类的equals方法的特点
  • 自反性:x.equals(x)应该返回true
  • 对称性:x.equals(y)为true，那么y.equals(x)也为true。
  • 传递性:x.equals(y)为true并且y.equals(z)为true，那么x.equals(z)也应该为ture。
  • 一致性:x.eauals(y)的第一次调用为true，那么x.equals(y)的第二次、第三次、第n次调用也应该为true，前提条件是在比较之间没有修改x也没有修改y。
  • 对于非空引用x,x.equuals(null)返回false
  1. 关于Object类的hashCode()方法的特点：
  • 在Java应用的一次执行过程当中，对于同一个对象的hashCode方法的多次调用，他们应该返回同样的值（前提是该对象的信息没有发生变化）。
  • 对于两个对象来说，如果使用equals方法比较返回ture,那么两个对象的hashCode一定是相同的。
  • 对于两个对象来说，如果使用equals方法比较返回false，那么这两个对象的hashCode值不要求一定不同（可以相同，可以不同），但是如果不同则可以提高应用的性能。
  • 对于Object类来说，不同的Object对象的hashCode值是不同的(Object类的hashCode值表示的是对象的地址)。
  1. 当使用HashSet时，hachCode()方法就会得到调用，判断已经存储在集合中的对象的hash code值是否与增加的对象的hash code值一直；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。
  2. 如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。
  3. 遍历set：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class TreeTest2 {
        public static void main(String[] args) {
            TreeSet<String> treeSet = new TreeSet();
            treeSet.add("C");
            treeSet.add("B");
            treeSet.add("A");
            treeSet.add("E");
            treeSet.add("D");
            treeSet.add("F");
            for (Iterator iterator = treeSet.iterator(); iterator.hasNext(); ) {
                System.out.println(iterator.next());
            }
        }
    }

Map

  1. Map(映射):Map的keySet()方法会返回key的集合，因为Map的键是不能重复的，因此keySet()方法的返回类型是Set；而Map的值是可以重复的，因此values()方法的返回类型是Collection，可以容纳重复元素。
  2. 遍历map：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class MapTest {
        public static void main(String[] args) {
            Map map = new HashMap();
            map.put("a", "aa");
            map.put("b", "bb");
            map.put("c", "cc");
            map.put("d", "dd");
            map.put("e", "ee");
            Set keySet = map.keySet();
            for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
                String key = (String) iterator.next();
                String value = (String) map.get(key);
                System.out.println(key + "=" + value);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class MapTest1 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("a", "aa");
        map.put("b", "bb");
        map.put("c", "cc");
        map.put("d", "dd");
        map.put("e", "ee");
        Set keySet = map.entrySet();
        for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}
  1. HashSet底层是使用HashMap实现的。当使用add方法将对象添加到Set当中时，实际上是将该对象作为底层所维护的Map对象的key，而value则都是统一Object对象（该对象我们用不上）；
  2. HashMap底层维护一个数组，我们向HashMap中所放置的对象实际上是存储在该数组当中；
  3. 当向HashMap中put一对键值时，它会根据key的hashCode值计算出一个位置，该位置就是此对象准备往数组中存放的位置。

  4. 如果该位置没有对象存在，就将此对象直接放进数组当中；如果该位置已经有对象存在了，则顺着此存在的对象的链开始寻找（Entry类有一个Entry类型的next成员变量，指向了该对象的下一个对象），如果此链上有对象的话，再去使用equals方法进行比较，如果对此链上的某个对象的equals方法比较为false，则景该对象放到数组当中，然后将数组中该位置以前存在的那个对象链接到此对象的后面。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

  5. 所谓泛型：就是变量类型的参数化。

  6. Integer类有一个缓存，它会缓存结余-128~127之间的整数。
  7. 可变参数：可变参数本质上就是一个数组，对于某个声明了可变参数的方法来说，我们既可以传递离散的值，也可以传递数组对象。但如果将方法中的参数定义为数组，那么只能传递数组对象而不能传递离散的值。
  8. 可变参数必须要作为方法参数的最后一个参数。即一个方法不可能具有两个或两个以上的可变参数。