有数组” int[] arr =  {11,2, 4, 2, 10, 11}，定义一个函数清除该数组的重复元素，返回一个没有重复元素而且不能出现0元素的数组。

备注：使用最基础的代码解答...

醉、倾鯎 发表于 2014-7-9 17:05
原谅我这简陋的代码，我自己看着都难受

哈哈。能给出答案就非常感谢了

1. package cn.ithm.text;
   
2. 
   
3. import java.util.HashSet;
   
4. import java.util.Iterator;
   
5. import java.util.Set;
   
6. 
   
7. /*
   
8. * 有数组” int[] arr =  {11,2, 4, 2, 10, 11}，
   
9. * 定义一个函数清除该数组的重复元素，
   
10. * 返回一个没有重复元素而且不能出现0元素的数组。
    
11. */
    
12. public class Demo {
    
13.         public int[] getNewArr(int[] oldArray) {
    
14.                 Set set = new HashSet();// 创建一个不允许重复的集合
    
15.                 for (int i = 0; i < oldArray.length; i++) {
    
16.                         // 循环遍历参数数组，将参数数组的元素导入集合
    
17.                         if (oldArray == 0)
    
18.                                 continue;
    
19. 
    
20.                         set.add(oldArray);
    
21.                 }
    
22.                 int[] newArray = new int[set.size()];//创建新数组，数组长度为集合长度
    
23.                 int count = 0;//创建计数器
    
24.                 for (Iterator it = set.iterator(); it.hasNext();) {
    
25. 
    
26.                         newArray[count] = (int) it.next();//把容器内的元素传入新数组
    
27.                         count++;
    
28.                 }
    
29. 
    
30.                 return newArray;//返回新数组
    
31.         }
    
32. 
    
33.         public static void main(String[] args) {
    
34.                 int[] arr = new int[] { 11, 2, 4, 2, 10, 11 };
    
35.                 Demo d = new Demo();
    
36.                 int[] newArr = d.getNewArr(arr);
    
37.                 for (int i = 0; i < newArr.length; i++) {
    
38.                         System.out.println(newArr);
    
39.                 }
    
40.         }
    
41. }

复制代码

原谅我这简陋的代码，我自己看着都难受

嗅ㄨiaǒ孑 发表于 2014-7-9 12:44
看别人代码　　真烦　　

正解.............

看别人代码　　真烦　　

不知道楼上这个方法怎么样，哪里需要完善的吗?总感觉好繁琐

1. public class Demo5 {
   
2.        
   
3.         public static void main(String[] args) {
   
4.                 // TODO Auto-generated method stub
   
5.                 int[] arr={11,2,4,2,10,11,4,4,2,11,11};
   
6.                 int[] newArr=getNewArr(arr);
   
7.                 for(int i: newArr){
   
8.                         System.out.println("["+i+"]");
   
9.                 }
   
10.                
    
11.         }
    
12.         public static int[] getNewArr(int[] arr)
    
13.         {
    
14.                 int temp=0;
    
15.                 for(int i=0;i<arr.length-1;i++){
    
16.                         for(int j=1+i;j<arr.length;j++){
    
17.                                 if(arr[i]==arr[j]&&arr[i]!=0)
    
18.                                 {
    
19.                                         arr[j]=0;
    
20.                                         temp++;
    
21.                                 }
    
22.                         }
    
23.                 }
    
24.                 System.out.println(temp);
    
25.                 return getNewArr(arr,temp);
    
26.         }
    
27.         public static int[] getNewArr(int[] arr, int temp){
    
28.                 int[] newArr = new int[arr.length-temp];
    
29.                 for(int x=0,y=0;x<arr.length;x++){
    
30.                         if(arr[x]==0){
    
31.                                 continue;
    
32.                         }
    
33.                         newArr[y]=arr[x];
    
34.                         y++;
    
35.                 }
    
36.                 return newArr;
    
37.         }
    
38. }
    

复制代码

cat73 发表于 2014-7-6 16:02
思路1:新建一个数组,一个个成员向里复制,在复制之前先判断是否存在过

思路2:懒人方案,用无序集合,往里扔就 ...

谢谢，思路1已经收到，思路2没学过...

思路1:新建一个数组,一个个成员向里复制,在复制之前先判断是否存在过

1. import java.util.Arrays;
   
2. 
   
3. public class Test{
   
4.         public static void main(String[] args) {
   
5.                
   
6.                 int[] srcArray = {1, 1, 1, 3, 4, 5, 6, 7, 888, 888, 888, 9};
   
7.                 int[] dstArray = test(srcArray);
   
8.                
   
9.                 for(int x : dstArray){
   
10.                         System.out.print(x + " ");
    
11.                 }
    
12.         }
    
13.         
    
14.         /**
    
15.          * 去除数组中的重复元素
    
16.          * @param srcArray 源数组
    
17.          * @return 处理后的数组
    
18.          */
    
19.         public static int[] test(int[] srcArray){
    
20.                 //首先新建一个与源数组一样长的, 防止源数组中全部不重复
    
21.                 int[] dstArray = new int[srcArray.length];
    
22.                
    
23.                 //temp用于在内循环中检测是否有重复, index用于记录已经复制了多少个元素, flag用于内循环中的记录
    
24.                 int temp, index = 0;
    
25.                 boolean flag;
    
26.                
    
27.                 for(int i = 0; i < srcArray.length; i++){
    
28.                         temp = srcArray[i];
    
29.                         flag = false;
    
30.                         //判断要复制的成员是否已经在新数组中
    
31.                         for(int x : dstArray){
    
32.                                 if(x == temp){
    
33.                                         flag = true;
    
34.                                         break;
    
35.                                 }
    
36.                         }
    
37.                         //如果不在则复制
    
38.                         if(!flag){
    
39.                                 dstArray[index] = temp;
    
40.                                 index++;
    
41.                         }
    
42.                 }
    
43.                 //最后去掉新数组中没用过的元素
    
44.                 return Arrays.copyOfRange(dstArray, 0, index);
    
45.         }
    
46. }

复制代码

我是用集合做的

1. public static void main(String[] args){
   
2.                         //定义一个有重复元素的数组
   
3.                         int[] arr={0,4,2,4,6,1,2,4,7,8};
   
4.                         //考虑到要去除重复元素，想到Set集合可以除去重复元素
   
5.                         TreeSet ts=new TreeSet();
   
6.                         //所以遍历数组，并添加到Set集合中，这样便去除了当中的重复元素
   
7.                         for(int x=0;x<arr.length;x++){
   
8.                                 if(arr[x]==0)
   
9.                                         continue;
   
10.                                 ts.add(arr[x]);
    
11.                         }
    
12.                         System.out.println(ts);
    
13.                 }

复制代码

思路1:新建一个数组,一个个成员向里复制,在复制之前先判断是否存在过

思路2:懒人方案,用无序集合,往里扔就行

愤怒的小蔡！ 发表于 2014-7-5 21:22
哈哈~~我来凑热闹！

做出来了吗？

哈哈~~我来凑热闹！