取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2).


有谁能给个解题思路？？？？？？？？？？？？？

这个题我认为是这样的，但是也不确定对不对，仅供参考
首先呢将字符串转换成字符数组，因为要对每一个字母进行操作。
然后定义一个map集合，因为打印结果的字母有顺序，所以使用
TreeMap集合。
再遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null,将该字母和1存入map集合中。
如果返回不是null,说明该字母在map集合已经
存在并有对应次数。
那么就获取该次数并进行自增，然后将该字母
和自增次数存入到map集合中，覆盖掉原来键所
对应的值。
4.将map集合中的数据变成指定的字符串形式返回。

*/
import java.util.*;
class MapTest3 {
        public static void main(String[] args) {
                String s = "sdfg,.zxcuasdfxcdfg<<>2vdf";
                char[] c = s.toCharArray();
                TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
                Set<Character> keySet = tm.keySet();

                for (int i = 0;i < c.length ;i++ ) {
                        //计算字母出现的次数，不包括特殊字符
                        if (c[i] >= 'a' && c[i] <= 'z' || c[i] >='A' && c[i] <= 'z') {
                                if (!(tm.containsKey(c[i]))) {
                                        tm.put(c[i],1);
                                } else {
                                  int count = tm.get(c[i]) + 1;
                                  tm.put(c[i],count);
                                }
                        }
                }
                Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
                Iterator<Map.Entry<Character,Integer>> iter = entrySet.iterator();
                while (iter.hasNext()) {
                        Map.Entry<Character,Integer> me = iter.next();
                        System.out.print(me.getKey()+"("+me.getValue()+")");
                }
                //Iterator<Character> it = keySet.iterator();
        }
}

import java.util.Set;
import java.util.TreeMap;

* 分析：输出格式类似键值对的形式（字符和对应的数字），考虑用Map集合
*                 Map集合中TreeMap和HashMap都可实现该输出格式
*                 如果用TreeMap，可按自然排序输出
*                 如果用HashMap，输出顺序非自然排序
*         最终，选择用TreeMap集合
*/
public class Test1 {
        public static void main(String[] args) {
                // 创建TreeMap对象，键值类型分别为Character和Integer
                TreeMap<Character, Integer> trm = new TreeMap<Character, Integer>();
                // 定义一个要被查找的字符串
                String srct = "abcdehelloworldjava";
                // 把字符串转为字符数组
                char[] chs = srct.toCharArray();
               
                // 遍历字符数组，字符作为键，去找集合中该键对应的值
                // 如果返回值为null，说明该键不存在，就把该字符作为作为键，1作为值存储
                // 如果返回值不是null，说明该键存在，就把值加1，然后重新存储该键和值
                for (char ch : chs) {
                                Integer value = trm.get(ch);
                                if ( value== null) {
                                        value = 1;
                                        trm.put(ch, value);
                                } else {
                                        value++;
                                        trm.put(ch, value);
                                }
                }
                //用StringBuilder类型的变量进行结果的拼接
                StringBuilder sb = new StringBuilder();
                //获取多有的键
                Set<Character> keys = trm.keySet();
                //遍历集合，得到键和值进行按要求拼接
                for (Character key : keys) {
                        Integer val = trm.get(key);
                        sb.append((char) key).append("(").append(val).append(")");
                }
                //把StringBuilder类型转为字符串输出
                String s = new String(sb);
                System.out.println(s);
        }
}

import java.util.Scanner;
public class Test4{  
    public static void main(String[] args)
    {  
           

            System.out.print("字符串:");

        //实例化Scanner工具类,获取封装后的标准输入流

        Scanner input = new Scanner(System.in);
//将输入流转化为字符串
        String str = input.nextLine();
        input.close();
      //字符串转化为字符数组
        char[] array = str.toCharArray();
            char x='a';       
            char a=0;
            System.out.print("输出格式为:");
            for(;x<='z';x++)
            {int k=0;
            for(int i=0;i<array.length;i++)
            {
                    a=array[i];              
                    if(a==x)                          //判断读取字符是否为'x'，若是，k自加，k表示读取次数
                            k++;
            }
       if(k!=0)
            System.out.print(x+"("+k+")");
            }


    }
   
}  

