Question

我正在尝试编写一个代码，用于查找方法中输入的字符串中的字符频率（phraseList()是一个已经有效的方法，它接受一个单词并将每个字符放在arrayList中）并返回一个新的List，其中包含字母及其频率，我的代码如下;

public List <String> ltrfrq(String phrase){
List <String> list0 = new ArrayList<String>();
int count = 1;
List <String> list = phraseList(phrase.toUpperCase());
for(int i = 0; i < list.size(); i++){
  for(int j = i + 1; j < list.size(); j++){
    if(list.get(i).equals(list.get(j))){
      count++;
    }
  }
  if(list.get(i).equals(" ")){
    list0.add("Space" + "-" + count);
  }
  else{
    list0.add(list.get(i) + "-" + count);
  }
  count = 1;
}
return list0;
  }
}

我的问题是，它返回所有字母，虽然我尝试了很多方法来删除它们，就像使用remove()方法一样，但它仍然不起作用，我有类似的东西

list.remove(list.get(i));
i--;

任何人都可以帮助我吗？

Answer 1

HashMaps是键值对。但钥匙是独一无二的。所以你不能有重复的密钥。有点像字典，你可以更新一个单词的值（定义），但你不会把这个单词列出两次。

观看：https://www.youtube.com/watch?v=j442WG8YzM4

阅读：https://beginnersbook.com/2013/12/hashmap-in-java-with-example/

输出：

{a=4, b=3, c=2, d=1}

我会把它作为练习让你穿越地图。

import java.util.HashMap;

public class F {

  public static void main(String[] args) {

    String string = "aaaabbbccd";

    HashMap<Character, Integer> map = frequency(string);

    System.out.println(map);
  }

  public static HashMap<Character, Integer> frequency(String string) {
    int length = string.length();
    char c;

    HashMap<Character, Integer> map = new HashMap<Character, Integer>();

    for (int i = 0; i < length; i++) {
      c = string.charAt(i);

      if (map.containsKey(c)) {
        map.put(c, map.get(c) + 1);

      } else {

        map.put(c, 1);
      }
    }

    return map;
  }
}

Answer 2

如果我只能使用List数据结构（以及我自己的自定义数据结构），我就是这样做的。我将重新定义所有添加，删除函数以补偿重复的条目。

输出：

[{a=4}, {b=3}, {c=2}, {d=1}]

代码：

import java.util.List;
import java.util.ArrayList;

public class F {

  static class Entry {
    char character;
    int count;

    public Entry(char c, int i) {
      character = c;
      count = i;
    }

    public String toString() {
      return "{" + character + "=" + count + "}";
    }
  }

  public static void main(String[] args) {

    String string = "aaaabbbccd";

    List<Entry> list = frequency(string);

    System.out.println(list);
  }


  public static List<Entry> frequency(String string) {
    int length = string.length();
    char c;
    Entry entry;

    List<Entry> list = new ArrayList<Entry>();

    for (int i = 0; i < length; i++) {
      c = string.charAt(i);

      // add to list
      add(c, list);
    }

    return list;
  }

  public static void add(char c, List<Entry> list) {

    // If the list does not contain the character
    if (!contains(c, list)) {
      list.add(new Entry(c, 1));

    } else {

      // Find the entry
      int index = find(c, list);

      // If we found the entry's indes
      if (index >= 0) {

        // Get the entry
        Entry temp = list.get(index);

        temp.count++;           // Increment its count
        list.remove(index);     // Delete old 1
        list.add(index, temp);  // Insert new 1
      }
    }
  }

  // Finds the index of an entry thats associated with a character
  public static int find(char c, List<Entry> list) {
    int index = -1;
    int length = list.size();


    Entry temp;


    for (int i = 0; i < length; i++) {
      temp = list.get(i);

      if (temp.character == c) {
        index = i;
        break;
      }
    }


    return index;
  }

  // Remove an Entry from list that is associate with a given character
  public static List<Entry> remove(char c, List<Entry> list) {

    for (Entry entry : list) {
      if (entry.character == c) {
        list.remove(entry);
      }
    }

    return list;
  }

  // Get the entry that correlates to a give character in the list
  public static Entry get(char c, List<Entry> list) {
    Entry entryToReturn = null;

    for (Entry entry : list) {
      if (entry.character == c) {
        entryToReturn = entry;
        break;
      }
    }

    return entryToReturn;
  }


  // Checks if the list contains the character
  public static boolean contains(char c, List<Entry> list) {
    boolean contains = false;

    for (Entry entry : list) {
      if (entry.character == c) {
        contains = true;
        break;
      }
    }

    return contains;
  }
}

Answer 3

HashMap是解决此问题的更简单方法。如果必须使用List，则可以先检查list0中是否存在该字符。如果list0中不存在该字符，则计算其频率。

更新代码：

public static void main(String args[]){
    ArrayList <String> list0 = new ArrayList<String>();
        int count = 1;
        //List <String> list = phraseList(phrase.toUpperCase());\
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("a");
        list.add("c");
        list.add("b");
        list.add("a");

        for(int i = 0; i < list.size(); i++){
            boolean isDuplicate = false;
             for (String s: list0){
                 if (s.contains(list.get(i).trim()))
                     isDuplicate =true;
             }

            if (!isDuplicate){

                  for(int j = i + 1; j < list.size(); j++){
                    if(list.get(i).equals(list.get(j))){
                      count++;
                    }
                  }
                  if(list.get(i).equals("/s")){
                    list0.add("Space" + "-" + count);
                  }
                  else{
                    list0.add(list.get(i) + "-" + count);
                  }
                  count = 1;     
            }
        }
        for (String a: list0)
            System.out.println(a);          
}

Answer 4

以下是使用Java8 merge()上提供的新方法Map的方法。

import java.util.HashMap;
import java.util.Map;

public class CountLetterFrequency {

    public static void main(String[] args) {
        System.out.println(ltrfrq("abacacdea"));
    }

    public static Map<Character, Integer> ltrfrq(String phrase){
        Map<Character, Integer> frqMap = new HashMap<>(); 
        for(int i=0; i<phrase.length(); i++){
            frqMap.merge(phrase.charAt(i), 1, Integer::sum);
        }
        return frqMap;
    }
}

输出：

{a=4, b=1, c=2, d=1, e=1}

使用方法merge()，当项目不在地图中时，它只会添加它，在这种情况下会添加key=charAt(i),value=1。另一方面，如果键已经在地图上，则merge调用一个传递当前值和新值的函数，并使用此函数的结果更新映射。

Integer::sum是一个方法参考，因为merge方法需要一个带有两个参数的函数，我们可以将其重写为(currV,newV) -> currV+newV。

现在，如果您愿意，可以使用新的Stream API。首先，将String转换为IntStream，然后将每个int映射到Character，然后在HashMap上收集结果并将其返回。方法ltrfrq如下：

public static Map<Character, Integer> ltrfrq(String phrase){
    return phrase.chars()
        .mapToObj(i->(char)i)
        .collect(HashMap::new,
            (m,k) -> m.merge(k, 1, Integer::sum),
            Map::putAll);
}

ArrayList中元素的频率

4 个答案: