public class Test2 {
        public static void main(String[] args) {
                int[] arr={5,2,5,6,1,2,5,7,8};
                int[]arr1=new int[10];
                for(int x=0;x<=arr.length;x++){
               
                if(arr[x]==arr[x+1]){
                arr1[x]=arr[x];       
                }
                else
                {
                        arr1[x]=arr[x];
                        arr1[x+1]=arr1[x+1];
                       
               
        }

}
                for(int x=0;x<arr1.length;x++){
                System.out.println(arr1[x]);
                }
}
}

  for(int x=0;x<=arr.length;x++){
               
                if(arr[x]==arr[x+1])
这样定义，当x=arr.length时arr[x+1]会越界，应该定义为
  for(int x=0;x<arr.length-1;x++){
               
                if(arr[x]==arr[x+1])
这样才能保证arr[x+1]取到最后一个角标而且不会越界

这样还是会越界

@翱翔@ 发表于 2013-12-31 13:50
这样还是会越界

1. public class Test2 {
   
2.         public static void main(String[] args)
   
3.         {
   
4.                 int[] arr={5,2,5,6,1,2,5,7,8};
   
5.                 int[]arr1=new int[10];
   
6.                 for(int x=0;x<arr.length-1;x++)//把<=改成< 再-1
   
7.                 {
   
8.                
   
9.                         if(arr[x] == arr[x+1])
   
10.                         {
    
11.                                 arr1[x] = arr[x];        
    
12.                         }
    
13.                         else
    
14.                         {
    
15.                                 arr1[x] = arr[x];
    
16.                                 arr1[x+1] = arr1[x+1];
    
17.                         }
    
18. 
    
19.                 }
    
20.                 for(int x=0;x<arr1.length;x++)
    
21.                 {
    
22.                         System.out.println(arr1[x]);
    
23.                 }
    
24.         }
    
25. }

复制代码

x<=arr.length，这句限定的x最大为9，那么arr[x+1]最大为10，是不是越界了？改成“x<arr.length-1”

for(int x=0;x<=arr.length;x++)   里面，不能=,if(arr[x]==arr[x+1])也有问题

arr.length = 9,而你代码中有arr[x+1]当x=9时，就会出现arr[10]当然会越界了，你可以这样改写：
for(int i=1; i<arr.length; i++){
                //定义一个标记
                int flag = 0;
            for(int j=0; j<i; j++){
                if(arr[i] == arr[j]){
                        //给重复的值一个标记
                    flag = -1;
                }
            }
            //把没有被标记的值输出
            if(flag != -1){
                    arr1[i]=arr[i];
            }
        }

个人拙见，仅供参考，如有错误，还望赐教。

程玉习 发表于 2013-12-31 13:56

这样是不会越界，那怎样修改才能实现去重的效果

for(int x=0;x<=arr.length;x++)
arr.length 的值为9
而你循环的取值范围为0-9
a[]的取值范围为0-8,所以抛了越界的异常

1. for(int x=0;x<=arr.length;x++){
   
2.                
   
3.                 if(arr[x]==arr[x+1]){
   
4.                 arr1[x]=arr[x];        
   
5.                 }
   
6.                 else
   
7.                 {
   
8.                         arr1[x]=arr[x];
   
9.                         arr1[x+1]=arr1[x+1];
   
10.                         

复制代码

循环过程中，当执行到x=arr1.length的时候，满足条件，然后会arr1.length+1，这时候就会产生越界的情况。

去重的话，你可以参考一下排序的代码，从大到小或者从小到大都可以，

1. class  arrayDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int [] array=new int []{1,2,3,4,5,6,7,8,9,0};
   
6.                 print(array);
   
7. 
   
8.         }
   
9.         public static void print(int []array)
   
10.         {
    
11.                 System.out.print("[ ");
    
12.                 for (int x=0;x<array.length;x++)
    
13.                 {
    
14.                         if (x!=array.length-1)
    
15.                                 System.out.print(array[x]+" , ");
    
16.                         else
    
17.                                 System.out.println(array[x]+" ]");
    
18.                 }
    
19.         }
    
20. }
    
21. 
    
22. 这是数组遍历

复制代码

排序随便给你一个吧：

1.         //冒泡排序
   
2.         public static void bubbleSort(int[]arr)
   
3.         {
   
4.                 for (int x=0;x<arr.length ;x++ )
   
5.                 {
   
6.                         for (int y=0;y<arr.length-x-1 ;y++ )
   
7.                         {
   
8.                                 if (arr[y]>arr[y+1])
   
9.                                 {
   
10.                                         swap(arr,y,y+1);
    
11.                                 }
    
12.                         }
    
13.                 }
    
14.         }
    
15.         冒泡排序

复制代码

楼主写的看不懂，貌似错的很严重。你看看我写的这个，一个思路，当然内部实现的过程避开了双数组存在时，会引发的问题。但是外部实现功能是可以的：

1. public class Test2 {
   
2.         public static void main(String[] args) {
   
3.                 int[] arr={5,2,5,6,1,2,5,7,8};
   
4.                 for(int x=0;x<arr.length-1;x++){
   
5.                          for(int j=x+1; j<arr.length; j++){   
   
6.                                  if(arr[x]==arr[j]){
   
7.                                          arr[x]=-1000;//把存在的数赋值为一个不存在的数或者其他，有bug，不用List或者异常真心不好解决。
   
8.                                  }
   
9.                         }
   
10.                 }
    
11.                 System.out.print("新数组：【");
    
12.                 for(int x=0;x<arr.length;x++)
    
13.                         if(arr[x]!=-1000)//对打印进行控制。
    
14.                                 System.out.print(arr[x]+"，");
    
15.                 System.out.print("】");
    
16.                 }
    
17.         }
    
18.        

复制代码

注释了，有bug，限于自己的水平搞不定。

for(int x=0;x<=arr.length;x++){   //如果x=arr.length
               
                if(arr[x]==arr[x+1]){//arr[x+1]就会超了arr.length,所以角标越界
                arr1[x]=arr[x];        
                }
                else
                {
                        arr1[x]=arr[x];
                        arr1[x+1]=arr1[x+1];

#在这里快速回复# for(int x=0;x<=arr.length;x++)等号去掉，再减一

先排序后去重。

1. public static void main(String[] args)
   
2.         {
   
3.                 int[] arr=new int[]{5,2,5,6,1,2,5,7,8};
   
4.                 int[]arr1=new int[9];
   
5.                 int temp = 0 ;
   
6.                 //总体思路是先排序后去重
   
7.                for(int i=arr.length-1;i>0;--i)//把<=改成< 再-1
   
8.                 {
   
9.                        
   
10.                         for(int k=0;k<i;++k)
    
11.                         {
    
12.                                 //冒泡排序
    
13.                                 if(arr[k]>arr[k+1])
    
14.                                 {
    
15.                                         temp=arr[k];
    
16.                                         arr[k]=arr[k+1];
    
17.                                         arr[k+1]=temp;
    
18.                                 }
    
19.                                
    
20.                         }
    
21.                        
    
22.                 }
    
23.                
    
24.                 arr1=arr;
    
25.                 System.out.print('\u005b');
    
26.                 int[] tempt = null;
    
27.                 int count=1;
    
28.                 for(int i=0;i<arr1.length-1;++i)
    
29.                 {       
    
30.               
    
31.                         //去除重复元素
    
32.                  if(arr1[i]==arr1[i+1])
    
33.                                 continue;
    
34.                          count++;
    
35.                         //tempt=new int[count++];
    
36.                          temp=arr1[i];
    
37.                         System.out.print(temp+" ");
    
38.                         //if(i==arr1.length-1)
    
39.                         if(i==arr1.length-2)
    
40.                         System.out.print(arr1[arr1.length-1]+" ");
    
41.                 }
    
42.                 /*tempt=arr1;
    
43.                 for(int i=0;i<tempt.length;++i)
    
44.                 {
    
45.                         System.out.print(tempt[i]+" ");
    
46.                 }*/
    
47.                 System.out.print('\u005d');
    
48.         }

复制代码

你写的题太乱了，你的需求是什么？  根据后面判断,if(arr[x]==arr[x+1]) 也越界了，应该改为：x<arr.length-2

776699 发表于 2014-1-1 00:44
你写的题太乱了，你的需求是什么？  根据后面判断,if(arr[x]==arr[x+1]) 也越界了，应该改为：x ...

去除重复值