面试时遇到一些考基础的逻辑问题！如何提高这方面的能力！

Question

今天我第一次参加了JAVA的面试。结果笔试题做的我郁闷死了！其中四道程序题，手写代码太痛苦了！1、使用递归函数调用求1+2+3+.....+100
2、一个字符串"fsfeuofjkeulkdue"（任意）写一程序统计出现过几个字母，各出现过几次？
3、用1、2、2、3、4、5六个数排列组合！求出所有的排列方式，要求3不出现在第3位，4、5不能相邻！
4、有一张表，里面有3个字段：语文，数学，英语。其中有3条记录分别表示语文70分，数学80分，英语58分，请用一条sql语句查询出这三条记录并按以下条件显示出来（并写出您的思路）： 
大于或等于80表示优秀，大于或等于60表示及格，小于60分表示不及格。 
显示格式： 
语文 数学 英语 
及格 优秀 不及格1、3、4都在网上查到答案了！但第二题没找到准确答案！我实现了个自己都想吐得方法：
package com.accp.test;public class TestString { public static void main(String[] args) {
String str = "fdkfjejfksdfusls";
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, m = 0, n = 0, o = 0, p = 0, q = 0, r = 0, s = 0, t = 0, u = 0, v = 0, w = 0, x = 0, y = 0, z = 0;
for (int count = 0; count < str.length(); count++) {
if ("a".equals(str.substring(count, count + 1))) {
a++;
}
if ("b".equals(str.substring(count, count + 1))) {
b++;
}
if ("c".equals(str.substring(count, count + 1))) {
c++;
}
if ("d".equals(str.substring(count, count + 1))) {
d++;
}
《此处省略一些相似的代码》
}
int sum = 0; if (a != 0) {
sum++;
System.out.println("a出现过：" + a + "次");
}
if (b != 0) {
sum++;
System.out.println("b出现过：" + b + "次");
}
if (c != 0) {
sum++;
System.out.println("c出现过：" + c + "次");
}
if (d != 0) {
sum++;
System.out.println("d出现过：" + d + "次");
}
　　　　　　　　　《此处省略一些相似的代码》
System.out.println("共出现过" + sum + "种字母!");
}
}请大家帮帮我优化一下实现此功能的代码！另外想问问这样的逻辑能力该如何培养。像这四道题，就算给我正确答案，我也要进行多次调试多次理解才行，更何况当场用手写程序！

Answer 1

下面的是偶写的 随手写的 没怎么改 你看看有什么地方改下你就能用吧(这个不光是用来统计字母的)package test;public class Test {
public static void main(String[] args) {
subString("aaabbbccc");
} public static void subString(String str) {
char[] abcArray = new char[27];
int[] abcNumArray = new int[27];
int arrayIndex = 0;
if (str != null && !str.trim().equals("")) {
char[] strArray = str.toCharArray();
for (int i = 0; i < strArray.length; i++) {
boolean b = true;
for (int y = 0; y < arrayIndex; y++) {
if (abcArray[y] == 0) {
break;
} else {
if (abcArray[y] == strArray[i]) {
abcNumArray[y] = ++abcNumArray[y];
b = false;
break;
}
}
}
if (b) {
abcArray[arrayIndex] = strArray[i];
abcNumArray[arrayIndex] = 1;
arrayIndex++;
}
}
for (int i = 0; i < arrayIndex; i++) {
System.out.println(abcArray[i] + " : " + abcNumArray[i]);
}
} else {
throw new RuntimeException("str is null");
}
}
}

Answer 2

        char[] abcArray = new char[27];
        int[] abcNumArray = new int[27];
这两个改下就能增加存储的空间 如果我还有时间的话我就写个HASHMAP的吧 应该更简单些呢

Answer 3

第二题答案public class Test{
    public static void main(String[]args){
        String s="fsfeuofjkeulkdue";
       Map<String,Integer> map1=new HashMap<String,Integer>();
       for(int i=0;i<s.length();i++){
        if(map1.get(s.substring(i, i+1))==null){
        map1.put(s.substring(i, i+1), 1);
        }else{
        map1.put(s.substring(i, i+1), map1.get(s.substring(i, i+1))+1);
        }
       }
       //输出
       for(String s1:map1.keySet()){
        System.out.println(s1+map1.get(s1));
       }
       
    }
}

Answer 4

