java集合去重和排序

1.去重

1.1 for循环去重

   for (int i = 0; i<list.size();i++) {
            for (int j=i+1;j<list.size();j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);
                    j--;
                }
            }
        }

测试结果：，感觉还是有点用的，感觉循环次数太多了，不推荐使用。

  List<Integer> list = new LinkedList<Integer>();
        List<Integer> list1 = new LinkedList<Integer>();
        Random random = new Random();
        int s=0;
        while (s<50) {
            list.add(random.nextInt(10));
            s++;
        }
        System.out.println("去重前"+list);
        for (Integer temp:list) {
            if (!list1.contains(temp)) { // 判断list1中是否存在这个元素，不存在就保存进去
                list1.add(temp);
            }
        }
        list=list1;
        System.out.println("去重后" + list);

第二种，可以用用。

1.2 set去重

set集合的提点是无序，不能重复，所以如果把list先存进set集合中，重复元素就没了，之后再取出，重现放进list就可以了，但这个方法有一个缺点，就是原来list元素的顺序会被打乱，如果对顺序有要求的话不推荐使用。

List<Integer> list = new LinkedList<Integer>();
        Set<Integer> set = new HashSet<Integer>();
        Random random = new Random();
        int s=0;
        while (s<50) {
            list.add(random.nextInt(10));
            s++;
        }
        System.out.println("去重前"+list);
        for (Integer temp:list) {
            set.add(temp);
        }
        list.clear();
        for (Integer temps:set) {
            list.add(temps);
        }
        System.out.println("去重后" + list);

1.3 map去重

hashmap的key是不能重复的，value是可以重复的，所以我们可以把list的值当做map的key，这样就可以把重复的值去掉了

    List<Integer> list = new LinkedList<Integer>();
        Map<Integer,String> map = new HashMap<Integer, String>();
        Random random = new Random();
        int s=0;
        while (s<50) {
            list.add(random.nextInt(10));
            s++;
        }
        System.out.println("去重前"+list);
        for (Integer temp:list) {
            map.put(temp,"value");
        }
        list.clear();
        for (int key : map.keySet()){
            list.add(key);
        }
        System.out.println("去重后" + list);

2.排序

排序一般是用集合工具类中的sort()方法，这个方法还有一个重载的方法，下面分别来介绍并测试一下。

2.1 Collections.sort(list)

直接调用sort方法，就可以了，排序方式是升序

List<Integer> list = new LinkedList<Integer>();
        Random random = new Random();
        int s=0;
        while (s<10) {
            list.add(random.nextInt(10));
            s++;
        }
        System.out.println("排序前"+list);
        Collections.sort(list);
        System.out.println("排序后" + list);

2.2 Collections.sort(list,Comparator<>)

这个重载方法主要用来帮对象排序，自定义排序

先创建一个实体类 dog类

public class dog {
    private int id;
    private String name;
    private String sex;

    public dog(int id,String name,String sex) {
        this.id=id;
        this.name = name;
        this.sex = sex;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

之后就是调用sort方法，并且实现Comparator接口，实现里面的compare方法。

 List<dog> list = new LinkedList<dog>();
        int s=10;
        while (s>0) {
            list.add(new dog(s,"南波万","雄"));
            s--;
        }
        for (dog o:list) {
            System.out.println(o.getId());
        }
        Collections.sort(list, new Comparator<dog>() {
            public int compare(dog o1, dog o2) {
                if (o1.getId() > o2.getId()) {
                    return 1;
                }else if (o1.getId() < o2.getId()) {
                    return -1;
                }else {
                    return 0;
                }
            }
        });
        System.out.println("排序后");
        for (dog o : list) {
            System.out.println(o.getId());

因为我的排序字段是id,就用了id做比较，大于返回正数，一般都是为1，小于返回负数，一般都是-1，等于返回0