Java 如何计算字符串中字符的频率？

我需要写一些循环，可以计算字符串中每个字母的频率
例如：“aasjjikkk”将计算2'a'，1's'，2'j'，1'i'，3'k'。最终，我希望它们最终出现在一个以字符为键、以计数为值的映射中。有什么好办法吗

您可以使用（从）。它将为您提供每个对象的计数。例如：

Multiset<Character> chars = HashMultiset.create();
for (int i = 0; i < string.length(); i++) {
    chars.add(string.charAt(i));
}

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);
   }
}

Multiset chars=HashMultiset.create（）；
对于（int i=0；i

---

然后，对于每个字符，您可以调用

chars.count（'a'）

，它返回出现的次数

如果不需要超快速，只需创建一个整数数组，每个字母一个整数（仅字母so 2*26整数？或任何可能的二进制数据？）。一次遍历字符串一个字符，获取负责整数的索引（例如，如果您只有字母字符，则可以将“a”置于索引0处，并通过将“a”减去“Z”中的任何“a”来获取该索引，这只是一个如何获得相当快的索引的示例）并增加该索引中的值

---

有各种各样的微优化可以加快速度（如有必要）。

好吧，有两种方法可以考虑，这取决于您的偏好：

按字符对数组进行排序。然后，计算每个字符就变得很简单了。但您必须先制作阵列的副本

创建另一个大小为26（比如freq）的整数数组，str是字符数组

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);
        }

for（int i=0；i

freq[str[i]-'a']++//假设所有字符都是小写的

---

因此，“a”的数量将存储在频率[0]处，“z”的数量将存储在频率[25]

您可以使用java映射并将

char

映射到

int

。然后可以迭代字符串中的字符，检查它们是否已添加到映射中，如果已添加，则可以增加其值

例如：

Multiset<Character> chars = HashMultiset.create();
for (int i = 0; i < string.length(); i++) {
    chars.add(string.charAt(i));
}

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);
   }
}

HashMap map=newhashmap（）；
字符串s=“aasjjikkk”；
对于（int i=0；i

最后，你将有一个你遇到的所有字符的计数，你可以从中提取它们的频率

---

或者，您可以使用Bozho的解决方案，即使用多集并计算总发生次数。

您可以使用哈希表，每个字符作为键，总计数成为值

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;
}

Hashtable=newhashtable（）；
String str=“aasjjikkk”；
对于（str中的c）{
if（table.get（c）==null）
表1.put（c，1）；
其他的
table.put（c，table.get（c）+1）；
}
用于（表中的元素）{
println“elem:+elem；
}

这里有一个解决方案：

定义您自己的

对

：

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;
}

公共静态对countCharFreq（字符串s）
{
字符串温度=s；
java.util.List List=new java.util.ArrayList（）；
while（临时长度（）！=0）
{
添加（新对（临时字符（0），计数出现次数（临时，临时字符（0）））；
临时替换全部（“[”+临时字符（0）+“]”，”）；
}
}
公共静态整数计数（字符串s，字符c）
{
整数计数=0；
对于（int i=0；i

这是另一种解决方案，尽管可能很狡猾

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);
}

public char getNumChar（字符串s）{
char[]c=s.toCharArray（）；
字符串字母表=“abcdefghijklmnopqrstuvxyz”；
int[]countArray=新int[26]；
用于（字符x:c）{
对于（int i=0；i

这与xunil154的答案类似，不同之处在于字符串是一个字符数组，链接的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);
        }

String text=“aasjjikkk”；
char[]charArray=text.toCharArray（）；
Map freqList=新建LinkedHashMap（）；
for（字符键：charArray）{
if（频率列表.容器（键））{
freqList.put（key，freqList.get（key）+1）；
}否则
频率列表。输入（键，1）；
}

导入java.io.FileInputStream；
导入java.util.HashSet；
导入java.util.Iterator；
公共类计数字符的频率{
公共静态void main（字符串args[]）引发异常
{
HashSet hs=新的HashSet（）；
String str=“你好吗？”；
char arr[]=新字符[str.length（）]；
对于（inti=0；i
import java.util.HashMap；
导入java.util.Iterator；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.Scanner；
公共类频率YOFCharacters{
公共静态void main（字符串[]args）{
System.out.println（“请输入字符串以计算每个字符的频率：”）；
扫描仪sc=新的扫描仪（System.in）；
字符串s=sc.nextLine（）；
String input=s.replaceAll（“\\s”，”）；//删除空格。
频率计数（输入）；
}
专用静态无效频率计数（字符串输入）{
Map hashCount=new HashMap（）；
字符c；
对于（inti=0；i
importjava.util.*；
类Charfrequency
{
公共静态void main（字符串a[]{
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入字符串：”）；
字符串s1=sc.nextLine（）；
整数计数，j=1；
char var='a'；
char ch[]=s1.toCharArray（）；
而（j
package com.rishi.zava；
导入java.util.HashMa
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);
    }
}

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;
    }

Map<Character,Integer> frequencies = new HashMap<>();
for (char ch : input.toCharArray()) 
   frequencies.put(ch, frequencies.getOrDefault(ch, 0) + 1);

CharBag bag = Strings.asChars("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'));

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

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);

    }
}

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));

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);

    }
}

*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

String s = "aaaabbbbcccddddd";
Map<Character, Integer> map = new HashMap<>();

s.chars().forEach(e->map.put((char)e, map.getOrDefault((char)e, 0) + 1));

    char inputChar = '|';
    int freq = "|fd|fdfd|f dfd|fd".replaceAll("[^" + inputChar +"]", "").length();
    System.out.println("freq " + freq);

 #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;
}

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));

  }
}

  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));
}

       for (Character c : s.toCharArray()) {
            freqMapSecond.merge(c, 1, Integer::sum);
           }

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);
    }
}

   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);