Как получить уникальный идентификатор объекта, который переопределяет hashCode()?

Question

Когда класс в Java не переопределяет хэш-код(), Печать экземпляр этого класса дает хороший уникальный номер.

В Javadoc Object говорится о хэш-код():

Насколько это практически возможно, метод hashCode, определенный классом Object, возвращает разные целые числа для разных объектов.

Но когда класс переопределяет хэш-код(), как я могу получить его уникальный номер?

Answer 1

System.identityHashCode(вашОбъект) вернет «исходный» хеш-код вашего объекта в виде целого числа.Уникальность не обязательно гарантируется.Реализация Sun JVM предоставит вам значение, связанное с исходным адресом памяти для этого объекта, но это деталь реализации, и вам не следует на нее полагаться.

РЕДАКТИРОВАТЬ:Ответ изменен после комментария Тома ниже.адреса памяти и движущиеся объекты.

Answer 2

Javadoc для Object указывает, что

Обычно это реализуется путем преобразования внутреннего адреса объекта в целое число, но этот метод реализации не требуется языком программирования JavaTM.

Если класс переопределяет hashCode, это означает, что он хочет сгенерировать определенный идентификатор, который (можно надеяться) будет иметь правильное поведение.

Вы можете использовать System.identityHashCode чтобы получить этот идентификатор для любого класса.

Answer 3

Может быть, это быстрое и грязное решение сработает?

public class A {
    static int UNIQUE_ID = 0;
    int uid = ++UNIQUE_ID;

    public int hashCode() {
        return uid;
    }
}

Это также дает количество экземпляров инициализируемого класса.

Answer 4

hashCode() Метод не предназначен для предоставления уникального идентификатора объекта.Он скорее переваривает состояние объекта (т.е.значения полей-членов) до одного целого числа.Это значение в основном используется некоторыми структурами данных на основе хэша, такими как карты и наборы, для эффективного хранения и извлечения объектов.

Если вам нужен идентификатор для ваших объектов, я рекомендую вам добавить свой собственный метод вместо переопределения hashCode.Для этой цели вы можете создать базовый интерфейс (или абстрактный класс), как показано ниже.

public interface IdentifiedObject<I> {
    I getId();
}

Пример использования:

public class User implements IdentifiedObject<Integer> {
    private Integer studentId;

    public User(Integer studentId) {
        this.studentId = studentId;
    }

    @Override
    public Integer getId() {
        return studentId;
    }
}

Для генерации идентификатора вы можете проверить мой пост в блоге что я пытался объяснить некоторые способы создания уникальных идентификаторов.

Answer 5

Если это класс, который вы можете изменить, вы можете объявить переменную класса. static java.util.concurrent.atomic.AtomicInteger nextInstanceId.(Вам придется присвоить ей начальное значение очевидным способом.) Затем объявите переменную экземпляра. int instanceId = nextInstanceId.getAndIncrement().

Answer 6

Я придумал это решение, которое работает в моем случае, когда у меня есть объекты, созданные в нескольких потоках и сериализуемые:

public abstract class ObjBase implements Serializable
    private static final long serialVersionUID = 1L;
    private static final AtomicLong atomicRefId = new AtomicLong();

    // transient field is not serialized
    private transient long refId;

    // default constructor will be called on base class even during deserialization
    public ObjBase() {
       refId = atomicRefId.incrementAndGet()
    }

    public long getRefId() {
        return refId;
    }
}

Answer 7

// looking for that last hex?
org.joda.DateTime@57110da6

Если вы изучаете hashcode Типы Java, когда вы делаете .toString() на объекте базовый код таков:

Integer.toHexString(hashCode())

Answer 8

Просто чтобы дополнить другие ответы под другим углом.

Если вы хотите повторно использовать хэш-коды из «вышеуказанного» и получать новые, используя неизменяемое состояние вашего класса, тогда вызов super будет работать.Хотя это может/не может каскадироваться вплоть до объекта (т.некоторые предки могут не вызывать super), это позволит вам получать хеш-коды путем повторного использования.

@Override
public int hashCode() {
    int ancestorHash = super.hashCode();
    // now derive new hash from ancestorHash plus immutable instance vars (id fields)
}

Answer 9

Существует разница между возвратами hashCode() иidentHashCode().Возможно, что для двух неравных (проверенных с помощью ==) объектов o1, o2 hashCode() может быть одинаковым.Посмотрите пример ниже, насколько это верно.

class SeeDifferences
{
    public static void main(String[] args)
    {
        String s1 = "stackoverflow";
        String s2 = new String("stackoverflow");
        String s3 = "stackoverflow";
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
        System.out.println(System.identityHashCode(s1));
        System.out.println(System.identityHashCode(s2));
        System.out.println(System.identityHashCode(s3));
        if (s1 == s2)
        {
            System.out.println("s1 and s2 equal");
        } 
        else
        {
            System.out.println("s1 and s2 not equal");
        }
        if (s1 == s3)
        {
            System.out.println("s1 and s3 equal");
        }
        else
        {
            System.out.println("s1 and s3 not equal");
        }
    }
}

Answer 10

У меня была та же проблема, и я не был удовлетворен ни одним из ответов, поскольку ни один из них не гарантировал уникальные идентификаторы.

Я тоже хотел распечатать идентификаторы объектов для целей отладки.Я знал, что должен быть какой-то способ сделать это, потому что в отладчике Eclipse для каждого объекта указываются уникальные идентификаторы.

Я придумал решение, основанное на том факте, что оператор «==" для объектов возвращает true только в том случае, если два объекта на самом деле являются одним и тем же экземпляром.

import java.util.HashMap;
import java.util.Map;

/**
 *  Utility for assigning a unique ID to objects and fetching objects given
 *  a specified ID
 */
public class ObjectIDBank {

    /**Singleton instance*/
    private static ObjectIDBank instance;

    /**Counting value to ensure unique incrementing IDs*/
    private long nextId = 1;

    /** Map from ObjectEntry to the objects corresponding ID*/
    private Map<ObjectEntry, Long> ids = new HashMap<ObjectEntry, Long>();

    /** Map from assigned IDs to their corresponding objects */
    private Map<Long, Object> objects = new HashMap<Long, Object>();

    /**Private constructor to ensure it is only instantiated by the singleton pattern*/
    private ObjectIDBank(){}

    /**Fetches the singleton instance of ObjectIDBank */
    public static ObjectIDBank instance() {
        if(instance == null)
            instance = new ObjectIDBank();

        return instance;
    }

    /** Fetches a unique ID for the specified object. If this method is called multiple
     * times with the same object, it is guaranteed to return the same value. It is also guaranteed
     * to never return the same value for different object instances (until we run out of IDs that can
     * be represented by a long of course)
     * @param obj The object instance for which we want to fetch an ID
     * @return Non zero unique ID or 0 if obj == null
     */
    public long getId(Object obj) {

        if(obj == null)
            return 0;

        ObjectEntry objEntry = new ObjectEntry(obj);

        if(!ids.containsKey(objEntry)) {
            ids.put(objEntry, nextId);
            objects.put(nextId++, obj);
        }

        return ids.get(objEntry);
    }

    /**
     * Fetches the object that has been assigned the specified ID, or null if no object is
     * assigned the given id
     * @param id Id of the object
     * @return The corresponding object or null
     */
    public Object getObject(long id) {
        return objects.get(id);
    }


    /**
     * Wrapper around an Object used as the key for the ids map. The wrapper is needed to
     * ensure that the equals method only returns true if the two objects are the same instance
     * and to ensure that the hash code is always the same for the same instance.
     */
    private class ObjectEntry {
        private Object obj;

        /** Instantiates an ObjectEntry wrapper around the specified object*/
        public ObjectEntry(Object obj) {
            this.obj = obj;
        }


        /** Returns true if and only if the objects contained in this wrapper and the other
         * wrapper are the exact same object (same instance, not just equivalent)*/
        @Override
        public boolean equals(Object other) {
            return obj == ((ObjectEntry)other).obj;
        }


        /**
         * Returns the contained object's identityHashCode. Note that identityHashCode values
         * are not guaranteed to be unique from object to object, but the hash code is guaranteed to
         * not change over time for a given instance of an Object.
         */
        @Override
        public int hashCode() {
            return System.identityHashCode(obj);
        }
    }
}

Я считаю, что это должно обеспечить уникальные идентификаторы на протяжении всего срока действия программы.Однако обратите внимание, что вы, вероятно, не захотите использовать это в рабочем приложении, поскольку оно поддерживает ссылки на все объекты, для которых вы генерируете идентификаторы.Это означает, что любые объекты, для которых вы создаете идентификатор, никогда не будут подлежать сборке мусора.

Поскольку я использую это для целей отладки, меня не слишком беспокоит освобождение памяти.

Вы можете изменить это, чтобы разрешить очистку объектов или удаление отдельных объектов, если освобождение памяти вызывает беспокойство.