1. 
   
2. <P>class StringTest2
   
3. {</P>
   
4. <P>public static int getTimes2(String s,String key)
   
5.         {
   
6.                 int count=0;
   
7.                 int index=s.indexOf(key);                          
   
8.                 while (index!=-1 )
   
9.                 {
   
10.                         System.out.println("s="+s);
    
11.                         s=s.substring(index+key.length());        
    
12.                         count++;
    
13.                 }
    
14.                 return count;
    
15.         }
    
16.         public static void main(String[] args)
    
17.         {
    
18.                 String s="abkkcdkkefkkskksde";
    
19.                 int count=getTimes2(s,"kk");
    
20.                 System.out.println("count="+count);
    
21.         }
    
22. }
    
23. </P>

复制代码

不知道为什么，这个程序总是提示角标越界。但是如果把
int index=s.indexOf(key);                     while (index!=-1 )
这两句改为：
int index=0；
while ((index=s.indexOf(key))!=-1 )  就没有问题了
请问第一种为什么会报错？这两种写法差别在哪里？

第一种写法：
循环只是判断到了字符串末尾没有循环内部做的事就是：输出当前字符串-->获取子串-->count++
中间没有判断过key是否在新的字符串中
第二种写法：
循环条件是：每次得到的字符串中返回key的索引index，且没有到字符串末尾
这里相比第一种多加了个每次在新的字符串中寻找key的过程

所以第二种对的
另外，你要是用第二种写法，不知道你有没有考虑过传入的字符串是kkk，key=kk的问题

我把你的代码改了一下，添加了注释，希望能帮到你

1. class Test1
   
2. {
   
3.         public static int getTimes2(String s,String key)
   
4.         {
   
5.                 int count=0;
   
6.                 int index=s.indexOf(key); //如果没有越界，你下面的循环是不停重复的，直到角标越界                        
   
7.                 while (index!=-1 )
   
8.         {
   
9.                           System.out.println("s="+s);
   
10.                           //这样获得的子串每次获得的都是减少同样长度的子串
    
11.                           s=s.substring(index+key.length());
    
12.                           //当获取子串后还要判断字串中是否含有该key，并重新获取角标，添加下面语句
    
13.                           //你的第二种写法就是把下面语句赋值到判断上
    
14.                           index = s.indexOf(key);
    
15.                           count++;
    
16.         }
    
17.                         return count;
    
18.         }
    
19.         public static void main(String[] args)
    
20.         {
    
21.                 String s="abkkcdkkefkkskksde";
    
22.                 int count=getTimes2(s,"kk");
    
23.                 System.out.println("count="+count);
    
24.         }
    
25. }
    

复制代码

首先：你这个方法中 while的循环条件有问题 没有结束标记
结合你这个字符串来说 while中的index是个固定的值 也就是2  而每次循环判断2！=-1 条件都满足
所以这样定义循环是停不下来的 就会一直去取子串  
其次：s=s.substring(index+key.length());         中的index+key.length（）也是个固定的值，你这个例子中的就是2+2=4，所以每次去子串的时候都是从取到的子串中的第四位开始取，那不断循环最后的结果肯定是角标越界异常。

最后：修改后的int index=0；
while ((index=s.indexOf(key))!=-1 )  中，s是变化的 是取后的子串，自然index也是随着s的变化在变化的。

你看看这个：原因我在代码中有解释

1. package com.itheima;
   
2. 
   
3. class MyMenuDemo {
   
4. 
   
5.         public static int getTimes2(String s, String key) {
   
6.                 int count = 0;
   
7.                 int index = s.indexOf(key);
   
8.                 while (index != -1) {
   
9.                         System.out.println("s=" + s);
   
10.                         s = s.substring(index + key.length());
    
11.                         index=s.indexOf(key);/*我在你源码的基础上加了这句话，如果不加这句index的值一直是2
    
12.                                                "index + key.length()"这个式子的值一直是4（相当于一直substring(4,length()-1)）
    
13.                                                执行4次后s变成：“de”，再执行一次就会报空指针异常了（因为长度现在是2，没有角标4）
    
14.                                                            */
    
15.                         count++;
    
16.                 }
    
17.                
    
18.                 return count;
    
19.         }
    
20. 
    
21.         public static void main(String[] args) {
    
22.                 String s = "abkkcdkkefkkskksde";        //
    
23.                 int count = getTimes2(s, "kk");
    
24.                 System.out.println("count=" + count);
    
25.         }
    
26. }
    

复制代码

楼主你好，如果问题已解决请将帖子状态修改为提问结束，如果未解决请继续提问，谢谢合作
如果不会修改请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html