6楼的大哥解释下啊。我是新手看不大懂那个“Map<String,Integer> map1=new HashMap<String,Integer>();”

Answer 5

第一题答案public class Add100 {
public static void main(String arg[]) {
System.out.println(add(100));
}

public static int add (int n) {
if(n>0) {
return (n + add(n-1));
} else {
return 0;
}
}
}
 

Answer 6

楼主  这么写真是有创意
建议还是用Map<character,Integer>

Answer 7

范型，jdk1.5新增的特性；
java里边的容器类，要尽量的使用，呵呵
你看看你的jdk，Map，以键值存储，解决这类的问题刚好。

Answer 8

public class TestMap {
public static void main(String[] args) {
sort();
} public static void sort() {
String str = "fsfeuofjkeulkdue";
Map<String, Integer> map = new HashMap<String, Integer>();
for (int i = 0; i < str.length(); i++) {
if (map.containsKey(str.substring(i, i + 1))) {
map.put(str.substring(i, i + 1), map.get(str
.substring(i, i + 1)) + 1);
} else {
map.put(str.substring(i, i + 1), 1);
} }
System.out.println(map.toString());
}}{f=3, d=1, u=3, e=3, s=1, o=1, l=1, j=1, k=2}

Answer 9

第二题：import java.util.*;public class StatisticsChar {
public static void main(String[] args) {
String str = "aabbccaadddddd";
Map<Character,Integer> map = new HashMap<Character,Integer>();
char c = 0;
int times;
for(int i=0;i<str.length(); i++) {
c = str.charAt(i);
if(map.containsKey(c)) {
times = (map.get(c)).intValue();
times ++;
map.put(c, times);
} else {
map.put(c, 0);
}
}

for(char cc: map.keySet()) {
System.out.println(cc + "出现" + map.get(cc) +"次");
}
}
}

Answer 10

这样的代码也敢拿出手？
int[] x = new int[26];
char[] ca = str.toCharArray();
for(int i=0;i<ca.length;i++){
 x[ca[i]-'a']++;
}显示：
for(int i=0;i<ca.length;i++){
 System.out.println("字符"+(char)('a'+i)+"出现了"+ca[i]+"次");
}至少比你上面的代码性能要高100个档次

Answer 11

如果不要显示出现0次的直接判断一下if(ca[i] == 0 ) continue;这就是800元和20000元工资的区别，明明能用最简短的代码，最少的内存开销能实现的非要用搞得那么复杂，就怕程序占用的资源太少。

Answer 12

显示那里应该是x.length;
     String a = "abcdefgasjhdfjklslajsva";
     char[] ca = a.toCharArray();
     int[] x = new int[26];
     for(int i = 0;i< ca.length;i++)
     x[ca[i]-'a']++;
    
     for(int i=0;i<x.length;i++)
     if(x[i] != 0)
     System.out.println((char)('a'+i)+"="+x[i]);

Answer 13

先把里面重复的字母都去掉,保存到一个数组里.然后再在原来的字符串里找与数组里的字母一样的有多少个.这样就不用LIST,MAP等集合,很浪费空间.也不用保持所有的26个字母,只是出现多少个保存多少个!程序我就没有写了.这样的思想设计应该都要简单,又节省空间.

Answer 14

使用MAP和substring,这样的程序只能拿去骗骗人。不是说subString不能用，而是在这个问题中，你一用肯定就在循环中用，那么：String str = "dsjvsdajdva....";假如是1000，不算长吧？1000个substring要返回1000个子串，每个字符串要点多少空间？即使一个长度字符的字符串，它
本身的属性也比一个数组中的char要高成百上千倍
而且速度会比一次str.toCharArray(); 要慢成百上千倍。为什么我们不一次得到char数组而要上千次地substring?我想不出任何理由。对于固定数据的字符的统计，仅仅只是整数的加操作，为什么要不断地从int转换到Integer放到map中然后再取出转换成int相加再转回头放入map?
难道我们对计算机有仇非要这么浪费它的性能？以前有一个经典的问题。求每个月的天数。明明是一个固定的数据加一个闰年的判断：int[] mDays = {31,28,31,30,31,30,31,31,30,31,30,31};
if(闰年) mDays[1] ++;
两行简单的数学运算，非要有人new一个Calendar的实例然后再getXXX.JAVA程序员的素质比C/C++差一大截，此言不差。

