使用自定义标签的标签

Question

有人可以向我指出正确的方向：我想拥有一个自定义标签而无需更改 hashcode（）/equals（）方法。

用法是拥有一组必须具有不同属性（或更多）的对象。

因此，例如，对于此类：

@FieldDefaults(level = AccessLevel.PRIVATE)
@Getter @Setter
public class User{
    String name;
    String email;
    String age;
}

我想拥有 usernameset ，它将仅包含具有不同名称的用户。我不想覆盖用户中的主题和等于用户的方法，因为我仍然想区分具有相同名称但不同电子邮件的用户。

我想以某种方式“ Override” hashcode（）/equals（）方法仅适用于此 hashmap 。

编辑

我乍看之下提出了这个解决方案，有人可以检查吗？

package com.znamenacek.debtor.util;

import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.experimental.FieldDefaults;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@FieldDefaults(level = AccessLevel.PRIVATE)
public class CustomizableHashSet<T> implements Set<T> {
    Function<T, Integer> customHashCode = Object::hashCode;
    HashSet<ClassWrapper> storage = new HashSet<>();

    public CustomizableHashSet(Function<T, Integer> customHashCode) {
        this.customHashCode = customHashCode;
    }

    public CustomizableHashSet() {}

    public CustomizableHashSet(Collection<? extends T> c, Function<T, Integer> customHashCode) {
        storage = new HashSet<>(c.stream().map(ClassWrapper::new).toList());
        this.customHashCode = customHashCode;
    }

    public CustomizableHashSet(Collection<? extends T> c) {
        storage = new HashSet<>(c.stream().map(ClassWrapper::new).toList());
    }

    public CustomizableHashSet(int initialCapacity, float loadFactor, Function<T, Integer> customHashCode) {
        storage = new HashSet<>(initialCapacity, loadFactor);
        this.customHashCode = customHashCode;
    }

    public CustomizableHashSet(int initialCapacity, float loadFactor) {
        storage = new HashSet<>(initialCapacity, loadFactor);
    }

    public CustomizableHashSet(int initialCapacity, Function<T, Integer> customHashCode) {
        storage = new HashSet<>(initialCapacity);
        this.customHashCode = customHashCode;
    }

    public CustomizableHashSet(int initialCapacity) {
        storage = new HashSet<>(initialCapacity);
    }

    @Override
    public Iterator<T> iterator() {
        return storage.stream().map(ClassWrapper::get).iterator();
    }

    @Override
    public int size() {
        return storage.size();
    }

    @Override
    public boolean isEmpty() {
        return storage.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return storage.stream().map(ClassWrapper::get).collect(Collectors.toSet()).contains(o);
    }

    @Override
    public boolean add(T t) {
        return storage.add(new ClassWrapper(t));
    }

    @Override
    public boolean remove(Object o) {
        boolean returnValue;
        var storageContent = storage.stream().map(ClassWrapper::get).collect(Collectors.toSet());
        returnValue = storageContent.remove(o);
        storage = storageContent.stream().map(ClassWrapper::new).collect(Collectors.toCollection(HashSet::new));

        return returnValue;
    }

    @Override
    public void clear() {
        storage.clear();
    }

    @Override
    public Object clone() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Spliterator<T> spliterator() {
        return storage.stream().map(ClassWrapper::get).spliterator();
    }

    @Override
    public Object[] toArray() {
        return storage.stream().map(ClassWrapper::get).toArray();
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return storage.stream().map(ClassWrapper::get).collect(Collectors.toSet()).toArray(a);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        boolean returnValue;
        var storageContent = storage.stream().map(ClassWrapper::get).collect(Collectors.toSet());
        returnValue = storageContent.removeAll(c);
        storage = storageContent.stream().map(ClassWrapper::new).collect(Collectors.toCollection(HashSet::new));

        return returnValue;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        boolean returnValue;
        var storageContent = storage.stream().map(ClassWrapper::get).collect(Collectors.toSet());
        returnValue = storageContent.containsAll(c);
        storage = storageContent.stream().map(ClassWrapper::new).collect(Collectors.toCollection(HashSet::new));

        return returnValue;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return storage.addAll(c.stream().map(ClassWrapper::new).collect(Collectors.toSet()));
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        boolean returnValue;
        var storageContent = storage.stream().map(ClassWrapper::get).collect(Collectors.toSet());
        returnValue = storageContent.retainAll(c);
        storage = storageContent.stream().map(ClassWrapper::new).collect(Collectors.toCollection(HashSet::new));

        return returnValue;
    }

