Union去重詳解

一、字元串數組去重

對於一個字元串數組，我們可以使用set集合或者哈希表來進行去重，其中哈希表的時間複雜度更低，這裡以哈希表為例。

public static String[] removeDuplicateStrings(String[] arr) {
    if(arr == null || arr.length == 0) {
        return arr;
    }

    Map<String, Integer> map = new HashMap();
    for (String s : arr) {
        map.put(s, 0);
    }

    return map.keySet().toArray(new String[map.size()]);
}

二、整數數組去重

對於一個整數數組，我們可以使用排序後比較相鄰元素或者哈希表來進行去重，其中前者可能會改變原數組元素順序，這裡以後者為例。

public static int[] removeDuplicateInts(int[] arr) {
    if(arr == null || arr.length == 0) {
        return arr;
    }

    Map<Integer, Integer> map = new HashMap();
    for (int i = 0; i < arr.length; i++) {
        map.put(arr[i], i);
    }

    int[] result = new int[map.size()];
    int index = 0;
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        result[index++] = entry.getKey();
    }

    return result;
}

三、對象數組去重

對於一個對象數組，我們可以使用set集合或者哈希表來進行去重，其中後者需要自定義對象的哈希碼和equals方法，這裡以後者為例。

public static Person[] removeDuplicatePersons(Person[] arr) {
    if(arr == null || arr.length == 0) {
        return arr;
    }

    Map<Person, Integer> map = new HashMap();
    for (Person p : arr) {
        map.put(p, 0);
    }

    return map.keySet().toArray(new Person[map.size()]);
}

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int hashCode() {
        int result = 1;
        result = 31 * result + name.hashCode();
        result = 31 * result + age;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;

        Person person = (Person) obj;

        if (age != person.age) return false;
        return name.equals(person.name);
    }
}

四、結構體數組去重

對於一個結構體數組，我們可以使用set集合或者哈希表來進行去重，其中後者需要自定義結構體的哈希碼和equals方法，這裡以後者為例。

public static Book[] removeDuplicateBooks(Book[] arr) {
    if(arr == null || arr.length == 0) {
        return arr;
    }

    Map<Book, Integer> map = new HashMap();
    for (Book b : arr) {
        map.put(b, 0);
    }

    return map.keySet().toArray(new Book[map.size()]);
}

public class Book {
    private String title;
    private String author;
    private double price;

    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public int hashCode() {
        int result = 1;
        result = 31 * result + title.hashCode();
        result = 31 * result + author.hashCode();
        long temp = Double.doubleToLongBits(price);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;

        Book book = (Book) obj;

        if (Double.compare(book.price, price) != 0) return false;
        if (!title.equals(book.title)) return false;
        return author.equals(book.author);
    }
}

五、總結

使用set集合或者哈希表可以輕鬆實現數組的去重，但注意對於對象或結構體數組，需要自定義哈希碼和equals方法，以確保正確的去重效果。