有一个数组里面存放的是有序的数字比如：
[1,2,4,5,7,8,9]
要求写一个方法把连续的数字放到一个数组中。
得到的结果为：
[1,2]
[4,5]
[7,8,9]

方法有3：
1.使用for循环语句逐个复制数组里的元素到对相应数组。
2.使用System类中的静态方法arrayCopy。
System.arrayCopy（source,0,target,0,source.length）
我这用方法二写了一个程序：

1. public class Shuzu {
   
2.         /*有一个数组里面存放的是有序的数字比如：
   
3.           [1,2,4,5,7,8,9]
   
4.          要求写一个方法把连续的数字放到一个数组中。
   
5.          得到的结果为：
   
6.          [1,2]
   
7.          [4,5]
   
8.          [7,8,9]*/
   
9.         public static void main(String[]args){
   
10.                 int []array1={1,2,4,5,6,7,8,9};
    
11.                 int []array2=new int[2];
    
12.                 int []array3=new int[2];
    
13.                 int []array4=new int[3];
    
14.                 System.arraycopy(array1,0,array2,0,2);
    
15.                 System.arraycopy(array1,2,array3,0,2);
    
16.                 System.arraycopy(array1,4,array4,0,3);
    
17.                 for(int s1:array2){
    
18.                         System.out.print(s1);
    
19.                 }
    
20.                 for(int s2:array3){
    
21.                         System.out.print(s2);
    
22.                 }
    
23.                 for(int s3:array4){
    
24.                         System.out.print(s3);
    
25.                 }
    
26.         }
    
27.        
    
28. 
    
29. }
    

复制代码

3.使用clone方法复制数组

张会文 发表于 2013-1-1 11:46
方法有3：
1.使用for循环语句逐个复制数组里的元素到对相应数组。
2.使用System类中的静态方法arrayCopy。

好像我没说清楚，我想知道的是给方法传递一个数组，方法的作用是将数组中的连续数字拆分出来。[1、2、4、5、7、8、9]这个数组只是一个列子。

int [] a={1,2,3,4,5,6,7}
int[] i=a.toIntArray[]

这是我刚想的办法(详情在注释里) :
想了半天 觉得这个办法最好了 ...

1. package heima.test;
   
2. 
   
3. import java.util.Arrays;
   
4. 
   
5. public class Test {
   
6. 
   
7.     /*
   
8.      * @param 黑马程序员
   
9.      * 有一个数组里面存放的是有序的数字比如：[1,2,4,5,7,8,9]要求写一个方法把连续的数字放到一个数组中。得到的结果为：
   
10.      * [1,2][4,5][7,8,9]
    
11.      *
    
12.      * @author 高一航
    
13.      */
    
14.     public static void main(String[] args) {
    
15.         int[] home = new int[] { 1, 2, 4, 5, 7, 8, 9 };
    
16.         fun(home);
    
17.     }
    
18. 
    
19.     public static void fun(int[] home) {
    
20.         int index = 0;// 截取home的开始位置
    
21.         int length = 1;//所要截取的长度
    
22.         int[] arr; //新的数组
    
23.         for (int i = 1; i < home.length; i++) {  //逐一遍历home数组
    
24.             if (home[i] == home[i - 1] + 1) {  //如果和前面的数连续则将长度加一
    
25.                 length++;
    
26.             } else {  //读到不连续的数字了,则输出前面连续的几个数
    
27.                 arr = new int[length]; //实例化要截取的新数组
    
28.                 System.arraycopy(home, index, arr, 0, length);  //将原数组从index开始截取length长度,复制到arr数组.
    
29.                 String s = Arrays.toString(arr);
    
30.                 System.out.print(s); //输出截取到的新数组
    
31.                 index = index + length;  //截取位置初始化
    
32.                 length = 1; //截取长度初始化
    
33.             }
    
34.         }
    
35.         
    
36.         //下面是为了打印最后一次截取到的arr数组
    
37.         arr = new int[length];
    
38.         System.arraycopy(home, index, arr, 0, length);
    
39.         String s = Arrays.toString(arr);
    
40.         System.out.println(s);
    
41.     }
    
42. 
    
43. }
    

复制代码

输出:



代码都是一个一个手敲的...给点技术分支持吧~

[code]
//可以参考字符串匹配算法
class Dispart
{

1. 
   
2. //可以参考字符串匹配算法
   
3. class Dispart
   
4. {
   
5.         int cnt=0;                //用于判断连续时用
   
6.         int index= 0;
   
7.         int[]st;
   
8.         Dispart(int len){        st = new int[2*len];        }        //分配所需要拆开的数组空间的2倍，防止空间不足
   
9.         void Disp(int a[])
   
10.         {
    
11.                 int j=0,i;
    
12.                 lab:
    
13.                 for ( i=0;i< a.length; i+=cnt)
    
14.                 {
    
15.                         j = i;
    
16.                         cnt = 0;
    
17.                         while(true)
    
18.                         {
    
19.                                 if (j==a.length)
    
20.                                         break lab;
    
21.                                 if (a[i]+cnt==a[j])                //如果相等  例如：a[i]=1  a[j]=1   那么j++ a[j]=2 cnt++ ,cnt=1
    
22.                                 {                                                //                a[i]+cnt==a[j]继续，否则偏移cnt个
    
23.                                        
    
24.                                         st[index] = a[j];
    
25.                                         cnt++;
    
26.                                         j++;
    
27.                                         index++;
    
28.                                 }
    
29.                                 else{
    
30.                                         st[index++] = -1;                //-1用于分隔用
    
31.                                         break;
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.                 i=0;
    
36.                 while(st[i]!=0)
    
37.                 {
    
38.                         if (st[i]==-1)
    
39.                         {
    
40.                                 System.out.println();
    
41.                         }
    
42.                         else
    
43.                                 System.out.print(st[i]);
    
44.                         i++;
    
45.                 }
    
46.                
    
47.         }
    
48.        
    
49. }
    
50. class DispartDemo
    
51. {
    
52.         public static void main(String []args)
    
53.         {
    
54.         //        Array a = new Array[10];
    
55.                 int []a = {1,2,4,5,7,8,9};
    
56.                 Dispart d = new Dispart(a.length);
    
57.                 d.Disp(a);
    
58.         }
    
59. }
    

复制代码