自定义HashMap排序方法全解析

golang学习网今天将给大家带来《自定义类值排序HashMap方法详解》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习文章或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

理解HashMap的排序特性

在Java中，HashMap是一种基于哈希表的Map实现，它不保证元素的顺序。这意味着当你遍历HashMap时，元素的返回顺序是不可预测的，并且可能随着时间或Map内容的改变而变化。

对于需要排序的场景，许多开发者可能会首先想到TreeMap。然而，TreeMap是根据其键（Key）的自然顺序或提供的Comparator进行排序的，而不是根据值（Value）进行排序。因此，如果我们的目标是根据Map中自定义类的值成员进行排序，TreeMap并不能直接满足需求。

为了实现按值排序并保持排序后的顺序，我们需要借助其他数据结构，如LinkedHashMap。LinkedHashMap维护了元素的插入顺序，这使得它成为在对Map条目排序后，能够保持这种排序结果的理想选择。

通过值对HashMap进行排序的策略

由于HashMap本身无法按值排序，我们需要采用一种变通的方法：将HashMap的条目（Entry）提取出来，对这些条目进行排序，然后将排序后的条目重新放入一个能够保持插入顺序的Map中，即LinkedHashMap。

假设我们有一个HashMap，其中CustomClass定义如下：

class CustomClass {
    String s;
    Integer i;
    // ... 构造函数 & getter/setter

    // 为了通过CustomClass的s成员进行比较，CustomClass需要实现Comparable接口
    // 或者在排序时提供一个Comparator
}

为了能够根据CustomClass的s成员进行排序，CustomClass需要实现Comparable接口，并重写compareTo方法，或者在排序时提供一个Comparator。

class FileMap implements Comparable{
    private String fileName;
    private int file;

