import java.util.ArrayList;

/**
*    请在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
*    如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），
*    否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，
*    应抛出IllegalArgumentException异常。
*    在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，
*    传入的数组为null等。
*         @author wangshiming
*
*/
public class Test2
{
       
        public static void main(String args[])
        {
                char chs[]=new char[]{'3','b','a','c','f','5'};
                char ch='b';
               
       
                try
                {
                        System.out.print(check(chs,ch));
                       
                } catch (Exception e)
                {
                       
                        e.printStackTrace();
                }
        }
        public static int check(char[]chs,char ch) throws Exception
        {        //ArrayList<Integer> list=new ArrayList<Integer>();
                int position[] =new int[]{};
               
                int times=0;
                if(chs==null)
                {
                        throw new Exception("IllegalArgumentException");
                }
               
                for(int i=0;i<chs.length;i++)
                {
                        if(ch==chs)
                        {
                                //list.add(i);
                                position[times]=i;
                                times++;
                        }
                }
                if(position.length==0)
                {
                        return -1;
                }
                //return (Integer) list.get(0);
                return position[0];
        }
}
刚开始我是这样子做的使用ArrayList 来存储接收到的出现的位置 然后通过list.get(0);就可以获字符取第一次出现的位置，后来我就想用一个数组来存储接收字符出现的位置 就有了以上的代码运行的时候就出现了，我是这样想的存储字符第一次出现的位置后将times++ 第二次存到position[times++]里面，结果总是和想的有差别于是就出现了java.lang.ArrayIndexOutOfBoundsException: 0异常
自己调试了一段时间找不到解决的方法

[code=java]int position[] =new int[]{};[/code]这个定义错了吧！你即没有动态的为它指定默认大小，也没有静态的为它指定元素
一般定义数组有两种方式；[code=java]int position[] =new int[chs.length];//动态初始化 每个数组元素值为 0
int position[] =new int[]{1 , 2 , 3 , 4};//静态[/code]改成这样试试
int position[] =new int[chs.length];
就是这样子[code=java]public class Test2
{
        
        public static void main(String args[])
        {
                char chs[]=new char[]{'3','b','a','c','f','5'};
                char ch='b';
                     
                try
                {
                        System.out.print(check(chs,ch));
                        
                } catch (Exception e)
                {
                        
                        e.printStackTrace();
                }
        }
        public static int check(char[]chs,char ch) throws Exception
        {        //ArrayList<Integer> list=new ArrayList<Integer>();
                //int position[] =new int[]{}; 这是你原来的
                int position[] =new int[chs.length];
                int times=0;
                if(chs==null)
                {
                        throw new Exception("IllegalArgumentException");
                }
               
                for(int i=0;i<chs.length;i++)
                {
                        if(ch==chs)
                        {
                                //list.add(i);
                                position[times]=i;
                                times++;
                        }
                }
                if(position.length==0)
                {
                        return -1;
                }
                //return (Integer) list.get(0);
                return position[0];
        }
}[/code]
[ 本帖最后由 詹季春 于 2011-07-30  02:06 编辑 ]

不知道我这样理解对不对，有两种返回值：-1：数组为null或者没有搜索到该字符即字符数组中没有该字符；字符在字符数组中第一次出现的下标：找到了字符在字符数组中第一次出现的位置，如果找到了我们不就用执行for语句直接return 该下标。
那么我就定义一个返回变量index初值指是-1，如果找了字符在字符数组中第一次出现的位置，把该位置的值传给index,返回index;[code=java]package com.test;

public class Test {

        /**
         *@author lan
         */
        public static void main(String args[]) {
                char chs[] = new char[] { '3', 'b', 'a', 'c', 'f', '5' };
                char ch = 'b';

                        try {
                                System.out.print(check(chs, ch));
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
        }

        public static int check(char[] chs, char ch) throws Exception {
                int index=-1;
                if (chs == null) {
                        throw new Exception("IllegalArgumentException");
                }
                for (int i = 0; i < chs.length; i++) {
                        if (ch == chs) {
                                index=i;
                                return index;
                        }
                }
                return index;
        }
}[/code][code=java]1[/code]
[ 本帖最后由 兰海忠 于 2011-07-30  03:34 编辑 ]

楼主，这道题换一种思路会比较简单的，只有用到一个字符串String.indexOf()的方法。这题是传智播客的入学考试题，我也曾经做过，让你看看我是如何解答这题的，希望对你有所帮助。[code=java]package test;

public class SeachChar {
       
       
        /*
        试题2：（6分）
                        请在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
                        如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。
                        要搜索的字符数组和字符都以参数形式传递传递给该方法，
                        如果传入的数组为null，应抛出IllegalArgumentException异常。
                        在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，
                        例如，字符不存在，字符存在，传入的数组为null等。        
         */       
       