二十六个字母整体遍历一遍，依次取每一个字母与给定字符串比较，记录相同字符个数，同时输出System.out.print(x+"("+k+")");“x“依次代表二十六个字母，“k”是记录数

        public static void main(String[] args) {
                int numa=0;
                int numb=0;
                int numk=0;       
                String s="abcdekka27qoq";
                char[] charArray = s.toCharArray();
                for (int i = 0; i < charArray.length; i++) {
                        if (charArray[i]=='a') {
                                numa++;
                        }else if(charArray[i]=='b'){
                                numb++;
                        }else if(charArray[i]=='k'){
                                numk++;
                        }
                }
                System.out.println("a("+numa+")b("+numb+")k("+numk+")");
        }

1. /*
   
2. * 需求：取出一个字符串中字母出现的次数。
   
3. * 如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2).
   
4. * 思路：用一个数组代表26个字母，每遇到一个字母，找到该字母在数组中的位置++即可。
   
5. */
   
6. class Test
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 String str = "abcdekka27qoq";
    
11.                 int[] arr = new int[26];
    
12.                 charCounts(str, arr);
    
13.                 for(int i=0; i<arr.length; i++)
    
14.                 {
    
15.                         if(arr[i]==0)
    
16.                                 continue;
    
17.                         System.out.print((char)(i+'a')+"("+arr[i]+")");
    
18.                 }
    
19.         }
    
20. 
    
21.         public static void charCounts(String str, int[] arr)
    
22.         {
    
23.                 for(int i=0; i<str.length(); i++)
    
24.                 {
    
25.                         char c = str.charAt(i);
    
26.                         if(c >= 'a' && c <= 'z')
    
27.                         {
    
28.                                 arr[c - 'a']++;
    
29.                         }
    
30.                 }
    
31.         }
    
32. }
    

复制代码

a(2)b(1)c(1)d(1)e(1)k(2)o(1)q(2)

特别深奥的感觉，看看。

这个还是比较简单的,如果需要按出现次数的高低来给结果排序,这个题目就有深度了.如果不需要排序,就像楼上说的那样,设置一个数组来按顺序代表字母,没遇到一个字母就在对该数组元素执行加1操作,这是基本解决方法.如果需要对结果排序的话,我有一个思路就是用结构体数组储存字母和字母出现的相应次数,最后根据次数对结构体数组排序即可.下面我给一个统计字母A/B/C/D出现次数的代码(26个字母的解答思路可以套用)

1. //从键盘输入一大堆字符串，统计A、B、C、D的出现次数，最后出现次数由高到低输出字母和出现次数。
   
2. //主要思路：将字母和相应出现的次数存储在一个结构体数组中，统计后再根据字母出现的次数对结构体数组排序
   
3. #include <stdio.h>
   
4. #define N 40
   
5. 
   
6. //创建一个包含两个变量的结构体
   
7. struct letter_num
   
8. {
   
9.     //letter表示要统计的字母
   
10.     char letter;
    
11.     //变量count表示相应字母出现的次数
    
12.     int count;
    
13. };
    
14. 
    
15. //使用冒泡排序对结构体数组重新排序
    
16. void sort(struct letter_num arr[], int n)
    
17. {
    
18.     //创建一个结构体临时变量tmp
    
19.     struct letter_num tmp;
    
20.     for (int i = 0; i < n - 1; i++)
    
21.     {
    
22.         for (int j = 0; j < n - 1 - i; j++) {
    
23.             /*当结构体数组中靠后的元素count值更大时，靠后的结构体元素
    
24.              与靠前的结构体数组互换位置
    
25.             */
    
26.             if (arr[j + 1].count > arr[j].count ) {
    
27.                 tmp = arr[j];
    
28.                 arr[j] = arr[j + 1];
    
29.                 arr[j + 1] = tmp;
    
30.             }
    
31.         }
    
32.     }
    
33. }
    
34. 
    
35. int main()
    
