HashCode () öğesini geçersiz kılan bir nesnenin benzersiz kimliğini nasıl edinebilirim?

Java'daki bir sınıf hashCode () yöntemini geçersiz kılmadığında , bu sınıfın bir örneğini yazdırmak hoş bir benzersiz sayı verir.

Object Javadoc hashCode () hakkında şunları söylüyor :

Oldukça pratik olduğu kadar, Object sınıfı tarafından tanımlanan hashCode yöntemi farklı nesneler için farklı tamsayılar döndürür.

Ancak sınıf hashCode () öğesini geçersiz kıldığında , benzersiz numarasını nasıl alabilirim?

System.identityHashCode (yourObject) , bir tamsayı olarakObject öğenizin 'orijinal' karma kodunu verecektir. Benzersizlik mutlaka garanti edilmez. Sun JVM uygulaması size bu nesnenin orijinal bellek adresiyle ilişkili bir değer verecektir, ancak bu bir uygulama detayıdır ve buna güvenmemelisiniz.

DÜZENLEME: Yanıt, Tom'un aşağıdaki yorumundan sonra değiştirildi. bellek adresleri ve hareketli nesneler.

Object için javadoc,

Bu genellikle nesnenin dahili adresini bir tamsayıya dönüştürerek uygulanır, ancak bu uygulama tekniği JavaTM programlama dili için gerekli değildir.

Bir sınıf hashCode'u geçersiz kılarsa, belirli bir kimliği oluşturmak istediği anlamına gelir;

Herhangi bir sınıf için bu kimliği almak için System.identityHashCode kullanabilirsiniz .

hashCode()yöntemi, bir nesne için benzersiz bir tanımlayıcı sağlamak değildir. Bunun yerine, nesnenin durumunu (üye alanlarının değerleri) tek bir tamsayıya sindirir. Bu değer çoğunlukla nesneleri etkili bir şekilde saklamak ve almak için haritalar ve kümeler gibi karma tabanlı veri yapıları tarafından kullanılır.

Nesneleriniz için bir tanımlayıcıya ihtiyacınız varsa, geçersiz kılmak yerine kendi yönteminizi eklemenizi öneririm hashCode. Bu amaçla, aşağıdaki gibi bir temel arayüz (veya soyut bir sınıf) oluşturabilirsiniz.

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

Örnek kullanım:

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

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

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

Belki bu hızlı, kirli çözüm işe yarar?

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

    public int hashCode() {
        return uid;
    }
}

Bu aynı zamanda başlatılan bir sınıfın örnek sayısını verir.

Eğer değiştirebileceğiniz bir sınıfsa, bir sınıf değişkeni bildirebilirsiniz static java.util.concurrent.atomic.AtomicInteger nextInstanceId. (Açık bir şekilde ona bir başlangıç ​​değeri vermeniz gerekir.) Ardından bir örnek değişkeni bildirin int instanceId = nextInstanceId.getAndIncrement().

Ben birden çok iş parçacıkları üzerinde oluşturulan nesneler var ve serileştirilebilir benim durumumda çalışan bu çözüm ile geldi:

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;
    }
}

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

Bir nesne üzerinde bir hashcodeJava yaptığınızda Java türlerine bakıyorsanız .toString(), temel kod şudur:

Integer.toHexString(hashCode())

Diğer cevapları farklı bir açıdan arttırmak için.

Eğer 'yukarıdan' hashcode (ları) tekrar kullanmak ve sınıfınızın değişmez durumunu kullanarak yenilerini türetmek istiyorsanız, super çağrısı işe yarayacaktır. Bu, Nesneye kadar kademeli olarak sıralanabilse de (örneğin, bazı atalar süper çağırmayabilir), ancak hash kodlarını yeniden kullanarak türetmenize izin verecektir.

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

HashCode () ve identityHashCode () döndürmeleri arasında bir fark vardır. İki eşit olmayan (== ile test edilmiş) o1 nesnesi için o2 hashCode () aynı olabilir. Bunun nasıl doğru olduğu aşağıdaki örneğe bakın.

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");
        }
    }
}

Aynı sorunu yaşadım ve hiçbiri benzersiz kimlikleri garanti etmediği için şimdiye kadar cevapların hiçbirinden memnun kalmadım.

Ben de amaçlanan hata ayıklama için nesne kimlikleri yazdırmak istedim. Eclipse hata ayıklayıcısında, her nesne için benzersiz kimlikler belirlediğinden, bunu yapmanın bir yolu olması gerektiğini biliyordum.

Ben nesneler için "==" operatörü sadece iki nesne aslında aynı örnek ise doğru döndürür dayalı bir çözüm geldi.

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);
        }
    }
}

Bunun, programın ömrü boyunca benzersiz kimlikler sağlaması gerektiğine inanıyorum. Bununla birlikte, büyük olasılıkla bunu bir üretim uygulamasında kullanmak istemediğinize dikkat edin, çünkü kimlikleri oluşturduğunuz tüm nesnelere referansları korur. Bu, bir kimlik oluşturduğunuz nesnelerin hiçbir zaman çöp toplanmayacağı anlamına gelir.

Bunu hata ayıklama amacıyla kullandığım için, hafızanın boşaltılmasıyla fazla ilgilenmiyorum.

Belleği boşaltmak bir sorun oluşturuyorsa, nesneleri temizlemeye veya nesneleri tek tek kaldırmaya izin vermek için bunu değiştirebilirsiniz.