    public FileMap(String fileName, int file){
        this.fileName = fileName;
        this.file = file;
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public int getFile() {
        return file;
    }

    public void setFile(int file) {
        this.file = file;
    }

    @Override
    public int compareTo(FileMap that){
        // 根据fileName进行比较
        return this.fileName.compareTo(that.getFileName());
    }

    @Override
    public String toString(){
        return this.fileName;
    }
}

有了可比较的CustomClass（或FileMap），我们就可以采用以下两种方法进行排序。

方法一：使用Java Stream API

Java 8引入的Stream API提供了一种简洁高效的方式来处理集合数据。我们可以利用它来对Map的Entry进行排序，并收集到LinkedHashMap中。

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class SortHashMapByValueStream {

    public static void main(String[] args) {
        Map fileMap = Map.of(
            0, new FileMap("abc.txt", 0),
            1, new FileMap("abd.txt", 0),
            2, new FileMap("abe.txt", 0),
            3, new FileMap("abf.txt", 0)
        );

        System.out.println("原始Map: " + fileMap);

        Map sortedMap = fileMap.entrySet().stream()
            // 使用Map.Entry.comparingByValue()根据值进行比较
            // 这要求值类型（FileMap）实现了Comparable接口
            .sorted(Map.Entry.comparingByValue()) 
            .collect(Collectors.toMap(
                Map.Entry::getKey,       // 提取键
                Map.Entry::getValue,     // 提取值
                (oldValue, newValue) -> { 
                    // 合并函数：如果键重复，抛出异常。
                    // 在此场景下，通常期望键是唯一的，所以这表示一个意外情况。
                    throw new AssertionError("所有源键都应是唯一的");
                },
                LinkedHashMap::new       // 指定收集器创建一个LinkedHashMap，以保持排序顺序
            ));

        System.out.println("按值排序后的Map (Stream): " + sortedMap);
    }
}

代码解析：

1. fileMap.entrySet().stream()：获取Map的Entry集合，并将其转换为一个Stream。
2. .sorted(Map.Entry.comparingByValue())：对Stream中的Map.Entry对象进行排序。comparingByValue()方法需要Map的值类型实现Comparable接口，或者你也可以传入一个自定义的Comparator。
3. .collect(Collectors.toMap(...))：将排序后的Entry收集到一个新的Map中。
   • Map.Entry::getKey 和 Map.Entry::getValue：指定如何从Stream中的每个Entry中提取键和值。
   • (oldValue, newValue) -> { throw new AssertionError("所有源键都应是唯一的"); }：这是一个合并函数，用于处理键冲突。在将Entry重新收集到Map时，如果遇到重复的键，此函数会被调用。在此例中，我们假设原始Map的键是唯一的，因此如果发生冲突，则抛出异常。
   • LinkedHashMap::new：这是一个Supplier，指定了要创建的Map类型。LinkedHashMap会保持元素的插入顺序，从而保留了排序后的结果。

方法二：传统命令式编程

如果你更偏好传统的循环和集合操作，也可以通过以下步骤实现：

1. 获取HashMap的entrySet()。
2. 将entrySet()转换为一个List。
3. 使用Collections.sort()或List.sort()对列表进行排序。
4. 创建一个新的LinkedHashMap。
5. 遍历排序后的列表，将Entry逐个放入新的LinkedHashMap中。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class SortHashMapByValueImperative {

    public static void main(String[] args) {
        Map fileMap = Map.of(
            0, new FileMap("abc.txt", 0),
            1, new FileMap("abd.txt", 0),
            2, new FileMap("abe.txt", 0),
            3, new FileMap("abf.txt", 0)
        );

        System.out.println("原始Map: " + fileMap);

        // 1. 获取Map的entrySet并转换为List
        List> sortedEntries = new ArrayList<>(fileMap.entrySet());

        // 2. 对List进行排序
        // 使用Map.Entry.comparingByValue()根据值进行比较
        sortedEntries.sort(Map.Entry.comparingByValue()); 
        // 或者使用 Collections.sort(sortedEntries, Map.Entry.comparingByValue());

        // 3. 创建一个新的LinkedHashMap
        Map result = new LinkedHashMap<>();

        // 4. 将排序后的Entry放入LinkedHashMap
        for (Map.Entry entry : sortedEntries) {
            result.put(entry.getKey(), entry.getValue());
        }

        System.out.println("按值排序后的Map (命令式): " + result);
    }
}

代码解析：

1. new ArrayList<>(fileMap.entrySet())：将HashMap的Entry集合转换为一个ArrayList，因为ArrayList是可排序的。
2. sortedEntries.sort(Map.Entry.comparingByValue())：使用List的sort方法对列表中的Entry进行排序。同样，这依赖于FileMap类实现了Comparable接口。
3. new LinkedHashMap<>()：创建一个新的LinkedHashMap实例，它将按照元素插入的顺序来维护Map的顺序。
4. for (Map.Entry entry : sortedEntries)：遍历排序后的列表，并逐个将Entry的键值对放入新的LinkedHashMap中。由于LinkedHashMap保持插入顺序，因此最终的Map将按照我们排序的顺序排列。

注意事项

• 自定义类的可比较性：无论采用Stream API还是命令式编程，核心都是对Map的Entry进行排序。这意味着Map的值类型（例如本例中的CustomClass或FileMap）必须是可比较的。这通常通过让该类实现Comparable接口并重写compareTo()方法来完成。如果不想修改自定义类，也可以在排序时提供一个Comparator。
• 创建新Map：这两种方法都会创建一个新的LinkedHashMap来存储排序后的结果。它们不会修改原始的HashMap，因为HashMap本身不支持排序。
• LinkedHashMap的特性：LinkedHashMap维护的是插入顺序。一旦你将排序后的Entry放入LinkedHashMap，它的顺序就固定了。如果原始Map后续有修改（例如添加、删除或更新了值），并且你希望这些修改也能反映在排序后的视图中，你需要重新执行上述排序逻辑来生成一个新的LinkedHashMap。
• 性能考量：将Map转换为List，然后排序，最后再重新构建Map，这涉及额外的内存分配和计算开销。对于非常大的Map，需要考虑其性能影响。

总结

在Java中，直接对HashMap按值排序是不可行的，因为它不保证顺序。然而，通过将HashMap的Entry提取出来，进行排序，然后将排序后的结果放入一个LinkedHashMap中，我们可以有效地实现按值排序并保持这种顺序。本文提供了两种主要的实现方式：使用现代的Java Stream API和传统的命令式编程方法。选择哪种方法取决于你的项目偏好和Java版本。重要的是，要确保你的自定义值类型实现了Comparable接口，或者在排序时提供一个Comparator，以便正确定义值的比较逻辑。

好了，本文到此结束，带大家了解了《自定义HashMap排序方法全解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！