private static List<String> matchDisNames(List<String> disNames,List<String> keyWords){ List<String> result = new ArrayList<>(); for (String disName:disNames){ for (String kw:keyWords){ if (!"".equals(kw) && disName.contains(kw)){ result.add(disName); break; } } } return result; } 优化

这段代码可以进行如下优化：

1. 避免对空字符串进行无意义的匹配，可以在传入关键词列表时进行过滤，去除空字符串。

2. 可以利用 Java 8 的 Stream API 进行简化，使代码更加简洁易读。

优化后的代码如下：

private static List<String> matchDisNames(List<String> disNames, List<String> keyWords) {
    return disNames.stream()
            .filter(disName -> keyWords.stream().anyMatch(kw -> !kw.isEmpty() && disName.contains(kw)))
            .collect(Collectors.toList());
}

这个版本使用了 lambda 表达式和 Stream API 来处理集合，可以更加高效和简洁地实现同样的功能。

相关问题

在我们课堂实现的基于容器类的记事本程序的基础上，添加如下功能： “记录查询”功能：即输入一组关键字（String[] keywords）查询所有包括这组关键字的记录内容。 “删除恢复”功能：即支持对最近n条删除的记录的恢复，恢复包括：内容恢复和存储位置恢复（插入到删除前的index）。 “单词翻译”功能：自动地将记录的字符串中的英文单词翻译为中文。 2.提示： 通过package有效的管理涉及的类 应用HashMap实现词典功能，即HashMap<String, String>，只需实现少量单词的翻译

根据您的要求，以下是一个基于容器类的记事本程序的Java代码，实现了记录查询、删除恢复和单词翻译功能：

Note.java:

public class Note {
    private String content;

    public Note(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

Notebook.java:

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

public class Notebook {
    private List<Note> notes;
    private List<Note> deletedNotes;
    private Map<String, String> dictionary;

    public Notebook() {
        notes = new ArrayList<>();
        deletedNotes = new ArrayList<>();
        dictionary = new HashMap<>();
        initializeDictionary();
    }

    public void addNote(String content) {
        Note note = new Note(content);
        notes.add(note);
    }

    public void deleteNote() {
        if (!notes.isEmpty()) {
            Note deletedNote = notes.remove(notes.size() - 1);
            deletedNotes.add(deletedNote);
        }
    }

    public void restoreDeletedNote() {
        if (!deletedNotes.isEmpty()) {
            Note restoredNote = deletedNotes.remove(deletedNotes.size() - 1);
            int index = notes.size() > 0 ? notes.size() - 1 : 0;
            notes.add(index, restoredNote);
        }
    }

    public List<Note> searchNotes(String[] keywords) {
        List<Note> result = new ArrayList<>();
        for (Note note : notes) {
            String content = note.getContent();
            boolean containsAllKeywords = true;
            for (String keyword : keywords) {
                if (!content.contains(keyword)) {
                    containsAllKeywords = false;
                    break;
                }
            }
            if (containsAllKeywords) {
                result.add(note);
            }
        }
        return result;
    }

    public String translate(String text) {
        StringBuilder translatedText = new StringBuilder();
        String[] words = text.split(" ");
        for (String word : words) {
            if (dictionary.containsKey(word)) {
                translatedText.append(dictionary.get(word));
            } else {
                translatedText.append(word);
            }
            translatedText.append(" ");
        }
        return translatedText.toString().trim();
    }

    private void initializeDictionary() {
        dictionary.put("hello", "你好");
        dictionary.put("world", "世界");
        dictionary.put("goodbye", "再见");
        dictionary.put("thank you", "谢谢你");
    }
}

Main.java:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        Notebook notebook = new Notebook();

        notebook.addNote("Hello world!");
        notebook.addNote("This is a sample note.");
        notebook.addNote("I am learning Java.");

        // 查询包含关键字的记录
        String[] keywords = {"hello", "Java"};
        List<Note> searchResults = notebook.searchNotes(keywords);
        System.out.println("Search results:");
        for (Note note : searchResults) {
            System.out.println(note.getContent());
        }

        // 删除最后一条记录
        notebook.deleteNote();

        // 恢复删除的记录
        notebook.restoreDeletedNote();

        // 翻译记录中的英文单词
        String translatedText = notebook.translate("Hello world! I am learning Java.");
        System.out.println("Translated text: " + translatedText);
    }
}

这个代码包含三个类：`Note`、`Notebook`和`Main`。`Note`类表示一个记事本记录，包含一个字符串类型的内容。`Notebook`类表示一个记事本，包含一组记录（`notes`）、一组已删除的记录（`deletedNotes`）和一个用于单词翻译的词典（`dictionary`）。它具有添加记录、删除记录、恢复删除的记录、查询记录和单词翻译的功能。`Main`类是程序的入口点，用于演示记事本的功能。

在`Main`类的`main()`方法中，首先创建一个`Notebook`对象，并添加几条记录。然后，演示了查询包含关键字的记录、删除最后一条记录并恢复、以及翻译记录中的英文单词的功能。

请注意，在使用单词翻译功能时，我们只提供了少量单词的翻译示例，您可以根据需要自行扩展词典中的单词和翻译。