我也有这道题学习了

我有个没有用集合的方法，在考试审核通过了发的，加技术分的各种可能都不放过0.0  @加分  大神

1. public class Test8
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {4,2,4,6,1,2,4,7,8};
   
6.                 int len = arr.length;
   
7.                 System.out.println("原数组：");
   
8.                 printArray(arr,len);
   
9.                
   
10.                 /*
    
11.                  *思路：每遇到重复的元素，就将其后面的元素向前移一位，然后将数组长度减1。
    
12.                  *                这样增加了系统的开销，因为移动次数多了，但是思路很好理解，而且结果没有打乱原数的顺序
    
13.                  */
    
14.                 for(int i=0; i<len-1; i++)
    
15.                 {
    
16.                         int key = arr[i];
    
17.                         for(int j=i+1; j<len; j++)
    
18.                         {
    
19.                                 if(arr[j] == key)
    
20.                                 {
    
21.                                         for(int k=j; k<len-1; k++)
    
22.                                         {
    
23.                                                 arr[k] = arr[k+1];                                                
    
24.                                         }
    
25.                                         len = len-1;
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.                 System.out.println("去重复后数组:");
    
30.                 printArray(arr,len);
    
31.                
    
32. 
    
33.                
    
34.         }
    
35.         //打印数组
    
36.         public static void printArray(int[] a, int len)
    
37.         {               
    
38.                 for(int i=0; i<len; i++)
    
39.                         System.out.print(a[i]+" ");      //这儿曾将双引号写成了单引号，死活打印不出正确数组，坑死了^_^
    
40.                 System.out.println();
    
41.         }
    
42. }

复制代码

贴一下我写的吧,只是用到数组知识
package com.itheima;
//*7、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
思路:
        1.新建一个长度和原数组长度相同的空数组,
        2.依次取出原数组中的数和新数组的每个数做比较,如果有就下一个数做比较,没有就把数放到新数组
                并且定义一个变量记录不重复数字的个数
        3.遍历完得到的新数组中为不重复数组,但是后面会有空的位置,再新建一个数组,长度为不重复数字的个数,将第二个数组复制到新数组.
public class Test7 {
        public static void main(String[] args) {
                int[]arr1={1,2,3,4,5,6,7,8,9,9};//原始数组arr1
                int[]arr2=new int[arr1.length];//新建数组arr2用来接收不重复数字,长度和原数组相同,因为可能原数组全部都不重复.
                int count=1;//记录不重复的数字个数
                arr2[0]=arr1[0];//将第一个数放进新数组
                loop2:
                for(int i=0;i<arr1.length;i++){//取出arr1 的每个数
                        for(int j=0;j<count;j++){
                                if(arr2[j]!=arr1[i]){//如果arr2 中没有arr1 取出的数字,把这个数字放进arr2,计数器加一
                                        if(j==count-1){
                                                arr2[count]=arr1[i];
                                                count++;
                                        }
                                        continue ;//放完继续下一个arr1中的数
                                }else{
                                        continue loop2;//有重复的,直接再来一轮
                                }
                        }
                }
                int arr3[]=new int[count];//因为arr2 后面有空位,去掉空位复制新数组,新数组就是不重复的
                for(int i=0;i<count;i++){
                        arr3[i]=arr2[i];
                }
                print(arr1);//
                System.out.println();
                print(arr3);
        }
        public static void print(int arr[]){//打印数组函数
                for(int i=0;i<arr.length;i++){
                        System.out.print(arr[i]+"\t");
                }
        }

}

王春涛 发表于 2014-6-26 10:24
for(Integer i : arr)   这是什么用法？新手没见过

for ...each 循环,就是遍历arr数组中的每一个数

挺好的不错。思维清晰

1. import java.util.List;
   
2. import java.util.concurrent.CopyOnWriteArrayList;
   
3. 
   
4. /**
   
5. * 创建时间：2014-11-18 下午3:26:35
   
6. *
   
7. * @author zhangtianyou
   
8. * @version 2.2
   
9. */
   
10. 
    
11. public class ArrayRemoveRepeat {
    
12. 
    
13.         /**
    
14.          * @param args
    
15.          */
    
16.         public static void main(String[] args) {
    
17.                 // 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}。
    
18.                 System.out.println("之前的数组");
    
19.                 Integer[] src = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
20.                 for (Integer k : src) {
    
21.                         System.out.print(k + ",");
    
22.                 }
    
23. 
    
24.                 List<Integer> list = new CopyOnWriteArrayList<Integer>(src);
    
25. 
    
26. 
    
27.                 int i = 0;
    
28.                 while (i < list.size() - 1) {
    
29.                        
    
30.                         int j = i+1;
    
31.                         while (j < list.size()) {
    
32.                                 if (list.get(i) == list.get(j)) {
    
33.                                         list.remove(j);
    
34.                                         j--;
    
35.                                 }
    
36.                                 j++;
    
37.                         }
    
38.                        
    
39. 
    
40.                         i++;
    
41.                 }
    
42. 
    
43.                 src = list.toArray(new Integer[list.size()]);
    
44.                 System.out.println("\n之后的数组");
    
45.                 for (Integer k : src) {
    
46.                         System.out.print(k + ",");
    
47.                 }
    
48.         }
    
49. }
    

复制代码

1453149997 发表于 2014-4-2 12:14
下面的内容请不要抄袭，这是我在黑马基础测试题里的解法：

还行吧，只是感觉你这样有生成数组吗？

不错，都挺厉害啊

Saner 发表于 2014-4-2 12:32
思想大概就是把数组放到set里面（set的值不会重复）就可以去重了
                  Integer[] arr = {4,2, ...

你这样,输出的结果并不是{4,2,6,1,7,8}.而是{1,2,4,6,7,8}

编立数组然后去掉相同的行吗？

2楼写的比较好                  

搞了好一会。没搞出来，

亓华森 发表于 2014-4-2 08:24
分享一下我写的

你这个思想挺好的，但是如果数组里面本来就有-1的话，-1这个值也会被跳过，结果就会有误。