        public static void main(String[] args){
               
               
                //一、当字符串数组非空，字符数组c中存在字符ch时,
                char[] c ={'a','b','c'};
                char ch  ='a';
               
               
               
               
                //二、当字符串数组非空，字符数组c不存在字符变量ch时,
                //char[] c ={'a','b','c'};
                //char ch  ='d';
               
               
               
               
               
                //三、当字符串数组为空，字符数组c中没有字符变量ch：
                //抛出IllegalArgumentException异常
                //        char[] c = null;
                //        char ch ='a';

               
                int k = serch(c,ch);       
                System.out.println(k);
               
        }

        private static int  serch(char[] c, char ch) {
               
                if (c!=null) {
                       
                        String str = new String(c);                        //        由字符数组c的元素字符组成的一个字符串str
                       
                        int i = str.indexOf(ch);
                       
                        if (i>=0) {                                                        //字符在字符串str中的位置>=0，说明在字符串中有这个月字符，那么这个字符就是数组c中的一个元素。
                                return i;
                        }
                        else {
                                return -1;
                        }
                       
                       
                }       
                else {
                        throw new IllegalArgumentException("字符串数组为不能为空，否则出错！");
                }
       
               
        }
       

}[/code]
[ 本帖最后由 覃俊瑞 于 2011-07-30  11:52 编辑 ]

不好“easy"代码中有一行写错了[code=java] if (ch == chs) ————if (ch == chs)[/code]才是 我代码明明写了什么粘贴成这样 哎
[ 本帖最后由 兰海忠 于 2011-07-30  12:48 编辑 ]

:L  为什么要执着于那个位置呢？你把问题复杂化了。
我把你的程序改了。[code=java]package test;

public class Test3
{
        
        public static void main(String args[])
        {
                char chs[]=new char[]{'3','b','a','c','f','5'};
                //chs = null; // 当数组为空时
               // char ch='b'; //当字符存在数组中时
               char ch = 'z';//当字符不在字符数组时
               
               
        
                try
                {
                        System.out.print(check(chs,ch));
                        
                } catch (Exception e)
                {
                        
                        e.printStackTrace();
                }
        }
        public static Integer check(char[]chs,char ch) throws Exception
        {        //ArrayList<Integer> list=new ArrayList<Integer>();
               
               // int position[] =new int[chs.length];  这种定义数组方式在这里不可取，因为chs.length 表明chs是非空的
               
               // int  position[] = new int[10];
              int i = 0;
              boolean flag = false; //用于判断字符是否存在
               // int times=0;  不需要times
                if(chs!=null)
                {
                     
               
               
                                for(i=0;i<chs.length;i++)
                                {
                                        if(ch==chs[i])
                                        {
                                                flag = true;//字符存在，改变flag的值为true
                                                //list.add(i);
                                               // position[times]=i;
                                                return i;
                                        }
                                   
                                       
                                                               
                                }
                                
                                if (flag) {
                                       
                                                }else {
                                                        i = -1;
                                                }
                                
                                
//                                if(position.length==0)
//                                {
//                                        return -1;
//                                }
                                //return (Integer) list.get(0);
                                
                              
                                //return position[0];
                                
                              
                                
                }
                else {
                          throw new Exception("IllegalArgumentException");
                                }
               
                return i;
        }
} [/code]

我觉得这样子更好
public static int check(char[]chs,char ch) throws Exception
        {       
                if(chs==null)
                {
                        throw new Exception("IllegalArgumentException");
                }
               
                for(int i=0;i<chs.length;i++)
                {
                        if(ch==chs[i])
                        {
                                return i;
                        }
                }
               
                return -1;
               
        }

如果我传入的数组为null 你int position[] =new int[chs.length];//动态初始化 每个数组元素值为 0 就会抛出了异常
java.lang.NullPointerException
同时              if(position.length==0)
                {
                        return -1;
                }
              return position[0];
因为动态初始化了数组 传入的chs是有长度的 就算找不到也会返回一个0

int position[] =new int[]{};
没错哦。

但是在他的源程序这样定义是会产生，索引访问异常的