这是黑马基础测试里的一个题目，感觉有点意思，和大家讨论一下。
需求：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}。
前提：在网上看到有其他办法，但目前我们课程刚进行到String类，很多知识都没学到，想到用“标志位计算元素个数”的办法。
问题：就目前我的知识水平（刚刚学完String类）不知道大家有什么好的解决办法没有。
我的代码如下

1. package com.itheima;
   
2. 
   
3. import java.util.Arrays;
   
4. 
   
5. public class Test8 {
   
6. 
   
7.         /**
   
8.          *需求：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.                 int arr[]={4,2,4,6,1,2,4,7,8};
    
13.                 System.out.println(Arrays.toString(repeat(arr)));        //将去重后数组打印出来
    
14.         }
    
15.         
    
16.         /*定义方法实现去重。
    
17.          * 思路：
    
18.          *                 1、先确定去重后数组元素的个数count，定义一个boolean类型数组来给重复的元素做标志；
    
19.          *                 2、定义元素个数为count的新数组arrNew，将所有不重复的元素存入数组中。
    
20.          *                 3、将arrNew返回。
    
21.          * */
    
22.         
    
23.         public static int[] repeat(int [] arr){
    
24.                 boolean flag[] = new boolean[arr.length];//定义一个和目标数组长度一样的boolean类型，此数组用作标示，用于获取不重复元素的个数的标志位
    
25.                 for (int i = 0; i < flag.length; i++) {//遍历数组,查找重复的元素。循环结束后，重复的元素对应的标志位置都为true。
    
26.                         if (flag[i]) //如果这个元素对应的标志位已被置为true，则返回循环继续检查下一个元素。
    
27.                                         continue;
    
28.                         for (int j = i+1; j < flag.length; j++) {    //后边元素和此位置上的元素比较，
    
29.                                 if (arr[j]==arr[i]) {     //如果后边元素和前边元素相同，
    
30.                                         flag [j]=true;   //则此重复元素对应的标志位置为true
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.                
    
35.                 int count=0;    //计数器，记录不重复元素的个数
    
36.                 for (int i = 0; i < flag.length; i++) {    //算出不重复元素的个数，记为count，
    
37.                         if (!flag[i]) {      //标志位依然为false的对应元素即为不重复的元素
    
38.                                 count++;
    
39.                         }
    
40.                 }
    
41.                
    
42.                 int index=0;
    
43.                 int [] arrNew = new int [count];        //定义新数组，元素个数为count。
    
44.                 for (int i = 0; i < arr.length; i++) {        //将所有不重复的元素存入新数组中
    
45.                         if (!flag[i]) {
    
46.                                 arrNew[index++]=arr[i];
    
47.                         }
    
48.                 }
    
49.                
    
50.                 return arrNew;        //返回数组
    
51.         }
    
52. }

复制代码

分享一下我写的

1. package com.itheima;
   
2. 
   
3. /*
   
4. * 5、 数组去重复，
   
5. 例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
6. */
   
7. 
   
8. public class Test5
   
9. {
   
10.         public static void main(String args[])
    
11.         {
    
12.                 int[] arr={4,2,4,6,1,2,4,7,8};//创建并初始化数组
    
13.                 for(int i=0;i<8;++i)
    
14.                 {
    
15.                         for(int j=i+1;j<9;++j)
    
16.                         {
    
17.                                 if(arr[i]==arr[j])
    
18.                                 {
    
19.                                         arr[j]=-1;//逐个比较数组中元素，如果出现两个元素相等，则后一个元素赋值-1
    
20.                                 }
    
21.                         }
    
22.                 }
    
23.                 for (int i=0;i<9;++i)
    
24.                 {
    
25.                         if(arr[i]!=-1)
    
26.                         {
    
27.                                 System.out.print(arr[i]+" ");}continue;//逐个输出数组元素，遇到-1的元素跳过
    
28.                         }
    
29.                 }
    
30. }
    
31.        
    

复制代码

下面的内容请不要抄袭，这是我在黑马基础测试题里的解法：

1. public class Test5 {
   
2.         public static void main(String[] args) {
   
3.                 //1.创建一个数组
   
4.                 Integer[] arr ={4,2,4,6,1,2,4,7,8};
   
5.                 //2.利用LinkedHashSet的"元素不可重复"特性去除重复元素（使用链表结构的集合主要是为了让数组元素的前后位置关系不发生变化）
   
6.                 LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
   
7.                 for(Integer temp:arr){
   
8.                         set.add(temp);
   
9.                 }
   
10.                 //3.把集合转换成数组
    
11.                 arr = set.toArray(new Integer[0]);
    
12.                
    
13.                 //4.输出去除重复元素后的数组元素
    
14.                 for(int temp:arr){
    
15.                         System.out.print(temp);
    
16.                 }
    
17.         }
    
18. }
    

复制代码

思想大概就是把数组放到set里面（set的值不会重复）就可以去重了
                  Integer[] arr = {4,2,4,6,1,2,4,7,8};

        Set<Integer> set = new HashSet<Integer>();

        for(Integer i : arr)

        set.add(i);

        for(Object j: set.toArray())

        System.out.print(j + " ");

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

你这个只是打印了一下不重复的元素，并没有生成新数组啊

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

你这用集合了，没学呢，不用集合有其他办法吗？

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

不用集合有其他办法吗？

群里高手很多啊!!

一世英明 发表于 2014-4-2 19:44
群里高手很多啊!!

我是刚报名的，正好我的测试题就有这道题，分享一下

/**
* 5、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
* 思路：
* 遍历原始数组
* 定义个容器，让数组中的每个元素与这个容器中的元素比较，如果这个元素不存在，就将数组中的这个元素存储到容器中。反之，舍弃。
* 再用个容器以{4,2,6,1,7,8}的形式存储。
* 最后打印结果。
*/
public class Test5 {

        public static void main(String[] args) {
                //原始数值
                int[] nums = new int[]{4,2,4,6,1,2,4,7,8};
                //定义一个容器，
                List<Integer> list = new ArrayList<Integer>();
                //循环遍历去除数组中重复的元素
                for (int i = 0; i < nums.length; i++) {
                        if (!list.contains(nums)) {
                                list.add(nums);
                        }
                }
               
                StringBuffer sb = new StringBuffer();
                sb.append("{");
                Iterator<Integer> it=list.iterator();
                while(it.hasNext()){
                        sb.append(it.next()+",");
                       
                }
                sb.delete(sb.length()-1,sb.length());//删除最后一个元素
                sb.append("}");
                System.out.println(sb);

        }

}

无此姓名 发表于 2014-4-2 18:20
你这个只是打印了一下不重复的元素，并没有生成新数组啊

我看了下，思路差不多的，你在这个基础上在数出-1的个数在计数，再初始化新数组在放在检查非-1的放进去就好，它这个主要是给你提供了一个除了脚标也可以赋值的思路，生成的过程是可以跟你的一样的

lwy0319 发表于 2014-4-2 22:42
我看了下，思路差不多的，你在这个基础上在数出-1的个数在计数，再初始化新数组在放在检查非-1的放进去就 ...

如果给出的数组里本身就有-1元素呢？ 比如{2,3,4,5,6,-1,3,4,2}

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

你这代码有问题，如果数组里本身就有-1呢？ 比如{1,2,3,4,5,6,-1,1,2,3,4}

无此姓名 发表于 2014-4-2 23:24
如果给出的数组里本身就有-1元素呢？ 比如{2,3,4,5,6,-1,3,4,2}

赋值之前检查下哈，如果有就赋值别的，大不了循环检查，依次减一定的数。

lwy0319 发表于 2014-4-2 23:26
赋值之前检查下哈，如果有就赋值别的，大不了循环检查，依次减一定的数。 ...

写出来看

无此姓名 发表于 2014-4-2 23:38
写出来看

1. public class Test{
   
2.         public static void main(String[] args) {
   
3.                 int oldA[]={4,2,4,6,1,2,4,7,8,0,0,-1,-1,-2,-2,-3};//初始化原始数组
   
4.                 int x=0;//初始化新的数组长度
   
5.                 int y=0;//初始化新数组的脚标
   
6.                 int m=0;
   
7.                 int n=0;
   
8.                 int nonexistent=0;
   
9.                 int a=0;
   
10.                 while(a<oldA.length){
    
11.                         for(int i=0;i<oldA.length;i++){
    
12.                                 if(oldA[i]==nonexistent)
    
13.                                         nonexistent--;
    
14.                         }
    
15.                         a++;
    
16.                 }
    
17.                         for(int i=1;i<oldA.length;i++){//嵌套循环给与数组索引编号靠后的项数相同的项赋值为nonexistent
    
18.                                 for(int j=0;j<i;j++){
    
19.                                         if(oldA[i]==oldA[j]){
    
20.                                                 oldA[i]=nonexistent;
    
21.                                         }
    
22.                                         }
    
23.                                 }
    
24.                         for(int i=0;i<oldA.length;i++){//判断原始数组变更后的0项的个数
    
25.                                 if(oldA[i]!=nonexistent){            //并从新数组长度的初值减去
    
26.                                         x++;
    
27.                                 }
    
28.                         }
    
29.                 //}
    
30.                
    
31.                 int newA[]=new int[x];//初始化新数组，类型，长度
    
32.                 for(int i=0;i<oldA.length;i++){
    
33.                         if(oldA[i]!=nonexistent){//将原始数组中的非零项加入新数组
    
34.                                 newA[y++]=oldA[i];//每被赋值一次，新数组的脚标数值+1以便下次赋值用
    
35.                         }
    
36.                 }
    
37.                 for(int i=0;i<newA.length;i++)
    
38.                         System.out.print(newA[i]+" ");//循环输出新数组
    
39.                 }
    
40.         }
    

复制代码

好吧。。。满足你。。不过感觉没必要太较真。。毕竟后面很快就会学到动态数组了。马上你就是不用跟小学奥数较真的大学生了哈，另外说下还是你的方法更好一些，那个人只是给你提供一个思路，虽然代码当时没实现得很好，提取有用的地方就好了。

lwy0319 发表于 2014-4-3 02:54
好吧。。。满足你。。不过感觉没必要太较真。。毕竟后面很快就会学到动态数组了。马上你就是不用跟小学 ...

好吧，你赢了，这题确实没什么实际用处。但是限定范围就是为了搞一搞奥数题嘛。

无此姓名 发表于 2014-4-5 10:03
好吧，你赢了，这题确实没什么实际用处。但是限定范围就是为了搞一搞奥数题嘛。 ...

你说的有道理，我最开始接触这题的时候，学习进度还不如你，我写了篇技术博客，引用了你的代码，地址：
http://blog.csdn.net/u013938806/article/details/22985985

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

for(Integer i : arr)   这是什么用法？新手没见过

学习学习！

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. @SuppressWarnings({ "rawtypes", "unchecked" })
   
7. public class Test7 {
   
8.         /**
   
9.          * 7、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
10.          */
    
11.         public static void main(String[] args) {
    
12.         int[] arr = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
13.         //创建对象
    
14.         List data = new ArrayList();
    
15.         //增强for
    
16.         for (int num : arr) {
    
17.             if (!data.contains(num)) {
    
18.                 data.add(num);
    
19.             }
    
20.         }
    
21.         //打印数组
    
22.         System.out.println(data);
    
23.     }
    
24. }

复制代码