Java集合笔记

Java集合笔记

1、Java集合框架

1.1、Collection的常用方法

1. Iterator<E> iterator()			//返回一个用于访问集合中每个元素的迭代器
   

2. int size()						//当前存储在集合中的元素个数
   

3. boolean isEmpty()				//如果集合中没有元素，返回 true 
   

4. boolean contains(Object obj)	//如果集合中包含了一个与 obj 相等的对象， 返回 true  
   

5. boolean add(Object obj)			//将一个元素添加到集合中。如果由于这个调用改变了集合，返回 true 
   

6. boolean remove(Object obj)		//从这个集合中删除等于 obj 的对象。 如果有匹配的对象被删除， 返回 true 
   

7. void clear()					//从这个集合中删除所有的元素  
   

8. Object[] toArray()				//返回这个集合的对象数组  
   

9. boolean contains(Object obj)	//判断 obj 是否出现，若出现返回 true
   

1.2、Iterator接口的方法

• boolean hashNext()	//如果存在可访问的元素， 返回 true  
  

• E next()			//返回将要访问的下一个对象，如果已经到达了集合的尾部， 将拋出一个异常
  

1.3、集合的分类

• Collection 接口 （单列集合）
  • List 接口
    • LinkedList 接口实现类，链表，
    • ArrayList 接口实现类，数组，
    • Vector 接口实现类，数组，同步线程安全
  • Set接口
    • HashSet 接口实现类
      • LinkedHashSet
    • TreeSet 接口实现类
• Map 接口 （双列集合）
  • Hashtable 接口实现类
  • HashMap 接口实现类
    • LinkedHashMap
    • WeakHashMap
  • TreeMap 接口实现类
  • IdentifyHashMap 接口实现类

2、具体的集合（List、Set、队列）

2.1、List

特点

1. ArrayList：底层实现是数组，查询快，增删慢，线程不安全
2. LinkedList：底层实现是链表，查询慢，增删快，线程不安全
3. Vector：底层实现是数组，查询快，增删慢，线程安全

方法

List 特有的方法

1. ListIterator<E> listIterator()			//返回一个列表迭代器， 以便用来访问列表中的元素 
   

2. ListIterator<E> listIterator(int index)	//返回一个列表迭代器， 以便用来访问列表中的元素， 这个元素是第一次调用 next 返回
   										//的给定索引的元素  
   

3. void add(int index, E element)			//在给定位置添加一个元素  
   

4. E remove(int index)						//删除给定位置的元素并返回这个元素  
   

5. E get(int index)						//获取给定位置的元素
   

6. E set(int index, E element)				//用新元素取代给定位置的元素， 并返回原来那个元素
   

7. int indexOf(Object element)				//返回与指定元素相等的元素在列表中第一次出现的位置， 如果没有这样的元素将返回-1
   

8. int lastIndexOf(Object element)			//返回与指定元素相等的元素在列表中最后一次出现的位置， 
       									//如果没有这样的元素将返回 -1
   

9. List subList(int startIndex, int endIndex)	//截取子集，左闭右开 [startIndex, endIndex)
   

ListIterator 方法

1. void add(E newElement)		//在当前位置前添加一个元素
   

2. void set(E newElement)		//用新元素取代 next 或 previous 上次访问的元素
   

3. boolean hasPrevious()		//当反向迭代列表时， 还有可供访问的元素， 返回 true
   

4. E previous()				//返回前一个对象
   

5. int nextIndex()				//返回下一次调用 next 方法时将返回的元素索引
   

6. int previousIndex()			//返回下一次调用 previous 方法时将返回的元素索引
   

ArrayList

• ArrayList 的方法仅有 Collention 和 List 接口的方法，它本身没有单独的方法

LinkedList 特有的方法

1. 添加元素到列表的头部或尾部

   void addFist(E element)
   void addLast(E element)
   

2. 返回链表的头部或尾部元素

   E getFirst()
   E getLast()
   

3. 删除并返回链表的头部或尾部元素

   E removeFirst()
   E removeLast()
   

Vector 特有方法

1. void addElement(E element)		//相当于 add()
   

2. E elementAt(int index)			//相当于get()
   

ArrayList 和 Vector 的比较

