Java 有没有一种简单的方法可以找到具有给定字符串的单词？

我的申请有一些问题

基本上，我需要从用户那里读取一些字符串（他们会混合输入大量的字母），我的工作是找到一个单词，我可以使用他们给我的一些字母来制作

下面是一个例子：

用户类型“

emmfosor

”。 快速思考，我可以把它写成两个单词：“some”和“from”，但这些单词的字母是混合的

然而，为了使我的工作更容易，我有一个单词数据库。它位于txt文件中，如下所示：

apple
strawberry
boring
buildings
book
superior
bathroom

---

我所做的每一个解决方案都是错误的，或者这些话根本就没有出现。有人能帮我吗？

如果您确定输入包含一个单词，那么有一个简单的线性技巧

定义对字符串中的字母进行排序的方法。

字符串

是不可变的，因此该方法将返回一个新对象，显然：

公共静态字符串排序字符串（字符串输入字符串）{
char tempArray[]=inputString.toCharArray（）；
排序（tempArray）；
返回新字符串（tempArray）；
}

对文件中所有字符串的字母进行排序，并将其放入地图中：

Map Map=Files.line（path.get（“文件名”））
.collect（收集器.toMap（s->sortString，s->s））；

现在，一旦一切准备就绪，您就可以接受输入：

String inputString=//以某种方式读取它
String outputString=map.get（sortString（inputString））；

首先，您必须找到获取.txt文件内容的方法，并将其放入某种数组中。以下是我最好的方法：

class ParseText extends File {
  private Scanner readSelf;
  private String content;

  public ParseText(String filename) {
    super(filename);
    readSelf = new Scanner(this);
    while(readSelf.hasNextLine()) {
      content += readSelf.nextLine();
    }
    readSelf.close();
  }

  public String[] getEntries() {
    ArrayList<String> entries;
    while(true) {
      int firstBreak = content.indexOf('\n');
      boolean notLast = (firstBreak != -1);
      // ternary operator
      entries.add(content.substring(0, notLast ? (firstBreak - 1) : content.length() - 1));

      //more ternary operators
      content = notLast ? (content.substring(firstBreak + 1)) : "";
      if(content.length() == 0) {break};
    }
    return entries.toArray(new String[0]); 
  }

  public static HashMap<char, int> getCharacterHashMap(String string) {
    HashMap<char, int> charHash = new HashMap<char, int>();

    for(char c : string.toCharArray()) {
      if(charHash.containsKey(c)) {
        int old = charHash.get(c);
        charHash.replace(c, old, old + 1);
      }
      else {
        charHash.put(c, 1);
      }
    }

    return charHash;
  }
}

类ParseText扩展文件{
私人扫描仪；
私有字符串内容；
公共解析文本（字符串文件名）{
超级（文件名）；
readSelf=新扫描仪（此）；
while（readSelf.hasNextLine（））{
content+=readSelf.nextLine（）；
}
readSelf.close（）；
}
公共字符串[]getEntries（）{
ArrayList条目；
while（true）{
int firstBreak=content.indexOf（'\n'）；
布尔值notLast=（firstBreak！=-1）；
//三元运算符
add（content.substring（0，notLast？（firstBreak-1）：content.length（）-1））；
//更多三元运算符
content=notLast？（content.substring（firstBreak+1））：“”；
如果（content.length（）==0）{break}；
}
返回条目.toArray（新字符串[0]）；
}
公共静态HashMap getCharacterHashMap（字符串）{
HashMap charHash=新的HashMap（）；
for（char c:string.toCharArray（））{
if（charHash.containsKey（c））{
int old=charHash.get（c）；
charHash.replace（c，old，old+1）；
}
否则{
charHash.put（c，1）；
}
}
返回charHash；
}
}

接下来是一个算法。我们应该在这里开始使用hashmaps，因为我们想为字符串创建一个非加扰器。每个HashMap对象都应该以字符作为键，以整数作为值

class Unscramble {
  private static String[] entries = new ParseText("entries.txt").getEntries();
  
  public static match(String someGibberish) {
    Object gibberishHash = ParseText.getCharacterHashMap(someGibberish);
    ArrayList<int> passes = new ArrayList<int>();
    for(int i = 0; i < entries.length; i++) {
      
      HashMap<char, int> currentHash = ParseText.getCharacterHashMap(entries[i]);
      char[] keyArray = currentHash.keySet().toArray();
      boolean[] fits = new boolean[keyArray.length];
      for(int j = 0; j < keyArray.length; i++) {
        if(gibberishHash.get(keyArray[j]) != null && currentHash.get(keyArray[j]) <= gibberishHash.get) {
          fits[j] = true
        }
        else {
          //breaking to speed up running
          break;
        }
      }

      boolean passesEntry = true;
      for(int k = 0; k < fits.length; i++) {
        if(!(fits[k])) {
          passesEntry = false;
          break;
        }
      }

      if(passesEntry) {
        passes.add(i);
      }
    }
  }
}

类解读{
私有静态字符串[]entries=new ParseText（“entries.txt”）.getEntries（）；
公共静态匹配（字符串乱码）{
Object gibberishHash=ParseText.getCharacterHashMap（someGibberish）；
ArrayList passs=新建ArrayList（）；
for（int i=0；iif（gibberishHash.get（keyArray[j]）！=null&¤tHash.get（keyArray[j]）这不是一种有效的方法。对于庞大的word数据库，它不适合。但我们可以尝试类似的方法。
对于输入中的每个字符，从
单词列表中的所有单词中删除该字符。
单词列表
最后将有0个长度匹配的字符串。

以下是我的基本实现。您可以使用StringBuilder、映射、从输入中删除重复字符等来提高性能

public class Test {

   public static void main(String[] args) throws Exception {
       String[] data = {"some", "zoo", "from"};
       String input = "emmfosor";
       System.out.println("input: " + input);
       System.out.println("possible words: "+getMatched(input, data));
    }
   
   public static List<String> getMatched(String input, String[] data){
       List<String> result = new ArrayList<>();
       //make a copy to work on
       String[] copy = Arrays.copyOf(data, data.length);
       char[] chars = input.toCharArray();
       for(char c : chars) {
           for (int i = 0; i < copy.length; i++) {
            String word = copy[i];
            if(!word.isBlank())
                copy[i] = word.replaceAll(Character.toString(c), "");
        }
       }
       for (int i = 0; i < copy.length; i++)
         if(copy[i].isBlank())     //find empty strings
             result.add(data[i]);
           return result;
   }
}

根据您的需要修改代码。
也许您可以查看汉明距离，尝试通过将输入的单词与您的字典进行比较来恢复输入的错误单词，但我不知道准确度是否足以满足您的需要输入的单词数是固定的吗？为什么不在txt文件中逐字检查每个单词，看看每个单词是否正确ter在给定的字符串中？如果给定的字符串中至少有一个字母不在，则该单词无法从给定的字符串中生成。相关：-这可能会给您一些想法，您可以根据自己的情况进行调整。@ETO谢谢，我特意不建议任何代码，因为OP没有显示任何代码。用户键入“emmfosor”。快速思考，我可以从中提取两个单词：OP似乎意识到输入不会包含一个单词。您可以很容易地从这样的文件中获取单词的列表：
List database=Files.readAllLines（Path.of（“words.txt”））
谢谢@onkarruikar，那么我就可以删除ParseText类，只需向Unscamble类添加一个属性。
input: emmfosor
possible words: [some, from]