36. {
    
37.     //为结构体数组中每个元素的letter分别赋值为A/B/C/D
    
38.     struct letter_num myLetter_num[4];
    
39.     for (int m = 0; m < 4; m ++) {
    
40.         myLetter_num[m].letter = 'A' + m;
    
41.     }
    
42.    
    
43.     //将结构体数组中所有的count都赋值为0
    
44.     for (int n = 0; n < 4; n++) {
    
45.         myLetter_num[n].count = 0;
    
46.     }
    
47. 
    
48.     printf("请输入一个字符串:");
    
49.     //定义一个字符串，长度为N
    
50.     char str[N];
    
51.     //从键盘获取用户输入
    
52.     fgets(str, N, stdin);
    
53.     //对字符串进行循环处理，直到读完字符串。
    
54.     for (int i = 0; str[i] != '\0'; i++) {
    
55.         //对字符串中的每个字符进行判断，如果该字符是A,则count[0]自增1，
    
56.         //以此类推，当字符是B/C/D的时候，count[1]/count[2]/count[3]分别自增1
    
57.         if (str[i] == 'A')
    
58.             myLetter_num[0].count++;
    
59.         if (str[i] == 'B')
    
60.             myLetter_num[1].count++;
    
61.         if (str[i] == 'C')
    
62.             myLetter_num[2].count++;
    
63.         if (str[i] == 'D')
    
64.             myLetter_num[3].count++;
    
65.     }
    
66.    
    
67.     //调用排序函数对得到的结构体数组排序
    
68.     sort(myLetter_num, 4);
    
69.    
    
70.     //按顺序打印出A/B/C/D这几个元素在字符串中出现的次数
    
71.     for (int j = 0; j < 4; j++) {
    
72.         printf("%c(%d)\n",myLetter_num[j].letter, myLetter_num[j].count);
    
73.     }
    
74.     return 0;
    
75. }
    

复制代码

只要思路的话
1.将字符串转换成字符数组
2.用TreeMap集合来存储，用key来保存每个字符，value来记录次数，默认值设置1
3.通过for循环来遍历字符数组，将每个字符存入TreeMap集合，如果集合中有相同的元素，value就+1
4.循环结束，TreeMap集合中记录的就是每个字符Key,对应出现的次数value
5.在通过for循环来输出System.out.print(key + "(" + value + ")");
通过以上步骤就能得到你想要的结果

学习oc的时候看老师的视频讲过这个问题，1用一个循环遍历这个字符串，2，统计字符的出现的个数 3，返回最终的个数  

我觉得是这样的
首先呢将字符串转换成字符数组，因为要对每一个字母进行操作。
然后定义一个map集合，因为打印结果的字母有顺序，所以使用
TreeMap集合。
再遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null,将该字母和1存入map集合中。
如果返回不是null,说明该字母在map集合已经
存在并有对应次数。
那么就获取该次数并进行自增，然后将该字母
和自增次数存入到map集合中，覆盖掉原来键所
对应的值。
4.将map集合中的数据变成指定的字符串形式返回。

*/
import java.util.*;
class MapTest3 {
        public static void main(String[] args) {
                String s = "sdfg,.zxcuasdfxcdfg<<>2vdf";
                char[] c = s.toCharArray();
                TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
                Set<Character> keySet = tm.keySet();

                for (int i = 0;i < c.length ;i++ ) {
                        //计算字母出现的次数，不包括特殊字符
                        if (c[i] >= 'a' && c[i] <= 'z' || c[i] >='A' && c[i] <= 'z') {
                                if (!(tm.containsKey(c[i]))) {
                                        tm.put(c[i],1);
                                } else {
                                  int count = tm.get(c[i]) + 1;
                                  tm.put(c[i],count);
                                }
                        }
                }
                Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
                Iterator<Map.Entry<Character,Integer>> iter = entrySet.iterator();
                while (iter.hasNext()) {
                        Map.Entry<Character,Integer> me = iter.next();
                        System.out.print(me.getKey()+"("+me.getValue()+")");
                }
                //Iterator<Character> it = keySet.iterator();
        }
}

package day12zuoye;

public class Demo_2 {

        /**
         * 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，
         * 输出格式为：a(2)b(1)k(2)...
         */
        public static void main(String[] args) {
                String s="abcdekka27qoq"; //
                int numa=0;
                int numb=0;
                int numk=0;
                for (int i = 0; i < s.length(); i++) {
                        char c=s.charAt(i);   //遍历出没个索引下的字符
                        if(c=='a'){//然后判断是a就自增一次,下面的b,k一样的道理最后输出
                                numa++;
                        }else if(c=='b'){
                                numb++;
                        }else if (c=='k'){
                                numk++;
                        }else{
                               
                        }
                }
                System.out.println("a("+numa+")b("+numb+")k("+numk+").......");
               
        }

}