我编写了一个程序来读取文本文件，其中每一行都是一个单词。 代码的第一部分找到以字母的每个字母开头的最长单词，并将其存储在数组中。 我希望程序执行的第二部分是为字母表中的每个字母找到该字母出现次数最多的单词。

因此输出应如下所示：

最长的字：

a: anthropomorphologically

b: blepharosphincterectomy

c: cholecystenterorrhaphy

d: dacryocystoblennorrhea

e: epididymodeferentectomy

f: formaldehydesulphoxylate

g: gastroenteroanastomosis

h: hematospectrophotometer

i: indistinguishableness

j: jurisprudentialist

k: keratoconjunctivitis

l: laparocolpohysterotomy

m: macracanthrorhynchiasis

n: naphthylaminesulphonic

o: omnirepresentativeness

p: pathologicopsychological

q: quadratomandibular

r: reticulatocoalescent

s: scientificophilosophical

t: tetraiodophenolphthalein

u: ureterocystanastomosis

v: vagoglossopharyngeal

w: weatherproofness

x: xanthocreatinine

y: yohimbinization

z: zoologicoarchaeologist

带有最多字母的单词：

a: astragalocalcaneal

b: beblubber

c: chlorococcaceae

d: disdodecahedroid

e: electrotelethermometer

f: giffgaff

g: cuggermugger

h: choledochorrhaphy

i: impossibilification

j: ajaja

k: akiskemikinik

l: allochlorophyll

m: dynamometamorphism

n: nonannouncement

o: choledochoduodenostomy

p: aplopappus

q: equivoque

r: archcorrupter

s: possessionlessness

t: anticonstitutionalist

u: untumultuous

v: overconservative

w: bowwow

x: adnexopexy

y: dacryocystosyringotomy

z: zizz

}

基本上，我需要弄清楚该怎么做，以便输出的单词不是与第一个字母相同的单词(例如，上面的'f'[giffgaff]怎么不以'f'开头)。 我已经用谷歌搜索了很多东西，却找不到任何帮助。

/**

* @param args first String argument is the

*        name of the input text file

*/

public static void main(String [] args) throws IOException {

//instance variable

String[] longestWords = new String[26];

String[] mostCharsWord = new String[26];

String currentLine = null;

int[] numCharacters = new int[26];

//because the while loop in try statement is comparing lengths in order to

//assign words, I must give each element a non-null value

//in this case, length = 0

Arrays.fill(longestWords,"");

Arrays.fill(mostCharsWord,"");

//try block

try(BufferedReader br = new BufferedReader(new FileReader(args[0]))) {

String currentLongestWord;

int index;

int indexer = 0;

int count = 0;

int counter = 0;

while((currentLine=br.readLine()) != null) {

currentLine = currentLine.toLowerCase();

index = currentLine.charAt(0)-'a';

currentLongestWord = longestWords[index];

if(currentLine.length() > currentLongestWord.length()) {

longestWords[index] = currentLine;

}

/**

* this code below is for the"AND" bit, but I know that it's not correct.

* Instead of printing out the word with the most occurrences of each

* letter, it prints out the word with the most occurrences of each letter

* THAT BEGINS WITH THAT LETTER

*/

for(char c : currentLine.toCharArray()) {

if(c == currentLine.charAt(0)) {

count += 1;

}

}

for(String currentMostCharsWord : mostCharsWord) {

indexer += 1;

for(char c : currentLine.toCharArray()) {

for( char d: currentMostCharsWord.toCharArray()) {

if(c==d) {

//hmmm....this would compare every letter, not just the one

//that I'm looking for. booooooo

}

}

}

}

if(count > numCharacters[index]) {

numCharacters[index] = count;

mostCharsWord[index] = currentLine;

}

count = 0;

}

//close file!

br.close();

}

//catch block

catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//finally / do anyway statement

finally {

System.out.println("Longest Words:

");

for(int j = 0; j < 26; j++) {

System.out.printf("%s: %s

", longestWords[j].charAt(0), longestWords[j]);

}

System.out.println("------------------------------------

Words with most letters:

");

for(int j = 0; j < 26; j++) {

System.out.printf("%s: %s

", mostCharsWord[j].charAt(0), mostCharsWord[j]);

}

}

}

}

尝试将您的问题分解为一些简单的问题。 让社区解决整个难题的可能性要比问他们哪一块拼图来的可能性小。

@ Okuma.Scott抱歉，这是我第一次真正在这里提出问题，我只想提供尽可能多的信息。 我以为我比实际上更接近答案。

您可以使用以下方式：

// Map with the longest word for each letter

Map longestWordMap = new HashMap();

// Map with the word with highest occurrences of each letter

Map mostCharsWordMap = new HashMap();

while((word = br.readLine()) != null) { {

word = word.toLowerCase();

Character beginning = word.charAt(0);

String longestWord = longestWordMap.get(beginning);

// If the current word is the longest, put the word in the map

if (longestWord == null || word.length() > longestWord.length()) {

longestWordMap.put(beginning, word);

}

for (char letter = 'a'; letter <= 'z'; letter++) {

String mostCharsWord = mostCharsWordMap.get(Character.valueOf(letter));

if (mostCharsWord == null ||

characterCount(letter, word) > characterCount(letter, mostCharsWord)) {

mostCharsWordMap.put(Character.valueOf(letter), word);

}

}

}

这是用于计算单词中字母出现次数的函数：

public static int characterCount(char letter, String word) {

int characterCount = 0;

for (char c : word.toCharArray()) {

if (c == letter) {

characterCount++;

}

}

return characterCount;

}

对此可能有更直接的方法。 因此，问题本质上是您有一个单词流，并根据当前从该流中读取的单词，将其与数据存储中已知的最长单词进行比较。 如果更长，则替换单词，否则什么也不做。 您的逻辑可能是根据其他内容(例如单词的字典顺序)来替换它。 您是否需要检查是否区分大小写是一项练习。

//主要是伪代码

public class LongestWord

{

Map longestWords = new HashMap();

while(wordsStream.hasNext())

{

String currentWord = wordStream.next();

String longestWordByLetter = longestWords.get(currentWord.charAt(0));

if(null != longestWordByLetter)

{

if(longestWordByLetter.size() < currentWord.size())

{

longestWords.put(currentWord.charAt(0),currentWord);

}//else do nothing

}else{

longestWords.put(currentWord.charAt(0),currentWord);

}

}

}