Answer 15

这个更搞笑。“先把里面重复的字母都去掉,保存到一个数组里”
这样的算法要多少空间来运算？而且每次replce后要产生多少新的字符串？保存所有26个字符最大的究竟是 26 * 4 = 104个字节
就算一个用不上也就浪费104个字节。“把里面重复的字母都去掉”这个算法要多个字节？给你104*100你给我弄出来试试.

Answer 16

char[] temp="fsfeuofjkeulkdue".toCharArray();
Map<Character,Integer> sMap=new HashMap<Character, Integer>();
Integer sInteger;
for(int i=0;i<temp.length;i++){
sInteger=sMap.get(temp[i]);
sMap.put(temp[i], (sInteger==null ? 1: sInteger+1));
} 
System.out.println(sMap);

Answer 17

public class Test{
    public static void main(String[]args){
        String s="fsfeuofjkeulkdue";
       Map<Character,Integer> map1=new HashMap<Character,Integer>();
       for(int i=0;i<s.length();i++){
           Character c1=s.charAt(i);
        if(map1.get(c1)==null){
        map1.put(c1, 1);
        }else{
        map1.put(c1, map1.get(c1)+1);
        }
       }
       //输出
       System.out.println(map1);
    }
}江渚渔樵兄，你看看这个行不？

Answer 18

           if(map1.get(c1)==null){
               map1.put(c1, 1);
           }else{
               map1.put(c1, map1.get(c1)+1);
           }先不说map要比数组多多大开销。
你把1put到map中，首先1要boxing成Integer.
下次先get一个Integer,然后unboxing成int,然后+1，再boxing为Integer,你觉得这样的操作比原子的
++操作要多少指令？（空间我们就不说了）Effective Java/JAVA并发编程实践/TKJ等名著不断地说，在JAVA实现上，"原始类型优先于类类型。"
这也是面向对象的原则，面向对象的原则是为了解决方便地解决问题，而不是要把简单的问题复杂化。能实现相同功能的前提下，代码越少（当然是编译后如果你把大量的语句放在其它类中，然后用一个方法一行代码完成
那不叫代码少，就相当于有人用一行代码调用系统或别人的类库那不能叫代码少。）
占用的究竟越小，代码越值钱。我所做的工作就是把别人的一百行代码优化成几十行，十几行，几行。
所以我的工资是和产出的代码量成反比。

Answer 19

package fx.algorithm;import java.util.Arrays;/**
 * 统计一个字符串中每个字母出现次数
 * 
 * @author 咖啡
 * 
 */
public class StatisticsStr { /**
 * 任意一字符串, 字符串转为一字符数组, 26个英文字母出现次数的集合
 */
private static final String STR_TEMPLATE = "fdkfjejfksdfusls";
private static final char[] ch = STR_TEMPLATE.toCharArray();
private static final int[] count = new int[26]; /**
 * 思路: 因为小写字母a的ascii为96,所以将每个字母减去96,从数组0开始
 * 
 * 每出现一个字母就在相应加1
 */
public static void main(String[] args) {
for (int i = 0; i < ch.length; i++) {
int ascii = (char) ch[i] - 96;
count[ascii] = count[ascii] + 1;
} for (int i = 0; i < count.length; i++) {
System.out.println((char) (i + 96) + "出现了: " + count[i]);
} }
}
复杂度为O(N),线性查找的级别

Answer 20

这种方式果然很高效
String str = "agdafagdafsdhgdasfasdgasdfjsdakl";
char[] arr = str.toCharArray();
int []c = new int[26];

for(int i=0;i<arr.length;i++){
++c[(int)arr[i]-'a'];
}
for(int i=0;i<c.length;i++){
System.out.print((char)(i+'a'));
System.out.print("   ");
System.out.println(c[i]);
}

Answer 21

第二题建立HASH表就可以解决了。

Answer 22

