我需要编写某种循环来计算字符串中每个字母的频率。
例如：“aasjjikkk”将计为2'a'，1''，2'j'，1'i'，3'k'。最终像这样的id最终会出现在一个地图中，其中字符为键，计数为值。有什么好主意怎么做？
答案 0 :(得分：30)
您可以使用java地图并将char映射到int。然后，您可以遍历字符串中的字符并检查它们是否已添加到地图中，如果有，则可以增加其值。
例如：
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
String s = "aasjjikkk";
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
Integer val = map.get(c);
if (val != null) {
map.put(c, new Integer(val + 1));
}
else {
map.put(c, 1);
}
}
最后你会得到你遇到的所有角色的数量，你可以从中提取它们的频率。
或者，您可以使用Bozho使用Multiset的解决方案并计算总发生次数。
答案 1 :(得分：15)
您可以使用Multiset（来自guava）。它会为您提供每个对象的计数。例如：
Multiset<Character> chars = HashMultiset.create();
for (int i = 0; i < string.length(); i++) {
chars.add(string.charAt(i));
}
然后，对于每个角色，您可以调用chars.count('a')并返回出现次数
答案 2 :(得分：7)
这样做的简洁方法是：
Map<Character,Integer> frequencies = new HashMap<>();
for (char ch : input.toCharArray())
frequencies.put(ch, frequencies.getOrDefault(ch, 0) + 1);
我们使用for-each循环遍历每个角色。如果key存在，则frequencies.getOrDefault()获取值或返回（作为默认值）其第二个参数。
答案 3 :(得分：4)
从JDK-8开始使用流API：
Map<Character, Long> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
，或者如果您希望键为整数：
Map<Character, Integer> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(c -> 1)));
另一个变体：
Map<Character, Integer> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.toMap(Function.identity(), c -> 1, Math::addExact));
答案 4 :(得分：4)
这是另一种解决方案，可能是狡猾的。
public char getNumChar(String s) {
char[] c = s.toCharArray();
String alphabet = "abcdefghijklmnopqrstuvwxyz";
int[] countArray = new int[26];
for (char x : c) {
for (int i = 0; i < alphabet.length(); i++) {
if (alphabet.charAt(i) == x) {
countArray[i]++;
}
}
}
java.util.HashMap<Integer, Character> countList = new java.util.HashMap<Integer, Character>();
for (int i = 0; i < 26; i++) {
countList.put(countArray[i], alphabet.charAt(i));
}
java.util.Arrays.sort(countArray);
int max = countArray[25];
return countList.get(max);
}
答案 5 :(得分：3)
嗯，想到两种方式，这取决于您的偏好：
按字符对数组进行排序。然后，计算每个字符变得微不足道。但是你必须先制作一个阵列的副本。
创建另一个大小为26的整数数组（比如freq），str是字符数组。
for(int i = 0; i < str.length; i ++)
freq[str[i] - 'a'] ++; //Assuming all characters are in lower case
因此'a'的数量将存储在freq [0]中，'z'的数量将存储在freq [25]
答案 6 :(得分：2)
这是一个解决方案：
定义您自己的Pair：
public class Pair
{
private char letter;
private int count;
public Pair(char letter, int count)
{
this.letter = letter;
this.count= count;
}
public char getLetter(){return key;}
public int getCount(){return count;}
}
然后你可以这样做：
public static Pair countCharFreq(String s)
{
String temp = s;
java.util.List<Pair> list = new java.util.ArrayList<Pair>();
while(temp.length() != 0)
{
list.add(new Pair(temp.charAt(0), countOccurrences(temp, temp.charAt(0))));
temp.replaceAll("[" + temp.charAt(0) +"]","");
}
}
public static int countOccurrences(String s, char c)
{
int count = 0;
for(int i = 0; i < s.length(); i++)
{
if(s.charAt(i) == c) count++;
}
return count;
}
答案 7 :(得分：2)
由于没有Java 8解决方案，想到发布一个。此外，这个解决方案比这里提到的其他一些解决方案更整洁，可读和简洁。
String string = "aasjjikkk";
Map<Character, Long> characterFrequency = string.chars() // creates an IntStream
.mapToObj(c -> (char) c) // converts the IntStream to Stream<Character>
.collect(Collectors.groupingBy(c -> c, Collectors.counting())); // creates a
// Map<Character, Long>
// where the Long is
// the frequency
答案 8 :(得分：1)
String s = "aaaabbbbcccddddd";
Map<Character, Integer> map = new HashMap<>();
在Java8中使用一行
s.chars().forEach(e->map.put((char)e, map.getOrDefault((char)e, 0) + 1));
答案 9 :(得分：1)
您可以使用Eclipse Collections中的CharAdapter和CharBag，并避免装箱到Character和Integer。
CharBag bag = CharAdapter.adapt("aasjjikkk").toBag();
Assert.assertEquals(2, bag.occurrencesOf('a'));
Assert.assertEquals(1, bag.occurrencesOf('s'));
Assert.assertEquals(2, bag.occurrencesOf('j'));
Assert.assertEquals(1, bag.occurrencesOf('i'));
Assert.assertEquals(3, bag.occurrencesOf('k'));
注意：我是Eclipse Collections的提交者。
答案 10 :(得分：0)
这是一种更有效的方法来计算字符串中字符的频率
public class demo {
public static void main(String[] args) {
String s = "babdcwertyuiuygf";
Map<Character, Integer> map = new TreeMap<>();
s.chars().forEach(e->map.put((char)e, map.getOrDefault((char)e, 0) + 1));
StringBuffer myValue = new StringBuffer();
String myMapKeyValue = "";
for (Map.Entry<Character, Integer> entry : map.entrySet()) {
myMapKeyValue = Character.toString(entry.getKey()).concat(
Integer.toString(entry.getValue()));
myValue.append(myMapKeyValue);
}
System.out.println(myValue);
}
}
答案 11 :(得分：0)
还有另一个选择，它看起来非常不错。 从Java 8开始，有新的方法合并java doc
public static void main(String[] args) {
String s = "aaabbbcca";
Map<Character, Integer> freqMap = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
Character c = s.charAt(i);
freqMap.merge(c, 1, (a, b) -> a + b);
}
freqMap.forEach((k, v) -> System.out.println(k + " and " + v));
}
答案 12 :(得分：0)
我们可以为此使用Collections类的频率方法。 将字符串拆分为字符串数组。使用HashSet删除重复项，并使用Collections的频率方法检查HashSet中每个对象的频率
void usingCollections(){
String input = "cuttack";
String [] stringArray = input.split("");
Set<String> s = new HashSet(Arrays.asList(stringArray));
for(String abc : s){
System.out.println (abc + ":"+Collections.frequency(Arrays.asList(stringArray),abc));
}
}
答案 13 :(得分：0)
#include<stdio.h>`
`#include <string.h>`
int main()
{
char s[1000];
int i,j,k,count=0,n;
printf("Enter the string : ");
gets(s);
for(j=0;s[j];j++);
n=j;
printf(" frequency count character in string:\n");
for(i=0;i<n;i++)
{
count=1;
if(s[i])
{
for(j=i+1;j<n;j++)
{
if(s[i]==s[j])
{
count++;
s[j]='\0';
}
}
printf(" '%c' = %d \n",s[i],count);
}
}
return 0;
}
答案 14 :(得分：0)
Uffh。您不认为这是最简单的解决方案吗？
pattern答案 15 :(得分：0)
*import java.util.ArrayList;
import java.util.Collections;
public class Freq {
public static void main(String[] args) {
// TODO Auto-generated method stub
String temp="zsaaqaaaaaaaabbbbbcc";
List<String> temp1= new ArrayList<String> ();
ArrayList<Integer>freq=new ArrayList<Integer>();
for(int i=0;i<temp.length()-1;i++)
{
temp1.add(Character.toString(temp.charAt(i)));
}
Set<String> uniqset=new HashSet<String>(temp1);
for(String s:uniqset)
{
freq.add(Collections.frequency(temp1, s));
System.out.println(s+" -->>"+Collections.frequency(temp1, s));
}
}
}
------Output-------
a -->>10
b -->>5
c -->>1
q -->>1
s -->>1
z -->>1
使用集合频率方法计算字符的频率*
答案 16 :(得分：0)
package com.dipu.string;
import java.util.HashMap;
import java.util.Map;
public class RepetativeCharInString {
public static void main(String[] args) {
String data = "aaabbbcccdddffffrss";
char[] charArray = data.toCharArray();
Map<Character, Integer> map = new HashMap<>();
for (char c : charArray) {
if (map.containsKey(c)) {
map.put(c, map.get(c) + 1);
} else {
map.put(c, 1);
}
}
System.out.println(map);
}
}
答案 17 :(得分：0)
使用地图合并方法的另一种方法
Map<Character, Integer> map = new HashMap<>();
String s = "aasjjikkk";
for (int i = 0; i < s.length(); i++) {
map.merge(s.charAt(i), 1, (l, r) -> l + r);
答案 18 :(得分：0)
问题：由用户获取字符串并获取每个字符的频率。!!!!!!!!!!
import java.util.HashMap;
import java.util.Scanner;
public class FrequencyPrograme {
public static void main(String str[]){
HashMap<Character,Integer> frequency=new HashMap<Character,Integer>();
Scanner inputString=new Scanner(System.in);
System.out.print("Please enter the string.");
String String =inputString.next();
for(int i=0; i<String .length();i++){
char ch=String .charAt(i);
Integer value=frequency.get(ch);
if(value!=null){
frequency.put(ch, new Integer(value+1));
}else{
frequency.put(ch, 1);
}
}
System.out.println(frequency);
}
}
答案 19 :(得分：0)
请尝试下面给出的代码，希望它对您有所帮助，
import java.util.Scanner;
class String55 {
public static int frequency(String s1,String s2)
{
int count=0;
char ch[]=s1.toCharArray();
char ch1[]=s2.toCharArray();
for (int i=0;i<ch.length-1; i++)
{
int k=i;
int j1=i+1;
int j=0;
int j11=j;
int j2=j+1;
{
while(k<ch.length && j11<ch1.length && ch[k]==ch1[j11])
{
k++;
j11++;
}
int l=k+j1;
int m=j11+j2;
if( l== m)
{
count=1;
count++;
}
}
}
return count;
}
public static void main (String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("enter the pattern");
String s1=sc.next();
System.out.println("enter the String");
String s2=sc.next();
int res=frequency(s1, s2);
System.out.println("FREQUENCY==" +res);
}
}
示例输出： 进入模式 人 输入字符串 dhimanman FREQUENCY == 2
谢谢你。快乐编码。
答案 20 :(得分：0)
使用HashMap缩短可能的代码。 （没有有力的线路保存）
private static Map<Character, Integer> findCharacterFrequency(String str) {
Map<Character, Integer> map = new HashMap<>();
for (char ch : str.toCharArray()) {
/* Using getOrDefault(), since Java1.8 */
map.put(ch, map.getOrDefault(ch, 0) + 1);
}
return map;
}
答案 21 :(得分：0)
package com.rishi.zava;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class ZipString {
public static void main(String arg[]) {
String input = "aaaajjjgggtttssvvkkllaaiiikk";
int len = input.length();
Map<Character, Integer> zip = new HashMap<Character, Integer>();
for (int j = 0; len > j; j++) {
int count = 0;
for (int i = 0; len > i; i++) {
if (input.charAt(j) == input.charAt(i)) {
count++;
}
}
zip.put(input.charAt(j), count);
}
StringBuffer myValue = new StringBuffer();
String myMapKeyValue = "";
for (Entry<Character, Integer> entry : zip.entrySet()) {
myMapKeyValue = Character.toString(entry.getKey()).concat(
Integer.toString(entry.getValue()));
myValue.append(myMapKeyValue);
}
System.out.println(myValue);
}
}
输入 = aaaajjjgggtttssvvkklaaiiikk
输出 = a6s2t3v2g3i3j3k4l2
答案 22 :(得分：0)
import java.util.*;
class Charfrequency
{
public static void main(String a[]){
Scanner sc=new Scanner(System.in);
System.out.println("Enter Your String :");
String s1=sc.nextLine();
int count,j=1;
char var='a';
char ch[]=s1.toCharArray();
while(j<=26)
{
count=0;
for(int i=0; i<s1.length(); i++)
{
if(ch[i]==var || ch[i]==var-32)
{
count++;
}
}
if(count>0){
System.out.println("Frequency of "+var+" is "+count);
}
var++;
j++;
}
}
}
答案 23 :(得分：0)
NOTE, this will also count the frequencies of empty spaces
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
public class FrequenceyOfCharacters {
public static void main(String[] args) {
System.out.println("Please enter the string to count each character frequencey: ");
Scanner sc=new Scanner(System.in);
String input=sc.nextLine();
frequenceyCount(input);
}
private static void frequenceyCount(String input) {
Map<Character,Integer> hashCount=new HashMap<>();
Character c;
for(int i=0; i<input.length();i++)
{
c =input.charAt(i);
if(hashCount.get(c)!=null){
hashCount.put(c, hashCount.get(c)+1);
}else{
hashCount.put(c, 1);
}
}
Iterator it = hashCount.entrySet().iterator();
System.out.println("char : frequency");
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry)it.next();
System.out.println(pairs.getKey() + " : " + pairs.getValue());
it.remove();
}
}
}
答案 24 :(得分：0)
这与xunil154的答案类似，不同之处在于字符串是char数组，链接的hashmap用于维护字符的插入顺序。
String text = "aasjjikkk";
char[] charArray = text.toCharArray();
Map<Character, Integer> freqList = new LinkedHashMap<Character, Integer>();
for(char key : charArray) {
if(freqList.containsKey(key)) {
freqList.put(key, freqList.get(key) + 1);
} else
freqList.put(key, 1);
}
答案 25 :(得分：0)
您可以使用Hashtable将每个字符作为键，总计数将成为值。
Hashtable<Character,Integer> table = new Hashtable<Character,Integer>();
String str = "aasjjikkk";
for( c in str ) {
if( table.get(c) == null )
table.put(c,1);
else
table.put(c,table.get(c) + 1);
}
for( elem in table ) {
println "elem:" + elem;
}
答案 26 :(得分：0)
如果这不需要超快，只需创建一个整数数组，每个字母一个整数（只有字母，所以2 * 26整数？或任何二进制数据可能吗？）。一次遍历字符串一个字符串，得到负责整数的索引（例如，如果你只有字母字符，你可以让'A'在索引0处，并通过减去任何'A'到'Z'得到该索引'A'就是如何获得合理快速索引的示例）并增加该索引中的值。
有各种微优化可以加快速度（如有必要）。
答案 27 :(得分：-1)
import java.io.FileInputStream;
import java.util.HashSet;
import java.util.Iterator;
public class CountFrequencyOfCharater {
public static void main(String args[]) throws Exception
{
HashSet hs=new HashSet();
String str="hey how are you?";
char arr[]=new char[str.length()];
for(int i=0;i<str.length();i++)
{
arr[i]=str.charAt(i);
}
for(int j=0;j<str.length();j++)
{
int c=0;
for(int k=0;k<str.length();k++)
{
if(arr[j]==arr[k])
c++;
}
hs.add(arr[j]+"="+c+",");
}
Iterator it=hs.iterator();
while(it.hasNext())
{
System.out.print(it.next());
}
}
}