    @Override
    public String toString() {
        return storage.stream().map(ClassWrapper::get).collect(Collectors.toSet()).toString();
    }

    @Override
    public <T1> T1[] toArray(IntFunction<T1[]> generator) {
        return storage.stream().map(ClassWrapper::get).collect(Collectors.toSet()).toArray(generator);
    }

    @Override
    public boolean removeIf(Predicate<? super T> filter) {
        boolean returnValue;
        var storageContent = storage.stream().map(ClassWrapper::get).collect(Collectors.toSet());
        returnValue = storageContent.removeIf(filter);
        storage = storageContent.stream().map(ClassWrapper::new).collect(Collectors.toCollection(HashSet::new));

        return returnValue;
    }

    @Override
    public Stream<T> stream() {
        return storage.stream().map(ClassWrapper::get);
    }

    @Override
    public Stream<T> parallelStream() {
        return storage.parallelStream().map(ClassWrapper::get);
    }

    @Override
    public void forEach(Consumer<? super T> action) {
        storage.stream().map(ClassWrapper::get).forEach(action);
    }

    @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
    @AllArgsConstructor
    public class ClassWrapper{
        T object;

        @Override
        public int hashCode() {
            return customHashCode.apply(object);
        }

        @Override
        public boolean equals(Object obj) {
            if(this == obj) return true;

            if(obj == null) return false;

            return hashCode() == obj.hashCode();
        }

        public T get(){
            return object;
        }

        @Override
        public String toString() {
            return "" + hashCode() + " - " + object.toString();
        }
    }
}

Answer 1

使用比较器 with treetet

as 评论约翰内斯·库恩（Johannes Kuhn），您可以使用 navigableset （或 sortedset ）或在Java 21+， segendset （ jep 431 ）。 无需发明自己的班级。

navigableset 例如 tree> treetet 可能会提供一个构造函数，以a cormactor cormactor 。该比较器用于对集合的元素进行排序。

在这个问题中，我们的观点是，比较器也用于决定接受新的不同元素，而不是使用元素的对象＃equals 方法。

而且，由于 treeTet 中没有散列的散列，因此不担心覆盖 hashcode 。

我们可以轻松地定义比较器实现。为了方便起见，我们可以致电 comparator.comparing 进行比较器实现。我们通过传递所需 name 字段的getter方法的方法参考来定义比较器： user :: name 。

您可以通过调用 thencomparparing 。我将其作为读者的练习。

对于简洁起见，让我们将您的用户类定义为记录。我们只是声明成员字段的类型和名称。编译器隐式创建构造函数，getters， equals ＆amp; HashCode 和 toString 。

record User( String name , String email , int age ) { }

制作一些示例数据。

List < User > listOfUsers =
        List.of(
                new User( "Bob" , "[email protected]" , 7 ) ,
                new User( "Alice" , "[email protected]" , 42 ) ,
                new User( "Carol" , "[email protected]" , 77 )
        );

定义我们的集合， treetet 。

NavigableSet < User > setOfUsers = new TreeSet <>( Comparator.comparing( User :: name )  );

用3个元素填充我们的场景。通过倾倒到控制台来验证3个元素。

setOfUsers.addAll( listOfUsers );
System.out.println( setOfUsers.size() + " elements in setOfUsers = " + setOfUsers );

现在，我们尝试在其他字段中添加另一个具有相同名称但不同值的用户。

setOfUsers.add( new User( "Alice" , "[email protected]" , -666  ) );

默认情况下，<代码>记录通过比较每个成员字段来决定平等。因此：

• 如果我们仅使用名称进行比较的目标失败，我们将在此集合中获得4个元素。
• 如果我们仅成功使用 name ，那么在阻止了该介入者的入学后，我们应该获得3个元素。

转储到控制台。

System.out.println( setOfUsers.size() + " elements in setOfUsers = " + setOfUsers );

setofusers中的3个元素= [user [name = alice，，age = 42]，用户[name = bob，，年龄= 7]，用户[name = carol，，年龄= 77]]

setOfusers中的3个元素= [user [name = alice，，age = 42]，用户[name = bob，，年龄= 7]，用户[name = carol，，年龄= 77]]

我们在这些结果中看到（a）按名称对元素进行排序，（b）用原始阻止第二个 alice 爱丽丝剩下。

要查看替代行为，请用以下方式替换 setOfusers 定义：

Set < User > setOfUsers = new HashSet <>();

在 setOfusers.size（）中，运行该版本会导致该版本。

setOfusers中的3个元素= [user [name = bob，，年龄= 7]，用户[name = carol，，年龄= 77]，用户[name = alice，，年龄= 42]]

