Java 的数据结构整理(整合版)

Java 的数据结构整理(整合版)

一、数据输入输出

https://www.runoob.com/java/java-scanner-class.html

这部分是为了预防 leetcode 刷习惯了,忘记怎么处理输入输出的问题

数据输入

Java的数据输入和 C++ 相比非常繁琐,因此大多数的Java的例题都无需处理输入输出,直接处理封装好的函数体即可

通过 Scanner 类来获取用户的输入。使用步骤如下:

  • 导包。Scanner 类在java.util包下,所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner;
  • 创建Scanner对象。
Scanner sc = new Scanner(System.in);// 创建Scanner对象,sc表示变量名,其他均不可变
  • 接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
import java.util.Scanner;public class ScannerDemo {public static void main(String[] args) { //创建对象Scanner sc = new Scanner(System.in); //接收数据// 可以使用 next() 与 nextLine() 方法接收数据,如果要输入 int 或 float 类型的数据,使用 nextXxx() 来读取// 在读取前一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据int x = sc.nextInt();//输出数据System.out.println("x:" + x);}
}
import java.util.Scanner;public class ScannerDemo {public static void main(String[] args) {Scanner scan = new Scanner(System.in);// 从键盘接收数据// nextLine方式接收字符串System.out.println("nextLine方式接收:");// 判断是否还有输入if (scan.hasNextLine()) {String str2 = scan.nextLine().trim();System.out.println("输入的数据为:" + str2);}scan.close();}
}

next() 与 nextLine() 区别

next():

  • 1、一定要读取到有效字符后才可以结束输入。
  • 2、对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next() 不能得到带有空格的字符串。

nextLine():

  • 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
  • 2、可以获得空白。

数据输出

System.out.println("Hello world");

二、集合框架

​ Java 集合框架主要包括两种类型的容器,一种是集合(Collection),存储一个元素集合,另一种是图(Map),存储键/值对映射。Collection 接口又有 3 种子类型,List、Set 和 Queue,再下面是一些抽象类,最后是具体实现类,常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

img

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容:

  • **接口:**是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口,是为了以不同的方式操作集合对象
  • **实现(类):**是集合接口的具体实现。从本质上讲,它们是可重复使用的数据结构,例如:ArrayList、LinkedList、HashSet、HashMap。
  • **算法:**是实现集合接口的对象里的方法执行的一些有用的计算,例如:搜索和排序,这些算法实现了多态,那是因为相同的方法可以在相似的接口上有着不同的实现。

​ 除了集合,该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合,但是它们完全整合在集合中。

img

三、集合接口

集合框架定义了一些接口。

序号接口描述
1Collection 接口
Collection 是最基本的集合接口,一个 Collection 代表一组 Object,即 Collection 的元素, Java不提供直接继承自Collection的类,只提供继承于的子接口(如List和set)。
Collection 接口存储一组不唯一,无序的对象。
2List 接口
List接口是一个有序的 Collection,使用此接口能够精确的控制每个元素插入的位置,能够通过索引(元素在List中位置,类似于数组的下标)来访问List中的元素,第一个元素的索引为 0,而且允许有相同的元素。
List 接口存储一组不唯一,有序(插入顺序)的对象。
3Set
Set 具有与 Collection 完全一样的接口,只是行为上不同,Set 不保存重复的元素。
Set 接口存储一组唯一,无序的对象。
4SortedSet
继承于Set保存有序的集合。
5Map
Map 接口存储一组键值对象,提供key(键)到value(值)的映射。
6Map.Entry
描述在一个Map中的一个元素(键/值对)。是一个 Map 的内部接口。
7SortedMap
继承于 Map,使 Key 保持在升序排列。
8Enumeration
这是一个传统的接口和定义的方法,通过它可以枚举(一次获得一个)对象集合中的元素。这个传统接口已被迭代器取代。

Set和List的区别

  • Set 接口实例存储的是无序的,不重复的数据。List 接口实例存储的是有序的,可以重复的元素
  • Set 检索效率低下,删除和插入效率高,插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>
  • List 和数组类似,可以动态增长,根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高,插入删除效率低,因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector>

Collection 接口

​ 集合接口是集合框架构建的基础。它声明了所有集合都会具有的核心方法。

序号方法和描述
1boolean add(Object obj)
将obj添加到调用的集合中。如果obj被添加到集合中,则返回true。如果obj已经是集合的成员,或者集合不允许重复,则返回false。
2boolean addAll(Collection c)
将c的所有元素添加到调用的集合中。如果操作成功(即元素被添加),则返回true。否则,返回false。
3void clear( )
从调用的集合中删除所有元素。
4boolean contains(Object obj)
如果obj是调用的集合的元素,则返回true。否则,返回false。
5boolean containsAll(Collection c)
如果调用的集合包含所有 c 的元素,则返回true。否则,返回false。
6boolean equals(Object obj)
如果调用的集合和obj相等,则返回true。否则,返回false。
7int hashCode( )
返回调用集合的哈希码。
8boolean isEmpty( )
如果调用的集合为空,则返回true。否则,返回false。
9Iterator iterator( )
返回调用集合的迭代器。
10boolean remove(Object obj)
从调用的集合中删除一个obj的实例。如果元素被删除,返回true。否则,返回false。
11boolean removeAll(Collection c)
从调用的集合中删除c的所有元素。如果集合发生了变化(即有元素被删除),返回true。否则,返回false。
12boolean retainAll(Collection c)
从调用的集合中删除除了c中的元素以外的所有元素。如果集合发生了变化(即有元素被删除),返回true。否则,返回false。
13int size( ) 返回调用集合中持有的元素数。
14Object[ ] toArray( ) 返回包含调用集合中所有元素的数组。该数组的元素是集合元素的副本。
15Object[ ] toArray(Object array[ ]) 返回一个只包含与数组类型匹配的集合元素的数组。

List 接口

列表接口扩展了 Collection 并声明了一个存储元素序列的集合的行为。

  • 可以通过在列表中的位置使用零为基的索引来插入或访问元素。
  • 列表可以包含重复的元素。
  • 除了由 Collection 定义的方法外,列表定义了一些自己的方法,这些方法在下表中总结。
  • 如果集合不能被修改,一些列表方法将抛出UnsupportedOperationException异常,并且当一个对象与另一个对象不兼容时,会生成ClassCastException。
序号方法和描述
1void add(int index, Object obj)
将obj插入到调用列表中传入的索引处。任何在插入点或超出插入点的预先存在的元素都会向上移动。因此,没有元素被覆盖。
2boolean addAll(int index, Collection c)
c的所有元素插入到调用列表中传递给索引的索引处。任何在插入点或超出插入点的预先存在的元素都会向上移动。因此,没有元素被覆盖。如果调用的列表发生变化,返回true,否则返回false。
3Object get(int index)
返回存储在调用集合中指定索引处的对象。
4int indexOf(Object obj)
返回调用列表中第一个obj实例的索引。如果obj不是列表中的元素,则返回.1。
5int lastIndexOf(Object obj)
返回调用列表中最后一个obj实例的索引。如果obj不是列表中的元素,则返回.1。
6ListIterator listIterator( )
返回指向调用列表起始处的迭代器。
7ListIterator listIterator(int index)
返回一个指向调用列表的迭代器,从指定的下标开始。
8Object remove(int index)
从调用的列表中删除索引位置的元素,并返回被删除的元素。结果列表被合并。也就是说,后续元素的索引减1。
9Object set(int index, Object obj)
将obj赋值到调用列表中由index指定的位置。
10List subList(int start, int end)
返回一个从头到尾包含元素的列表。1在调用列表中。返回列表中的元素也会被调用的对象引用。

Set 接口

​ Set是一种不能包含重复元素的集合。它模拟了数学集合的抽象概念。Set接口只包含继承自Collection的方法,并且增加了禁止有重复元素的限制。

​ Set还对equals和hashCode操作的行为增加了更强的约束,使得即使它们的类型实现不同,Set实例也可以有意义地进行比较。

序号方法和描述
1add( ) 向集合中添加一个对象。
2clear( ) 从集合中移除所有对象。
3contains( ) 如果指定对象是集合中的元素,返回true。
4isEmpty( ) 如果集合没有元素,返回true。
5iterator( ) 返回集合的迭代器对象,该对象可用于检索元素。
6remove( ) 从集合中移除指定对象。
7size( ) 返回集合中的元素数量。

SortedSet 接口

​ SortedSet接口扩展了Set接口,并声明了按升序排序的集合的行为。SortedSet接口除了Set接口定义的方法之外,还声明了下表中总结的方法。

​ 在调用集合中不包含任何项时,几个方法会抛出NoSuchElementException。当一个对象与集合中的元素不兼容时,会抛出ClassCastException异常。

​ 如果尝试使用一个空对象,并且集合中不允许使用null,那么将抛出NullPointerException异常。

序号方法和描述
1Comparator comparator() 返回调用的有序集的比较器。如果对该集使用自然排序,则返回null。
2Object first() 返回调用的有序集中的第一个元素。
3SortedSet headSet(Object end) 返回一个包含调用的有序集中小于end的元素的SortedSet。返回的有序集中的元素也被调用的有序集引用。
4Object last() 返回调用的有序集中的最后一个元素。
5SortedSet subSet(Object start, Object end) 返回一个包含在start和end之间的元素的SortedSet。返回集合中的元素也被调用的对象引用。
6SortedSet tailSet(Object start) 返回一个包含大于或等于start的元素的SortedSet,这些元素包含在有序集中。返回集合中的元素也被调用的对象引用。

Map 接口

Map接口将唯一的键映射到值。键是用来在以后检索值的对象。

  • 给定一个键和一个值,你可以将该值存储在一个Map对象中。在值被存储后,可以通过使用它的键来检索它。
  • 几个方法在调用 Map 中不存在项目时会引发NoSuchElementException。
  • 当对象与地图中的元素不兼容时,会引发ClassCastException。
  • 如果尝试使用null对象并且在地图中不允许null,将引发NullPointerException。
  • 当试图更改一个不可修改的映射时,将引发UnsupportedOperationException。
序号方法与描述
1void clear( )
从调用的映射中删除所有的键/值对。
2boolean containsKey(Object k)
如果调用的映射包含 k 作为键,则返回true。否则,返回false。
3boolean containsValue(Object v)
如果映射中包含 v 作为值,则返回true。否则,返回false。
4Set entrySet( )
返回一个包含映射条目的Set。该Set包含类型为Map.Entry的对象。此方法提供了对调用的映射的Set视图。
5boolean equals(Object obj)
如果obj是一个Map且包含相同的条目,则返回true。否则,返回false。
6Object get(Object k) 返回与键 k 关联的值。
7int hashCode( ) 返回调用map的哈希码。
8boolean isEmpty( ) 如果调用的map为空,则返回true。否则,返回false。
9Set keySet( ) 返回一个包含调用map中键的集合。该方法提供了调用map中键的视图。
10Object put(Object k, Object v)
向调用的映射中放入一个条目,覆盖与该键关联的任何先前值。键和值分别为k和v。如果键以前不存在,则返回null。否则,返回与该键关联的先前值。
11void putAll(Map m)m 中的所有条目放入此映射中。
12Object remove(Object k) 删除键等于 k 的条目。
13int size( ) 返回映射中键/值对的数量。
14Collection values( ) 返回包含映射中的值的集合。该方法提供了映射中值的集合视图。

Map.Entry 接口

​ The Map.Entry接口使我们能够使用Map条目进行操作。有点类似 Pair。

​ 由Map接口声明的 entrySet() 方法返回一个包含地图条目的Set。这些集合元素都是Map.Entry对象。

序号方法与描述
1boolean equals(Object obj) 如果obj是一个与调用对象的键和值相等的Map.Entry,则返回true。
2Object getKey( ) 返回此映射项的键。
3Object getValue( ) 返回此映射项的值。
4int hashCode( ) 返回此映射项的哈希码。
5Object setValue(Object v) 将此映射项的值设置为 v 。如果 v 不是映射的正确类型,则抛出ClassCastException。如果映射不允许空键,则如果 v 是null,则抛出NullPointerException。如果映射无法更改,则抛出UnsupportedOperationException。

SortedMap 接口

​ 排序映射接口扩展了映射接口。它确保条目按照升序的键顺序进行维护。

​ 当调用映射中没有条目时,几个方法会抛出 NoSuchElementException 异常。当一个对象与映射中的元素不兼容时,会抛出 ClassCastException 异常。如果在映射中出于不允许使用 null 的原因而试图使用一个 null 对象,则会抛出 NullPointerException 异常。

序号方法与说明
1Comparator comparator( )
返回调用排序映射的比较器。如果使用自然顺序进行调用映射,则返回null。
2Object firstKey( ) 返回调用映射中的第一个键。
3SortedMap headMap(Object end)
返回那些键小于end的映射条目的排序映射。
4Object lastKey( ) 返回调用映射中的最后一个键。
5SortedMap subMap(Object start, Object end)
返回包含那些键大于或等于start且小于end的条目的映射。
6SortedMap tailMap(Object start)
返回包含那些键大于或等于start的条目的映射。

集合实现类(集合类)

​ Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类,这些类可以直接拿来使用,而另外一些是抽象类,提供了接口的部分实现

序号类描述
1AbstractCollection
实现了大部分的集合接口。
2AbstractList
继承于AbstractCollection 并且实现了大部分List接口。
3AbstractSequentialList
继承于 AbstractList ,提供了对数据元素的链式访问而不是随机访问。
4LinkedList
该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:List list=Collections.synchronizedList(newLinkedList(...));
LinkedList 查找效率低。
5ArrayList
该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。
ArrayList 增长当前长度的50%,插入删除效率低。
6AbstractSet
继承于AbstractCollection 并且实现了大部分Set接口。
7HashSet
该类实现了Set接口,不允许出现重复元素,不保证集合中元素的顺序,允许包含值为null的元素,但最多只能一个。
8LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9TreeSet
该类实现了Set接口,可以实现排序等功能。
10AbstractMap
实现了大部分的Map接口。
11HashMap
HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。
该类实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null,不支持线程同步。
12TreeMap
继承了AbstractMap,并且使用一颗树。
13WeakHashMap
继承AbstractMap类,使用弱密钥的哈希表。
14LinkedHashMap
继承于HashMap,使用元素的自然顺序对元素进行排序.
15IdentityHashMap
继承AbstractMap类,比较文档时使用引用相等。

四、集合实现类

​ Java 提供了一套实现了 Collection 接口的标准集合类。其中一些是具体类,这些类可以直接拿来使用,而另外一些是抽象类,提供了接口的部分实现

序号类描述
1AbstractCollection
实现了大部分的集合接口。
2AbstractList
继承于AbstractCollection 并且实现了大部分List接口。
3AbstractSequentialList
继承于 AbstractList ,提供了对数据元素的链式访问而不是随机访问。
4LinkedList
该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:List list=Collections.synchronizedList(newLinkedList(...));
LinkedList 查找效率低。
5ArrayList
该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。
ArrayList 增长当前长度的50%,插入删除效率低。
6AbstractSet
继承于AbstractCollection 并且实现了大部分Set接口。
7HashSet
该类实现了Set接口,不允许出现重复元素,不保证集合中元素的顺序,允许包含值为null的元素,但最多只能一个。
8LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9TreeSet
该类实现了Set接口,可以实现排序等功能。
10AbstractMap
实现了大部分的Map接口。
11HashMap
HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。
该类实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null,不支持线程同步。
12TreeMap
继承了AbstractMap,并且使用一颗树。
13WeakHashMap
继承AbstractMap类,使用弱密钥的哈希表。
14LinkedHashMap
继承于HashMap,使用元素的自然顺序对元素进行排序.
15IdentityHashMap
继承AbstractMap类,比较文档时使用引用相等。

LinkedList 类

​ LinkedList类扩展了AbstractSequentialList类并实现了List接口。它提供了一个链表数据结构

​ 与 ArrayList 相比,LinkedList 的增加和删除的操作效率更高,而查找和修改的操作效率较低。

以下情况使用 ArrayList :

  • 频繁访问列表中的某一个元素。
  • 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

  • 你需要通过循环迭代来访问列表中的某些元素。
  • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口,可作为队列使用。

LinkedList 实现了 List 接口,可进行列表的相关操作。

LinkedList 实现了 Deque 接口,可作为队列使用。

LinkedList 实现了 Cloneable 接口,可实现克隆。

LinkedList 实现了 java.io.Serializable 接口,即可支持序列化,能通过序列化去传输。

img

构造函数

序号构造函数 & 描述
1LinkedList( ) 这个构造函数构建一个空的链表。
2LinkedList(Collection c) 这个构造函数构建一个链表,该链表使用集合 c 中的元素初始化。

其他方法

序号方法与描述
1void add(int index, Object element)
在列表中指定的位置index处插入指定的元素。如果指定的索引超出范围 (index < 0 || index > size()),则抛出IndexOutOfBoundsException异常。
2boolean add(Object o)
将指定的元素追加到列表的末尾。
3boolean addAll(Collection c)
将指定集合中的所有元素按照指定集合迭代器返回的顺序追加到列表的末尾。如果指定的集合为null,则抛出NullPointerException异常。
4boolean addAll(int index, Collection c)
将指定集合中的所有元素从指定位置开始插入到此列表中。如果指定的集合为空,则抛出NullPointerException。
5void addFirst(Object o) 在此列表的开头插入指定的元素。
6void addLast(Object o) 将指定的元素追加到此列表的末尾。
7void clear() 从此列表中移除所有元素。
8Object clone() 返回此LinkedList的浅拷贝。
9boolean contains(Object o)
如果此列表包含指定的元素,则返回true。更正式地说,如果且仅如果此列表包含至少一个元素e,使得(onull ? enull : o.equals(e)),则返回true。
10Object get(int index)
返回列表中指定位置的元素。如果指定的索引超出范围 (index < 0 || index >= size()),则抛出IndexOutOfBoundsException。
11Object getFirst()
返回此列表中的第一个元素。如果此列表为空,则抛出NoSuchElementException。
12Object getLast()
返回此列表中的最后一个元素。如果此列表为空,则抛出NoSuchElementException。
13int indexOf(Object o)
返回指定元素在列表中第一次出现的索引,如果列表不包含该元素则返回-1。
14int lastIndexOf(Object o)
返回指定元素在列表中最后一次出现的索引,如果列表不包含该元素则返回-1。
15ListIterator listIterator(int index)
返回一个列表迭代器,它按列表中的正确顺序(从指定位置开始)遍历列表中的元素。如果指定的索引超出范围(index < 0 || index >= size()),则抛出IndexOutOfBoundsException。
16Iterator descendingIterator() 返回倒序迭代器。
17Object remove(int index)
在此列表中删除指定位置的元素。如果此列表为空,则抛出NoSuchElementException异常。
18boolean remove(Object o)
在列表中删除指定元素的第一个匹配项。如果此列表为空,则抛出NoSuchElementException异常。如果指定的索引超出范围(索引 < 0 || 索引 >= size()),则抛出IndexOutOfBoundsException异常。
19Object removeFirst()
从列表中删除并返回第一个元素。如果此列表为空,则抛出NoSuchElementException异常。
20Object removeLast()
从列表中删除并返回最后一个元素。如果此列表为空,则抛出NoSuchElementException异常。
21Object set(int index, Object element)
用指定的元素替换列表中指定位置的元素。如果指定的索引超出范围(索引 < 0 || 索引 >= size()),则抛出IndexOutOfBoundsException异常。
22int size() 返回列表中的元素数。
23Object[] toArray()
返回包含列表中所有元素的数组,按正确的顺序。如果指定的数组为null,则抛出NullPointerException异常。
24Object[] toArray(Object[] a)
返回包含列表中所有元素的数组,按正确的顺序;返回数组的运行时类型是指定数组的类型。
25E poll() 删除并返回第一个元素。
26**E peek() **返回第一个元素,如果队列是空的就返回null
27**E element() **返回第一个元素,如果队列是空的就抛出异常NoSuchElementException
28E peekFirst() 返回头部元素。
29E peekLast() 返回尾部元素。

ArrayList 类

​ ArrayList类继承了 AbstractList 类并实现了 List 接口。ArrayList 支持动态数组,可以根据需要增长。

​ 标准的Java数组是固定长度的。一旦数组被创建,它们不能增长或缩小,这意味着您必须提前知道数组将容纳多少个元素。

​ 数组列表是带有初始大小的。当超过这个大小时,集合会自动扩大。当对象被移除时,数组可能会缩小。

img

构造函数

序号构造方法 & 描述
1ArrayList( ) 此构造方法构建一个空的数组列表。
2ArrayList(Collection c) 此构造方法构建一个包含集合元素的数组列表 c
3ArrayList(int capacity) 此构造方法构建一个具有指定初始容量的数组列表。容量是用于存储元素的底层数组的大小。随着元素加入数组列表,容量会自动增长。

其他方法

序号方法及描述
1void add(int index, Object element)
在此列表中的指定位置index插入指定的元素。如果指定的索引超出范围(index < 0 || index > size()),则抛出IndexOutOfBoundsException异常。
2boolean add(Object o) 将指定的元素追加到此列表的末尾。
3boolean addAll(Collection c)
将指定集合中的所有元素按照指定集合的迭代器返回顺序追加到此列表的末尾。如果指定的集合为空(null),则抛出NullPointerException异常。
4boolean addAll(int index, Collection c)
将指定集合中的所有元素插入到列表的指定位置。如果指定集合为null,将抛出NullPointerException异常。
5void clear() 从列表中移除所有元素。
6Object clone() 返回此ArrayList的浅表副本。
7boolean contains(Object o)
如果列表包含指定的元素,则返回true。更正式地说,如果列表至少包含一个元素 e 满足(onull ? enull : o.equals(e)),则返回true。
8void ensureCapacity(int minCapacity)
如果需要,增加此ArrayList实例的容量,以确保至少可以容纳由最小容量参数指定的元素数量。
9Object get(int index)
返回列表中指定位置的元素。如果指定的索引超出范围(index < 0 || index >= size()),则抛出IndexOutOfBoundsException。
10int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引,如果列表不包含此元素,则返回-1。
11int lastIndexOf(Object o)
返回列表中指定元素的最后一次出现的索引,如果列表不包含此元素,则返回-1。
12Object remove(int index)
删除列表中指定位置的元素。如果索引超出范围(index < 0 || index >= size()),则抛出IndexOutOfBoundsException异常。
13protected void removeRange(int fromIndex, int toIndex)
从此列表中删除所有索引位于fromIndex(包含)和toIndex(不包含)之间的元素。
14Object set(int index, Object element)
用指定的元素替换列表中指定位置的元素。如果指定的索引超出范围(index < 0 || index >= size()),则抛出IndexOutOfBoundsException异常。
15int size() 返回列表中元素的数量。
16Object[] toArray()
返回一个按正确顺序包含列表中所有元素的数组。如果指定的数组为null,则抛出NullPointerException。
17Object[] toArray(Object[] a)
返回一个按正确顺序包含列表中所有元素的数组;返回的数组的运行时类型是指定数组的类型。
18void trimToSize() 将此ArrayList实例的容量调整为列表的当前大小。
19Object[] subList(int fromIndex, int toIndex)
用于截取并返回动态数组中的一部分,
fromIndex - 截取元素的起始位置,包含该索引位置元素
toIndex - 截取元素的结束位置,不包含该索引位置元素。
返回给定的动态数组截取的部分,如果fromIndex 小于 0 或大于数组的长度,则抛出 IndexOutOfBoundsException 的异常,如果 fromIndex 大于 toIndex 的值则抛出 IllegalArgumentException 异常;该动态数组包含的元素起始于 fromIndex 位置,直到元素索引位置为 toIndex-1,而索引位置 toIndex 的元素并不包括
20void sort(Comparator c) 根据指定的顺序对动态数组中的元素进行排序,不返回任何值,它只是更改动态数组列表中元素的顺序

HashSet 类

​ HashSet 扩展了 AbstractSet 类并实现了 Set 接口。HashSet 基于 HashMap 来实现的,是一个不允许有重复元素的集合。HashSet 允许有 null 值。HashSet 是无序的,即不会记录插入的顺序。HashSet 不是线程安全的, 如果多个线程尝试同时修改 HashSet,则最终结果是不确定的。 必须在多线程访问时显式同步对 HashSet 的并发访问。

构造方法

No.构造函数与描述
1HashSet() 这个构造函数构造一个默认的HashSet。
2HashSet(Collection c) 这个构造函数使用集合 c 的元素初始化哈希集。
3HashSet(int capacity) 这个构造函数将哈希集的容量初始化为给定的整数值 capacity 。当向HashSet添加元素时,容量会自动增长。
4HashSet(int capacity, float fillRatio) 这个构造函数根据参数初始化哈希集的容量和填充比率(也称为装载因子)。填充比率必须在0.0和1.0之间,它决定了哈希集在调整大小之前可以有多满。具体来说,当元素的数量大于哈希集的容量乘以其填充比率时,哈希集将进行扩展。

其他方法

序号方法和描述
1boolean add(Object o) 如果该集合中尚未包含指定元素,则将其添加到该集合中。
2void clear() 从该集合中移除所有元素。
3Object clone() 返回此HashSet实例的浅拷贝:元素本身不会被克隆。
4boolean contains(Object o) 如果该集合包含指定的元素,则返回true。
5boolean isEmpty() 如果该集合不包含任何元素,则返回true。
6Iterator iterator() 返回该集合中元素的迭代器。
7boolean remove(Object o) 如果该集合中存在指定的元素,则将其从集合中移除。
8int size() 返回该集合中元素的数量(基数)。

LinkedHashSet 类

​ 该类继承自HashSet,但没有添加自己的成员。LinkedHashSet 维护了一个以插入顺序为排序的条目链表。这允许按照插入顺序进行迭代。也就是说,使用迭代器循环访问 LinkedHashSet 时,元素将按照插入顺序返回。

构造函数

序号构造函数及其描述
1HashSet( ) 该构造函数构造一个默认的HashSet。
2HashSet(Collection c) 该构造函数通过使用集合 c 中的元素来初始化hash set。
3LinkedHashSet(int capacity) 该构造函数将linkedhashset的容量初始化为给定的整数值capacity。随着元素的添加,容量会自动增长。
4LinkedHashSet(int capacity, float fillRatio) 该构造函数通过参数初始化hash set的容量和填充比率(也称为加载容量)。

TreeSet 类

​ TreeSet 提供了一种使用树进行存储的 Set 接口的实现。对象按照排序和升序的方式存储。访问和检索时间非常快,这使得 TreeSet 成为在存储大量需要快速找到的已排序信息时的绝佳选择。

构造函数

序号构造函数 & 描述
1TreeSet( ) 此构造函数构建一个空的树集,根据其元素的自然顺序进行升序排序。
2TreeSet(Collection c) 此构造函数构建一个包含集合中元素的树集 c
3TreeSet(Comparator comp) 此构造函数构建一个空的树集,根据给定的比较器进行排序。
4TreeSet(SortedSet ss) 此构造函数构建一个包含给定 SortedSet 元素的TreeSet。

其他方法

序号方法和描述
1void add(Object o) 如果此集合中尚未存在指定的元素,则将其添加到集合中。
2boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合。
3void clear() 从集合中移除所有元素。
4Object clone() 返回此TreeSet实例的浅拷贝。
5Comparator comparator() 返回用于排序此排序集的比较器,如果此树集使用其元素的自然顺序,则返回null。
6boolean contains(Object o) 如果此集合包含指定的元素,则返回true。
7Object first() 返回此排序集中当前第一个(最低)元素。
8SortedSet headSet(Object toElement) 返回此集合中严格小于toElement的部分的视图。
9boolean isEmpty() 如果此集合不包含任何元素,则返回true。
10Iterator iterator() 返回此集合中的元素的迭代器。
11Object last() 返回此排序集中当前最后一个(最高)元素。
12boolean remove(Object o) 如果存在,则从此集合中移除指定的元素。
13int size() 返回此集合中的元素数量(基数)。
14SortedSet subSet(Object fromElement, Object toElement) 返回该集合中元素范围从fromElement(包括)到toElement(不包括)的部分的视图。
15SortedSet tailSet(Object fromElement) 返回此集合中大于或等于fromElement的部分的视图。

HashMap 类

​ HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。HashMap 实现了 Map 接口,根据键的 HashCode 值存储数据,具有很快的访问速度,最多允许一条记录的键为 null,不支持线程同步。HashMap 是无序的,即不会记录插入的顺序。HashMap 继承于AbstractMap,实现了 Map、Cloneable、java.io.Serializable 接口。

构造函数

序号构造函数和描述
1HashMap( ) 这个构造函数构造一个默认的HashMap。
2HashMap(Map m) 这个构造函数使用给定的Map对象的元素来初始化哈希映射中的元素 m
3HashMap(int capacity) 这个构造函数通过使用给定的整数值capacity来初始化哈希映射的容量。
4HashMap(int capacity, float fillRatio) 这个构造函数使用其参数来初始化哈希映射的容量和填充比例。

其他方法

Java HashMap 新增方法(merge,compute)

序号方法与描述
1void clear() 从映射中移除所有的键值对。
2Object clone() 返回此HashMap实例的浅拷贝:键和值本身不会被克隆。
3boolean containsKey(Object key) 如果此映射中包含指定键的映射关系,则返回true。
4boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值,则返回true。
5Set entrySet() 返回包含此映射中的映射关系的集合视图。
6Object get(Object key)
返回此标识哈希映射中与指定键映射关系对应的值,如果映射不包含该键的映射关系,则返回 null。
7Object getOrDefault(Object key, V defaultValue)
获取指定 key 对应对 value,如果找不到 key ,则返回设置的默认值
8boolean isEmpty() 如果此映射不包含键值映射,则返回true。
9Set keySet() 返回此映射中包含的键的Set视图。
10Object put(Object key, Object value) 在此映射中关联指定值与指定键。
11putAll(Map m)
将指定映射中的所有映射复制到此映射。 这些映射将替换此映射当前在指定映射中的任何键的映射。
12Object putIfAbsent(K key, V value)
如果 hashMap 中不存在指定的键,则将指定的键/值对插入到 hashMap 中;和 put 方法功能等价,效率并不等价
13Object remove(Object key) 如果存在,从此映射中删除指定键的映射关系。
14int size() 返回此映射中的键值映射的数量。
15Collection values() 返回此映射中包含的值的集合视图。
16Object replace(K key, V newValue) 或 replace(K key, V oldValue, V newValue)
替换 hashMap 中是指定的 key 对应的 value;如果 oldValue 不存,则替换 key 对应的值,返回 key 对应的旧值,如果存在 oldValue,替换成功返回 true,如果 key 不存在,则返回 null
17Object merge(key, value, remappingFunction)
方法会先判断指定的 key 是否存在,如果不存在,则添加键值对到 hashMap 中;

merge(key, value, (oldVal, newVal) -> oldVal + newVal)
如果key存在,则执行lambda表达式,表达式入参为oldValnewVal(neVal即merge()的第二个参数)。表达式返回最终put的val。如果key不存在,则直接putnewVal
18compute(K key, BiFunction remappingFunction)
方法对 hashMap 中指定 key 的值进行重新计算;
**根据已知的 k v 算出新的v并put。
注意:**如果无此key,那么oldVal为null,lambda中涉及到oldVal的计算会报空指针
19computeIfAbsent(K key, Function remappingFunction)
对 hashMap 中指定 key 的值进行重新计算,如果不存在这个 key,则添加到 hashMap 中
20computeIfPresent(K key, BiFunction remappingFunction)
对 hashMap 中指定 key 的值进行重新计算,前提是该 key 存在于 hashMap 中,key存在时才compute()避免潜在的空指针情况

TreeMap类

​ TreeMap类通过使用一棵树来实现Map接口。TreeMap提供了一种有效的方式来存储按照排序顺序排列的键/值对,并允许快速检索。需要注意的是,与哈希映射不同,树映射保证其元素按照键的升序排序。

构造函数

序号构造方法 & 描述
1TreeMap( ) 此构造方法构建一个空的树映射,将使用其键的自然顺序进行排序。
2TreeMap(Comparator comp) 此构造方法构建一个空的树映射,将使用比较器 comp 进行排序。
3TreeMap(Map m) 此构造方法使用键的自然顺序初始化一个树映射,其中的条目来自于 m
4TreeMap(SortedMap sm) 此构造方法使用 SortedMap sm 中的条目来初始化一个树映射,条目的排序顺序与 sm 相同。

其他方法

序号方法和描述
1void clear() 从此TreeMap中删除所有映射。
2Object clone() 返回此TreeMap实例的浅拷贝。
3Comparator comparator()
返回用于对此映射进行排序的比较器,如果此映射使用其键的自然顺序,则返回null。
4boolean containsKey(Object key) 如果此映射包含指定键的映射关系,则返回true。
5boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值,则返回true。
6Set entrySet() 返回此映射中包含的映射的集合视图。
7Object firstKey() 返回当前此排序映射中的第一个(最低)键。
8Object get(Object key) 返回此映射将指定键映射到的值。
9SortedMap headMap(Object toKey) 返回此映射中键严格小于toKey的部分的视图。
10Set keySet() 返回此映射中包含的键的Set视图。
11Object lastKey() 返回当前此排序映射中的最后一个(最高)键。
12Object put(Object key, Object value) 将指定的值与指定的键关联到此映射中。
13void putAll(Map map) 将指定映射中的所有映射都复制到此映射中。
14Object remove(Object key) 如果存在,从此TreeMap中删除与此键关联的映射。
15int size() 返回此映射中的键值映射数。
16SortedMap subMap(Object fromKey, Object toKey)
返回此映射中键范围从fromKey(包括)到toKey(排除)的部分的视图。
17SortedMap tailMap(Object fromKey) 返回此映射中键大于或等于 fromKey 的部分视图。
18Collection values() 返回此映射中包含的值的集合视图。

WeakHashMap 类

​ WeakHashMap 是 Map 接口的实现,它只存储对其键的弱引用。只存储弱引用允许在其键在 WeakHashMap 之外不再被引用时,可以进行垃圾回收。这个类提供了利用弱引用的最简单方法。它非常适用于实现类似“注册表”的数据结构,当键不再被任何线程引用时,一个条目的实用性就消失了。WeakHashMap 的功能与 HashMap 完全相同,只有一个非常重要的例外:如果 Java 内存管理器不再对指定为键的对象有强引用,那么映射中的条目将被删除。

弱引用 − 如果对象的所有引用都是弱引用,垃圾收集器可以随时回收对象的内存,而不需要等到系统内存耗尽。通常,在下一次垃圾收集器运行时,它将被释放

关于引用可以看这个Java中的引用类型: 弱引用、软引用与强引用详解

构造函数

序号构造函数 & 描述
1WeakHashMap() 该构造函数创建一个新的、空的WeakHashMap对象,其默认初始容量为16,加载因子为0.75。
2WeakHashMap(int initialCapacity) 该构造函数创建一个新的、空的WeakHashMap对象,具有指定的初始容量和默认加载因子(0.75)。
3WeakHashMap(int initialCapacity, float loadFactor) 该构造函数创建一个新的、空的WeakHashMap对象,具有指定的初始容量和加载因子。
4WeakHashMap(Map t) 该构造函数创建一个新的WeakHashMap对象,其映射与指定的Map相同。

其他方法

序号方法与描述
1void clear() 从该映射中删除所有的键值映射。
2boolean containsKey(Object key) 如果该映射包含指定键的映射关系,则返回 true。
3boolean containsValue(Object value) 如果该映射将一个或多个键映射到指定值,则返回 true。
4Set entrySet() 返回此映射中包含的映射的集合视图。
5Object get(Object key) 返回指定键所映射到的在此弱哈希映射中的值,如果此映射不包含该键的映射关系,则返回 null。
6boolean isEmpty() 如果该映射不包含键-值映射关系,则返回 true。
7Set keySet() 返回此映射中包含的键的集合视图。
8Object put(Object key, Object value) 将指定的值与该映射中的指定键关联起来。
9void putAll(Map m) 将指定映射中的所有映射关系复制到此映射中。这些映射关系将替换开始此映射中具有任何当前在指定映射中的键的映射关系。
10Object remove(Object key) 如果存在,则从该映射中移除键的映射关系。
11int size() 返回此映射中的键-值映射关系的数目。
12Collection values() 返回此映射中包含的值的集合视图。

LinkedHashMap 类

​ 该类扩展了 HashMap 类,并按照插入顺序维护了一个链表存储在 map 中的条目。这允许在迭代 LinkedHashMap 时按照插入顺序返回元素

构造函数

序号构造函数和说明
1LinkedHashMap( ) 该构造函数构建了一个默认的LinkedHashMap。
2LinkedHashMap(Map m) 该构造函数使用给定的Map类中的元素初始化LinkedHashMap。 m 代表给定的Map类。
3LinkedHashMap(int capacity) 该构造函数使用给定的容量初始化LinkedHashMap。
4LinkedHashMap(int capacity, float fillRatio) 该构造函数同时初始化容量和填充比例。容量和填充比例的含义与HashMap相同。
5LinkedHashMap(int capacity, float fillRatio, boolean Order) 该构造函数允许您指定元素是按插入顺序还是按最后访问顺序存储在链表中。如果Order为true,则使用访问顺序。如果Order为false,则使用插入顺序。

其他方法

序号方法和描述
1void clear() 从此映射中移除所有映射。
2boolean containsKey(Object key) 如果此映射将一个或多个键映射到指定值,则返回true。
3Object get(Object key) 返回此映射到指定键的值。
4protected boolean removeEldestEntry(Map.Entry eldest) 如果此映射应该移除其最旧的条目,则返回true。

IdentityHashMap 类

IdentityHashMap 是Java集合框架中的一部分,此类实现 AbstractMap,它是HashMap的一种特殊实现。与标准的HashMap相比,IdentityHashMap在比较键(Key)时使用的是引用相等性(identity)而不是对象的等价性(equality)。这意味着,对于 IdentityHashMap 来说,当且仅当两个键(k1 和 k2)是且仅是同一个对象(k1 == k2)时,它们才被认为是相等的,换句话说,是允许key重复的。

​ IdentityHashMap通常用于需要维护对象的身份而不是对象的逻辑相等性的特殊情况。例如,它可以用于保存对象的元数据或维护对象引用的唯一列表。由于IdentityHashMap 不使用 hashCode() 和 equals() 方法,因此它的性能在某些情况下可能比标准HashMap更优。

​ 此类有一个调整参数(影响性能但不影响语义):预期的最大大小。该参数是地图预计将保存的键值映射的最大数量。

构造函数

序号构造函数及描述
1IdentityHashMap() 该构造函数创建一个新的空的身份哈希映射,具有默认的预期最大大小(21)。
2IdentityHashMap(int expectedMaxSize) 该构造函数使用指定的预期最大大小创建一个新的空的身份哈希映射。
3IdentityHashMap(Map m) 该构造函数创建一个新的身份哈希映射,其中包含指定映射中的键值对。

其他方法

编号方法及描述
1void clear() 从该映射中移除所有映射关系。
2Object clone() 返回此标识哈希映射的浅层副本:键和值本身未被克隆。
3boolean containsKey(Object key) 测试指定的对象引用是否为此标识哈希映射的键。
4boolean containsValue(Object value) 测试指定的对象引用是否为此标识哈希映射的值。
5Set entrySet() 返回此映射中包含的映射的集合视图。
6boolean equals(Object o) 将指定的对象与此映射进行比较,以确保相等性。
7Object get(Object key) 返回此标识哈希映射中映射到指定键的值,如果该映射不包含此键的映射,则返回null。
8int hashCode() 返回此映射的哈希码值。
9boolean isEmpty() 如果此标识哈希映射不包含键值映射关系,则返回true。
10Set keySet() 返回此映射中包含的键的基于标识的集合视图。
11Object put(Object key, Object value) 在此标识哈希映射中将指定的值与指定的键关联。
12void putAll(Map t) 将指定映射中的所有映射复制到此映射中。这些映射将替换掉此映射当前拥有的任何键的映射。
13Object remove(Object key) 如果存在,则从此映射中移除指定键的映射。
14int size() 返回此标识哈希映射中的键值映射数。
15Collection values() 返回此映射中包含的值的集合视图。

Java.util 包中定义的类(非框架结构下):

序号类描述
1Vector
该类和ArrayList非常相似,但是该类是同步的,可以用在多线程的情况,该类允许设置默认的增长长度,默认扩容方式为原来的2倍。
2Stack
栈是Vector的一个子类,它实现了一个标准的后进先出的栈。
3Dictionary
Dictionary 类是一个抽象类,用来存储键/值对,作用和Map类相似。
4Hashtable
Hashtable 是 Dictionary(字典) 类的子类,位于 java.util 包中。
5Properties
Properties 继承于 Hashtable,表示一个持久的属性集,属性列表中每个键及其对应值都是一个字符串。
6BitSet
一个Bitset 类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

Java Vector类

​ Vector 类实现了一个动态数组。和 ArrayList 很相似,但两者是不同的:

  • Vector 是同步访问的。
  • Vector 包含了许多传统的方法,这些方法不属于集合框架。

​ Vector 主要用在事先不知道数组的大小,或者只是需要一个可以改变大小的数组的情况。

Vector 类支持 4 种构造方法。

序号构造函数 & 描述
1Vector( ) 此构造函数创建一个默认的向量,初始大小为10。
2Vector(int size) 此构造函数接受一个与所需大小相等的参数,并创建一个初始容量由size指定的向量。
3Vector(int size, int incr) 此构造函数创建一个初始容量由size指定,并且增量由incr指定的向量。增量指定每次调整向量大小时要分配的元素数量。
4Vector(Collection c) 此构造函数创建一个包含集合c的元素的向量。

Vector 类中的其他方法

序号方法与描述
1void add(int index, Object element) 在Vector的指定位置插入指定的元素。
2boolean add(Object o) 将指定的元素添加到Vector的末尾。
3boolean addAll(Collection c) 将指定Collection中的所有元素以指定Collection的迭代器返回的顺序追加到Vector的末尾。
4boolean addAll(int index, Collection c) 将指定Collection中的所有元素插入到Vector的指定位置。
5void addElement(Object obj) 将指定组件添加到此向量的末尾,增加其大小一个。
6int capacity() 返回此向量的当前容量。
7void clear() 从此向量中删除所有元素。
8Object clone() 返回此向量的克隆。
9boolean contains(Object elem) 测试指定的对象是否是此向量的组件。
10boolean containsAll(Collection c) 如果此向量包含指定集合中的所有元素,则返回true。
11void copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
12Object elementAt(int index) 返回指定索引处的组件。
13Enumeration elements() 返回此向量的组件的枚举。
14void ensureCapacity(int minCapacity) 如有必要,增加此向量的容量,以确保能够容纳至少由最小容量参数指定的组件数量。
15boolean equals(Object o) 将指定对象与此向量进行比较是否相等。
16Object firstElement() 返回此向量的第一个组件(索引为0的项)。
17**Object get(int index)**返回此向量中指定位置的元素。
18**int hashCode()**返回此向量的哈希码值。
19**int indexOf(Object elem)**搜索给定参数的第一次出现,使用equals方法进行相等性测试。
20**int indexOf(Object elem, int index)**搜索给定参数的第一次出现,从索引开始搜索,并使用equals方法进行相等性测试。
21void insertElementAt(Object obj, int index) 在此向量中的指定索引位置插入指定的对象作为组件。
22boolean isEmpty() 测试此向量是否没有组件。
23Object lastElement() 返回向量的最后一个组件。
24int lastIndexOf(Object elem) 返回指定对象在此向量中最后一次出现的索引。
25int lastIndexOf(Object elem, int index) 从指定索引开始反向搜索指定对象,并返回其索引。
26Object remove(int index) 从向量中指定的位置删除元素。
27boolean remove(Object o) 从向量中删除指定元素的第一个出现,如果向量不包含该元素,则不改变。
28boolean removeAll(Collection c) 从向量中删除包含在指定集合中的所有元素。
29void removeAllElements() 从向量中删除所有组件,并将其大小设置为零。
30boolean removeElement(Object obj) 从向量中删除参数的第一个(最低索引)出现。
31void removeElementAt(int index) 删除指定索引位置的元素。
32protected void removeRange(int fromIndex, int toIndex) 删除此列表中从fromIndex(含)到toIndex(不含)之间的所有元素。
33boolean retainAll(Collection c) 仅保留在此向量中包含在指定集合中的元素。
34Object set(int index, Object element) 用指定的元素替换此向量中指定位置的元素。
35void setElementAt(Object obj, int index) 将此向量中指定索引的组件设置为指定的对象。
36void setSize(int newSize) 设置此向量的大小。
37int size() 返回此向量中的组件数。
38List subList(int fromIndex,int toIndex) 以fromIndex(含)和toIndex(不含)之间的部分返回此列表的视图。
39Object[] toArray() 按正确的顺序返回包含此向量中所有元素的数组。
40Object[] toArray(Object[] a) 按正确的顺序返回包含此向量中所有元素的数组;返回的数组的运行时类型是指定数组的类型。
41String toString() 返回此向量的字符串表示形式,包含每个元素的字符串表示形式。
42void trimToSize() 将此向量的容量调整为向量的当前大小。

Java Stack类

Stack是Vector的子类,实现了标准的后进先出的堆栈。

Stack只定义了默认构造函数,用于创建一个空的堆栈。Stack包含了所有Vector定义的方法,并添加了一些自己的方法。

Stack()

除了从其父类Vector继承的方法外,Stack还定义了以下方法

编号方法和描述
1boolean empty() 测试此堆栈是否为空。如果堆栈为空则返回true,否则返回false。
2Object peek( ) 返回堆栈顶部的元素,但不将其移除。
3Object pop( ) 返回堆栈顶部的元素,并将其移除。
4Object push(Object element) 将元素推入堆栈。元素也将被返回。
5int search(Object element) 在堆栈中搜索元素。如果找到,则返回元素与堆栈顶部的偏移量。否则,返回-1。

Dictionary 类

Dictionary 类是一个抽象类,用来存储键/值对,作用和Map类相似。

​ 给出键和值,你就可以将值存储在Dictionary对象中。一旦该值被存储,就可以通过它的键来获取它。所以和Map一样, Dictionary 也可以作为一个键/值对列表。

​ 但 Dictionary 类已经过时。可以实现Map接口来获得键/值存储功能

Dictionary定义的抽象方法如下表所示:

No方法与描述
1enumeration elements() 返回字典中包含的值的枚举。
2Object get(Object key) 返回包含与键相关联的值的对象。如果键不在字典中,则返回一个空对象。
3boolean isEmpty() 如果字典为空,返回true;如果字典包含至少一个键,则返回false。
4enumeration keys() 返回字典中包含的键的枚举。
5Object put(Object key, Object value) 将键及其值插入字典中。如果键尚未在字典中,则返回null;如果键已经在字典中,则返回与键相关联的先前值。
6Object remove(Object key) 移除键及其值。返回与键相关联的值。如果键不在字典中,则返回null。
7int size() 返回字典中的条目数。

Hashtable 类

​ Hashtable是原始的 java.util 的一部分, 是一个 Dictionary 具体的实现。然而,Java 2 重构的Hashtable实现了Map接口,因此,Hashtable现在集成到了集合框架中。它和 HashMap 类很相似,但是它支持同步。

​ 像HashMap一样,Hashtable在哈希表中存储键/值对。当使用一个哈希表,要指定用作键的对象,以及要链接到该键的值。

​ 然后,该键经过哈希处理,所得到的散列码被用作存储在该表中值的索引。

构造函数列表

序号构造函数和描述
1Hashtable( ) 这是哈希表的默认构造函数,它实例化Hashtable类。
2Hashtable(int size) 这个构造函数接受一个整数参数,并创建一个具有由整数值size指定的初始大小的哈希表。
3Hashtable(int size, float fillRatio) 这创建了一个具有由大小指定的初始大小和由fillRatio指定的填充比率的哈希表。此比率必须介于0.0和1.0之间,并确定哈希表在重新调整大小之前可以有多满。
4**Hashtable(Map t) ** 这使用给定的映射构造一个Hashtable。哈希表的容量被设置为 t 的两倍

除了从 Map 接口中定义的方法外,其他方法

序号方法及描述
1void clear( ) 重置并清空哈希表。
2Object clone( ) 返回调用对象的副本。
3boolean contains(Object value) 如果哈希表中存在与value相等的值,则返回true。如果找不到该值,则返回false。
4boolean containsKey(Object key) 如果哈希表中存在与key相等的键,则返回true。如果找不到该键,则返回false。
5boolean containsValue(Object value) 如果哈希表中存在与value相等的值,则返回true。如果找不到该值,则返回false。
6Enumeration elements( ) 返回哈希表中包含的值的枚举。
7Object get(Object key) 返回与key关联的值。如果哈希表中不存在该键,则返回空对象。
8boolean isEmpty( ) 如果哈希表为空,则返回true;如果至少包含一个键,则返回false。
9Enumeration keys( ) 返回哈希表中包含的键的枚举。
10Object put(Object key, Object value) 将键和值插入哈希表。如果键尚未存在于哈希表中,则返回空;如果键已经存在于哈希表中,则返回与键关联的先前值。
11void rehash( ) 增加哈希表的大小并重新哈希化所有键。
12Object remove(Object key) 删除键及其值。返回与键关联的值。如果哈希表中不存在该键,则返回空对象。
13int size( ) 返回哈希表中的条目数。
14String toString( ) 返回哈希表的字符串表示形式。

五、集合算法

​ 集合框架定义了几种算法,可用于集合和映射。这些算法被定义为集合类的静态方法。

​ 在尝试比较不兼容的类型时,一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时,抛出UnsupportedOperationException异常。

​ 集合定义三个静态的变量:EMPTY_SET,EMPTY_LIST,EMPTY_MAP的。这些变量都不可改变。

序号方法与描述
1static int binarySearch(List list, Object value, Comparator c) 根据 c 按顺序在列表中搜索值。如果找到该值,则返回其位置;如果未找到该值,则返回-1。
2static int binarySearch(List list, Object value) 在列表中搜索值。列表必须是有序的。如果找到该值,则返回其位置;如果未找到该值,则返回-1。
3static void copy(List list1, List list2) 将list2的元素复制到list1中。
4static Enumeration enumeration(Collection c) 返回一个枚举 c 的枚举。
5static void fill(List list,Object obj) 将 obj 分配给列表的每个元素。
6static int indexOfSubList(List list,List subList) 在列表中搜索subList的第一次出现。返回第一个匹配项的索引,如果没有找到匹配项,则返回1。
7static int lastIndexOfSubList(List list,List subList) 在列表中搜索subList的最后一次出现。返回最后一个匹配项的索引,如果没有找到匹配项,则返回1。
8static ArrayList list(Enumeration enum) 返回一个包含enum元素的ArrayList。
9static Object max(Collection c, Comparator comp) 根据 comp 决定,返回集合 c 中的最大元素。
10static Object max(Collection c) 根据自然排序,返回集合 c 中的最大元素。集合不需要排序。
11static Object min(Collection c, Comparator comp) 根据 comp 决定,返回集合 c 中的最小元素。集合不需要排序。
12static Object min(Collection c) 根据自然排序,返回集合 c 中的最小元素。
13static List nCopies(int num, Object obj) 返回一个包含 num 个 obj 副本的不可变列表。num 必须大于或等于零。
14static boolean replaceAll(List list, Object old, Object new) 将列表中所有的 old 替换为 new。如果至少有一个替换发生,则返回 true。否则返回 false。
15static void reverse(List list) 反转列表中的顺序。
16static Comparator reverseOrder( ) 返回一个逆向比较器。
17static void rotate(List list, int n) 将列表按照 n 进行旋转右边的地方。要向左旋转,请给n设置一个负值.
18static void shuffle(List list, Random r) 使用 r 作为随机数源,对列表中的元素进行洗牌(即随机排序)。
19static void shuffle(List list) 对列表中的元素进行洗牌(即随机排序)。
20static Set singleton(Object obj) 将obj作为不可变的set返回。这是将单个对象转换为set的简便方法。
21static List singletonList(Object obj) 将obj作为不可变的列表返回。这是将单个对象转换为列表的简便方法。
22static Map singletonMap(Object k, Object v) 将键/值对k/v作为不可变映射返回。这是将单个键/值对转换为映射的简单方法。
23static void sort(List list, Comparator comp) 根据comp确定的顺序对list的元素进行排序。
24static void sort(List list) 根据元素的自然顺序对list的元素进行排序。
25static void swap(List list, int idx1, int idx2) 交换列表中由idx1和idx2指定的索引处的元素。
26static Collection synchronizedCollection(Collection c) 返回一个同步的集合,该集合是由c支持的。返回一个由 c 支持的线程安全集合。
27static List synchronizedList(List list) 返回一个由list支持的线程安全列表。
28static Map synchronizedMap(Map m) 返回一个由 m 支持的线程安全映射。
29static Set synchronizedSet(Set s) 返回一个由 s 支持的线程安全集合。
30static SortedMap synchronizedSortedMap(SortedMap sm) 返回一个由 sm 支持的线程安全的排序映射。
31static SortedSet synchronizedSortedSet(SortedSet ss) 返回一个由 ss 支持的线程安全的集合。
32static Collection unmodifiableCollection(Collection c) 返回由 c 支持的不可修改的集合。
33static List unmodifiableList(List list) 返回由列表支持的不可修改的列表。
34static Map unmodifiableMap(Map m) 返回由 m 支持的不可修改的映射。
35static Set unmodifiableSet(Set s) 返回由 s 支持的不可修改的集合。
36static SortedMap unmodifiableSortedMap(SortedMap sm) 返回由 sm 支持的不可修改的排序映射。
37static SortedSet unmodifiableSortedSet(SortedSet ss) 返回由 ss 支持的不可修改的排序集合。

迭代器

​ Java迭代器(Iterator)是 Java 集合框架中的一种机制,是一种用于遍历集合(如列表、集合和映射等)的接口。

​ 它提供了一种统一的方式来访问集合中的元素,而不需要了解底层集合的具体实现细节。

​ Java Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法,可用于迭代 ArrayList 和 HashSet 等集合。

​ Iterator 是 Java 迭代器最简单的实现,ListIterator 是 Collection API 中的接口, 它扩展了 Iterator 接口,允许列表的双向遍历和元素的修改。

迭代器声明的方法

序号方法与描述
1boolean hasNext( ) 如果还有更多元素,则返回true。否则,返回false。
2Object next( ) 返回下一个元素。如果没有下一个元素,则抛出NoSuchElementException异常。
3void remove( ) 移除当前元素。如果在调用remove( )之前没有调用next( ),则抛出IllegalStateException异常。

ListIterator 声明的方法

序号方法与描述
1void add(Object obj) 在列表中obj对象之前插入元素,该元素将在下一次调用next()时返回。
2boolean hasNext( ) 如果存在下一个元素,则返回true。否则,返回false。
3boolean hasPrevious( ) 如果存在上一个元素,则返回true。否则,返回false。
4Object next( ) 返回下一个元素。如果没有下一个元素,则会抛出NoSuchElementException异常。
5int nextIndex( ) 返回下一个元素的索引。如果没有下一个元素,则返回列表的大小。
6Object previous( ) 返回上一个元素。如果没有上一个元素,则会抛出NoSuchElementException异常。
7int previousIndex( ) 返回上一个元素的索引。如果没有上一个元素,则返回-1。
8void remove( ) 从列表中删除当前元素。如果在调用next()或previous()之前调用remove(),则会抛出IllegalStateException异常。
9void set(Object obj) 将obj赋值给当前元素。这是最后一次调用next()或previous()返回的元素。

通常,要使用迭代器循环遍历集合的内容

  • 通过调用集合的iterator()方法获取一个迭代器到集合的起始位置。
  • 设置循环,调用hasNext()方法并使循环迭代,只要hasNext()返回true。
  • 在循环内,通过调用next()方法获取每个元素。
while(it.hasNext()) {System.out.println(it.next());
}

遍历ArrayList

import java.util.*;public class Test{public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("Hello");list.add("World");list.add("HAHAHAHA");//第一种遍历方法使用 For-Each 遍历 Listfor (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式System.out.println(str);}//第二种遍历,把链表变为数组相关的内容进行遍历String[] strArray=new String[list.size()];list.toArray(strArray);for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式{System.out.println(strArray[i]);}//第三种遍历 使用迭代器进行相关遍历Iterator<String> ite=list.iterator();while(ite.hasNext())//判断下一个元素之后有值{System.out.println(ite.next());}}
}

遍历Map

import java.util.*;public class Test{public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("1", "value1");map.put("2", "value2");map.put("3", "value3");//第一种:普遍使用,二次取值System.out.println("通过Map.keySet遍历key和value:");for (String key : map.keySet()) {System.out.println("key= "+ key + " and value= " + map.get(key));}//第二种System.out.println("通过Map.entrySet使用iterator遍历key和value:");Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();while (it.hasNext()) {Map.Entry<String, String> entry = it.next();System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());}//第三种:推荐,尤其是容量大时System.out.println("通过Map.entrySet遍历key和value");for (Map.Entry<String, String> entry : map.entrySet()) {System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());}//第四种System.out.println("通过Map.values()遍历所有的value,但不能遍历key");for (String v : map.values()) {System.out.println("value= " + v);}}
}

比较器

​ TreeSet和TreeMap都以排序顺序存储元素。然而,正是比较器定义了确切的排序顺序的含义。

​ Comparator接口定义了两个方法:compare()和equals()。compare()方法如下所示,用于比较两个元素的顺序

compare方法

int compare(Object obj1, Object obj2)

​ obj1和obj2是要进行比较的对象。该方法如果对象相等返回零。如果obj1大于obj2则返回正数。否则返回负值。

​ 通过重写compare()方法,您可以改变对象的排序方式。例如,可以创建一个反向比较结果的比较器以实现按照反向顺序排序。

equals方法

用于测试一个对象是否与调用比较器相等。

boolean equals(Object obj)

​ obj是要测试是否相等的对象。如果obj和调用对象都是Comparator对象并且使用相同的排序顺序,则该方法返回true。否则,返回false。

​ 覆盖equals()是不必要的,大多数简单的比较器都不会这样做。

比较器使用

Arrays.sort(a, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;// return o2.compareTo(o1);}
});
public int compareTo(T other)
// compareTo() 方法比较当前对象与 other 对象的顺序关系,并返回以下结果:
// 如果当前对象小于 other 则返回一个负整数
// 如果当前对象等于 other 返回 0
// 如果当前对象大于 other 则返回一个正整数// 降序 Collections.reverseOrder()
Arrays.sort(a, Collections.reverseOrder());// lambda 写法
Arrays.sort(a, (o1, o2) -> o2 - o1); // 实现 Comparator 接口,重写 compare() 方法
Arrays.sort(str, new CompLen());
class CompLen implements Comparator<String>{@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();}
}

