java中List对象列表实现去重或取出及排序的方法

前言

因为在面试的时候碰到几次list的去重和排序，觉着有必要给大家总结一下具体的方法，分享出来供大家学习参考，话不多说了，来一起看看下面介绍的一种做法：

一、list去重

1.1 实体类student

list<student>容量10k以上，要求去重复。这里student的重复标准是属性相同，因此需要重写equals和hashcode方法，不知道有几个可以手写出来。

student的equals方法：

public void equals(object o){
 if(this == o) retun true;
 if(!(o instanceof student)) return false;
 student stu = (studend)o;
 if(id!=stu.id) return false;
 if(age!=stu.age) return false;
 return name!=null ? name.equals(stu.name) : stu.name ==null; 
}

这里只要记住宗旨是比较student的属性即可，如果属性相同则相等。先考虑地址相等，然后类型匹配instanceof。接下来是各种属性，int属性直接双等号比较，string类型需要判断是否为null，如果是null则都是null返回true，如果不是null则比较equals。

student的hashcode方法：

public int hashcode(){
 int result = id;
 reuslt = 31*id +(name!=null?name.hashcode():0);
 reuslt = 31*age;
 return reuslt;
}

hashcode是为了hash表计算做辅助，方便快速查找。因此hash算法的结果要尽量的散列。这里用到31，这个31在别的博客中看到的原因是这样的： obj*31==obj<<5-obj.左移5位相当乘以2的5次方，就是32.null的hashcode为空。

通过equals和hashcode的实现可以发现，如果equals为true，则所有属性相同，而属性相同则计算出的hashcode必然相同。然而hashcode相同，属性未必一样，即equals不一定为真。

关于hashcode的价值体现并不在这里，而在于hashmap的实现。hashmap内部是通过链表数组的hash结构来实现的，这里就要用到hashcode。

下面是完整的student代码：

package com.test.arithmetic.listequals;

/**
 * 这里id，name,age相同则student相同，
 * 若有其他相同
 * created by administrator on 2016/3/29.
 */
public class student {
 int id;
 string name;
 int age;

 public student(int id, string name, int age) {
  this.id = id;
  this.name = name;
  this.age = age;
 }

 @override
 public boolean equals(object o) {
  if (this == o) return true;
  if (!(o instanceof student)) return false;

  student student = (student) o;

  if (id != student.id) return false;
  if (age != student.age) return false;
  return name != null ? name.equals(student.name) : student.name == null;

 }

 @override
 public int hashcode() {
  int result = id;
  result = 31 * result + (name != null ? name.hashcode() : 0);
  result = 31 * result + age;
  return result;
 }

}

1.2通过hashset去重

如果你觉得自己可以hold住一个完善的hash算法就可以自己去实现它。这里采用jdk自带的hashset来完成重复获取。

先放代码：

package com.test.arithmetic.listequals;
import org.junit.assert;

import java.util.*;

/**
 * 取出list中重复的student对象
 * created by administrator on 2016/3/29.
 */
public class obtainlistequals {
 public static void main(string[] args){
  //原始数据
  list<student> list = new arraylist<>();
  //重复数据
  list<student> list2 = new arraylist<>();
  //填充
  for (int i = 0; i < 10 ; i++) {
   list.add(new student(i,"_"+i,18+i));
   random random = new random();
   if (random.nextboolean()){
    list.add(new student(i,"_"+i,18+i));
   }
  }
  //使用hashset去重复，set为重复的集合，可以通过new arraylist(set)转换成list
  hashset<student> set = new hashset<>();
  for (student student : list) {
   boolean add = set.add(student);
   if (!add){
    list2.add(student);
   }
  }
  //比较
  assert.assertequals(list.size(),list2.size()+set.size());
  
 }

}

去重的原理和简单，无论你仅仅是想把重复的丢掉，或者将重复的取出来。这里去掉的是第二次遇到的对象，取出的也是第二次遇到的对象。hashset中的add方法会返回一个boolean值，如果插入的值已经存在，则直接返回false。关于hashset的源码放到以后研究。大概的说，是通过hashmap的key来实现的，而hashmap在1.8中改动很大，据说是用红黑树实现的，提高了get的时间复杂度。

二、list对象排序

