public class StrngTest2 {

        public static void main(String[] args) {
                String s="welcom to chinaworld";
                char[] ch=s.toCharArray();
                int count=0;
                for(int i=0;i<ch.length;i++)
                {
                       
                        if(ch[i].contains(s){
                                count++;
                        }
                       
               
                }

      System.out.println(count);
        }
}

1.首先把字符串转换成一个字符数组
2.定义一个计数器初始值为0
3.遍历该数组！
4.并判断一个字符是否等于数组中某个脚标上的字符（哈希码值）
如果相等那么计数器就自加一次，如果不等，返回_1表示该字符串中没有该字符
5，返回计数器

我是手机上的论坛……就不写代码了……相信你有了该思路以后能够写出代码

给你一个代码。用StringBuilder，每次取出builer的最前面一个字符，记下，删除该字符。
然后在后面的字符中查找，如果有该字符一样的字符，则将count++，并删除该字符
如此循环，可以取到不重复的字符的计数，GOOD LUCK

1.         public static void main(String[] args) {
   
2.         String s="welcome to chinaworld";
   
3.         StringBuilder builder = new StringBuilder(s);
   
4.         while(builder.length() > 0){
   
5.                 int count = 1;
   
6.                 char ch = builder.charAt(0);
   
7.                 builder.deleteCharAt(0);
   
8.                 while(builder.indexOf(ch+"") != -1){
   
9.                         count++;
   
10.                         builder.deleteCharAt(builder.indexOf(ch+""));
    
11.                 }
    
12.                 System.out.println(ch+"出现"+count+"次");
    
13.         }
    
14.         }

复制代码

个人看法：
如果字符串比较长的话，可以自己定义一个26个字母的数组（不区分大小写的情况下）；
只需遍历一次，指针位如果是字母，均转换成小写，在数组相应位置自增，最后遍历，就知道每个字母出现的次数啦~

楼主这个代码。。 count统计的并不是某个固定的位置或字母，可能思路有些混乱了~

修改你的，这个是简单易懂的代码：

1. class  StringTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 String s="welcome to china";
   
6.                 char[] ch=s.toCharArray();//字符串转存为字符数组
   
7. 
   
8.                 for(int i=0;i<ch.length;i++)
   
9.                 {
   
10.                         if(ch[i]==' ')//遍历时遇到空格跳到下一个字符
    
11.                                 continue;
    
12. 
    
13.                         int count=1;//累加器
    
14.                         for(int j=i+1;j<ch.length;j++)
    
15.                         {
    
16.                                 if(ch[i]==ch[j])
    
17.                                 {
    
18.                                         count++;
    
19. 
    
20.                                         ch[j]=' ';//把计数过的字母变为空格，让遍历的时候跳过
    
21.                                 }
    
22. 
    
23.                                 
    
24.                         }
    
25.                         System.out.println(ch[i]+"出现"+count+"次");
    
26.                 }
    
27.         }
    
28. }
    

复制代码

陈丽莉 发表于 2013-4-7 00:45
个人看法：
如果字符串比较长的话，可以自己定义一个26个字母的数组（不区分大小写的情况下）；
只需遍历一 ...

老师这个……如果有些字母未出现，则也要从头到尾判断一遍。有点无用功了:)

1. import java.util.*;
   
2. 
   
3. class MapTest4
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 String s = "welcome to chinaworld";
   
8.                 char[] chs = s.toCharArray();
   
9.                 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
   
10. 
    
11.                 int count = 0;
    
12.                 for(int x=0; x<chs.length; x++)
    
13.                 {
    
14.                         if(chs[x]==' ')
    
15.                                 continue;
    
16.                         Integer value = tm.get(chs[x]);
    
17.                         
    
18.                         if(value!=null)
    
19.                                 count = value;
    
20. 
    
21.                         count++;
    
22. 
    
23.                         tm.put(chs[x],count);
    
24.                         count = 0;
    
25. 
    
26.                 }
    
27. 
    
28.                 StringBuilder sb = new StringBuilder();
    
29.                
    
30.                 Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
    
31.                 Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
    
32. 
    
33.                 while (it.hasNext())
    
