集合框架之线性表、栈、队列、set、键值对Map、字符串、IO流、静态类

 1. 线性表

1.1 java.util 接口 List

• 所有已知实现类：ArrayList, LinkedList, Vector, Stack
• 有序的 collection（也称为序列）,与 set 不同，列表通常允许重复的元素

抽象方法

添加功能 add

• boolean add(E e): 将指定的元素追加到此列表的末尾。
• void add(int index, E element): 在列表的指定位置插入指定元素。
• boolean addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾
• boolean addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素都插入到列表中的指定位置

删除功能 remove

• void clear()： 从列表中移除所有元素。
• E remove(int index)： 移除列表中指定位置的元素。
• boolean remove(Object o)： 从此列表中移除第一次出现的指定元素。
• boolean removeAll(Collection<?> c)： 从列表中移除指定 collection 中包含的其所有元素。

判断功能 contains, equals, isEmpty

• boolean contains(Object o): 如果列表包含指定的元素，则返回 true。
• boolean containsAll(Collection<?> c): 如果列表包含指定 collection 的所有元素，则返回 true。
• boolean equals(Object o): 比较指定的对象与列表是否相等。
• boolean isEmpty(): 如果列表不包含元素，则返回 true。

获取功能 get, indexOf, size, hashCode

• E get(int index): 返回列表中指定位置的元素。
• int hashCode(): 返回列表的哈希码值。
• int indexOf(Object o): 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
• lastIndexOf(Object o): 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
• int size(): 返回列表中的元素数。
• List subList(int fromIndex, int toIndex): 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

修改功能 set

• E set(int index, E element): 用指定元素替换列表中指定位置的元素。

迭代器功能 iterator

• Iterator iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。
• ListIterator listIterator(): 返回此列表元素的列表迭代器。

其他功能 toArray

• Object[] toArray()： 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
• boolean retainAll(Collection<?> c)： 仅在列表中保留指定 collection 中所包含的元素。

注意事项

• 迭代器功能可用增强for替换： for(E e : list)
• 获取长度为：int size()不是length()

• 集合和数组的区别?

  A:长度区别  
      数组固定  
      集合可变  
  B:内容区别  
      数组可以是基本类型，也可以是引用类型  
      集合只能是引用类型  
  

• 并发修改异常？

  A:出现的现象
      迭代器遍历集合，集合修改集合元素
  B:原因
      迭代器是依赖于集合的，而集合的改变迭代器并不知道。
      Iterator在迭代时，只能对元素进行获取next()和删除remove()的操作。
  C:解决方案
      a:迭代器遍历，迭代器修改(ListIterator)
          元素添加在刚才迭代的位置
      b:集合遍历，集合修改(size()和get())
          元素添加在集合的末尾
  

1.2 java.util 类 ArrayList

• List 接口的大小可变数组的实现：transient Object[] elementData。
• 是随机存取结构，查找块，增删慢
• 实现不是同步的，线程不安全

具体方法

构造方法

• public ArrayList(int initialCapacity):构造一个具有指定初始容量的空列表。
• public ArrayList():构造一个初始容量为 10 的空列表。
• public ArrayList(Collection<? extends E> c):构造一个包含指定 collection 的元素的列表。

特殊方法

• public Object clone()：返回此 ArrayList 实例的浅表副本。（不复制这些元素本身。）
• public void ensureCapacity(int minCapacity)：如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
• protected void removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
• public void trimToSize()：将此 ArrayList 实例的容量调整为列表的当前大小。

1.3 java.util 类 LinkedList

• List 接口的链接列表实现，底层双向列表实现。
• 不是随机存取结构，查找慢，增删快
• 此实现不是同步的，线程不安全

具体方法

构造方法

• public LinkedList():构造一个初始容量为 10 的空列表。
• public LinkedList(Collection<? extends E> c):构造一个包含指定 collection 的元素的列表。

栈方法

• public void push(E e)：将该元素插入此列表的开头, 此方法等效于 addFirst(E)。
• public E pop()：移除并返回此列表的第一个元素, 此方法等效于 removeFirst()。

队列方法

• boolean add(E e): 将指定的元素追加到此列表的末尾。
• public E peek()：获取但不移除此列表的头（第一个元素）。
• public E poll()：获取并移除此列表的头（第一个元素）。

特有方法

• public void addFirst(E e)
• public void addLast(E e)
• public E removeFirst()
• public E removeLast()
• public E getFirst()
• public E getLast()