如果仅仅做这点事，谈不上什么效率。但如果一个大项目，你每处都比别人慢上百倍，那么整个系统就比别人慢上百倍，这样的系统如果谈优化，结构再好，也还是重写。
因为你的代码无一处可用。说后了就是八股文，架子搭得很好，但一无可用。
计算机，首先保证的是计算性能，如果你的程序运行比别人手工操作还慢，那为什么要用你的程序？我还不如雇个人在那操作。
至于说与人交流，把一行代码能解决的问题弄成十行，这样与人交流方便吗？再说，简单的代码如果读不懂，就不适合写程序。程序不是课文，没有点了逻辑思维的人是不适合看的。以前有一个“大师”说if(boolean)?reg1:reg2
不如
if(boolean){
   reg1;
} 
else{
   reg2;
}
好读，这样的人也叫大师吗？那么汇编代码，C的远指针操作代码都不能与别人交流了？那些真正的大师们写出来的汇编代码和c代码，肯定比上面的几行难读得多，难道不存在优雅？
结构优雅是设计的事，没有好的结构肯定做不成大的项目，所以在实现的时候，你不仅要面向对象，更要面向系统。这阶段眼中没有任何代码，甚至没有
语言类型，没有平台。
但在具体实现上，如果你有能力面向二进制，你就应该努力向最底层去控制。我想这样的面试，如果用map来滤重和统计，学过十天的JAVA程序员都会。所以拿3K-5K的水平足够了。但如果你用MAP来做，绝对不会给你10K以上的，因为
其它3K-5K的人也能做到，我为什么要花10K来让你做。

Answer 23

/*
 * 从控制台获取一串字符串，并对每个字符出现的次数进行统计
 */package test3_21;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 *
 * @author dnktty
 */
class AccountChar {    public static int n=1;    public static void main(String[] args){
    
