一、字符串数组去重

对于一个字符串数组，我们可以使用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方法，以确保正确的去重效果。