纯数组去重

一般而言,数组最简单快捷的方法是直接利用HashSet的不重复的特性就可以做到,或者是遍历时利用List的contains 判断是否存在就可以去重了

如果是对象数组,对象的类需要 重写 equal 和 hashCode方法.。

但是面试题经常有数组去重的试题,如果在不使用hashSet 和 list的contains方法情况下,纯数组怎么去重?

可以这么做:

使用一个标识数组来标识重复的元素位置,再新建一个新的数组来存储去重后的元素

     User user1 = new User("zjamgs",16,12);    //User 需要重写equal 和 hashcode 方法
        User user2 = new User("lisi",13,18);
        User user3 = new User("wangwi",15,13);
        User user4 = new User("zhangsli",23,10);
        User user5 = new User("zjamgs",16,12);

        User user6 = new User("zjamgs1",16,12);
        User user7 = new User("lisi2",13,18);
        User user8 = new User("zjamgs",16,12);
        User user9 = new User("wangwi",15,13);
        User user10 = new User("zjamgs5",16,12);

        User[] users = {user1,user2,user3,user4,user5,user6,user7,user8,user9,user10};

        int[] userindex = new int[users.length];//标记相同的元素的,0表示未重复,1表示已重复
        int repeatCount = 0;            
        for(int i=0;i<users.length;i++){
            if(userindex[i]==1)continue;        //非常重要
            for(int j=users.length-1;j>i;j--){
                if(users[i].equals(users[j])){
                    userindex[j] = 1;
                    repeatCount++;
                }
            }
        }
        System.out.println(Arrays.toString(userindex);
        User[] newUsers = new User[users.length - repeatCount];

        for (int i = 0;i < userindex.length;i++){
            if (userindex[i] == 0){
                for (int j = 0;j < newUsers.length;j++){
                    if(newUsers[j] == null){
                        newUsers[j] = users[i];
                        break;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(newUsers));

  User类:

class User implements Comparable<User>{
    private String name;
    private int age;
    private int index;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return getAge() == user.getAge() &&
                getIndex() == user.getIndex() &&
                Objects.equals(getName(), user.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge(), getIndex());
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", index=" + index + "]";
    }

    public User(String name, int age, int index) {
        super();
        this.name = name;
        this.age = age;
        this.index = index;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public User() {
        super();
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int compareTo(User o) {
        if(this.getAge()<o.getAge()){
            return -1;
        }else if(this.getAge()>o.getAge()){
            return 1;
        }
        return 0;
    }
}

  输出结果:

[0, 0, 0, 0, 1, 0, 0, 1, 1, 0]

[User [name=zjamgs, age=16, index=12],

User [name=lisi, age=13, index=18],

User [name=wangwi, age=15, index=13],

User [name=zhangsli, age=23, index=10],

User [name=zjamgs1, age=16, index=12],

User [name=lisi2, age=13, index=18],

User [name=zjamgs5, age=16, index=12]]

有三个元素是前面已经有的元素,是重复元素,余下的7个都不是重复元素,结果正确

原文地址:https://www.cnblogs.com/hcklqy/p/11610837.html

时间: 2024-10-16 03:00:24

纯数组去重的相关文章

js 含有对象的数组去重

1.  参考:https://www.cnblogs.com/le220/p/9130656.html js中数组对象去重的方法     中的方法二 2. 纯数组去重:https://blog.csdn.net/jiangwei1994/article/details/82992985 var arr = [1,1,2,9,6,9,6,3,1,4,5]; arr = Array.from(new Set(arr)) console.log(arr) 原文地址:https://www.cnblog

JavaScript数组去重(转载)

转载自https://zhuanlan.zhihu.com/p/24753549 作者:TooBug 定义重复(相等) NaN 初看NaN时,很容易把它当成和null.undefined一样的独立数据类型.但其实,它是数字类型. console.log(typeof NaN); //number 根据规范,比较运算中只要有一个值为NaN,则比较结果为false,所以会有下面这些看起来略蛋疼的结论: // 全都是false 0 < NaN; 0 > NaN; 0 == NaN; 0 === Na

javaScript数组去重方法

在JAvascript平时项目开发中经常会用到数组去重的操作.这时候就要用到JS数组去重的方法了. demo1: 第一种:JS数组去重操作方法是利用遍历原数组,利用数组的indexOf()方法来来判断新数组b中是否有原数组a中的元素,如果没有的话则在b数组的后面追加上a[i],如果有的话就不执行任何操作,最后可以达到数组去重的操作. 这种方法应该是平时开发中最常用的JS数组去重的方法了,简单又实用. demo2: 第二种去重的方法比较巧妙,是定义一个空对象和一个空数组,在遍历原数组的时候来用原数

json数组去重

// json数组去重 function getJsonArr(arr) { //定义需要的空数组 var newArr = []; //定义转换字符串后的数组 var newStringArr = []; $.each(arr, function (i, v) { var sArr = JSON.stringify(v); if ($.inArray(sArr, newStringArr) == -1) { // 根据字符串数组push对象 newStringArr.push(sArr); n

【学】数组去重的3种方式

数组去重的3种方式 var arr = [1,4,2,3,4,5,6,7,3,4,5,23,2,3,4,5,3,2,3,4,5];   function findInArray(n,arr){ for (var i=0; i<arr.length; i++) { if(arr[i]==n){ return true; } } return false; }   function removeRep1(arr){ //方法2 var arr1 = []; for (var i=0; i<arr.

JavaScript 数组去重

JavaScript 数组去重 Why underscore (觉得这部分眼熟的可以直接跳到下一段了...) 最近开始看 underscore.js 源码,并将 underscore.js 源码解读 放在了我的 2016 计划中. 阅读一些著名框架类库的源码,就好像和一个个大师对话,你会学到很多.为什么是 underscore?最主要的原因是 underscore 简短精悍(约 1.5k 行),封装了 100 多个有用的方法,耦合度低,非常适合逐个方法阅读,适合楼主这样的 JavaScript

TP框架数组去重后分页

$view = D('HistoryTest')     ->alias("as a")     ->join("qxy_test as b on a.object = b.id")     ->field("b.title,b.id,a.uid")     ->order('a.id desc')     ->where("a.title like '%".$key."%'"

数组去重方法总结

这几天正在整理面试题,顺便把以前学的东西给总结一下,数组去重,我猜面试应该考的几率还是蛮高的,所以下面就让博主给讲讲iOS数组去重的几种方法. 第一种:冒泡排序,然后挨个挨个比较,这个没什么可说的,关键是麻烦,而且时间复杂度也挺大的,所以博主就不给讲了. 第二种:利用数组排序. NSArray *array = @[@"小玉",@"小小鱼",@"小玉"]; //数组去重方法---方法1 //建立一个新的的可变数组,数组长度为0 NSMutable

js中数组去重的几种方法

js中数组去重的几种方法         1.遍历数组,一一比较,比较到相同的就删除后面的                 function unique(arr){                         for(var i=0;i<arr.length;i++){                                 for(var j=i+1;j<arr.length;j++){                                         if(ar