写compare()方法,您可以改变对象的排序方式。例如,可以创建一个反向比较结果的比较器以实现按照反向顺序排序。

equals方法

用于测试一个对象是否与调用比较器相等。

boolean equals(Object obj)

​ obj是要测试是否相等的对象。如果obj和调用对象都是Comparator对象并且使用相同的排序顺序,则该方法返回true。否则,返回false。

​ 覆盖equals()是不必要的,大多数简单的比较器都不会这样做。

比较器使用

Arrays.sort(a, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;// return o2.compareTo(o1);}
});
public int compareTo(T other)
// compareTo() 方法比较当前对象与 other 对象的顺序关系,并返回以下结果:
// 如果当前对象小于 other 则返回一个负整数
// 如果当前对象等于 other 返回 0
// 如果当前对象大于 other 则返回一个正整数// 降序 Collections.reverseOrder()
Arrays.sort(a, Collections.reverseOrder());// lambda 写法
Arrays.sort(a, (o1, o2) -> o2 - o1); // 实现 Comparator 接口,重写 compare() 方法
Arrays.sort(str, new CompLen());
class CompLen implements Comparator<String>{@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();}
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/443540.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

zookeeper API使用——znode的CRUD

这应该是目录 一、创建连接1.1构造函数1.2创建连接(封装) 二、节点操作2.1创建节点create语法代码 2.2获取节点数据getData语法代码 2.3获取子节点getChildren语法代码 2.4修改节点的值setData语法代码 2.5删除delete语法代码 以下的代码只能作为基础的语法使用&#xff0c;为了…

LangChain: 大语言模型的新篇章

本文介绍了LangChain框架&#xff0c;它能够将大型语言模型与其他计算或知识来源相结合&#xff0c;从而实现功能更加强大的应用。接着&#xff0c;对LangChain的关键概念进行了详细说明&#xff0c;并基于该框架进行了一些案例尝试&#xff0c;旨在帮助读者更轻松地理解LangCh…

65 切面AOP

65 切面AOP 切面基础概念 AOP&#xff1a;Aspect Oriented Programming&#xff0c;面向切面编程。是通过预编译方式&#xff08;aspectj&#xff09;或者运行期动态代理&#xff08;Spring&#xff09;实现程序功能的统一维护的技术。 面试问题&#xff1a; Spring的两大核心…

【VUE】双端比较算法

假设我们有两个虚拟节点 oldVnode 和 newVnode&#xff0c;它们分别对应的DOM结构为&#xff1a; 我们需要将 oldVnode 更新为 newVnode&#xff0c;这时就可以使用双端比较算法了。算法本质上是将新旧节点进行一次交叉比较&#xff0c;尽可能地重复使用已有的节点来达到最小…

懒人笔记-QT程序UOS打包篇

懒人笔记-uos打包篇 前言1、deploy2、组织打包目录2.1 控制文件2.1.1 control的内容&#xff1a;2.1.2 postinst的内容&#xff1a;2.1.3 postrm的内容&#xff1a; 2.2 执行程序2.3 开机自启&#xff08;可选项&#xff09; 3、输出deb安装包4、服务卸载4.1 服务卸载4.2 程序按…

