public class Test06 {

         /*
                    *取出一个字符串中字母出现的次数。如："abcdekka27qoq"  a(2)b(1)k(2)...
         */
         
         public static void main(String[] args) {
                 count("abcdekka27qoq");
         }

         public static void count(String string) {
                 String s1 = "";
                 
                 char[] arr = string.toCharArray();
                 int i = 1;
                 
                 for (char c : arr) {
                         if (Character.isLetter(c)){
                                 i = countTime(c, arr.toString());
                                 
                                 s1 = s1 + c+"("+ i +")";
                                 System.out.println(s1);
                         }
                 }
                 
         }

         private static int countTime(char key, String string) {
                 char[] arr = string.toCharArray();
                 int times = 0;
                 for (int i = 0; i < arr.length; i++ ) {
                         if (arr== key){
                                 times++;
                         }
                 }
                 return times;
         }

}

思路是对的吗？哪儿些地方错了？

基础测试的题目？

不是基础测试

哥们思路确实有点问题，不过也有亮点
我借鉴了下你的思路，想了个新方法
定义一个具有26个元素的整型数组
分别存放a-z出现的次数
如果字母出现的次数，不为0，就打印出来
代码如下

1. package qbb;
   
2. 
   
3. public class Test06 {
   
4.         /*
   
5.          *取出一个字符串中字母出现的次数。如："abcdekka27qoq"  a(2)b(1)k(2)...
   
6.          */
   
7.         public static void main(String[] args) {
   
8.                 count("abcdekka27qoq");
   
9.         }
   
10.         public static void count(String string) {
    
11.                 String s1 = "";
    
12.                 int[] array = new int[26];
    
13.                 char[] arr = string.toCharArray();
    
14.                 for (char c : arr) {
    
15.                         if (Character.isLetter(c)){
    
16.                                 array[c - 97]++;
    
17.                         }
    
18.                 }
    
19.                 show(array);
    
20.         }
    
21.         private static void show(int[] array) {
    
22.                 for(int i = 0; i < array.length; i++) {
    
23.                         if(array[i] != 0) {
    
24.                                 char c = (char)(97 + i);
    
25.                                 System.out.println(c + "\t" + array[i]);
    
26.                         }
    
27.                 }
    
28.                
    
29.         }
    
30. }

复制代码

运行结果：
a        2
b        1
c        1
d        1
e        1
k        2
o        1
q        2

按照你的思路，我帮你写了一个，主要是我发现你这样的话 s加到后面如果出现重复的字母，你会再做调用一边字母统计，再加一边重复字母，为了避免这样的问题，我把你要存放的字母放在一个HashSet里面。HashSet有元素不可重复的特性，我重写一下equals方法，比较s1里面的字母是否一样来去除重复。虽然可能这个方法不是很好，希望对你有帮助哈。

1. package cn.itcast.day3;
   
2. 
   
3. import java.util.HashSet;
   
4. import java.util.Iterator;
   
5. 
   
6. 
   
7. public class newproblem1 {
   
8. 
   
9.     /*
   
10.                *取出一个字符串中字母出现的次数。如："abcdekka27qoq"  a(2)b(1)k(2)...
    
11.     */
    
12.    
    
13.     public static void main(String[] args) {
    
14.             count("abcdekka27qoq");
    
15.     }
    
16. 
    
17.     public static void count(String s1) {
    
18.             String ss = "";
    
19.             
    
20.             char[] arr = s1.toCharArray();
    
21.             
    
22.       
    
23.             HashSet<S1> hs1 = new HashSet<S1>();
    
24.             for (char c : arr) {
    
25.                     if (Character.isLetter(c)){
    
26.                                 if(hs1.add(new S1(c,1))){
    
27.                                 int        i = countTime(c, s1);
    
28.                                         Iterator<S1> it= hs1.iterator();
    
29.                                         S1 s=(S1)it.next();
    
30.                            
    
31.                                         s.setI(i);
    
32.                                         ss = ss + c+"("+ i +")";
    
33.                             }
    
34.                         }
    
35.                        
    
36.                     
    
37.             }
    
38. 
    
39.             System.out.println(ss);
    
40.             
    
41.     }
    
42. 
    
43.    
    
44.     private static int countTime(char key, String s1) {
    
45.                     
    
46.             char[] arr = s1.toCharArray();
    
47.             int times = 0;
    
48.             for (int i = 0; i < arr.length; i++ ) {
    
49.                     if (arr[i]== key){
    
50.                             times++;
    
51.                     }
    
52.             }
    
53.             return times;
    
54.     }
    
55.   
    
56. }
    
57. class S1{
    
58.         
    
59.         private char c;
    
60.         private int  i;
    
61.         S1(char c,int i){
    
62.                 this.c=c;
    
63.                 this.i=i;
    
64.         }
    
65.         public boolean equals(Object obj){
    
66.                 S1 s2=(S1)obj;
    
67.                 return this.c==s2.c;
    
68.         }
    
69.         public void setC(char c){
    
70.                 this.c=c;
    
71.         }
    
72.         public void setI(int i){
    
73.                 this.i=i;
    
74.         }
    
75.         public char getC(){
    
76.                 return this.c;
    
77.         }
    
78.         public int getI(){
    
79.                 return this.i;
    
80.         }
    
81.         public int hashCode(){
    
82.                     return 60;
    
83.         }
    
84. }
    

复制代码

dicegame 发表于 2013-7-27 22:52
哥们思路确实有点问题，不过也有亮点
我借鉴了下你的思路，想了个新方法
定义一个具有26个元素的整型数组

这方法很巧妙啊。

Mr_Free 发表于 2013-7-28 01:02
按照你的思路，我帮你写了一个，主要是我发现你这样的话 s加到后面如果出现重复的字母，你会再做调用一边字 ...

但是HashSet是无序的啊，存入顺序和取出顺序不一致啊

这种写法会导致重复的元素进行多次判断，导致输出结果不符合要求