Java 强制执行支票：don'；如果第0列中已有字符串，则无法继续

通过下面的代码，我希望将所有以相同名称开头的字母合并到一个数组列中，并在第二列中保留与字母相关联的数字的总和

例如：

array_1 = { {"bat","1"},
            {"rat","2"},
            {"ball","3"},
            {"run","4"},
            {"lizard","5"}
          }

into array_2 = { {"b","4"},
                 {"r","6"},
                 {"l",5}
                }

下面的代码给出了一半正确的结果。问题是当它到达

ball

时，它再次添加以

b

开头的下一个字母表，并将其存储为单独的值。问题是第42行。我已经标记了它。我应该如何检查它在添加字母表后是否没有添加字母表的编号

package keylogger;
import java.util.Arrays;
public class ArrayTester {

private static int finalLength=0;
private static String firstAlphabet[][];
private String data[][] = { 
                               {"Nokia" , "7"},
                               {"Blackberry" , "1"},
                               {"Nimbus","10"},
                               {"Apple","19"},
                               {"Ami","21"},
                               {"Bug","35"},
                               {"Native","200"},
                               {"zebra","100"},
                               {"Nine","9"}

                          };  

public void calculator() {
   try {  
    // traverse the whole array
    firstAlphabet = new String[data.length][data.length]; // set the length of firstAlphabet array

    for(int i=0;i<data.length;i++) {
        firstAlphabet[i][0] = data[i][0].substring( 0, 1); // get the first alphabet
        firstAlphabet[i][1] = data[i][1];
        int k = i+1;
        int v = k;
        int t=0;
        for(int j=0;j<data.length-v;j++) {
            System.out.println("Inner for loop" + j);
            String s = data[k][0];
// line 42:
            if(firstAlphabet[i][0].compareToIgnoreCase(s.substring(0, 1))==0) { 
               System.out.println("If statement");
               firstAlphabet[i][0] = s.substring(0, 1);
               Integer z = Integer.parseInt(data[k][1]) + Integer.parseInt(firstAlphabet[i][1]);
               firstAlphabet[i][1] = z.toString();                   
            }
            k++;
        }   
    }               
  }catch(Exception exc) {
     exc.printStackTrace();
   }
}

public static void main(String args[]) {
    ArrayTester o = new ArrayTester();
    o.calculator();
    for(String s[] : firstAlphabet) {
        for(String x : s) {
            System.out.println(x);
        }
    }
}
}

---

如果我们注意到与字母表相关的总和是正确的。唯一的问题是重复。i、 例如，N=219，即200+19，基本上您可以执行以下操作：

// words is an array of tuples (word, frequency); that should probably be a class in your java code
// sums is a HashMap<Character, Integer>
foreach word, frequency in words:
     letter = word[0]
     sums[letter] = sums[letter] + frequency

//单词是元组数组（单词、频率）；这可能是java代码中的一个类
//sums是一个HashMap
每个单词的词频：
字母=单词[0]
总和[字母]=总和[字母]+频率

---

应该可以直接用Java编写，而且比您当前的代码更快、更简单。你要做的唯一一件事就是检查

sums[letter]

是否已经存在，如果不使用

frequency

对其进行初始化，那就太糟糕了，Java没有为这些事情提供DefaultDict。

基本上你可以做以下几点：

// words is an array of tuples (word, frequency); that should probably be a class in your java code
// sums is a HashMap<Character, Integer>
foreach word, frequency in words:
     letter = word[0]
     sums[letter] = sums[letter] + frequency

//单词是元组数组（单词、频率）；这可能是java代码中的一个类
//sums是一个HashMap
每个单词的词频：
字母=单词[0]
总和[字母]=总和[字母]+频率

---

应该可以直接用Java编写，而且比您当前的代码更快、更简单。你要做的唯一一件事就是检查

sums[字母]

是否已经存在，如果不使用

frequency

对其进行初始化，那就太糟糕了，Java没有为这些事情提供默认dict。

重复是因为你没有将已经选择的字母表标记为脏的

public void calculator() {
        List<String> marked = new ArrayList<String>();
        try {
            // traverse the whole array
            firstAlphabet = new String[data.length][2]; // set the length of first Alphabet array
            for (int i = 0; i < data.length; i++) {
                String firstLetter = data[i][0].substring(0, 1);
                if(marked.contains(firstLetter)){
                    continue;
                }
                marked.add(firstLetter);
                firstAlphabet[i][0] = firstLetter; // get the first alphabet
                firstAlphabet[i][1] = data[i][1];
                int k = i + 1;
                int v = k;
                int t = 0;
                for (int j = 0; j < data.length - v; j++) {
                    System.out.println("Inner for loop" + j);
                    String s = data[k][0];
                    if (firstAlphabet[i][0].equalsIgnoreCase(s.substring(0,
                            1))) { // line 42
                        System.out.println("If statement");
                        firstAlphabet[i][0] = s.substring(0, 1);
                        Integer z = Integer.parseInt(data[k][1])
                                + Integer.parseInt(firstAlphabet[i][1]);
                        firstAlphabet[i][1] = z.toString();
                    }
                    k++;
                }
            }
        } catch (Exception exc) {
            exc.printStackTrace();
        }
    }

