[ 本帖最后由 编程学徙 于 2014-5-10 02:21 编辑 ]\n\n以下是代码：

1. /**
   
2. *此程序解决的问题：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}；
   
3. *思路：把数组中重复的元素赋以int型的最小值，然后用另一个数组来接收不是最小值的数，最后输出；
   
4. *步骤：
   
5. *1、将数组中的元素与其后的元素一一比较；
   
6. *2、如果元素相等，则把该元素赋值为int型的最小值（通常情况下，我们不用到这个值）。
   
7. *3、遍历数组，把没有被赋为最小值的数赋给另一个数组；
   
8. *4、输出这个数组；
   
9. */
   
10. 
    
11. 
    
12. class Chong_Fu
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 int min = java.lang.Integer.MAX_VALUE;
    
17.                 int [] array = {4,2,4,6,1,2,4,7,8};
    
18.                 int n=array.length;                                                                //n用来统计元素被删除后的元素个数；
    
19.                 int i,j;
    
20.                 for(i=0;i<array.length-1;i++)
    
21.                 {
    
22.                         for(j=i+1;j<array.length;j++)
    
23.                         {
    
24.                                 if(array[i]==array[j])
    
25.                                 {
    
26.                                         array[i] = min;                                                //如果有元素与后面的某个元素值相等，则把该元素赋值为最小值，等同与删除这个数；
    
27.                                         n--;
    
28.                                         continue;
    
29.                                        
    
30.                                 }                                
    
31.                         }
    
32.                 }
    
33.                 int b[] = new int [n];
    
34.                 n = 0;
    
35.                 for(int a:array)
    
36.                 {
    
37.                         if(a!=min)
    
38.                         {
    
39.                                 b[n] = a;
    
40.                                 n++;
    
41.                         }
    
42.                 }
    
43.                 for(int boo:b)
    
44.                 {
    
45.                         System.out.print("\t"+boo);                                        //遍历数组b，输出结果；
    
46.                 }
    
47.                 System.out.println();
    
48.         }
    
49. }

复制代码

以下是结果：
有个几小问题请教一下：
1、此程序有个缺点：如果原数组中有某个元素的值为int 型最小值，则无法正常输出，请问如何解决？
2、这个题是我的基础测试题，这种把基础测试题或以后的入学测试题拿到论坛上来讨论的做法，是否有违黑马规则？

没人理啊……自己顶一下，各位，指点一下呗……

1. /*
   
2. 需求：去除数组中相同的元素。
   
3. 分析：把数组中的每一个元素存入集合中，用集合的方法来去除重复的元素。
   
4. */
   
5. import java.util.*;
   
6. class  ArrayTest
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 int[] arr = {1,3,4,5,3,4};
    
11.                 Object[] it = remove(arr);
    
12.                 print(it);
    
13.         }
    
14.         public static Object[] remove(int[] arr)
    
15.         {
    
16.                 //建立一个集合容器，把数组的元素装集合。
    
17.                 List<Integer> list = new ArrayList<Integer>();
    
18.                 for (int x = 0; x < arr.length ; x++ )
    
19.                 {
    
20.                         if(!list.contains(arr[x]))
    
21.                                 list.add(arr[x]);
    
22.                 }
    
23.                 return list.toArray();
    
24.         }
    
25.         //打印数组。
    
26.         public static void print(Object[] arr)
    
27.         {
    
28.                 System.out.print("[");
    
29.                 for (int x = 0; x < arr.length ; x++ )
    
30.                 {
    
31.                         if(x != arr.length -1 )
    
32.                                 System.out.print( arr[x] + ",");
    
33.                         else
    
34.                                 System.out.println(arr[x] + "]");
    
35.                 }
    
36.         }
    
37. }
    

复制代码

1. import java.util.*;
   
2. 
   
3. 
   
4.        
   
5.        
   
6. public class Test5
   
7. {
   
8.         /**
   
9.          *
   
10.          * 思路：
    
11.          * 1、定义一个数组并赋值
    
12.          * 2、定义一个容器，让数组中的每个元素与这个容器中的元素比较，如果这个元素不存在，
    
13.          *             则将元素添加进容器，若存在，舍弃。
    
14.          * 3、使用迭代器遍历打印容器中元素
    
15.          */
    
16. 
    
17.                          public static void main(String[] args)
    
18.                         {
    
19.                 //定义一个数组并赋值
    
20.                 int[] arr = new int[]{4,2,4,6,1,2,4,7,8};
    
21.                 //定义一个容器集合
    
22.                ArrayList<Integer> al = new ArrayList<Integer>();
    
23.                 //将数组中不重复的元素添加进入容器
    
24.                                 for (int i = 0; i < arr.length; i++)
    
25.                                 {
    
26.                                         if (!al.contains(arr[i]))
    
27.                        al.add(arr[i]);   
    
28.                 }
    
29.                                 Iterator<Integer> it=al.iterator();//定义一个迭代器并打印
    
30.                                 sop("{");
    
31.                                 for (int i=0;i<al.size()-1 ;i++)
    
32.                                 {
    
33.                                         sop(it.next()+",");
    
34.                                        
    
35.                                 }
    
36.                                 sop(it.next());
    
37.                                 sop("}");
    
38.                         }
    
39.                         public static void sop(Object obj )//实现打印功能的小程序，减少代码。
    
40.                         {
    
41.                                 System.out.print(obj);
    
42.                         }
    
43. 
    
44. }
    

复制代码

/这是我写的，你看看希望对你有帮助/

这个题用集合做好容易的，Set集合存放的元素不能重复，将数组里面的元素存进Set集合里，就可以过滤掉重复的了，想取出来就迭代吧。
      这个题还可以变一下，就是取除重复后排序，涉及到排序的话，就用TreeSet集合就可以！