setofusers中的4个元素= [user [name = bob， /a>，年龄= 7]，用户[name = carol， /a>，年龄= 77]，用户[name = alice，，年龄= 42]，用户[name = alice， /a>，age = -666]]

我们在这些结果中看到（a）没有特定的排序，（b）添加第二个“爱丽丝”，将集合从3个元素增加到4

个

。我在这里解决方案的可能缺点是，我们违反了 treeset 的Javadoc的建议，“与 equals > equals ”，从而违反了 set的一般合同。

我不确定这个问题是否有问题 - 我没有足够的观点来形成判断。

Answer 2

干净有效

我想拥有一个用户名，它只能包含具有不同名称的用户

您可以应用构图并创建一个可以维护 map 的类，并委派所有调用。

封装收藏品并提供有限的访问权限的方法比扩展集合更加灵活，更乏味，而且也不会产生紧密的耦合。

类似的建议，以及通过扩展您的代码取决于现有收藏的弊端的示例，项目偏爱继承。

这就是这样的类的样子：

class UserNameSet {
    private Map<String, User> userByName = new HashMap<>();
    
    public User add(User user) {
        return userByName.put(user.getName(), user); // or `putIfAbsent()` if you want to retain the previously added user
    }
    
    public User remove(User user) {
        return userByName.remove(user.getName());
    }
    
    public boolean contains(User user) {
        return userByName.containsValue(user.getName());
    }
    
    public User remove(String name) {
        return userByName.remove(name);
    }
    
    public boolean contains(String name) {
        return userByName.containsKey(name);
    }
    
    // all other methods that are required
}

我们还可以使此类成为 generic 并能够包装任何对象。

为此，我们需要引入一个其他参数-A 函数，该函数将负责从对象中提取目标属性。

class MyCustomSet<K, V> {
    private Map<K, V> userByName = new HashMap<>();
    private Function<V, K> keyExtractor;
    
    public MyCustomSet(Function<V, K> keyExtractor) {
        this.keyExtractor = keyExtractor;
    }
    
    public V add(V user) {
        return userByName.put(keyExtractor.apply(user), user); // or `putIfAbsent()` if you want to retain the previously added user
    }
    
    public V remove(V user) {
        return userByName.remove(keyExtractor.apply(user));
    }
    
    public boolean contains(V user) {
        return userByName.containsValue(user);
    }
    
    public V removeByKey(K name) {
        return userByName.remove(name);
    }
    
    public boolean containsKey(K name) {
        return userByName.containsKey(name);
    }
    
    // all other methods that are required
}

这就是在客户端代码中实例化的方式：

MyCustomSet<String, User> uniqueNameUsers = new MyCustomSet<>(User::getName);

简洁而简单地

使用排序的集合的方法，例如 treeset A/72482101/17949945“> basil的Bourque答案 可用于相对较小的对象数量。

重要的是要强调，将数据存储在排序的集合中的成本。它们越大，操作速度较慢。 treeset 由 Tree 和大多数操作（例如基本 add（）， remove> remove（） and contains（）操作要求 o（n）时间，除了最低/最高键时，除了边缘箱外。

Answer 3

Commons-Collections已经提供了赤道接口可以按照您的建议进行操作：

public interface Equator<T> {
    boolean equate(T o1, T o2);
    int hash(T o);
}

无论基于赤道创建集合的直接支持是有限的。 collectionUtils 。

但是，您可以利用将所需的对象包装到使用赤道的对象中，然后使用所有支持Commons-Collections为变压器提供的对象。 For example using

class EquatorWrapper<T> {
    private final Class<T> clazz;
    private final T wrapped;
    private final Equator<T> equator;

    public EquatorWrapper(Class<T> clazz, T wrapped, Equator<T> equator) {
        this.clazz = clazz;
        this.wrapped = wrapped;
        this.equator = equator;
    }

    @Override
    public boolean equals(Object obj) {
        if (clazz.isInstance(obj)) {
            return equator.equate(wrapped, clazz.cast(obj));
        }
        return false;
    }

    @Override
    public int hashCode() {
        return equator.hash(wrapped);
    }
}

class EquatorTransformer<T> implements Transformer<T, Object> {
    private final Class<T> clazz;
    private final Equator<T> equator;

    public EquatorTransformer(Class<T> clazz, Equator<T> equator) {
        this.clazz = clazz;
        this.equator = equator;
    }
        
    @Override
    public Object transform(T input) {
        return new EquatorWrapper<>(clazz, input, equator);
    }
}

SetUtils.transformedSet(someSet, EquatorTransformer.of(someEquator, SomeClazz.clazz));