同样list中存放的是student对象，我需要一个规则来排序。这个排序的规则这里定义为id的比较大小。参考：java中list排序

2.1 student对象实现comparable接口

comparable接口提供一个比较的compareto(object o)方法，通过返回值>0,=0,<0比较大小。这里由于仅仅把id当做比较大小的方法，直接用id做减法，如果是要比较对象，建议套用this.property.compareto(o.property) .

package com.test.arithmetic.listequals;

/**
 * 这里id，name,age相同则student相同，
 * 若有其他相同
 * created by administrator on 2016/3/29.
 */
public class student implements comparable<student>{
  int id;
  string name;
  int age;

  public student(int id, string name, int age) {
    this.id = id;
    this.name = name;
    this.age = age;
  }

  @override
  public boolean equals(object o) {
    if (this == o) return true;
    if (!(o instanceof student)) return false;

    student student = (student) o;

    if (id != student.id) return false;
    if (age != student.age) return false;
    return name != null ? name.equals(student.name) : student.name == null;

  }

  @override
  public int hashcode() {
    int result = id;
    result = 31 * result + (name != null ? name.hashcode() : 0);
    result = 31 * result + age;
    return result;
  }

  @override
  public int compareto(student o) {
    return this.id-o.id;
  }
}

通过collections.sort(list)排序：

package com.test.arithmetic.list.sort;

import com.test.arithmetic.list.student;
import org.junit.before;
import org.junit.test;

import java.util.arraylist;
import java.util.collections;
import java.util.list;

/**
 * 对list中对象排序
 * created by administrator on 2016/3/29.
 */
public class sortlist {
  list<student> list;
  @before
  public void setup(){
    list = new arraylist<>();
    for (int i = 0; i < 10; i++) {
      int v = (int)(math.random() * 100);
      list.add(new student(v,"_"+v,18+v));
    }
    system.out.println("原list："+list);
  }
  //方法一，对象实现comparable接口
  @test
  public void byimplements(){
    collections.sort(list);
    system.out.println("排序后："+list);
  }
}

2.2 重载sort方法，传入一个比较器

student类还是未实现comparable接口之前的：

package com.test.arithmetic.list;

/**
 * 这里id，name,age相同则student相同，
 * 若有其他相同
 * created by administrator on 2016/3/29.
 */
public class student{
  int id;
  string name;
  int age;

  public student(int id, string name, int age) {
    this.id = id;
    this.name = name;
    this.age = age;
  }

  public int getid() {
    return id;
  }

  public student(int id) {
    this.id = id;
  }

  @override
  public boolean equals(object o) {
    if (this == o) return true;
    if (!(o instanceof student)) return false;

    student student = (student) o;

    if (id != student.id) return false;
    if (age != student.age) return false;
    return name != null ? name.equals(student.name) : student.name == null;

  }

  @override
  public int hashcode() {
    int result = id;
    result = 31 * result + (name != null ? name.hashcode() : 0);
    result = 31 * result + age;
    return result;
  }

  @override
  public string tostring() {
    return "student{" +
        "id=" + id +
        ", name='" + name + '\'' +
        ", age=" + age +
        '}';
  }
}

在排序的代码出添加排序规则：

package com.test.arithmetic.list.sort;

import com.test.arithmetic.list.student;
import org.junit.before;
import org.junit.test;

import java.util.arraylist;
import java.util.collections;
import java.util.comparator;
import java.util.list;

/**
 * 对list中对象排序
 * created by administrator on 2016/3/29.
 */
public class sortlist {
  list<student> list;
  @before
  public void setup(){
    list = new arraylist<>();
    for (int i = 0; i < 10; i++) {
      int v = (int)(math.random() * 100);
      list.add(new student(v,"_"+v,18+v));
    }
    system.out.println("原list："+list);
  }
  //方法一，对象实现comparable接口
  @test
  public void byimplements(){
//    collections.sort(list);
    system.out.println("排序后："+list);
  }

  /*方法二，添加比较器*/
  @test
  public void byoveridecompare(){

    collections.sort(list, new comparator<student>() {
      @override
      public int compare(student o1, student o2) {
        return o1.getid()-o2.getid();
      }
    });
    system.out.println(list);
  }
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对的支持。