1.4 java.util 类 Vector

• 可以实现可增长的对象数组：protected Object[] elementData;
• 是随机存取结构，查找块，增删慢
• 实现是同步的，线程安全

特有方法

• public void addElement(E obj)：add()。
• public E elementAt(int index)：get()。
• public Enumeration elements()：iterator()。

1.5 综合比较

    ArrayList
        底层数据结构是数组，查询快，增删慢。
        线程不安全，效率高。
    Vector
        底层数据结构是数组，查询快，增删慢。
        线程安全，效率低。
    LinkedList
        底层数据结构是链表，查询慢，增删快。
        线程不安全，效率高。

2. 栈和队列

2.1 java.util 类 Stack

• 栈先进后出
• 继承了Vector<E>集合，实现了List<E>接口
• 底层是可变长度数组，方法同步，线程安全。

具体方法push,pop,peek

构造方法

• public Stack()：创建一个空堆栈。

其他方法

• public boolean empty()：测试堆栈是否为空。
• public void push(E e)：把项压入堆栈顶部。
• public E pop()：移除堆栈顶部的对象，并作为此函数的值返回该对象。
• public E peek()：查看堆栈顶部的对象，但不从堆栈中移除它。
• public int search(Object o)：返回对象在堆栈中的位置，栈顶计为1。

2.2 java.util 接口 Queue

• 队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。
• 不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。。
• 继承了Collection<E>接口
• 实现子类PriorityQueue<E>、ArrayDeque<E>、LinkedList<E>
• 子接口Deque<E>

	抛出异常	返回特殊值
插入	add(e)	offer(e)
移除	remove()	poll()
检查	element()	peek()

抽象方法add,poll,peek

插入方法

• boolean add(E e)：将指定的元素插入此队列，在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
• boolean offer(E e)：将指定的元素插入此队列，offer 方法设计用于正常的失败情况，而不是出现异常的情况，例如在容量固定（有界）的队列中。

移除方法

• E remove()：获取并移除此队列的头，如果此队列为空，抛出一个异常。
• E poll()：获取并移除此队列的头，如果此队列为空，则返回 null。

检查方法

• E element()：获取，但是不移除此队列的头。如果此队列为空，抛出一个异常。
• E peek()：获取但不移除此队列的头；如果此队列为空，则返回 null。

2.3 java.util 类 PriorityQueue

• 实现了Collection<E>和Queue<E>接口
• 底层是由数组实现： transient Object[] queue
• 实现不是同步的，线程不安全
• 一个基于优先级堆的无界优先级队列。
• 优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序,具体取决于所使用的构造方法。
• 不允许使用 null 元素。

具体方法

构造方法

• public PriorityQueue()：使用默认的初始容量（11）创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
• public PriorityQueue(int initialCapacity)：使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
• public PriorityQueue(int initialCapacity, Comparator<? super E> comparator)：使用指定的初始容量创建一个 PriorityQueue，并根据指定的比较器对元素进行排序。

插入方法

• boolean add(E e)：将指定的元素插入此优先级队列。
• boolean offer(E e)：将指定的元素插入此优先级队列。

移除方法

• E poll()：获取并移除此队列的头，如果此队列为空，则返回 null。
• public boolean remove(Object o)：从此队列中移除指定元素的单个实例（如果存在）。

检查方法

• E peek()：获取但不移除此队列的头；如果此队列为空，则返回 null。

其他方法

• public Comparator<? super E> comparator()：返回用来对此队列中的元素进行排序的比较器；如果此队列根据其元素的自然顺序进行排序，则返回 null。

2.4 java.util 类 ArrayDeque

• 实现了Queue<E>接口和Deque<E>接口
• 名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。
• Deque 接口的大小可变数组的实现： transient Object[] elements
• 实现不是同步的，线程不安全
• 此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。
• 方法类型几乎等同于LinkedList
• Deque<E>接口、ArrayDeque<E>、LinkedList<E>方法几乎相同，只是实现的方法不同。

2.5 综合比较

• 比较Stack<E>先进后出、Queue<E>：先进先出
• 从底层实现、是否线程安全、适用场景方面，比较PriorityQueue<E>、ArrayDeque<E>、LinkedList<E>

	栈、队列	底层实现	是否线程安全
LinkedList	栈、 队列	链表	不安全
Stack	栈	数组	安全
ArrayDeque	双端队列（栈、队列）	数组	不安全
PriorityQueue	优先队列	数组	不安全