因此，在第一个循环中，N本身有一个最终计数，但根据当前逻辑，当Nimbus在itertion下时，您将执行整个处理，因为您没有将N标记为dirty

public void calculator() {
        List<String> marked = new ArrayList<String>();
        try {
            // traverse the whole array
            firstAlphabet = new String[data.length][2]; // set the length of first Alphabet array
            for (int i = 0; i < data.length; i++) {
                String firstLetter = data[i][0].substring(0, 1);
                if(marked.contains(firstLetter)){
                    continue;
                }
                marked.add(firstLetter);
                firstAlphabet[i][0] = firstLetter; // get the first alphabet
                firstAlphabet[i][1] = data[i][1];
                int k = i + 1;
                int v = k;
                int t = 0;
                for (int j = 0; j < data.length - v; j++) {
                    System.out.println("Inner for loop" + j);
                    String s = data[k][0];
                    if (firstAlphabet[i][0].equalsIgnoreCase(s.substring(0,
                            1))) { // line 42
                        System.out.println("If statement");
                        firstAlphabet[i][0] = s.substring(0, 1);
                        Integer z = Integer.parseInt(data[k][1])
                                + Integer.parseInt(firstAlphabet[i][1]);
                        firstAlphabet[i][1] = z.toString();
                    }
                    k++;
                }
            }
        } catch (Exception exc) {
            exc.printStackTrace();
        }
    }

public void calculator（）{
列表标记=新的ArrayList（）；
试一试{
//遍历整个阵列
firstAlphabet=新字符串[data.length][2]；//设置第一个字母数组的长度
对于（int i=0；i

重复是因为您没有将已选择的字母表标记为脏的

public void calculator() {
        List<String> marked = new ArrayList<String>();
        try {
            // traverse the whole array
            firstAlphabet = new String[data.length][2]; // set the length of first Alphabet array
            for (int i = 0; i < data.length; i++) {
                String firstLetter = data[i][0].substring(0, 1);
                if(marked.contains(firstLetter)){
                    continue;
                }
                marked.add(firstLetter);
                firstAlphabet[i][0] = firstLetter; // get the first alphabet
                firstAlphabet[i][1] = data[i][1];
                int k = i + 1;
                int v = k;
                int t = 0;
                for (int j = 0; j < data.length - v; j++) {
                    System.out.println("Inner for loop" + j);
                    String s = data[k][0];
                    if (firstAlphabet[i][0].equalsIgnoreCase(s.substring(0,
                            1))) { // line 42
                        System.out.println("If statement");
                        firstAlphabet[i][0] = s.substring(0, 1);
                        Integer z = Integer.parseInt(data[k][1])
                                + Integer.parseInt(firstAlphabet[i][1]);
                        firstAlphabet[i][1] = z.toString();
                    }
                    k++;
                }
            }
        } catch (Exception exc) {
            exc.printStackTrace();
        }
    }

因此，在第一个循环中，N本身有一个最终计数，但根据当前逻辑，当Nimbus在itertion下时，您将执行整个处理，因为您没有将N标记为dirty

public void calculator() {
        List<String> marked = new ArrayList<String>();
        try {
            // traverse the whole array
            firstAlphabet = new String[data.length][2]; // set the length of first Alphabet array
            for (int i = 0; i < data.length; i++) {
                String firstLetter = data[i][0].substring(0, 1);
                if(marked.contains(firstLetter)){
                    continue;
                }
                marked.add(firstLetter);
                firstAlphabet[i][0] = firstLetter; // get the first alphabet
                firstAlphabet[i][1] = data[i][1];
                int k = i + 1;
                int v = k;
                int t = 0;
                for (int j = 0; j < data.length - v; j++) {
                    System.out.println("Inner for loop" + j);
                    String s = data[k][0];
                    if (firstAlphabet[i][0].equalsIgnoreCase(s.substring(0,
                            1))) { // line 42
                        System.out.println("If statement");
                        firstAlphabet[i][0] = s.substring(0, 1);
                        Integer z = Integer.parseInt(data[k][1])
                                + Integer.parseInt(firstAlphabet[i][1]);
                        firstAlphabet[i][1] = z.toString();
                    }
                    k++;
                }
            }
        } catch (Exception exc) {
            exc.printStackTrace();
        }
    }

public void calculator（）{
列表标记=新的ArrayList（）；
试一试{
//遍历整个阵列
firstAlphabet=新字符串[data.length][2]；//设置第一个字母数组的长度
对于（int i=0；i

您可以：

使用更方便的数据结构，如

地图

如果更改数据结构不适合您，您还可以在开始迭代之前使用自定义的

比较器对输入数组进行排序。看

Arrays.sort（数据，新比较器（）{
公共整数比较（字符串[]o1，字符串[]o2）{
字符letter1=o1[0]。字符（0）；
字符字母2=o2[0]。字符（0）；
返回信1.比较（信2）；
}
});