数组去重 JavaScript 和Java

JavaScript 数组去重是面试中经常问到的问题

[html] view plain copy

1. var arr=[1,3,4,52,4,5,4,8,7,6];  

第一种方法：使用ES5中的indexOf进行去重：

[javascript] view plain copy

1. function arr1(){  
2.       var n=[];  
3.        for(var i=0;i<arr.length;i++){  
4.            if(n.indexOf(arr[i])==-1){  
5.                n.push(arr[i]);  
6.            }  
7.        }  
8.        return n;  
9.    }//先定义一个空数组，然后遍历数组，使用indexOf检查是否含有重复元素，如果没有则插入到n中。使用此类方法应考虑ES5的兼容性问题  

[javascript] view plain copy

1.   

运行结果如下：

第二种方法：先排序后然后再相邻比较去重

[javascript] view plain copy

1. function arr3(){  
2.          arr.sort();  
3.         var re=[arr[0]];  
4.         for(var i=1;i<arr.length;i++){  
5.             if(arr[i]!==re[re.length-1]){  
6.                 re.push(arr[i]);  
7.   
8.             }  
9.         }  
10.         return re;  
11.     }  

此种方法比第一种效率更好：

第三种方法：使用map去重

[javascript] view plain copy

1. function arr4(arr){  
2.         var map={};  
3.         if(arr&&Array.isArray(arr)){  
4.             for(var i=arr.length;i>=0;--i){  
5.                 if(arr[i] in map){  
6.                     arr.splice(arr[i],1);  
7.                 }else{  
8.                     map[arr[i]] = true;  
9.                 }  
10.             }  
11.         }  
12.         return arr;  
13.   
14.     }  

效率最高：

Java：

要求：清除数组中重复的元素

思路：因为开始时我以为是不能用集合(使用集合的方式在文章底部)，所以绞尽脑汁在不用集合的情况下去除数组中重复的元素，需要些一个去除重复内容的方法，我首先想到的的需要一个存储去重后元素的数组，然后两层循环，外层遍历原数组，内容逐个判断是否和之后的元素重复，然后再提出来存入新的数组。

走的弯路：因为数组是有长度的，在使用数组之前一定要先初始化数组给定长度，我在确定去重后数组长度这里纠结和很久，最后想起了有个方法System.arraycopy(被复制的数组，起始下标，接收的新数组，起始下标，结束下标);可以直接复制数组，既然这样，我就没必要纠结新数组的长度了，直接声明一个跟原数组长度一样的临时数组，只要记录下去重后的元素个数，然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。

方法代码：

//需要传入一个Object数组，然后返回去重后的数组
public static Object[] ifRepeat(Object[] arr){
        //用来记录去除重复之后的数组长度和给临时数组作为下标索引
        int t = 0;
        //临时数组
        Object[] tempArr = new Object[arr.length];
        //遍历原数组
        for(int i = 0; i < arr.length; i++){
            //声明一个标记，并每次重置
            boolean isTrue = true;
            //内层循环将原数组的元素逐个对比
            for(int j=i+1;j<arr.length;j++){
                //如果发现有重复元素，改变标记状态并结束当次内层循环
                if(arr[i]==arr[j]){
                    isTrue = false;
                    break;
                }
            }
            //判断标记是否被改变，如果没被改变就是没有重复元素
            if(isTrue){
                //没有元素就将原数组的元素赋给临时数组
                tempArr[t] = arr[i];
                //走到这里证明当前元素没有重复，那么记录自增
                t++;
            }
        }
        //声明需要返回的数组，这个才是去重后的数组
        Object[]  newArr = new Object[t];
        //用arraycopy方法将刚才去重的数组拷贝到新数组并返回
        System.arraycopy(tempArr,0,newArr,0,t);
        return newArr;
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

测试一下，可行 

如果使用集合，那么去重复就简单多了。 
只需要创建一个集合，然后遍历数组逐一放入集合，只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了，然后用toArray转成数组一切搞定。

代码：

import java.util.*;
public class Demo {

    public static void main(String[] args) {
        //声明一个需要去重的数组
        Object[] arr = {1,1,1,2,3,3,4,5,"夏","夏","冬","春",};
        //创建一个集合
        List list = new ArrayList();
        //遍历数组往集合里存元素
        for(int i=0;i<arr.length;i++){
            //如果集合里面没有相同的元素才往里存
            if(!list.contains(arr[i])){
                list.add(arr[i]);
            }
        }
        //toArray()方法会返回一个包含集合所有元素的Object类型数组
        Object[] newArr = list.toArray();
        //遍历输出一下测试是否有效
        for(int i=0;i<newArr.length;i++){
            System.out.print(" "+newArr[i]);
        }

    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

最后,最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤;

public static Object[] unique(Object [] arr){
        //实例化一个set集合
        Set set = new HashSet();
        //遍历数组并存入集合,如果元素已存在则不会重复存入
        for (int i = 0; i < arr.length; i++) {
            set.add(arr[i]);
        }
        //返回Set集合的数组形式
        return set.toArray();
    }

import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
public class lzwCode {

    public static void main(String [] args) {
        testA();
        System.out.println("===========================");
        testB();
        System.out.println("===========================");
        testC();
    }

    //去掉数组中重复的值
    public static void testA() {
        String [] str = {"Java", "C++", "Php", "C#", "Python", "C++", "Java"};
        for (String elementA:str ) {
            System.out.print(elementA + " ");
        }
        List<String> list = new ArrayList<String>();
        for (int i=0; i<str.length; i++) {
            if(!list.contains(str[i])) {
                list.add(str[i]);
            }
        }
        /*
        Set<String> set = new HashSet<String>();
        for (int i=0; i<str.length; i++) {
            set.add(str[i]);
        }
        String[] newStr =  set.toArray(new String[1]); 
        */
        System.out.println();
        String[] newStr =  list.toArray(new String[1]); //返回一个包含所有对象的指定类型的数组 
        for (String elementB:newStr ) {
            System.out.print(elementB + " ");
        }
        System.out.println();
    }

    //删除数组中其中一个元素
    public static void testB() {
        String [] str = {"Java", "C++", "Php", "C#", "Python"};
        for (String elementA:str ) {
            System.out.print(elementA + " ");
        }
        //删除php
        List<String> list = new ArrayList<String>();
        for (int i=0; i<str.length; i++) {
            list.add(str[i]);
        }
        list.remove(2); //list.remove("Php") 
        System.out.println();
        String[] newStr =  list.toArray(new String[1]); //返回一个包含所有对象的指定类型的数组 
        for (String elementB:newStr ) {
            System.out.print(elementB + " ");
        }    
        System.out.println();
    }

    //在数组中增加一个元素
    public static void testC() {
        String [] str = {"Java", "C++", "Php", "C#", "Python"};
        for (String elementA:str ) {
            System.out.print(elementA + " ");
        }
        //增加ruby
        List<String> list = new ArrayList<String>();
        for (int i=0; i<str.length; i++) {
            list.add(str[i]);
        }
        list.add(2, "ruby"); //list.add("ruby") 
        System.out.println();
        String[] newStr =  list.toArray(new String[1]); //返回一个包含所有对象的指定类型的数组 
        for (String elementB:newStr ) {
            System.out.print(elementB + " ");
        }    
        System.out.println();
    }
}