34.                 {
    
35.                         Map.Entry<Character,Integer> me = it.next();
    
36.                         Character ch = me.getKey();
    
37.                         Integer value = me.getValue();
    
38.                         sb.append(ch+"="+value+'\n');
    
39.                 }
    
40.                 System.out.println(sb.toString());
    
41.         }
    
42. }
    

复制代码

代码较繁琐，唯一的优点是排了序。

从上面的回答看，藤椅的方法 ：时间复杂度 n(字符串长度)  ，灵活性强（不区分大小写及标点符）

                            板凳的方法：                    n                                    弱

                             报纸的方法：                   n*(n+1)/2                      强

受教了，刚给回复了自己的方法的，不过看了楼上的回复，发现自己弱爆了，还是不献丑了，楼上的方法学习了。

Thinks.

import java.util.*;
class  Count
{
        public static void main(String[] args)
        {
                String s = countMethod("welcom to chinaworld");
                System.out.println(s);
        }

        public static String countMethod(String str)
        {
                //将字母转换成一个数组
                char[] arr = str.toCharArray();

                //使用TreeMap
                TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

                //定义一个计数器
                int count = 0;
                for(int x=0;x<arr.length;x++)
                {
                        if(!(arr[x]>='a'&&arr[x]<='z'||arr[x]>='A'&&arr[x]<='Z'))
                                continue;
                        //定义一个值记录
                        Integer value = tm.get(arr[x]);
                        if(value!=null)
                                count = value;
                        count++;
                        //将键和值一起存入TreeMap中
                        tm.put(arr[x],count);
                        //计数器清零
                        count = 0;
                }
                StringBuilder sb = new StringBuilder();
                                //对集合中的元素进行遍历
                Iterator<Map.Entry<Character,Integer>> it = tm.entrySet().iterator();
                while(it.hasNext())
                {
                        Map.Entry<Character,Integer> me = it.next();
                        Character ch = me.getKey();
                        Integer value = me.getValue();
                        sb.append(ch+"="+value+",   ");
                }
                //返回字符串
                return sb.toString();
        }
}

起来逛论坛，复习写了一遍

回答得都很好啊，受教啦

要没记错的话，毕老师的视频中应该有讲

给你几种思路... 一种就是开辟 26*2 个int数组ans[]，假设字符为 tmp  如果是 小写字母 ans[tmp-'a']++  如果是大写 ans[tmp-'A'] ++；不要用eles 因为读入可能就不是a-z||A-Z
第二种有点难的，你可以试一下 用map集合来写
TreeMap<Character,Integer> M = new   TreeMap<Character,Integer>; 然后朝里面添加键值对。
这个方法一般用来统计单词的个数和单词出现的次数比较常用，你可以用这个来熟悉一下map的使用。
这个方法是比较好的方法。
可以自己试一下

王川 发表于 2013-4-7 00:53
老师这个……如果有些字母未出现，则也要从头到尾判断一遍。有点无用功了 ...

额  我不是老师~  也是打算来学习的学员~  
如果26个都定义的话，自增的时候，比如判断ch是字母后，只要字母数组，假定x吧，只要

1. <EM>x[ch[i]-65]++; </EM>

复制代码

就可以了~
若是不这样，出现哪个，再做统计的话，自增的时候还要判断查找一次~
并且我的回答说，前提是字符串很长，如果很长的话，比如一篇文章，这种方法还是比较有效率的~

看到楼上说的~ 高级一点的话Map很好的~  我昨晚说的比较简便，上面也提到了，如果不区分大小写，定义26个就可以了；
恩，总之楼上的答案蛮好的~   ^_^

PS：又看了一遍你的答案和给我的回复，可能有点理解错了，我的思路和你那种是不一样的。  ╮(╯▽╰)╭  还是懒得写代码咧~   

王川 发表于 2013-4-7 00:42
给你一个代码。用StringBuilder，每次取出builer的最前面一个字符，记下，删除该字符。
然后在后面的字符中 ...

你这个方法，查找的时候，循环的次数有些多，而且还需要删除的话，效率难免有些低了~
不过是按照楼主的思路改进的呢~  比较贴心~