A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

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技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

13 个回复

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

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

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
给你一个代码。用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.         }
复制代码

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
个人看法:
如果字符串比较长的话,可以自己定义一个26个字母的数组(不区分大小写的情况下);
只需遍历一次,指针位如果是字母,均转换成小写,在数组相应位置自增,最后遍历,就知道每个字母出现的次数啦~

楼主这个代码。。 count统计的并不是某个固定的位置或字母,可能思路有些混乱了~
回复 使用道具 举报
本帖最后由 杨成 于 2013-4-7 03:15 编辑

修改你的,这个是简单易懂的代码:
  1. class  StringTest
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 String s="welcome to china";
  6.                 char[] ch=s.toCharArray();//字符串转存为字符数组

  7.                 for(int i=0;i<ch.length;i++)
  8.                 {
  9.                         if(ch[i]==' ')//遍历时遇到空格跳到下一个字符
  10.                                 continue;

  11.                         int count=1;//累加器
  12.                         for(int j=i+1;j<ch.length;j++)
  13.                         {
  14.                                 if(ch[i]==ch[j])
  15.                                 {
  16.                                         count++;

  17.                                         ch[j]=' ';//把计数过的字母变为空格,让遍历的时候跳过
  18.                                 }

  19.                                 
  20.                         }
  21.                         System.out.println(ch[i]+"出现"+count+"次");
  22.                 }
  23.         }
  24. }
复制代码


评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
陈丽莉 发表于 2013-4-7 00:45
个人看法:
如果字符串比较长的话,可以自己定义一个26个字母的数组(不区分大小写的情况下);
只需遍历一 ...

老师这个……如果有些字母未出现,则也要从头到尾判断一遍。有点无用功了:)
回复 使用道具 举报
本帖最后由 騛鹏 于 2013-4-7 02:00 编辑
  1. import java.util.*;

  2. class MapTest4
  3. {
  4.         public static void main(String[] args)
  5.         {
  6.                 String s = "welcome to chinaworld";
  7.                 char[] chs = s.toCharArray();
  8.                 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

  9.                 int count = 0;
  10.                 for(int x=0; x<chs.length; x++)
  11.                 {
  12.                         if(chs[x]==' ')
  13.                                 continue;
  14.                         Integer value = tm.get(chs[x]);
  15.                         
  16.                         if(value!=null)
  17.                                 count = value;

  18.                         count++;

  19.                         tm.put(chs[x],count);
  20.                         count = 0;

  21.                 }

  22.                 StringBuilder sb = new StringBuilder();
  23.                
  24.                 Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
  25.                 Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();

  26.                 while (it.hasNext())
  27.                 {
  28.                         Map.Entry<Character,Integer> me = it.next();
  29.                         Character ch = me.getKey();
  30.                         Integer value = me.getValue();
  31.                         sb.append(ch+"="+value+'\n');
  32.                 }
  33.                 System.out.println(sb.toString());
  34.         }
  35. }
复制代码
代码较繁琐,唯一的优点是排了序。

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

                            板凳的方法:                    n                                    弱

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

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
本帖最后由 曹宇 于 2013-4-7 03:11 编辑

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

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

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

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
回答得都很好啊,受教啦
回复 使用道具 举报
要没记错的话,毕老师的视频中应该有讲
回复 使用道具 举报
给你几种思路... 一种就是开辟 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的使用。
这个方法是比较好的方法。
可以自己试一下

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
本帖最后由 陈丽莉 于 2013-4-7 14:20 编辑
王川 发表于 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的最前面一个字符,记下,删除该字符。
然后在后面的字符中 ...

你这个方法,查找的时候,循环的次数有些多,而且还需要删除的话,效率难免有些低了~
不过是按照楼主的思路改进的呢~  比较贴心~
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马