Java中Guava Multimap与枚举：理解变量作用域并正确传递参数-java教程-PHP中文网

Java中Guava Multimap与枚举：理解变量作用域并正确传递参数

本文深入探讨了在java中使用guava multimap和枚举构建复杂数据结构时遇到的常见变量作用域问题。通过分析一个字典应用案例，我们解释了局部变量在方法间不可见的原因，并提供了通过方法参数传递变量的解决方案。此外，文章还优化了数据访问逻辑，提高了代码效率，旨在帮助开发者构建结构清晰、性能优越的java应用程序。

在Java编程中，特别是在构建复杂应用时，理解变量的作用域至关重要。一个常见的错误是尝试在一个方法中访问在另一个方法中声明的局部变量，这通常会导致“无法找到符号”（cannot find symbol）的编译错误。本文将通过一个使用Google Guava Multimap 和 Java Enum 构建字典的实际案例，深入探讨这一问题及其解决方案，并提供代码优化建议。

1. 案例背景与问题描述

假设我们需要构建一个多功能字典，其中每个单词可以有多个定义和多个词性（例如，“book”既可以是名词也可以是动词）。我们选择使用Java枚举来存储这些词条数据，并利用Guava ListMultimap 来存储单词到定义，以及单词到词性的映射。

初始代码结构如下所示：

public class Test1 {
    private enum Entry {
        // ... 枚举定义，包含key, partOfSpeech, definition ...
        BOOK("Book","noun", "A written work published in printed or electric form."),
        BOOK2("Book","verb","To arrange for someone to have a seat on a plane."),
        // ... 其他词条 ...

        private String key;
        private String partOfSpeech;
        private String definition;

        Entry(String key, String partOfSpeech, String definition) {
            this.key = key;
            this.partOfSpeech = partOfSpeech;
            this.definition = definition;
        }
        // ... getter 方法和 toString 方法 ...
        public String getKey() { return this.key.toUpperCase(); }
        public String getPartOfSpeech() { return this.partOfSpeech; }
        public String getDefinition() { return this.definition; }
        public String toString() { return this.key+" ["+ this.partOfSpeech+"] :  "+this.definition; }
    }

    public static void main(String[] args) {
        ListMultimap<String, String> dictionary = ArrayListMultimap.create();
        // ... 填充 dictionary ...
        dictionary.put(Entry.BOOK.getKey(),Entry.BOOK.getDefinition());
        dictionary.put(Entry.BOOK2.getKey(), Entry.BOOK2.getDefinition());
        // ...

        ListMultimap<String, String> partOfSpeechDict = ArrayListMultimap.create();
        // ... 填充 partOfSpeechDict ...
        partOfSpeechDict.put(Entry.BOOK.getKey(),Entry.BOOK.getPartOfSpeech());
        partOfSpeechDict.put(Entry.BOOK2.getKey(), Entry.BOOK2.getPartOfSpeech());
        // ...

        // ... 用户输入和查询逻辑 ...
        // 在 iterate 方法中，尝试访问 partOfSpeechDict 导致编译错误
        // System.out.print("\t"+str2+" ["+getPartOfSpeech(partOfSpeechDict, str2)+"] : "+entry.getValue()+"\n");
    }

    public static <K,V> void iterate(ListMultimap<String, String> alMultimap, String str) {
        for(Map.Entry<String,String> entry : alMultimap.entries()) {
            if(str.equalsIgnoreCase(entry.getKey())) {
                // ... 字符串格式化 ...
                String str2 = new String(charArray);
                // 错误发生在这里：IDE 提示无法找到符号 partOfSpeechDict
                // System.out.print("\t"+str2+" ["+getPartOfSpeech(partOfSpeechDict, str2)+"] : "+entry.getValue()+"\n");
            }
        }
    }

    public static <K,V> String getPartOfSpeech(ListMultimap<String, String> alMultimap,String str) {
        // ... 获取词性逻辑 ...
        return null;
    }
}

登录后复制

在 main 方法中声明并填充了 partOfSpeechDict 后，当尝试在 iterate 方法中通过 getPartOfSpeech(partOfSpeechDict, str2) 调用时，IDE 报告“无法找到符号: partOfSpeechDict”错误。

立即学习“Java免费学习笔记（深入）”；

2. 理解Java中的变量作用域

这个问题的核心在于Java的变量作用域规则。在Java中：

局部变量：在方法、构造器或代码块中声明的变量称为局部变量。它们只在声明它们的代码块内部可见和可访问。一旦代码块执行完毕，这些变量就会被销毁。
方法参数：方法参数本质上也是局部变量，它们的作用域仅限于该方法内部。

在我们的案例中，partOfSpeechDict 变量是在 main 方法内部声明的局部变量。因此，它只在 main 方法的作用域内可见。当 iterate 方法尝试访问 partOfSpeechDict 时，它超出了 partOfSpeechDict 的作用域，导致编译器无法找到该变量。