• ArrayList 方法不是同步的
• Vector 类的所有方法都是同步的，可以由两个线程安全地访问一个 Vector 对象
• 如果只有一个线程访问 Vector, 代码要在同步操作上耗费大量的时间，因此，建议在不需要同步时使用 ArrayList, 而不要使用 Vector

List 构造方法

ArrayList

ArrayList<E> list = new ArrayList<E>();								//无参构造方法
ArrayList<E> list = new ArrayList<E>(int initialCapacity);			//带容量的构造方法
ArrayList<E> newList = new ArrayList<E>(Collection<? extends E> c);	//从另一个集合构造

LinkedList

LinkedList<E> list = new LinkedList<E>();								//无参构造方法
LinkedList<E> newList = new LinkedList<E>(Collection<? extends E> c);	//从另一个集合构造

Vector

Vector<E> vector = new Vector<E>();												//无参构造方法
Vector<E> vector = new Vector<E>(int initialCapacity);							//带容量的构造方法
Vector<E> vector = new Vector<E>(int initialCapacity, int capacityIncrement);	//带容量和负载因子的构造方法
Vector<E> vector = new Vector<E>(Collection<? extends E> c);					//从另一个集合构造

• 注：capacityIncrement 负载因子， 一个 0.0 ~ 1.0 之间的数值， 当填充百分比大于capacityIncrement时，进行扩容

2.2、Set

特点

• **HashSet **底层数据结构采用哈希表实现，元素唯一，无序，线程不安全，效率高，可以存储 null 元素
  它的contains方法已经被重新定义， 用来快速地查看是否某个元素已经出现在集中

  • LinkedHashSet 底层数据结构采用链表和哈希表共同实现，有序（按存储顺序排列），元素唯一，线程不安全，效率高
    它的父类是 HashSet

• TreeHashSet 底层数据结构采用二叉树实现，元素唯一，而且已经排好序（可以默认排序或自定义排序）
  它是一个有序集合，可以以任意顺序将元素插入到集合中，在对元素进行遍历时，每个值将自动地按照排序后的顺序呈现

方法

Set 具有和 Collection 接口完全一样的方法，没有任何额外的方法

Set 构造方法

HashSet

HashSet<E> set = new HashSet<E>();										//无参构造方法										
HashSet<E> set = new HashSet<E>(int initialCapacity);					//带容量的构造方法
HashSet<E> set = new HashSet<E>(int initialCapacity, float loadFactor);	//带容量和负载因子的构造方法
HashSet<E> newSet = new HashSet<E>(Collection<? extends E> c);			//从另一个集合构造

TreeSet

TreeSet<E> set = new TreeSet<E>();									//无参构造方法	
TreeSet<E> set = new TreeSet<E>(Comparator<? super E> comparator);	//带比较器构造
TreeSet<E> newSet = new TreeSet<E>(Collection<? extends E> c);		//从另一个集合构造

2.3、队列

3、映射（Map）

特点

• Java 类库为映射提供了两个通用的实现：HashMap 和 TreeMap 。这两个类都实现了 Map 接口

• HashMap 对 key 进行散列

• TreeMap 用 key 的整体顺序对元素进行排序，并将其组织成搜索树

• Map 中的元素总是以 key-value 键值对的形式存储的，可以通过 key 查找 value ，一个 Map 中不能包含相同的 key

方法

• K 和 V 分别为 key 和 value 的数据类型

1. V get(Object key)		//获取与键对应的值；返回与键对应的对象， 如果在映射中没有这个对象则返回 null。 键可以为 null                     
   

2. V put(K key, V value)	//将键与对应的值关系插入到映射中。 如果这个键已经存在， 新的对象将取代与这个键对应的旧对象。
       					//这个方法将返回键对应的旧值。 如果这个键以前没有出现过则返回null。键可以为 null， 但值不能为 null
   

3. void putAll(Map m)		//将 Map 中的 key-value键值对 复制到 Map 中
   

4. boolean containsKey(Object key)			// 查询 Map 中是否存在 key 键，如果存在则返回true
   

5. boolean containsValue(Object value)		// 查询 Map 中是否存在 value 值，如果存在则返回true
   

6. boolean isEmpty()						//查询 Map 是否为空
   

7. void clear()			
   

8. int size()						//返回 Map 中 key-value 键值对的个数
   

9. Object remove(Object key)		//删除指定的 key 所对应的键值对，返回key关联的value，如果key不存在，则返回 null
   

10. Set<Map.Entry<K, V> entrySet()	//返回该 Map 中所有 key-value键值对 组成的 set 集合，集合的元素的Map.Entry(Map.Entry是Map的内部类)
    

11. Set<K> keySet()					//返回该 Map 中所有 key 组成的 set 集合
    

12. Collection<V> values()			//返回 Map 中所有value组成的 Collection
    

    • Map.Entry 的方法（是Map的内部类）

      K getKey()				//返回这一条目的键
      V getValue()			//返回这一条目的值
      V setValue(V newValue)	//将相关映射中的值改为新值， 并返回原来的值
      

HashMap

HashMap 继承自 AbstractMap 类，实现了 Map 接口，它使用哈希表来存储键值对。

• HashMap 线程不安全
• HashMap 不同步，性能较高
• HashMap 允许 键、值都为null

TreeMap

TreeMap 是 Java 中的一种基于红黑树（Red-Black Tree）实现的有序映射（SortedMap）数据结构。它继承自AbstractMap类，并实现了NavigableMap接口，用于存储键值对，并且可以根据键的自然顺序或自定义比较器来维护键的有序性。

• 有序性
  TreeMap 维护了存储的键值对的有序性。这意味着键是按升序排序的，或者根据提供的比较器进行排序。

• 键的比较
  TreeMap 中的键要么实现了Comparable接口，以支持自然排序，要么在创建 TreeMap 时提供了一个比较器（Comparator）来定义键的排序规则。

• 特殊方法

  • K firstKey() 		//返回第一个（最小的）键
    

  • K lastKey() 		//返回最后一个（最大的）键
    

  • K ceilingKey(key)		//返回大于等于给定键的最小键
    

  • K floorKey(key)		//返回小于等于给定键的最大键
    

  • K higherKey(key)		//返回大于给定键的最小键
    

  • K lowerKey(key)		//返回小于给定键的最大键
    

Map 其他类

• HashTable
  • HashTable 是 Java 中的一个旧的哈希表实现
  • HashTable 是线程安全的
  • HashTable 在每个方法上都有同步，所以性能较低
  • HashTable 不允许 null键或null值
• LinkedHashMap
  • 它继承自 HashMap，具有与 HashMap 相似的功能，但与普通的 HashMap 不同，额外维护了一个双向链表， 它保持了插入顺序或访问顺序的有序性。
  • 有序性：LinkedHashMap 维护了插入顺序或访问顺序的有序性。可以选择构造一个根据插入顺序或访问顺序（最近访问的元素排在前面）排序的 LinkedHashMap。
  • 性能：LinkedHashMap 的性能与 HashMap 类似，提供了常数时间复杂度 O(1) 的平均性能
• WeakHashMap
  • WeakHashMap 是 Java 中的一种特殊类型的哈希表，用于实现键值对存储，但它的键是弱引用的。这意味着，如果在程序中没有强引用指向键对象，那么这些键可以被垃圾回收，从而从 WeakHashMap 中自动删除。
  • 使用场景：WeakHashMap 的主要用途是在某些情况下，当键不再被强引用时，自动将键值对从映射中删除。这对于缓存和资源管理非常有用，因为它可以防止资源泄漏。
  • 性能：WeakHashMap 的性能与 HashMap 类似，提供了常数时间复杂度 O(1) 的平均性能，这使得插入、查找和删除操作非常快。
• IdentifyHashMap
  • 类 IdentityHashMap 有特殊的作用。在这个类中， 键的散列值不是用 hashCode 函数计算的， 而是用 System.identityHashCode 方法计算的。 这是 Object.hashCode 方法根据对象的内存地址来计算散列码时所使用的方式。 而且， 在对两个对象进行比较时， IdentityHashMap 类使用 ==, 而不使用 equals。也就是说， 不同的键对象， 即使内容相同， 也被视为是不同的对象。 在实现对象遍历算法 （如对象串行化）时， 这个类非常有用， 可以用来跟踪每个对象的遍历状况。