Web自动化Demo-PHP+Selenium

1.新建工程 打开PhpStorm新建工程如下&#xff1a; 打开终端输入如下命令安装selenium&#xff1a; composer require php-webdriver/webdriver 2.编写代码 <?php require vendor/autoload.php;use Facebook\WebDriver\Remote\RemoteWebDriver; use Facebook\WebDriver…

BMS-绝缘检测

一、为什么要进行绝缘检测 前言&#xff1a;BMS绝缘检测是指对电池组与车体之间的绝缘状态进行实时监测和检测。为了确保电池组与车体之间的绝缘性能良好&#xff0c;防止漏电和短路等安全隐患&#xff0c;BMS绝缘检测系统能够及时发现绝缘故障&#xff0c;并采取相应的措施进…

计算机毕业设计Python深度学习游戏推荐系统 Django PySpark游戏可视化 游戏数据分析 游戏爬虫 Scrapy 机器学习 人工智能 大数据毕设

主要功能如下&#xff1a; &#xff08;1&#xff09;用户管理模块&#xff1a;用户能够注册、登录及修改个人信息&#xff0c;查看热门游戏及攻略信息。 &#xff08;2&#xff09;数据采集与处理模块&#xff1a;主要通过Python编程&#xff0c;爬取Tap Tap社区中游戏热门榜…