3. Set

3.1 java.util 接口 Set

• 一个不包含重复元素的 collection。
• 所有已知实现类：HashSet<E>、TreeSet<E>

抽象方法

添加功能 add

• boolean add(E e): 如果 set 中尚未存在指定的元素，则添加此元素。
• boolean addAll(Collection<? extends E> c)：如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中。

删除功能 remove

• void clear()： 从列表中移除所有元素。
• boolean remove(Object o)： 移除此 set 中的所有元素。
• boolean removeAll(Collection<?> c)： 移除 set 中那些包含在指定 collection 中的元素。

判断功能 contains, equals, isEmpty

• boolean contains(Object o): 如果 set 包含指定的元素，则返回 true。
• boolean containsAll(Collection<?> c): 如果此 set 包含指定 collection 的所有元素，则返回 true。
• boolean equals(Object o): 比较指定对象与此 set 的相等性。
• boolean isEmpty(): 如果列表不包含元素，则返回 true。

迭代器功能 iterator

• Iterator iterator(): 返回在此 set 中的元素上进行迭代的迭代器。

其他功能 size, toArray

• int size(): 返回列表中的元素数。
• int hashCode(): 返回列表的哈希码值。
• Object[] toArray()： 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
• boolean retainAll(Collection<?> c)： 仅在列表中保留指定 collection 中所包含的元素。

3.2 java.util 类 HashSet

    A:底层数据结构是哈希表(是一个元素为链表的数组)
    B:此类实现 Set 接口，由哈希表（实际上是一个 只使用了key成员变量的HashMap 实例）支持。
    C:实现不是同步的,线程不安全。
    D:哈希表底层依赖两个方法：hashCode()和equals()
      执行顺序：
        首先比较哈希值是否相同
            相同：继续执行equals()方法
                返回true：元素重复了，不添加
                返回false：直接把元素添加到集合
            不同：就直接把元素添加到集合
    E:如何保证元素唯一性的呢?
        由hashCode()和equals()保证的
    F:如何解救hash冲突：链地址法
    G:开发的时候，自动生成即可。

具体方法（没有特殊方法）

构造方法

• public HashSet()：构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
• public HashSet(int initialCapacity)：构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
• public HashSet(Collection<? extends E> c)：构造一个包含指定 collection 中的元素的新 set。
• public HashSet(int initialCapacity, float loadFactor)：构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。

3.3 java.util 类 TreeSet

    A:底层数据结构是红黑树(是一个自平衡的二叉树，有指向left、right、parent的指针)
    B:基于 TreeMap 的 NavigableSet 实现。
    C:实现不是同步的,线程不安全。
    D:保证元素的排序方式
        a:自然排序(元素具备比较性)
            让元素所属的类实现Comparable接口
        b:比较器排序(集合具备比较性)
            让集合构造方法接收Comparator的实现类对象

具体方法

构造方法

• public TreeSet()：构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
• public TreeSet(Comparator<? super E> comparator)：构造一个新的空 TreeSet，它根据指定比较器进行排序。
• public HashSet(Collection<? extends E> c)：构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

获取方法

• public E ceiling(E e):返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
• public E floor(E e):返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
• public E higher(E e):返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
• public E lower(E e):返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
• public E first():返回此 set 中当前第一个（最低）元素。
• public E last():返回此 set 中当前最后一个（最高）元素。

删除方法

• public E pollFirst():获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
• public E pollLast():获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

3.4 综合比较

唯一吗?
    是：Set
        排序吗?
            是：TreeSet
            否：HashSet
    如果你知道是Set，但是不知道是哪个Set，就用HashSet。

    否：List
        要安全吗?
            是：Vector
            否：ArrayList或者LinkedList
                查询多：ArrayList
                增删多：LinkedList
    如果你知道是List，但是不知道是哪个List，就用ArrayList。

4. 键值对

4.1 java.util 接口 Map<K,V>

• 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
• Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。
• 所有已知实现类：HashMap, Hashtable,TreeMap。
• Map和Collection的区别?
  A:Map 存储的是键值对形式的元素，键唯一，值可以重复。
  B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。

嵌套类

