Java 无重复的数组、算法

我必须写一个函数，返回给定的排序数组，并且不重复

我想出了这样的解决办法：

 public static String [] no_repeats(String [] a)
    {
        Arrays.sort(a);

        ArrayList<String> ret = new ArrayList<>();
        for (int i =1; i < a.length; i++)
                   if(a[i].compareTo(a[i-1]) != 0)
                       ret.add(a[i]);

        return  ret.toArray(ret.toArray(new String[0]));
    }

公共静态字符串[]无重复（字符串[]a）
{
数组。排序（a）；
ArrayList ret=新的ArrayList（）；
for（int i=1；i

我想知道是否有更好（更快）的方法解决我的问题？

---

此处不允许像Set这样的集合。

使用流可以优雅地解决此问题：

public static String[] no_repeats(String[] a) {
    return Arrays.stream(a)
            .distinct()
            .sorted()
            .toArray(String[]::new);
}

---

使用流可以优雅地解决此问题：

public static String[] no_repeats(String[] a) {
    return Arrays.stream(a)
            .distinct()
            .sorted()
            .toArray(String[]::new);
}

---

排序，然后检查元素是否相等（如果相等，则它们在一起）

公共静态字符串[]无重复（字符串[]a）
{
数组。排序（a）；
ArrayList al=新的ArrayList（）；
加（a[0]）；
对于（int i=1；i对其排序，然后检查元素是否相等（如果相等，则它们在一起）

公共静态字符串[]无重复（字符串[]a）
{
数组。排序（a）；
ArrayList al=新的ArrayList（）；
加（a[0]）；
对于（int i=1；i，因为无论如何都需要排序，所以我认为这是一种很好的方法。该算法只是跟踪最后添加的值，以确保不添加重复项

public static String[] no_repeats(String[] a) {
    
    Arrays.sort(a);
    
    ArrayList<String> ret = new ArrayList<>();
    String lastAdded = "";
    for (String str : a) {
        if (!str.equals(lastAdded)) {
            ret.add(str);
        }
        lastAdded = str;
    }
    return ret.toArray(new String[0]);
}

这是一个简单的实现，它只有一个add和contains方法来加速查找过程。哈希表的大小相当大，以减少冲突的机会


此类使用对象的hashCode来获取适当的
bucket
来放置列表
每个列表都可能包含散列到该存储桶中的任何项目。
-返回的bucket要么是数组中该索引的现有列表，要么是以前不存在的新列表

@SuppressWarnings（“未选中”）
类迷你哈希集{
int size=10_000；
列表[]数据=新的ArrayList[大小]；
公共布尔加法（T val）{
列表b=getBucket（val）；
如果（！b.contains（val））{
b、 添加（val）；
返回true；
}
返回false；
}
公共布尔包含（T val）{
列表b=getBucket（val）；
返回b.contains（val）；
}
私有列表getBucket（T val）{
int i=val.hashCode（）%size；
列表b=数据[i]；
如果（b==null）{
b=新的ArrayList（）；
数据[i]=b；
}
返回b；
}
}

虽然这是一项相当多的额外工作，但此解决方案明显优于我提供的第一个解决方案，因为查找效率很高，而且现在可以在删除重复项后进行排序。
由于您需要进行排序，我认为这将是一个很好的方法。该算法只需跟踪最后一个va添加lue以确保不添加重复项

public static String[] no_repeats(String[] a) {
    
    Arrays.sort(a);
    
    ArrayList<String> ret = new ArrayList<>();
    String lastAdded = "";
    for (String str : a) {
        if (!str.equals(lastAdded)) {
            ret.add(str);
        }
        lastAdded = str;
    }
    return ret.toArray(new String[0]);
}

这是一个简单的实现，它只有一个add和contains方法来加速查找过程。哈希表的大小相当大，以减少冲突的机会


此类使用对象的hashCode来获取适当的
bucket
来放置列表
每个列表都可能包含散列到该存储桶中的任何项目。
-返回的bucket要么是数组中该索引的现有列表，要么是以前不存在的新列表

@SuppressWarnings（“未选中”）
类迷你哈希集{
int size=10_000；
列表[]数据=新的ArrayList[大小]；
公共布尔加法（T val）{
列表b=getBucket（val）；
如果（！b.contains（val））{
b、 添加（val）；
返回true；
}
返回false；
}
公共布尔包含（T val）{
列表b=getBucket（val）；
返回b.contains（val）；
}
私有列表getBucket（T val）{
int i=val.hashCode（）%size；
列表b=数据[i]；
如果（b==null）{
b=新的ArrayList（）；
数据[i]=b；
}
返回b；
}
}

虽然这是一项相当多的额外工作，但此解决方案明显优于我提供的第一个解决方案，因为查找效率很高，而且在删除重复项后，现在可以进行排序。
感谢您的回答。此任务的重点是独立编写解决方案，以良好的方式减少重复次数或者你的答案。这项任务的重点是独立编写解决方案，以良好的方式减少重复
@SuppressWarnings("unchecked")
class MiniHashSet<T> {
    int size = 10_000;
    
    List<T>[] data = new ArrayList[size];
    
    public boolean add(T val) {
        List<T> b = getBucket(val);
        if (!b.contains(val)) {
            b.add(val);
            return true;
        }
        return false;
    }
    
    public boolean contains(T val) {
        List<T> b = getBucket(val);
        return b.contains(val);
    }
    
    private List<T> getBucket(T val) {
        int i = val.hashCode() % size;
        List<T> b = data[i];
        if (b == null) {
            b = new ArrayList<>();
            data[i] = b;
        }
        return b;
    }
}