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