        //建立输入流，从用户获取需要统计的字符串
        BufferedReader buffR=new  BufferedReader(
                                      new InputStreamReader(System.in));        try {             System.out.println("请输入一串需要统计的字符串：");
             String str = buffR.readLine();            AccountChar ac=new AccountChar();
            //对统计的字符串拆成字符
            char[] ch=str.toCharArray();             for(int i=0;i<str.length();i++){
                if(str.indexOf(ch[i])==i)  //排除重复出现的字符
                System.out.println(ch[i] +" the number is "+ac.accountNumber(str,i));
                n=1;  //恢复全局变量的值
            }//end for loop        }//end try
        catch (IOException ex) {  ex.printStackTrace(); }    }    //用递归方法统计字符串中某个元素的个数  a为元素在str中的索引值
    public int accountNumber(String str,int a){
         int b=a;
        
         a=a+1;
         String subStr=str.substring(a,str.length());
       
         if(subStr.indexOf(str.charAt(b))!=-1){
             n++;
             return accountNumber(subStr,subStr.indexOf(str.charAt(b)));
             // return accountNumber(subStr,b);//会重复算vabsa 算a时会在b和s出各算一次         }
         return n;    }}

Answer 24

针对accountNumber中会出现重复的算法  在main中的if(str.indexOf(ch[i])==i) 得到了解决

Answer 25

数组也是对象好不 我觉的axman你不能用了java还说java的东西不好 现在都什么时代了差那么一点点性能比算得了什么，这不过是个小程序，java类库里的东西都是前人总结的经验 可扩展性比你写的东西多的多 如果你天天做c++的工作 那么ok 看起来你的程序的确易懂 但是你的程序缺陷不会少 java已经有很多提升性能的机制。而且你一直纠结工资。这个东西跟很多东西有关了光光简化代码就能拿到2w？

Answer 26

打包解包其实就是一个过程而已 就像你的[ca[i]-'a']你敢说它的计算过程没有转换类型？
for(int i=0;i <ca.length;i++){ 
System.out.println("字符"+(char)('a'+i)+"出现了"+ca[i]+"次"); 
} 
你的显示需要用for循环输出 那么这里面生成了多少个PrintStream对象你又知道吗？

Answer 27

第二题用HashMap的方法最简单了，顶！~~

Answer 28

int[] x = new int[26]; 
char[] ca = str.toCharArray(); 
for(int i=0;i <ca.length;i++)
{ 
    x[ca[i]-'a']++; 
} 显示： 
for(int i=0;i <ca.length;i++)
{ 
    System.out.println("字符"+(char)('a'+i)+"出现了"+ca[i]+"次"); 
} 是个不错的解法，至少很简单，也不浪费资源！

Answer 29

好像不用package包吧? (packagetest3_21; )  刚开始思路有点难，呵呵！借鉴经验，交流学习心得，加油！

Answer 30

楼上真是人才辈出啊，小弟回家小试了一下，希望试过的大伙给我提点宝贵意见。。
是可以的噢......class TestCountString {
    public static void main(String[] args) {
    String a = "zhuangyan";
    System.out.println("你输入的是:"+a+";长度为:"+a.length());
    Makeout(a);
  }
  
  static void Makeout(String s) {
    Character[] d = new Character[s.length()];
    int sum = 0;
    Character[] c = new Character[s.length()];
    for(int i=0;i<s.length();i++) {
    c[i] = s.charAt(i);
    }
    
    for(int k=0;k<s.length();k++) {
    System.out.print(c[k]);
    }
    System.out.println();
    
    for(int u=0;u<s.length();u++) {
    d[u] = c[u];                      //循环把c[]的值赋予d[];
    for(int y=0;y<s.length();y++) {
    if(d[u]==c[y])
    sum++;    
    }
    System.out.println(d[u]+"有"+sum+"个");
    sum = 0;  
  }
 }
}

Answer 31

第二题
public static Map  mat() {
Map map = new HashMap();
String s = "sdfsdfdsfaaalllk3222ddddddd";
Pattern pattern = Pattern.compile("([a-zA-Z])");
Matcher mat= pattern.matcher(s);
boolean result = mat.find();

while (result) {
 String pat =mat.group(1);
// System.out.println(mat.group(1));
 if (map.containsKey(pat)) {
 Integer obj = (Integer)map.get(pat);
 int num = obj.intValue();
 map.put(pat, new Integer(++num));  
 } else {
 map.put(pat, new Integer(1));
 }
 
 result = mat.find();
}
return map;
}

Answer 32

六楼,谢谢啊,第二题的答案又让我见识了map对于重复元素存的处理方法(覆盖-存最后一次),set是只存第一次

Answer 33

这个问题俺也想问，那句所谓的“JAVA程序员的素质比C/C++差一大截，此言不差。”也不大好听呵呵，这个貌似看的是个人修养，而不是一类人的修养。
注意：2、一个字符串"fsfeuofjkeulkdue"（任意）写一程序统计出现过几个字母，各出现过几次？ 
题目说的任意字符串，而不是只有小写字母的字符串。你的程序如果俺输入个“12A”相信其结果会让人很难接受或者让程序很难接受。

Answer 34

思路很好，不过if else不能少。呵呵 

Answer 35

package com;public class sumTest {
  public static void main(String[] args){
System.out.println(testSum(1,0,100));   
  } 
  public static int testSum(int n1,int res,int time){
  
      res = res + n1 + n1+1;
      n1 = n1 + 2;
      if(n1<=time){
      return testSum(n1,res,time);  
      }
      return res;
  }
}

Answer 36

我来发个最终版的  就是可以用的版本  呵呵  绝对是可以的哦class TestCountString {
    public static void main(String[] args) {
    String a = "zhuangyanzhuangyan";
    System.out.println("你输入的是:"+a+";长度为:"+a.length());
    Makeout(a);
  }
  
  static void Makeout(String s) {
    Character[] d = new Character[s.length()];
    int sum = 0;
    //int z = 0;
    boolean[] z = new boolean[s.length()];
    for(int x=0;x<s.length();x++) {
     z[x] = false;
    }
    //int count = 0;
    Character[] c = new Character[s.length()];
    for(int i=0;i<s.length();i++) {
    c[i] = s.charAt(i);                //把取出的一个字符放进c[]字符数组中
    }
    
    for(int k=0;k<s.length();k++) {
    System.out.print(c[k]);
    }
    System.out.println();
    
    for(int u=0;u<s.length();u++) {
    
    d[u] = c[u];                      //循环把c[]的值赋予d[];
    for(int y=0;y<s.length();y++) {   //从d[0]开始比较c[0]-c[s.length()]
    if(d[u]==c[y]) {                  //如果发现一样的
    if(z[y] == false) {
    z[y] = true;                   
    System.out.println("在第"+(y+1)+"个位置");
    sum++;
    }
   }    
  } 
    if(sum!=0&&sum!=s.length()) {
    System.out.println("有"+sum+"个"+d[u]);
    System.out.println();
    sum = 0;
  }
    if(sum==s.length()) {
    System.out.println("你输入的全是"+d[u]);
    System.out.println();
    sum = 0;
    }
    
    /*if(count==s.length()) {
    System.exit(-1);
    }*/  
  }
 }
}

Answer 37

感谢大家的讨论！我听了比较有启发！看来还要多多练习才行！我觉得29的兄弟的代码不错，我已经理解了！然后我完善了下输出，形成了以下代码！
public class TestString {
public static void main(String[] args) {
String str = "fdkfjejfksdfusls";
Map<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 0; i < str.length(); i++) {
Character c1 = str.charAt(i);
if (map.get(c1) == null) {
map.put(c1, 1);
} else {
map.put(c1, map.get(c1) + 1);
}
}
//输出
System.out.println("一共出现了" + map.size() + "种字母!如下：");
Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String key = entry.getKey().toString();
String value = entry.getValue().toString();
System.out.println(key + "字母出现了" + value + "次");
}
}
}
希望大家继续讨论！！

