计算字符串中的字符出现次数（频率）

Question

我有这个 GUI 可以计算字符串中第一个字母的出现次数。我希望它以列格式计算所有字母，例如：

这是我目前所拥有的：

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JPanel;  
import javax.swing.JTabbedPane;  
import javax.swing.JTextField;  
public class Index2 extends JFrame implements ActionListener  
{  
    private JTabbedPane jtabbedPane;  
    private JPanel characterFinder;  
    JTextField enterText, countText;  

    public Index2()  
    {  
        setSize(400, 250);  
        setVisible(true);  
        setSize(400, 250);  
        setVisible(true);  
        setTitle("Total Characters");  
        setSize(300, 200);  
        JPanel topPanel = new JPanel();  
        topPanel.setLayout(new BorderLayout());  
        getContentPane().add(topPanel);  
        createCharacterFinder();  
        jtabbedPane = new JTabbedPane();  
        jtabbedPane.addTab("Count Characters", characterFinder); 
        topPanel.add(jtabbedPane, BorderLayout.CENTER);  
    }
    public void createCharacterFinder()  
    {  
        characterFinder = new JPanel();  
        characterFinder.setLayout(null); 
        JLabel enterLabel = new JLabel(  
                "Enter Some Text");  
        enterLabel.setBounds(90, 5, 260, 20);  
        characterFinder.add(enterLabel); 
        enterText = new JTextField();  
        enterText.setBounds(10, 30, 270, 70);  
        characterFinder.add(enterText);  

        JButton search = new JButton("Count Occurences of Each Letter");  
        search.setBounds(15, 100, 260, 20);  
        search.addActionListener(this);  
        characterFinder.add(search);

        countText = new JTextField();  
        countText.setBounds(80, 130, 120, 500);  
        characterFinder.add(countText);
    }
        public void actionPerformed(ActionEvent e){
            String st=enterText.getText();
            char searchedChar=enterText.getText().charAt(0);
            count(searchedChar,st);
    }
    public int count(char c, String str) {
        if (str == null) return 0;
        int cnt = 0;
        for (int i = 0;; cnt++) {
        if ((i = str.indexOf(c,i)+1) == 0) break;
        }
        countText.setText("Character "+c+" occurs "+cnt+" times");
        return cnt;
        }

    public static void main(String[] args)  
    {  
        JFrame frame = new Index2();  
        frame.setSize(300, 700);  
        frame.setVisible(true);  
    }  
}

Answer 1

计算字符数（假设为 ASCII 字符）的一个好方法是利用 'a' 可以直接映射到数字的事实。

int[] charCounts(String s) {
  int[] counts = new int[256]; // maximum value of an ASCII character
  char[] c = s.toCharArray();
  for (int i=0;i<c.length;++i) {
      counts[c[i]]++;
  }
  return counts;
}

现在要查找您可以执行的任何特定元素的计数counts['a']。

使用上面的方法预先计算计数，然后用非常粗略的方式显示计数可能会使代码更整洁：

int[] counts = charCounts("my string");
StringBuilder sb = new StringBuilder();
for (char a = 'a'; a <= 'z'; a++) {
    sb.append(a).append(" occurred ").append(counts[a]).append(" times\n");
}

Answer 2

嗯，好吧 你可以创建一个Hashmap

HashMap<Char, Integer> countedChars = new HashMap<Char, Integer>();

并使用此方法解析字符串的每个字符：

private void parseChar(String c) {
   if (!this.countedChars.containsKey(c)) {
       this.countedChars.put(c, 1);
   } else
       this.countedChars.put(c, this.countedChars.get(c)+1);
}

Answer 3

要计算字符串中的字符出现次数（每个字符的使用频率），我建议使用此优化版本：

在大多数情况下使用 int[] 和 SortedMap<> 用于 Unicode 字符，避免由于自动装箱而隐藏的 Integer 实例化：

import java.util.Map.Entry;
import java.util.SortedMap;
import java.util.TreeMap;

public class CharCount {
   static class MutableInteger {
      int value;
      public MutableInteger( int v ) {
         value = v;
      }
      public void increment() {
         ++value;
      }
   }
   public static void main( String[] args ) {
      String string = "alabama&é€";
      int    len = string.length();
      int[]  freqArray = new int[255];
      SortedMap< Character, MutableInteger > freqMap = null;
      for( int i = 0; i < len; ++i )
      {
         char c = string.charAt( i );
         if( c < freqArray.length ) {
            ++freqArray[c];
         }
         else { // Unicode
            if( freqMap == null ) { // first use
               freqMap = new TreeMap<>();
            }
            MutableInteger f = freqMap.get( c );
            if( f == null ) {
               freqMap.put( c, new MutableInteger( 1 ));
            }
            else {
               f.increment();
            }
         }
      }
      for( int i = 0; i < freqArray.length; ++i ) {
         int v = freqArray[i];
         if( v > 0 ) {
            System.out.printf( "%c (%4d) : %d\n", (char)i, i, v );
         }
      }
      if( freqMap != null ) {
         for( Entry< Character, MutableInteger > entry : freqMap.entrySet()) {
            char c = entry.getKey().charValue();
            int v = entry.getValue().value;
            System.out.printf( "%c (%4d) : %d\n", c, (int)c, v );
         }
      }
   }
}

输出：

& (  38) : 1
a (  97) : 4
b (  98) : 1
l ( 108) : 1
m ( 109) : 1
é ( 233) : 1
€ (8364) : 1

Answer 4

计算字符串中第一个字母的出现次数。我希望它计算所有字母

这里它通过第一个字符

char searchedChar=enterText.getText().charAt(0);

如果你需要考虑每个字符，那么

char[] charsToSearch =enterText.getText().toCharArray();//and invoke method for each char

Answer 5

import java.util.*;

public class CharsCounter {

    public Map<Character, Integer> count(String input) {
        char[] chars = (input + '\uFFFF').toCharArray();
        Arrays.sort(chars);

        Map<Character, Integer> charsCount = new LinkedHashMap<Character, Integer>();
        int first = 0;
        for (int i = 1; i < chars.length; i++) {
            if (chars[i] != chars[first]) {
                charsCount.put(chars[first], i - first);
                first = i;
            }
        }

        return charsCount;
    }

}