python发送邮件带附件:配置全指南与步骤?

python发送邮件带附件教程&#xff1f;python如何发邮件带附件&#xff1f; 无论是工作报告、项目文档还是个人通知&#xff0c;邮件都能快速传递信息。而当这些信息需要附带文件时&#xff0c;Python发送邮件带附件的功能就显得尤为重要。AokSend将详细介绍如何使用Python发送…

简易入门:使用Docke 部署一个tomcat服务

简易入门&#xff1a;使用Docke 部署一个tomcat服务 # 拉取 >docker pull tomcat:9.0# 后台运行容器&#xff0c;端口映射为8080. -p 宿主机端口:容器端口 >docker run -d --name tomcat-c-01 -p 8080:8080 tomcat:9.0# 查看容器id >docker ps CONTAINER ID IMAG…

大数据毕业设计选题推荐-王者荣耀战队数据分析-Python数据可视化-Hive-Hadoop-Spark

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…

图解 微信开发者工具 小程序源码 调试、断点标记方法 , 微信小程序调试器,真机调试断点调试方法,小程序网络API请求调试方法 总结

在我们使用微信开发者工具进行微信小程序开发的时候&#xff0c;在这个微信开发者工具的代码编辑框里面我们是无法像使用vscode, idea等IDE工具时那样直接对代码打断点进行调试&#xff0c; 原因是小程序实际上他就是一个web浏览器应用的包装, 在其内部使用的还是类似chrome的…