Answer 38

1.最终搞笑版就不要来了。如果有人喜欢用Map,一个Map和一个数组的操作是不可比的，但如果你一定要用Map。
我建议往里put的时候不要put int，这样要反复多次从int boxing成Integer,再从Integer unboxing成int.
建议第一次往里put一个new int[]{1),这和第一次new Integer(1) put进去的开销一样。但以后再访问就快多了get(c)[0]++;
这样多次实际上是直接对原始类型操作，不用反来复去地boxing/unboxing.
2.上面有人说有大写还有符号怎么办？（另外还有人在后面拾边）这个问题根本不是问题，问这样的问题更说明。比C/C++int[] x = new int[127];
有人把 'a'改成96，那才叫“不好交流”，硬编码。同样'\0'不应用String str = "dv sa[v m]qw kvb\S;cmca[qwdw BCVQ[F~112#$!U02";
char[] cs = str.toCharArray();
for(int i = 0;i<c.length;i++)
  x[cs[i]] ++;显示：
for(int i=0;i<x.length;i++)
if(x[i] != 0)
System.out.println((char)i+"="+x[i]);也不过是127个int而已，所有ASCII都进去了。如果说还有汉字，那么要看统计的长度，如果长度总是十几二十几个，那可以用map（其实应该直接手工数啊，十几二十几个还叫统计？）但put int类型的一个元素的数组。如果你认为你写的程序是用来真正的统计的，直接
int[] x = new int[65535]; //如果字符串足够长，MAP总会比这个数组要多很多开销。

Answer 39

难道你认为你问的有问题了吗，别人做的是A题，你却要用B题来衡量他，R U ok ?,你到底想要说明什么？

Answer 40

难道你不认为你问的有问题了吗，别人做的是A题，你却要用B题来衡量他，R U ok ?,你到底想要说明什么？

Answer 41

JAVA 不懂。以后有时间，一定要学学它！！

Answer 42

import java.util.HashMap;
import java.util.Map;public class Test03 {
public static void main(String[] args) {
String s = "fsfeuofjkeulkdue";
Map<Character, Integer> map = new HashMap<Character, Integer>();
for (char c : s.toCharArray()) {
if (map.containsKey(c)) {
map.put(c, map.get(c) + 1);
} else {
map.put(c, 1);
}
}

System.out.println(map);
}
}

Answer 43

合理即可~！  MAP不错·~！

Answer 44

大家都好牛啊，我一开始想到的也是用MAP，后来发现19L的代码不仅量少，而且系统开销更小，真是长知识了

Answer 45

同意数组的方式，即使是jav语言，在基本算法里大量使用集合和对象也是很夸张的
代码里大量的使用对象并不代表面向对象，C一样能写出面向对象的程序。
性能应该是所有程序猿都必须面对的问题(^╴^Ａ；) 

Answer 46

import java.util.HashMap;
import java.util.Map;
public class StatisticLetter { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
String text="asdZzzasdfaswDfsldfDlweropPdsfasdlfFDd";
Map<Character,Integer> map=new HashMap<Character,Integer>();//用于存储字母次数的
char[] chs=text.toCharArray();
for(int i=0;i<chs.length;i++){
if(map.containsKey(chs[i])){
map.put(chs[i], map.get(chs[i])+1);
}else{
map.put(chs[i], 1);
}
}
for(Character c:map.keySet()){
System.out.println(c+":"+map.get(c));
}
}}

Answer 47