• Map.Entry<K,V> 映射项（键-值对）：public static interface Map.Entry<K,V>
• Map.Entry<K,V>中 Entry<K,V> 为Map接口的内部接口，定义了数据类型为键值对。
• HashMap中Entry<K,V>实现并扩展了Map.Entry<K,V>，定义为元素为数组中的链表头结点。
• TreeMap中Entry<K,V>实现并扩展了Map.Entry<K,V>，定义为元素为三叉链表，包含孩子和父指针。
• 其中设计采用了接口的内部接口，类的静态内部类的方式。

抽象方法

添加功能 put

• V put(K key, V value):将指定的值与此映射中的指定键关联,返回以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。
• void putAll(Map<? extends K,? extends V> m)：从指定映射中将所有映射关系复制到此映射中。

删除功能 remove

• void clear()：从此映射中移除所有映射关系。
• V remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除，返回此映射中以前关联该键的值，如果此映射不包含该键的映射关系，则返回 null。

判断功能 containsKey, containsValue

• boolean containsKey(Object key):如果此映射包含指定键的映射关系，则返回 true。
• boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值，则返回 true。
• boolean equals(Object o):比较指定的对象与此映射是否相等。
• boolean isEmpty():如果此映射未包含键-值映射关系，则返回 true。

获取功能 entrySet, keySet, values, get, size

• Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的 Set 视图，得到键值对。
• Set keySet()：返回此映射中包含的键的 Set 视图。
• Collection values()：返回此映射中包含的值的 Collection 视图。
• V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
• int hashCode()：返回此映射的哈希码值。
• int size()：返回此映射中的键-值映射关系数。如果该映射包含的元素大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。

知识扩展

Map集合的遍历
    A:键找值
        a:获取所有键的集合
        b:遍历键的集合,得到每一个键
        c:根据键到集合中去找值

    B:键值对对象找键和值
        a:获取所有的键值对对象的集合
        b:遍历键值对对象的集合，获取每一个键值对对象
        c:根据键值对对象去获取键和值

    代码体现：
        Map<String,String> hm = new HashMap<String,String>();

        hm.put("it002","hello");
        hm.put("it003","world");
        hm.put("it001","java");

        //方式1 键找值
        Set<String> set = hm.keySet();
        for(String key : set) {
            String value = hm.get(key);
            System.out.println(key+"---"+value);
        }

        //方式2 键值对对象找键和值
        Set<Map.Entry<String,String>> set2 = hm.entrySet();
        for(Map.Entry<String,String> me : set2) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"---"+value);
        }

4.2 java.util 类 HashMap<K,V>