Mysql数据库安装与C++配置

本文档旨在为需要安装和配置MySQL 8.3、MySQL Workbench以及C Connector的用户提供详细的步骤指导。在安装过程中&#xff0c;可能会遇到一些常见问题&#xff0c;如DLL文件缺失等&#xff0c;本指南也会提供相应的解决办法。 1.安装Mysql8.3 安装Mysql有很多教程&#xff0c…

10.MySql全局参数优化

从上图可以看出SQL及索引的优化效果是最好的&#xff0c;而且成本最低&#xff0c;所以工作中我们要在这块花更多时间。 一、全局参数 配置文件my.ini(windows)或my.cnf(mac)的全局参数&#xff1a; 假设服务器配置为&#xff1a; CPU&#xff1a;32核 内存&#xff1a;64G…

《Linux运维总结:基于ARM64+X86_64架构CPU使用docker-compose一键离线部署mongodb 7.0.14容器版分片集群》

总结&#xff1a;整理不易&#xff0c;如果对你有帮助&#xff0c;可否点赞关注一下&#xff1f; 更多详细内容请参考&#xff1a;《Linux运维篇&#xff1a;Linux系统运维指南》 一、部署背景 由于业务系统的特殊性&#xff0c;我们需要面向不通的客户安装我们的业务系统&…

