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 等等。

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

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

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

三、集合接口

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

Set和List的区别

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

Collection 接口

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

List 接口

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

• 可以通过在列表中的位置使用零为基的索引来插入或访问元素。
• 列表可以包含重复的元素。
• 除了由 Collection 定义的方法外，列表定义了一些自己的方法，这些方法在下表中总结。
• 如果集合不能被修改，一些列表方法将抛出UnsupportedOperationException异常，并且当一个对象与另一个对象不兼容时，会生成ClassCastException。

Set 接口

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

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

SortedSet 接口

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

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

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

Map 接口

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

• 给定一个键和一个值，你可以将该值存储在一个Map对象中。在值被存储后，可以通过使用它的键来检索它。
• 几个方法在调用 Map 中不存在项目时会引发NoSuchElementException。
• 当对象与地图中的元素不兼容时，会引发ClassCastException。
• 如果尝试使用null对象并且在地图中不允许null，将引发NullPointerException。
• 当试图更改一个不可修改的映射时，将引发UnsupportedOperationException。

Map.Entry 接口

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

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

SortedMap 接口

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

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

集合实现类（集合类）

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

四、集合实现类

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

LinkedList 类

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

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

以下情况使用 ArrayList :

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

以下情况使用 LinkedList :

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

LinkedList 继承了 AbstractSequentialList 类。

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

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

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

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

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

构造函数

其他方法

ArrayList 类

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

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

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

构造函数

其他方法

HashSet 类

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

构造方法

其他方法

LinkedHashSet 类

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

构造函数

TreeSet 类

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

构造函数

其他方法

HashMap 类

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

构造函数

其他方法

Java HashMap 新增方法（merge,compute）

TreeMap类

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

构造函数

其他方法

WeakHashMap 类

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

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

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

构造函数

其他方法

LinkedHashMap 类

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

构造函数

其他方法

IdentityHashMap 类

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

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

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

构造函数

其他方法

Java.util 包中定义的类（非框架结构下）：

Java Vector类

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

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

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

Vector 类支持 4 种构造方法。

Vector 类中的其他方法

Java Stack类

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

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

Stack()

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

Dictionary 类

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

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

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

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

Hashtable 类

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

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

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

构造函数列表

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

五、集合算法

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

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

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

迭代器

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

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

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

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

迭代器声明的方法

ListIterator 声明的方法

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

• 通过调用集合的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 遍历 List
     for (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>() {
    @Override
    public 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>{
    @Override
    public 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>() {
    @Override
    public 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>{
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();
    }
}