一个有趣的问题：怎么在JS的数组中去除重复元素？（JAVA实现吧..）

• 当然，我不知道怎么在JS中去去除重复元素，因为我不会js。

• 但是，我想，如果在Java中呢？如果只使用数组呢？

  ---

• 我们知道，在Java中，如果是仅仅实现对数组重复元素的剔除，可以有很多的方式：比如，我用一个Set去接收数组中的所有元素，然后再遍历该Set取出所有元素，存放到一个新的数组中，就完成了重复元素的剔除操作。

• 但是，如果不使用集合呢？如果只能用数组去实现呢？
• 那么，我们可以想想如果是一道数学题，有10个数，其中可能有重复数，我要怎么去找到重复数，然后剔除他呢？
• 我的想法是这样的：

1. 将第一个元素取出来和第二个元素，第三个元素...最后一个元素进行比较。如果有相等的，那么剔除第一个元素，结束本次的比较；如果没有相等的，那么一直比较到头，保留第一个元素。
2. 将第二个元素取出来，和第三个元素，第四个元素...最后一个元素进行比较。如果有相等的，那么剔除第一个元素，结束本次的比较；如果没有相等的，那么一直比较到头，保留第一个元素。
3. ....
4. 将倒数第二个元素与最后一个元素进行比较 ===》完成比较剔除重复元素的操作。
5. *注意，每次都是和后面的元素进行比较，不要和前面的元素比较*

• 那么问题来了，如何使用Java代码去实现呢？

去除数组的重复元素
假设 int[] arr = new int[]{1, 1, 2, 3, 4, 3, 4, 5, 8, 5, 7, 8};
怎么去除重复呢？
1. 先定义一个长度与arr相同的数组arr2，用于记录不重复元素的角标，重复元素的角标使用-1来代替
    arr[0] 与后面的进行比较，如果arr[0] == arr[i] ，那么记录arr2[0] = 0;否则记录arr[0] = -1;
    然后 arr[1]与后面的比较，
    以此类推，知道n-1 与n比较，结束比较，得到存储了不重复元素角标的数组
2. 遍历arr2，获得>-1 的元素个数count
3. 创建一个新数组result，数组长度为count
4. 将arr中的不重复元素(根据arr2存储的角标可获取)存放到新数组result中。
===完成。

• OK。说了这么多，还是代码比较实际一点：

package com.pythonCat.removeSame;

import java.util.Arrays;

/**
 * Created by pythonCat on 16-3-2.
 */
public class RemoveSame {

    public static void main(String[] args) {

        int[] arr = new int[]{1, 1, 2, 3, 4, 3, 4, 5, 8, 5, 7, 8};

        int[] removeSame = removeSame(arr);
        System.out.println(" arr = " + Arrays.toString(arr));
        System.out.println(" removeSame = " + Arrays.toString(removeSame));
        System.out.println("hello world");
    }


    public static int[] removeSame(int[] array) {

        if (array == null || array.length == 0 || array.length == 1) return array;

        int[] arr2 = new int[array.length];//记录array中的不重复元素的角标
        for (int i = 0; i < array.length - 1; i++) { //循环取 array[0] - array[n-1]
            for (int j = 1; j < array.length; j++) {//循环取 array[1] - array[n]
                // 比较array[0] 与array[1],array[2]... array[n]的大小
                // 比较array[0] 与array[2]... array[n]的大小
                //   ...
                //比较array[n-1] 与array[n]的大小
                if (j > i) {
//                    System.out.println("本次比较的 i= "+i+ "\t j= "+j);
                    if (array[i] == array[j]) {
                        System.out.println("重复元素的角标：" + i);
                        arr2[i] = -1;
                        break; //跳出内部循环，不妨碍外部的循环
                    } else {
                        arr2[i] = i;
                        System.out.println("=======不重复元素的角标：" + i);
                    }
                }

            }
        }
        System.out.println(Arrays.toString(arr2));
        //通过以上的遍历获取重复元素的角标前面位置的
        int count = 0; //记录非重复元素的个数
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] != -1) {
                count++;
            }
        }
        int[] result = new int[count];
        int index = 0;
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] != -1) {
                result[index] = array[i];
                index++;
            }
        }
        //通过以上循环获取所有非重复元素放入数组result
        return result;
    }


}

• 运行之后的LOG如下：

arr = [1, 1, 2, 3, 4, 3, 4, 5, 8, 5, 7, 8]
removeSame = [1, 2, 3, 4, 5, 7, 8]

• 那么，这样子就完成了数组的重复元素的剔除。这个问题对于Java实现的难点就在于，数组是一个定长的东西，那么我怎么知道该去创建一个多大的数组去放剔除之后的结果呢？或者，数组是一个定长的东西，我找到重复数之后，怎么在当前数组中去剔除呢？ 没有办法，我们只能通过记录重复元素的角标的方式去弄了。