1.public class Ex1 {
public static void main(String[] args) {
System.out.println(m(100));
}

public static int m(int n) {
return n > 0 ? n + m(n-1): 0;
}
}
import java.util.*;public class Ex2 {
public static void main(String[] args) {
String str = args[0];
Map<Character,Integer> map = new LinkedHashMap<Character,Integer>();

for(int i=0;i<str.length();i++) {
char c = str.charAt(i);

if(map.containsKey(c)) {
map.put(c,map.get(c)+1);
} else {
map.put(c,1);
}
}

System.out.println(map);
}

}
3. 

Answer 48

  觉得 axman 说的很好，让我学到了很多东西。高手~~敬佩之^ ^  但忍不住也要说点自己的想法：学习一门技术并不能一蹴而就，一下子把这门技术的所有知识都一起学习。
就像学功夫，明明学习那种高深的套路就能把人打到，为什么还要练蹬马步这种又“蠢”又累人的事呢？  看看lz的标题，我认为学习用hashmap的方法也不是一无是处~~不知道有没有人同意我的观点呵呵~~

Answer 49

第二题，不是最简单的。public class CountChar {
private HashMap<Character, Integer> map = new HashMap<Character, Integer>();
public static void main(String[] args) {
CountChar ob = new CountChar();
String s = "fsfeuofjkeulkdue";
Set<Map.Entry<Character,Integer>> set = ob.count(s).entrySet();
System.out.println(set);
}

public Map<Character, Integer> count(String s) {
for(int i = 0; i < s.length(); i++){
Character c = s.charAt(i);
if(map.containsKey(c)) {
map.put(c, (map.get(c)) + 1);
}else {
map.put(c, 1);
}
}
return map;
}
}

Answer 50

package 面试题;import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;/**
 * 一个字符串"fsfeuofjkeulkdue"（任意）写一程序统计出现过几个字母，各出现过几次？
 * 
 * @author 苏帅 Apr 5, 20093:22:21 AM
 * 
 */
public class Test123 {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String str = "fsfeuofjkeulkdue";
Map<String, Integer> map = new HashMap<String, Integer>();
for (int i = 0; i < str.length(); i++) {
String temp = String.valueOf(str.charAt(i));
if (map.get(temp) == null) {
map.put(temp, 1);
} else {
map.put(temp, map.get(temp) + 1);
}
}
Set set = map.keySet();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
String string = (String) iterator.next();
System.out.println(string + " " + map.get(string));
}
}
}

Answer 51

下面的代码没有运行，我用C写的，希望Lz能看懂C,这个第二题主要是算法，语言不是重点.
上面的所以回帖没有一个令人满意的，都写的太复杂了，完全没有必要,希望Lz多做一些关于
ACM的题目,对自己很有帮助的.
注：我刚学JAVA的Swing，对前面的字符操作都是飘过的(^_^),见谅……
#include<stdio.h>
int main()
{
    int intArray[52];//装26个字母个数,用来计数
    int i;
    char charArray[100];//装字符串
    for(i=0;i<52;i++)
    {//初始化数组
        intArray[i]=0;
    }
    scanf("%s",charArray);
    for(i=0;charArray[i]!=NULL;i++)
    {/////注意,这里是这个代码的核心,自己体会吧，说了就么得意思了
        intArray[charArray[i]-'a']++;
    }
    for(i=0;i<52;i++)
    {//////结果打印出来
        printf("%c\n",intArray[i]+'a');
    }
    system("PAUSE");
    return 0;
}

Answer 52

跟帖99楼不好意思，没有认真看题目要求，修改一下：
最后的打印语句：
printf("%c:%d\t",intArray[i]+'a',intArray[i]); #include <stdio.h> 
int main() 
{ 
    int intArray[52];//装26个字母个数,用来计数 
    int i; 
    char charArray[100];//装字符串 
    for(i=0;i <52;i++) 
    {//初始化数组 
        intArray[i]=0; 
    } 
    scanf("%s",charArray); 
    for(i=0;charArray[i]!=NULL;i++) 
    {/////注意,这里是这个代码的核心,自己体会吧，说了就么得意思了 
        intArray[charArray[i]-'a']++; 
    } 
    for(i=0;i <52;i++) 
    {//////结果打印出来 
        if(intArray[i])///加个判断，输出部不为0的,也就是出现的字符
      {
           printf("%c\n",intArray[i]+'a'); /////////
      }
    } 
    system("PAUSE"); 
    return 0; 
}