charAt,chartCodeAt,codePointAt,fromCodePoint,fromCharCode

生僻字的length算2,有些空格是特殊空格,比如\u3000 u3000不是全角空格&#xff0c;u3000是表意字空格&#xff08;Ideographic Space&#xff09;&#xff0c;宽度和一个表意字&#xff08;汉字&#xff09;相同。它应当被当做汉字来处理。比如&#xff0c;在一些排版中&#x…

Python安装|PyCharm Professional 下载安装教程。2024最新版,亲测使用!

一、下载地址&#xff1a; 二、Python的下载及安装&#xff1a; 1、从上面网址进入Python官网 2、安装流程图&#xff1a; 双击已经下载好的python-*.*.*-amd64.exe文件&#xff0c;开始安装 最后就等它自己安装完成就好了 3、检验是否安装完成&#xff1a; windowsR快捷键…

Spring系列 循环依赖

文章目录 注入方式循环依赖的场景单例创建流程getSingletoncreateBeandoCreateBeancreateBeanInstance 循环依赖分析为什么都使用构造函数无法解决&#xff1f;为什么使用Autowired可以解决&#xff1f;为什么要添加到 earlySingletonObjects 缓存中&#xff1f;allowCircularR…

计算机毕业设计 基于Python音乐平台的设计与实现 Python毕业设计 Python毕业设计选题 Vue 前后端分离【附源码+安装调试】

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…

windows C++-移除界面工作线程(一)

本文档演示了如何使用并发运行时将 Microsoft 基础类 (MFC) 应用程序中由用户界面 (UI) 线程执行的工作移动到工作线程。 本文档还演示了如何提高冗长绘制操作的性能。 通过将阻塞性操作&#xff08;例如&#xff0c;绘制&#xff09;卸载到工作线程来从 UI 线程中移除工作&am…