• 基于哈希表的 Map 接口的实现，HashSet集合也是基于HashMap实现。
• 底层数据结构是哈希表(是一个元素为链表的数组)。
• 此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size。
• 此实现不是同步，线程不安全。
• 除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。
• HashMap 的实例有两个参数影响其性能：初始容量和加载因子。
• 默认加载因子 (0.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本。

具体方法（参考Map即可）

嵌套类

• 类 AbstractMap.SimpleEntry<K,V> 映射项（键-值对）：public static class AbstractMap.SimpleEntry<K,V>
• 类 AbstractMap.SimpleImmutableEntry<K,V>：维护不可变的键和值的 Entry。此类不支持 setValue 方法。
• 均实现了Map.Entry<K,V>其中的方法，但没有实际意义。因为HashMap和TreeMap中的Entry<K,V>是实现了Map.Entry<K,V>内部接口，并不是实现了AbstractMap中的内部类。

构造方法

• public HashMap()：构造一个映射关系与指定 Map 相同的新 HashMap。所创建的 HashMap 具有默认加载因子 (0.75) 和足以容纳指定 Map 中映射关系的初始容量。
• public HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
• public HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。
• public HashMap(Map<? extends K,? extends V> m)：构造一个映射关系与指定 Map 相同的新 HashMap。

4.3 java.util 类 TreeMap<K,V>

• 基于红黑树（Red-Black tree）的 NavigableMap 实现。
• 该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
• 此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。
• 此实现不是同步，线程不安全。

具体方法

嵌套类（与hashMap相同）

构造方法

• public TreeMap()：使用键的自然顺序构造一个新的、空的树映射。
• public TreeMap(Comparator<? super K> comparator)：构造一个新的、空的树映射，该映射根据给定比较器进行排序。
• public TreeMap(Map<? extends K,? extends V> m)：构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。

特殊方法（主要利用了tree结构中key的排序功能）

返回键值对

• public Map.Entry<K,V> ceilingEntry(K key)：返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
• public Map.Entry<K,V> floorEntry(K key)：返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
• public Map.Entry<K,V> higherEntry(K key)：返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
• public Map.Entry<K,V> lowerEntry(K key)：返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
• public Map.Entry<K,V> firstEntry()：返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
• public Map.Entry<K,V> lastEntry()：返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
• public Map.Entry<K,V> pollFirstEntry()：移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
• public Map.Entry<K,V> pollLastEntry()：移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。

返回键

• public K ceilingKey(K key)：返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
• public K floorKey(K key)：返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
• public K higherKey(K key)：返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
• public K lowerKey(K key)：返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
• public K firstKey()：返回此映射中当前第一个（最低）键。
• public K lastKey()：返回映射中当前最后一个（最高）键。

4.4 java.util 类 Hashtable<K,V>

• 此类实现一个哈希表，该哈希表将键映射到相应的值。
• 同步，线程安全。

特殊方法（其余参考HashMap即可）

• public Enumeration elements()：返回此哈希表中的值的枚举。
• public Enumeration keys()：返回此哈希表中的键的枚举。
• protected void rehash()：增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。当哈希表中的键的数量超出哈希表的容量和加载因子时，自动调用此方法。

4.5 java.util 接口 Map.Entry<K,V>

• public static interface Map.Entry<K,V>，Map接口的内部接口。
• 定义了数据类型为映射项（键-值对）。

抽象方法 getKey, getValue, setValue

• boolean equals(Object o)：比较指定对象与此项的相等性。
• K getKey()：返回与此项对应的键。
• V getValue()：返回与此项对应的值。
• int hashCode()：返回此映射项的哈希码值。
• V setValue(V value)：用指定的值替换与此项对应的值。

知识扩展

java中外部接口与内部接口的使用
新建一个非抽象类（普通类）实现接口如下：
1、普通类实现了接口，那么就必须实现接口中的所有方法
2、那么反过来没有实现接口中的方法的类就是抽象类
3、一个类可以实现多个接口
这里用内部类的好处就是： 
1、当你只实现外部接口，那么只需实现外部接口的方法即可（内部接口是调不到的）。
2、而实现内部接口的方式是“外部接口.内部接口”，那么就可以实现内部接口的方法了。通过这个方法，可以将外部接口和内部接口分开实现，一般内部接口中的方法只在 3、内部接口也是一种数据类型。

参考链接：https://www.jianshu.com/p/ab539e9a7955

4.6 java.util 类 AbstractMap.SimpleEntry<K,V>

• 是AbstractMap的内部类，实现了 Map.Entry<K,V>
• 维护键和值的 Entry。可以使用 setValue 方法更改值。
• 具体方法看 Map.Entry<K,V>即可。

4.7 综合比较

	底层实现	是否线程安全
HashMap<K,V>	hash表（元素为链表的数组）	不安全
TreeMap<K,V>	树（三叉链表）	不安全
Hashtable<K,V>	hash表（元素为链表的数组）	安全

 

5. 字符串

5.1 java.lang 类 String

• 字符串是常量,它们的值在创建之后不能更改。
• 底层是由数组实现：private final char value[]; 由final修饰，只能赋一次值。
• 多个字符组成的一串数据。
• 字面值作为字符串对象（变量指向main方法区）和通过构造方法创建对象（变量指向堆内存，堆内存再指向main方法区）的不同。
  String s = new String("hello"); 和String s = "hello"不同。

具体方法

构造方法 byte[], char[]

• public String()：初始化一个新创建的 String 对象，使其表示一个空字符序列。
• public String(byte[] bytes)：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。注意这个得到了是数字对应的字符，A-Z 65-90，a-z 97-122。
• public String(byte[] bytes,int offset,int length)：通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
• public String(char[] value)：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
• public String(char[] value,int offset,int count)：分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
• public String(String original)：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列。

判断方法 contains, equals, equalsIgnoreCase, startsWith, endsWith, isEmpty

• boolean contains(String str)：当且仅当此字符串包含指定的 char 值序列时，返回 true。
• boolean equals(Object obj)：将此字符串与指定的对象比较。
• boolean equalsIgnoreCase(String str)：将此 String 与另一个 String 比较，不考虑大小写。
• boolean startsWith(String str)：测试此字符串是否以指定的前缀开始。
• public boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
• boolean endsWith(String str)：测试此字符串是否以指定的后缀结束。
• boolean isEmpty()：当且仅当 length() 为 0 时返回 true。
• public boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。

获取方法 length, charAt, indexOf, substring, split

• int length():返回此字符串的长度。
• char charAt(int index):返回指定索引处的 char 值。
• int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
• int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引。
• int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
• public int lastIndexOf(int ch):返回指定字符在此字符串中最后一次出现处的索引。
• public int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引。
• String substring(int start)：返回一个新的字符串，它是此字符串的一个子字符串。
• String substring(int start,int end)：返回一个新字符串，它是此字符串的一个子字符串。
• public String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
• public String[] split(String regex,int limit):根据匹配给定的正则表达式来拆分此字符串。limit 参数控制模式应用的次数，因此影响所得数组的长度。

转换方法 getBytes, toCharArray, valueOf, toLowerCase, toUpperCase

• byte[] getBytes()： 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
• char[] toCharArray()：将此字符串转换为一个新的字符数组。
• static String valueOf(char[] chs)：返回 char 数组参数的字符串表示形式。
• static String valueOf(int i)：返回 int 参数的字符串表示形式。
• String toLowerCase():使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
• String toUpperCase():使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
• String concat(String str):将指定字符串连接到此字符串的结尾,用‘+’即可。

替换功能 replace

• String replace(char old,char new):返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
• String replace(String old,String new):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

其他方法 trim

• String trim()： 返回字符串的副本，忽略前导空白和尾部空白。
• int compareTo(String str)：按字典顺序比较两个字符串。
• int compareToIgnoreCase(String str)：按字典顺序比较两个字符串，不考虑大小写。

5.2 java.lang 类 StringBuffer

• 线程安全的可变字符序列。
• private transient char[] toStringCache;底层由可变数组实现。
• StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。

具体方法

构造方法

• StringBuffer()：构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
• StringBuffer(int capacity)：构造一个不带字符，但具有指定初始容量的字符串缓冲区。
• StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

添加方法 append, insert

• public StringBuffer append(String str)：将指定的字符串追加到此字符序列。其中String可以是其余数据类型。
• public StringBuffer insert(int offset, String str):将字符串插入此字符序列中。

删除方法 delete

• public StringBuffer delete(int start, int end)：移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符。
• public StringBuffer deleteCharAt(int index)：移除此序列指定位置的 char。此序列将缩短一个 char。

替换方法 replace

• public StringBuffer replace(int start, int end, String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。

反转方法 reverse

• public StringBuffer reverse()：将此字符序列用其反转形式取代。

获取方法 substring, toString

• public String substring(int start)：返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
• public String substring(int start, int end):返回一个新的 String，它包含此序列当前所包含的字符子序列。
• public String toString():返回此序列中数据的字符串表示形式。

5.3 java.lang 类 StringBuilder

• 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
• 在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
• 如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

具体方法(与StringBuffer相同）

5.4 综合比较

• String提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
• StringBuilder（或 StringBuffer）类及其 append 方法实现的。字符串转换是通过 toString 方法实现。
• 比较String与StringBuffer或StringBuilder的不同
  StringBuffer和StringBuilder长度和内容可变，做字符串的拼接不会浪费太多的资源。
  StringBuffer：同步的，数据安全，效率低。
  StringBuilder：不同步的，数据不安全，效率高。

6. IO流

(1)IO用于在设备间进行数据传输的操作    
(2)分类：
    A:流向
        输入流 读取数据
        输出流 写出数据
    B:数据类型
        字节流 
                字节输入流
                字节输出流
        字符流
                字符输入流
                字符输出流

（3）IO流
    |--字节流
        |--字节输入流
            InputStream
                int read():一次读取一个字节
                int read(byte[] bys):一次读取一个字节数组

                |--FileInputStream
                |--BufferedInputStream
        |--字节输出流
            OutputStream
                void write(int by):一次写一个字节
                void write(byte[] bys,int index,int len):一次写一个字节数组的一部分

                |--FileOutputStream
                |--BufferedOutputStream
    |--字符流 （是由字节流和编码表组成，因此字符流的层次关系较字节流多一层)
        |--字符输入流
            Reader
                int read():一次读取一个字符
                int read(char[] chs):一次读取一个字符数组

                |--InputStreamReader
                    |--FileReader （相当于FileInputStreamReader，但是太长了，因此用FileReader来表示）    
                |--BufferedReader
                    String readLine():一次读取一个字符串
        |--字符输出流
            Writer
                void write(int ch):一次写一个字符
                void write(char[] chs,int index,int len):一次写一个字符数组的一部分

                |--OutputStreamWriter
                    |--FileWriter
                |--BufferedWriter
                    void newLine():写一个换行符                       
                    void write(String line):一次写一个字符串

注意事项

• 当用字节流read()方法将文本文件中的汉字输出到控制台会出现错误，但是当 write(int by)写入到文本文件中则没有问题
  • read()方法每次只获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台，但是汉字最少由2个字节数组组成。
  • write(int by)写入到文本文件中，会自己做转换。
• 字符流FileReader和FileWriter拷贝图片或者音频文件会出错。
  • 发现丢失了信息。
  • 图片本来就是二进制文件，不需要进行编码。
• 字节流是通用的流，可用于任何类型的对象，包括二进制流对象和汉字字符，而字符流只能处理字符或者字符串。
  • 但是用字节流处理字符有可能出现编码表不匹配等问题，因为采用的是默认编码表。
  • 用字节流输出字符到控制台时候，不能一次只读取一个字节，因为字符是多个字节组成。
  • 用字符流处理字符更高效，使用了缓冲区，并且可以选择编码表类型。
• 何时使用字符流，何时使用字节流？依据是什么？
  • 使用字符流的应用场景：如果是读写字符数据的时候则使用字符流，打开文档能看懂。
  • 使用字节流的应用场景：如果是读写的数据都不需要转换成字符的时候，则使用字节流，打开文档看不懂的。
• 字节流默认不使用缓冲区；字符流使用缓冲区。

6.1 java.io 类 File

• 文件和目录路径名的抽象表示形式。

具体方法

构造方法（接收String和File参数）

• public File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例，file = new File("e:\demo\a.txt");
• public File(String parent, String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例，file = new File("e:\demo","a.txt");
• public File(File parent, String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例，File file2 = new File(file,"a.txt");

创建功能 createNewFile, mkdirs

• public boolean createNewFile() throws IOException：当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
• public boolean mkdir()：创建此抽象路径名指定的目录。
• public boolean mkdirs()：创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

删除功能 delete

• public boolean delete()：删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。

重命名功能 renameTo

• public boolean renameTo(File dest)：重新命名此抽象路径名表示的文件。

判断功能 isDirectory, isFile, exists, canRead, canWrite

• public boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
• public boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
• public boolean exists()：测试此抽象路径名表示的文件或目录是否存在。
• public boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
• public boolean canRead()：测试应用程序是否可以读取此抽象路径名表示的文件。
• public boolean canWrite()：测试应用程序是否可以修改此抽象路径名表示的文件。

获取功能 getAbsolutePath, getPath, list

• public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
• public String getPath()：获取相对于当前目录下的相对路径。
• public String getName()：返回由此抽象路径名表示的文件或目录的名称。
• public long length()：返回由此抽象路径名表示的文件的长度。
• public long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
• public String[] list()：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
• public File[] listFiles()：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

过滤器功能

• public String[] list(FilenameFilter filter)：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
• public File[] listFiles(FilenameFilter filter)：返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

6.2 java.io 类 InputStream

• 此抽象类是表示字节输入流的所有类的超类。
• 实现子类FileInputStream

抽象方法 read, close

• public abstract int read() throws IOException：从输入流中读取数据的下一个字节。
• public int read(byte[] b) throws IOException：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
• public int read(byte[] b, int off, int len) throws IOException:将输入流中最多 len 个数据字节读入 byte 数组。
• public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
• public void mark(int readlimit)：在此输入流中标记当前的位置。
• public void reset() throws IOException：将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。

6.2 java.io 类 FileInputStream

• 为InputStream字节流的实现子类
• FileInputStream 从文件系统中的某个文件中获得输入字节。
• FileInputStream 用于读取诸如图像数据之类的原始字节流。
• 要读取字符流，请考虑使用 FileReader。

构造方法（方法查看InputStream即可）

• public FileInputStream(File file) throws FileNotFoundException:通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
• public FileInputStream(String name) throws FileNotFoundException:通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

6.3 java.io 类 InputStreamReader

• 为Reader字符流的实现子类
• InputStreamReader 是字节流通向字符流的桥梁。
• 每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。
• 为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。

构造方法（方法查看InputStream即可）

• public InputStreamReader(InputStream in):创建一个使用默认字符集的 InputStreamReader。
• public InputStreamReader(InputStream in, String charsetName):指定编码。

6.4 java.io 类 BufferedReader

• 为Reader字符流的实现子类
• 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
• 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
• 建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。
  • BufferedReader in = new BufferedReader(new FileReader("foo.in"));
  • BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

构造方法

• public BufferedReader(Reader in):创建一个使用默认大小输入缓冲区的缓冲字符输入流。
• public BufferedReader(Reader in, int sz):创建一个使用指定大小输入缓冲区的缓冲字符输入流。

特殊方法 readLine（其余参考InputStream即可）

• public String readLine()：读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。

6.5 java.io 类 OutputStream

• 此抽象类是表示输出字节流的所有类的超类。
• 实现子类 FileOutputStream

抽象方法 write, flush, close

• public abstract void write(int b)：将指定的字节写入此输出流。
• public void write(byte[] b)：将 b.length 个字节从指定的 byte 数组写入此输出流。
• public void write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
• public void flush()：刷新此输出流并强制写出所有缓冲的输出字节。
• public void close()：关闭此输出流并释放与此流有关的所有系统资源。

6.6 java.io 类 FileOutputStream

• 为OutputStream字节流的实现子类。
• FileOutputStream 用于写入诸如图像数据之类的原始字节的流。
• 要写入字符流，请考虑使用 FileWriter。

构造方法（方法查看OutputStream即可）

• public FileOutputStream(File file):创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
• public FileOutputStream(File file, boolean append):如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
• public FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出文件流。
• public FileOutputStream(String name, boolean append)：如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。

6.7 java.io 类 OutputStreamWriter

• 为Writer字符流的实现子类
• OutputStreamWriter 是字符流通向字节流的桥梁。
• 每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。
• 为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。
  • Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

构造方法（方法查看InputStream即可）

• OutputStreamWriter(OutputStream out) :创建使用默认字符编码的 OutputStreamWriter。
• public OutputStreamWriter(OutputStream out, String charsetName):指定编码。

6.8 java.io 类 BufferedWriter

• 为Writer字符流的实现子类
• 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
• 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
• 建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。
  • PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));
  • Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

构造方法

• public BufferedWriter(Writer out):创建一个使用默认大小输出缓冲区的缓冲字符输出流。
• public BufferedWriter(Writer out, int sz):创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

特殊方法 newLine（其余参考OutputStream即可）

• public void newLine()：写入一个行分隔符。

7. 静态类

7.1 java.util 类 Arrays

• 此类包含用来操作数组（比如排序和搜索）的各种方法。
• 此类还包含一个允许将数组作为列表来查看的静态工厂。

静态方法 binarySearch, sort, toString

• public static int binarySearch(int[] a, int key)：使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
• public static void sort(int[] a)：对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法。
• public static String toString(int[] a)：返回指定数组内容的字符串表示形式。
• public static boolean equals(int[] a, int[] a2)：如果两个指定的 int 型数组彼此相等，则返回 true。

7.2 java.util 类 Collections

• 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

二分查找方法 binarySearch,

• public static int binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
• public static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)：使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过 sort(List, Comparator) 方法）。

排序方法 sort

• public static <T extends Comparable<? super T>> void sort(List list)：根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的。
• public static void sort(List list, Comparator<? super T> c)：根据指定比较器产生的顺序对指定列表进行排序。

最值方法 max, min

• public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)：根据元素的自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是可相互比较的。
• public static T max(Collection<? extends T> coll, Comparator<? super T> comp)：根据指定比较器产生的顺序，返回给定 collection 的最大元素。
• public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)：根据元素的自然顺序 返回给定 collection 的最小元素。
• public static T min(Collection<? extends T> coll, Comparator<? super T> comp)：根据指定比较器产生的顺序，返回给定 collection 的最小元素。

同步方法

• public static Collection synchronizedCollection(Collection c)：返回指定 collection 支持的同步（线程安全的）collection。
• public static List synchronizedList(List list)：返回指定列表支持的同步（线程安全的）列表。
• public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)：返回由指定映射支持的同步（线程安全的）映射。
• public static Set synchronizedSet(Set s)：返回指定 set 支持的同步（线程安全的）set。

其他方法 shuffle, reverse

• public static void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。
• public static void reverse(List<?> list)：反转指定列表中元素的顺序。
• public static boolean replaceAll(List list, T oldVal, T newVal)：使用另一个值替换列表中出现的所有某一指定值。

知识拓展

Collection和Collections的区别
    A:Collection 是单列集合的顶层接口，有两个子接口List和Set
    B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等