3. 解决方案：通过参数传递

解决这个问题的直接方法是，将 partOfSpeechDict 作为参数传递给需要访问它的 iterate 方法。这样，iterate 方法就能在其局部作用域内接收并使用这个 Multimap 实例。

修改 iterate 方法的签名，使其接收 partOfSpeechDict 作为额外参数：

import com.google.common.collect.ListMultimap;
import com.google.common.collect.ArrayListMultimap;
import java.util.Map;
import java.util.Scanner;
import java.util.Collection; // 引入 Collection 以便处理 Multimap.get() 的返回值

public class Test1 {
    private enum Entry {
        BOOK("Book","noun", "A written work published in printed or electric form."),
        BOOK2("Book","verb","To arrange for someone to have a seat on a plane."),
        BOOKABLE("Bookable","adjective","Can be ordered in advance."),
        BOOKCASE("Bookcase","noun","A piece of furniture with shelves."),
        BOOKBINDER("Bol okBinder","noun","A person who fastens the pages of books."),
        CSC2201("CSC220","noun","Data Structures."),
        CSC2202("CSC220","adjective","Ready to create complex data structures."),
        CSC2203("CSC220","verb","To create data structures.");
        private String key;
        private String partOfSpeech;
        private String definition;

        Entry(String key, String partOfSpeech, String definition) {
            this.key = key;
            this.partOfSpeech = partOfSpeech;
            this.definition = definition;
        }
        public String getKey() { return this.key.toUpperCase(); }
        public String getPartOfSpeech() { return this.partOfSpeech; }
        public String getDefinition() { return this.definition; }
        public String toString() { return this.key+" ["+ this.partOfSpeech+"] :  "+this.definition; }
    }

    public static void main(String[] args) {
        ListMultimap<String, String> dictionary = ArrayListMultimap.create();
        dictionary.put(Entry.BOOK.getKey(),Entry.BOOK.getDefinition());
        dictionary.put(Entry.BOOK2.getKey(), Entry.BOOK2.getDefinition());
        dictionary.put(Entry.BOOKABLE.getKey(), Entry.BOOKABLE.getDefinition());
        dictionary.put(Entry.BOOKCASE.getKey(), Entry.BOOKCASE.getDefinition());
        dictionary.put(Entry.BOOKBINDER.getKey(), Entry.BOOKBINDER.getDefinition());
        dictionary.put(Entry.CSC2201.getKey(), Entry.CSC2201.getDefinition());
        dictionary.put(Entry.CSC2202.getKey(), Entry.CSC2202.getDefinition());
        dictionary.put(Entry.CSC2203.getKey(), Entry.CSC2203.getDefinition());

        ListMultimap<String, String> partOfSpeechDict = ArrayListMultimap.create();
        partOfSpeechDict.put(Entry.BOOK.getKey(),Entry.BOOK.getPartOfSpeech());
        partOfSpeechDict.put(Entry.BOOK2.getKey(), Entry.BOOK2.getPartOfSpeech());
        partOfSpeechDict.put(Entry.BOOKABLE.getKey(), Entry.BOOKABLE.getPartOfSpeech());
        partOfSpeechDict.put(Entry.BOOKCASE.getKey(), Entry.BOOKCASE.getPartOfSpeech());
        partOfSpeechDict.put(Entry.BOOKBINDER.getKey(),Entry.BOOKBINDER.getPartOfSpeech());
        partOfSpeechDict.put(Entry.CSC2201.getKey(), Entry.CSC2201.getPartOfSpeech());
        partOfSpeechDict.put(Entry.CSC2202.getKey(), Entry.CSC2202.getPartOfSpeech());
        partOfSpeechDict.put(Entry.CSC2203.getKey(), Entry.CSC2203.getPartOfSpeech());

        System.out.println("- DICTIONARY JAVA Standard -----");
        System.out.println("-----      powered by Google Guava -");
        String searchKey = "null";
        String endCode = "!q";
        do {
            Scanner scan = new Scanner(System.in);
            System.out.print("Search:  ");
            searchKey = scan.nextLine();
            searchKey = searchKey.toUpperCase();
            if(dictionary.containsKey(searchKey)) {
                char[] charArray = searchKey.toCharArray();
                for(int i = 1; i < charArray.length; i++)
                    charArray[i] = Character.toLowerCase(charArray[i]);
                String str = new String(charArray);
                System.out.println("   |");
                // 调用 iterate 时，将 partOfSpeechDict 作为参数传入
                iterate(dictionary, partOfSpeechDict, str); 
                System.out.println("   |");
            } else if(searchKey.equalsIgnoreCase(endCode)) {
                break;
            } else {
                System.out.println("   |");
                System.out.println("\t<Not found>");
                System.out.println("   |");
            }
        } while(!searchKey.equalsIgnoreCase(endCode));
        System.out.println("\n-----THANK YOU-----");
        // 关闭Scanner是一个好习惯，尽管在循环中创建新Scanner不推荐
        // 在实际应用中，Scanner应该在循环外创建一次，并在程序结束时关闭。
        // scan.close(); // 如果Scanner在循环外创建，则在此处关闭
    }

    // iterate 方法现在接收 partOfSpeechDict 作为参数
    public static void iterate(ListMultimap<String, String> alMultimap, 
                                 ListMultimap<String, String> partOfSpeechDict, 
                                 String str) {
        for(Map.Entry<String, String> entry : alMultimap.entries()) {
            if(str.equalsIgnoreCase(entry.getKey())) {
                char[] charArray = entry.getKey().toCharArray();
                for(int i = 1; i < charArray.length; i++)
                    charArray[i] = Character.toLowerCase(charArray[i]);
                String str2 = new String(charArray);

                // 现在可以正确访问 partOfSpeechDict
                // 优化：直接使用 partOfSpeechDict.get(str2) 获取词性
                Collection<String> partsOfSpeech = partOfSpeechDict.get(str2);
                String partOfSpeechString = String.join("/", partsOfSpeech); // 如果有多个词性，用斜杠连接

                System.out.print("\t"+str2+" ["+ partOfSpeechString +"] : "+entry.getValue()+"\n");
            }
        }
    }

    // getPartOfSpeech 方法不再需要，因为我们直接使用 partOfSpeechDict.get()
    // 如果仍需要，其实现应直接使用 Multimap 的 get 方法
    /*
    public static String getPartOfSpeech(ListMultimap<String, String> alMultimap, String str) {
        // Multimap.get(key) 返回一个 Collection<V>，所以需要处理
        Collection<String> parts = alMultimap.get(str);
        if (parts != null && !parts.isEmpty()) {
            return String.join("/", parts); // 返回所有词性，用斜杠连接
        }
        return null;
    }
    */
}

登录后复制

注意事项：

Scanner的创建与关闭：在 do-while 循环内部每次迭代都创建一个新的 Scanner 实例是不推荐的，这可能导致资源泄露。更佳实践是在循环外部创建一次 Scanner，并在程序结束时关闭它。
泛型参数 <K,V> 的移除：在 iterate 方法中，alMultimap 和 partOfSpeechDict 的类型都是 ListMultimap<String, String>，因此泛型参数 <K,V> 是不必要的，可以直接移除，使方法签名更清晰。

4. 代码优化与最佳实践

除了解决作用域问题，我们还可以对代码进行进一步优化，提高其可读性和效率。

奇域

奇域是一个专注于中式美学的国风AI绘画创作平台

查看详情

4.1 优化 getPartOfSpeech 方法的使用

原始的 getPartOfSpeech 方法通过遍历 Multimap 的所有条目来查找匹配的键，效率较低。Multimap 接口本身提供了 get(key) 方法，可以直接获取与给定键关联的所有值（以 Collection 的形式返回）。

因此，我们可以直接在 iterate 方法中使用 partOfSpeechDict.get(str2) 来获取词性，而不再需要单独的 getPartOfSpeech 方法，或者如果保留该方法，其内部实现应利用 Multimap.get()。

优化后的 iterate 方法（如上面完整代码所示）：

public static void iterate(ListMultimap<String, String> alMultimap, 
                                 ListMultimap<String, String> partOfSpeechDict, 
                                 String str) {
    for(Map.Entry<String, String> entry : alMultimap.entries()) {
        if(str.equalsIgnoreCase(entry.getKey())) {
            char[] charArray = entry.getKey().toCharArray();
            for(int i = 1; i < charArray.length; i++)
                charArray[i] = Character.toLowerCase(charArray[i]);
            String str2 = new String(charArray);

            // 直接使用 Multimap.get()，更高效
            Collection<String> partsOfSpeech = partOfSpeechDict.get(str2);
            String partOfSpeechString = String.join("/", partsOfSpeech); // 如果有多个词性，用斜杠连接

            System.out.print("\t"+str2+" ["+ partOfSpeechString +"] : "+entry.getValue()+"\n");
        }
    }
}

登录后复制

4.2 改进 Enum 的数据结构（可选）

对于这种紧密关联的数据（单词、词性、定义），将它们都存储在同一个 Entry 枚举中是合理的。但如果未来需要更复杂的查询或数据操作，可以考虑将 Entry 枚举的值作为 Multimap 的值，而不是仅仅是字符串。例如：

// 如果 Multimap 的值是 Entry 枚举本身，可以更方便地访问所有属性
// ListMultimap<String, Entry> fullDictionary = ArrayListMultimap.create();
// fullDictionary.put(Entry.BOOK.getKey(), Entry.BOOK);
// 这样在 iterate 时，可以直接从 Entry 对象中获取 definition 和 partOfSpeech

登录后复制

然而，根据当前需求，将定义和词性分开存储在两个 Multimap 中也是一种有效且清晰的组织方式。