Mendapatkan elemen dari Set

Mengapa tidak Setmenyediakan operasi untuk mendapatkan elemen yang sama dengan elemen lain?

Set<Foo> set = ...;
...
Foo foo = new Foo(1, 2, 3);
Foo bar = set.get(foo);   // get the Foo element from the Set that equals foo

Saya bisa bertanya apakah Setelemen itu mengandung elemen yang sama dengan bar, jadi mengapa saya tidak bisa mendapatkan elemen itu? :(

Untuk memperjelas, equalsmetode ini diganti, tetapi hanya memeriksa salah satu bidang, tidak semua. Jadi dua Fooobjek yang dianggap sama sebenarnya dapat memiliki nilai yang berbeda, itu sebabnya saya tidak bisa hanya menggunakan foo.

Tidak akan ada gunanya mendapatkan elemen jika itu sama. A Maplebih cocok untuk usecase ini.

Jika Anda masih ingin menemukan elemen, Anda tidak memiliki pilihan lain selain menggunakan iterator:

public static void main(String[] args) {

    Set<Foo> set = new HashSet<Foo>();
    set.add(new Foo("Hello"));

    for (Iterator<Foo> it = set.iterator(); it.hasNext(); ) {
        Foo f = it.next();
        if (f.equals(new Foo("Hello")))
            System.out.println("foo found");
    }
}

static class Foo {
    String string;
    Foo(String string) {
        this.string = string;
    }
    @Override
    public int hashCode() { 
        return string.hashCode(); 
    }
    @Override
    public boolean equals(Object obj) {
        return string.equals(((Foo) obj).string);
    }
}

Untuk menjawab pertanyaan yang tepat, " Mengapa tidak Setmenyediakan operasi untuk mendapatkan elemen yang sama dengan elemen lain?", Jawabannya adalah: karena perancang kerangka koleksi tidak terlalu melihat ke depan. Mereka tidak mengantisipasi use case Anda yang sangat sah, dengan naif mencoba "memodelkan abstraksi set matematis" (dari javadoc) dan hanya lupa menambahkan yang bergunaget() metode yang .

Sekarang untuk pertanyaan tersirat " bagaimana Anda mendapatkan elemen itu": Saya pikir solusi terbaik adalah dengan menggunakan, Map<E,E>bukan Set<E>, untuk memetakan elemen untuk diri mereka sendiri. Dengan cara itu, Anda dapat secara efisien mengambil elemen dari "set", karena metode get () dari Mapakan menemukan elemen menggunakan tabel hash yang efisien atau algoritma pohon. Jika Anda mau, Anda bisa menulis implementasi Anda sendiri Setyang menawarkan get()metode tambahan , merangkum Map.

Jawaban berikut menurut saya salah atau salah:

"Anda tidak perlu mendapatkan elemen, karena Anda sudah memiliki objek yang sama": pernyataan itu salah, seperti yang sudah Anda tunjukkan dalam pertanyaan. Dua objek yang sama masih dapat memiliki keadaan yang berbeda yang tidak relevan dengan objek kesetaraan. Tujuannya adalah untuk mendapatkan akses ke status elemen yang terkandung dalam Set, bukan status objek yang digunakan sebagai "kueri".

"Anda tidak memiliki pilihan lain selain menggunakan iterator": itu adalah pencarian linier atas koleksi yang sama sekali tidak efisien untuk set besar (ironisnya, secara internal Setdiatur sebagai peta hash atau pohon yang dapat ditanyakan dengan efisien). Jangan lakukan itu! Saya telah melihat masalah kinerja yang parah dalam sistem kehidupan nyata dengan menggunakan pendekatan itu. Menurut pendapat saya apa yang mengerikan tentang get()metode yang hilang tidak begitu banyak sehingga agak sulit untuk mengatasinya, tetapi sebagian besar programmer akan menggunakan pendekatan pencarian linier tanpa memikirkan implikasinya.

Jika Anda memiliki objek yang sama, mengapa Anda membutuhkannya dari set? Jika "sama" hanya dengan kunci, maka Mapakan menjadi pilihan yang lebih baik.

Bagaimanapun, berikut ini akan melakukannya:

Foo getEqual(Foo sample, Set<Foo> all) {
  for (Foo one : all) {
    if (one.equals(sample)) {
      return one;
    }
  } 
  return null;
}

Dengan Java 8 ini bisa menjadi satu liner:

return all.stream().filter(sample::equals).findAny().orElse(null);

Konversikan set ke daftar, lalu gunakan getmetode daftar

Set<Foo> set = ...;
List<Foo> list = new ArrayList<Foo>(set);
Foo obj = list.get(0);

Set Default di Java, sayangnya, tidak dirancang untuk memberikan operasi "get", seperti yang dijelaskan jschreiner secara akurat.

Solusi menggunakan iterator untuk menemukan elemen yang menarik (disarankan oleh dacwe ) atau menghapus elemen dan menambahkannya kembali dengan nilainya diperbarui (disarankan oleh KyleM ), dapat bekerja, tetapi bisa sangat tidak efisien.

Meng-override implementasi equals sehingga objek non-equal adalah "equal", sebagaimana dinyatakan dengan benar oleh David Ogren , dapat dengan mudah menyebabkan masalah pemeliharaan.

Dan menggunakan Peta sebagai pengganti eksplisit (seperti yang disarankan oleh banyak orang), imho, membuat kode kurang elegan.

Jika tujuannya adalah untuk mendapatkan akses ke instance asli dari elemen yang terkandung dalam set (harap saya mengerti benar kasus penggunaan Anda), berikut adalah solusi lain yang mungkin.

Saya pribadi memiliki kebutuhan yang sama saat mengembangkan videogame client-server dengan Java. Dalam kasus saya, setiap klien memiliki salinan komponen yang disimpan di server dan masalahnya adalah kapan pun klien perlu memodifikasi objek server.

Melewati sebuah objek melalui internet berarti bahwa klien memiliki instance berbeda dari objek itu pula. Untuk mencocokkan contoh "disalin" ini dengan yang asli, saya memutuskan untuk menggunakan Java UUIDs.

Jadi saya membuat kelas abstrak UniqueItem, yang secara otomatis memberikan id unik acak untuk setiap instance dari subkelasnya.

UUID ini dibagi antara klien dan server contoh, jadi dengan cara ini bisa mudah untuk mencocokkan mereka hanya dengan menggunakan Peta.

Namun secara langsung menggunakan Peta di usecase yang sama masih tidak sempurna. Seseorang mungkin berpendapat bahwa menggunakan Peta mungkin lebih rumit untuk mempertahankan dan menangani.

Untuk alasan ini saya mengimplementasikan perpustakaan yang disebut MagicSet, yang membuat penggunaan Peta "transparan" kepada pengembang.

https://github.com/ricpacca/magicset

Seperti Java HashSet asli, MagicHashSet (yang merupakan salah satu implementasi MagicSet yang disediakan di perpustakaan) menggunakan backing HashMap, tetapi alih-alih memiliki elemen sebagai kunci dan nilai dummy sebagai nilai, ia menggunakan UUID elemen sebagai kunci dan elemen itu sendiri sebagai nilai. Ini tidak menyebabkan overhead dalam penggunaan memori dibandingkan dengan HashSet normal.

Selain itu, MagicSet dapat digunakan tepat sebagai Set, tetapi dengan beberapa metode lagi menyediakan fungsionalitas tambahan, seperti getFromId (), popFromId (), removeFromId (), dll.

Satu-satunya syarat untuk menggunakannya adalah elemen apa pun yang ingin Anda simpan di MagicSet perlu memperpanjang kelas abstrak UniqueItem.

Berikut adalah contoh kode, membayangkan untuk mengambil contoh asli dari sebuah kota dari MagicSet, memberikan contoh lain dari kota itu dengan UUID yang sama (atau bahkan hanya UUID-nya).

class City extends UniqueItem {

    // Somewhere in this class

    public void doSomething() {
        // Whatever
    }
}

public class GameMap {
    private MagicSet<City> cities;

    public GameMap(Collection<City> cities) {
        cities = new MagicHashSet<>(cities);
    }

    /*
     * cityId is the UUID of the city you want to retrieve.
     * If you have a copied instance of that city, you can simply 
     * call copiedCity.getId() and pass the return value to this method.
     */
    public void doSomethingInCity(UUID cityId) {
        City city = cities.getFromId(cityId);
        city.doSomething();
    }

    // Other methods can be called on a MagicSet too
}

Jika set Anda sebenarnya a NavigableSet<Foo>(seperti a TreeSet), dan Foo implements Comparable<Foo>, Anda dapat menggunakan

Foo bar = set.floor(foo); // or .ceiling
if (foo.equals(bar)) {
    // use bar…
}

(Terima kasih atas komentar @ eliran-malka untuk petunjuknya.)

Dengan Java 8 Anda dapat melakukan:

Foo foo = set.stream().filter(item->item.equals(theItemYouAreLookingFor)).findFirst().get();

Tapi hati-hati, .get () melempar NoSuchElementException, atau Anda dapat memanipulasi item opsional.

Object objectToGet = ...
Map<Object, Object> map = new HashMap<Object, Object>(set.size());
for (Object o : set) {
    map.put(o, o);
}
Object objectFromSet = map.get(objectToGet);

Jika Anda hanya mendapatkan satu, ini tidak akan sangat berkinerja karena Anda akan mengulang semua elemen Anda tetapi ketika melakukan beberapa pengambilan pada set besar Anda akan melihat perbedaannya.

Mengapa:

Tampaknya Set memainkan peran yang berguna dalam menyediakan sarana perbandingan. Ini dirancang untuk tidak menyimpan elemen duplikat.

Karena niat / desain ini, jika seseorang mendapatkan () referensi ke objek yang disimpan, kemudian memutasinya, mungkin saja niat desain Set dapat digagalkan dan dapat menyebabkan perilaku yang tidak terduga.

Dari JavaDocs

Perhatian yang besar harus dilakukan jika benda yang dapat berubah digunakan sebagai elemen yang ditetapkan. Perilaku suatu himpunan tidak ditentukan jika nilai suatu objek diubah dengan cara yang mempengaruhi sama dengan perbandingan sementara objek adalah elemen dalam himpunan.

Bagaimana:

Sekarang, ketika Stream telah diperkenalkan, seseorang dapat melakukan hal berikut

mySet.stream()
.filter(object -> object.property.equals(myProperty))
.findFirst().get();

Bagaimana dengan menggunakan kelas Array?

import java.util.Arrays;
import java.util.List;
import java.util.HashSet;
import java.util.Arrays;

public class MyClass {
    public static void main(String args[]) {
        Set mySet = new HashSet();
        mySet.add("one");
        mySet.add("two");
        List list = Arrays.asList(mySet.toArray());
        Object o0 = list.get(0);
        Object o1 = list.get(1);
        System.out.println("items " + o0+","+o1);
    }
}

output:
item satu, dua

Anda lebih baik menggunakan objek Java HashMap untuk tujuan itu http://download.oracle.com/javase/1,5.0/docs/api/java/util/HashMap.html

Saya tahu, ini telah ditanyakan dan dijawab lama, namun jika ada yang tertarik, inilah solusi saya - kelas set khusus yang didukung oleh HashMap:

http://pastebin.com/Qv6S91n9

Anda dapat dengan mudah menerapkan semua metode Set lainnya.

Telah ada yang melakukannya !! Jika Anda menggunakan Guava, cara cepat untuk mengubahnya menjadi peta adalah:

Map<Integer,Foo> map = Maps.uniqueIndex(fooSet, Foo::getKey);

Anda dapat menggunakan kelas Iterator

import java.util.Iterator;
import java.util.HashSet;

public class MyClass {
 public static void main(String[ ] args) {
 HashSet<String> animals = new HashSet<String>();
animals.add("fox");
animals.add("cat");
animals.add("dog");
animals.add("rabbit");

Iterator<String> it = animals.iterator();
while(it.hasNext()) {
  String value = it.next();
  System.out.println(value);   
 }
 }
}

Jika Anda ingin nth Element dari HashSet, Anda dapat pergi dengan solusi di bawah ini, di sini saya telah menambahkan objek ModelClass di HashSet.

ModelClass m1 = null;
int nth=scanner.nextInt();
for(int index=0;index<hashset1.size();index++){
    m1 = (ModelClass) itr.next();
    if(nth == index) {
        System.out.println(m1);
        break;
    }
}

Jika Anda melihat beberapa baris pertama implementasi java.util.HashSetAnda akan melihat:

public class HashSet<E>
    ....
    private transient HashMap<E,Object> map;

Jadi, HashSetgunakan HashMapinterally, yang berarti bahwa jika Anda hanya menggunakan secara HashMaplangsung dan menggunakan nilai yang sama dengan kunci dan nilai Anda akan mendapatkan efek yang Anda inginkan dan menghemat sedikit memori.

sepertinya objek yang tepat untuk digunakan adalah Interner dari jambu biji:

Memberikan perilaku yang setara ke String.intern () untuk tipe tidak berubah lainnya. Implementasi umum tersedia dari kelas Interners .

Ini juga memiliki beberapa tuas yang sangat menarik, seperti concurrencyLevel, atau jenis referensi yang digunakan (mungkin perlu dicatat bahwa itu tidak menawarkan SoftInterner yang saya lihat lebih berguna daripada WeakInterner).

Karena implementasi tertentu dari Set mungkin atau mungkin bukan akses acak .

Anda selalu bisa mendapatkan iterator dan melangkah melalui Set, menggunakan metode iterators next()untuk mengembalikan hasil yang Anda inginkan setelah Anda menemukan elemen yang sama. Ini berfungsi terlepas dari implementasinya. Jika implementasinya BUKAN akses acak (gambar Set yang didukung daftar-tertaut), get(E element)metode di antarmuka akan menipu, karena harus mengulangi koleksi untuk menemukan elemen yang akan dikembalikan, dan get(E element)tampaknya akan menyiratkan ini akan menjadi perlu, bahwa Set bisa melompat langsung ke elemen untuk mendapatkan.

contains() mungkin atau mungkin tidak harus melakukan hal yang sama, tentu saja, tergantung pada implementasinya, tetapi nama tersebut sepertinya tidak cocok dengan kesalahpahaman yang sama.

Ya, gunakan HashMap... tetapi dengan cara khusus: jebakan yang saya ramalkan dalam mencoba menggunakan a HashMapsebagai pseudo- Setadalah kemungkinan kebingungan antara elemen "aktual" elemen Map/Set, dan "kandidat", yaitu elemen yang digunakan untuk menguji apakah suatu equalelemen sudah ada. Ini jauh dari sangat mudah, tetapi mendorong Anda menjauh dari perangkap:

class SelfMappingHashMap<V> extends HashMap<V, V>{
    @Override
    public String toString(){
        // otherwise you get lots of "... object1=object1, object2=object2..." stuff
        return keySet().toString();
    }

    @Override
    public V get( Object key ){
        throw new UnsupportedOperationException( "use tryToGetRealFromCandidate()");
    }

    @Override
    public V put( V key, V value ){
       // thorny issue here: if you were indavertently to `put`
       // a "candidate instance" with the element already in the `Map/Set`: 
       // these will obviously be considered equivalent 
       assert key.equals( value );
       return super.put( key, value );
    }

    public V tryToGetRealFromCandidate( V key ){
        return super.get(key);
    }
}

Kemudian lakukan ini:

SelfMappingHashMap<SomeClass> selfMap = new SelfMappingHashMap<SomeClass>();
...
SomeClass candidate = new SomeClass();
if( selfMap.contains( candidate ) ){
    SomeClass realThing = selfMap.tryToGetRealFromCandidate( candidate );
    ...
    realThing.useInSomeWay()...
}

Tapi ... Anda sekarang ingin candidatemerusak diri sendiri dalam beberapa cara kecuali programmer benar-benar segera meletakkannya di Map/Set... Anda ingin contains"mencemari" candidatesehingga setiap penggunaannya kecuali jika bergabung dengan Mapmembuatnya menjadi "kutukan" ". Mungkin Anda bisa membuat SomeClassimplement yang baruTaintable antarmuka .

Solusi yang lebih memuaskan adalah GettableSet , seperti di bawah ini. Namun, agar ini berfungsi, Anda harus bertanggung jawab atas desain SomeClassuntuk membuat semua konstruktor tidak terlihat (atau ... mampu dan mau merancang dan menggunakan kelas wrapper untuk itu):

public interface NoVisibleConstructor {
    // again, this is a "nudge" technique, in the sense that there is no known method of 
    // making an interface enforce "no visible constructor" in its implementing classes 
    // - of course when Java finally implements full multiple inheritance some reflection 
    // technique might be used...
    NoVisibleConstructor addOrGetExisting( GettableSet<? extends NoVisibleConstructor> gettableSet );
};

public interface GettableSet<V extends NoVisibleConstructor> extends Set<V> {
    V getGenuineFromImpostor( V impostor ); // see below for naming
}

Penerapan:

public class GettableHashSet<V extends NoVisibleConstructor> implements GettableSet<V> {
    private Map<V, V> map = new HashMap<V, V>();

    @Override
    public V getGenuineFromImpostor(V impostor ) {
        return map.get( impostor );
    }

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

    @Override
    public boolean contains(Object o) {
        return map.containsKey( o );
    }

    @Override
    public boolean add(V e) {
        assert e != null;
        V result = map.put( e,  e );
        return result != null;
    }

    @Override
    public boolean remove(Object o) {
        V result = map.remove( o );
        return result != null;
    }

    @Override
    public boolean addAll(Collection<? extends V> c) {
        // for example:
        throw new UnsupportedOperationException();
    }

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

    // implement the other methods from Set ...
}

NoVisibleConstructorKelas Anda kemudian terlihat seperti ini:

class SomeClass implements NoVisibleConstructor {

    private SomeClass( Object param1, Object param2 ){
        // ...
    }

    static SomeClass getOrCreate( GettableSet<SomeClass> gettableSet, Object param1, Object param2 ) {
        SomeClass candidate = new SomeClass( param1, param2 );
        if (gettableSet.contains(candidate)) {
            // obviously this then means that the candidate "fails" (or is revealed
            // to be an "impostor" if you will).  Return the existing element:
            return gettableSet.getGenuineFromImpostor(candidate);
        }
        gettableSet.add( candidate );
        return candidate;
    }

    @Override
    public NoVisibleConstructor addOrGetExisting( GettableSet<? extends NoVisibleConstructor> gettableSet ){
       // more elegant implementation-hiding: see below
    }
}

PS satu masalah teknis dengan NoVisibleConstructorkelas seperti itu: mungkin keberatan bahwa kelas seperti itu secara inheren final, yang mungkin tidak diinginkan. Sebenarnya Anda selalu bisa menambahkan protectedkonstruktor tanpa parameter dummy :

protected SomeClass(){
    throw new UnsupportedOperationException();
}

... yang paling tidak akan membiarkan kompilasi subclass. Anda kemudian harus memikirkan apakah Anda perlu memasukkan getOrCreate()metode pabrik lain dalam subkelas.

Langkah terakhir adalah kelas dasar abstrak (NB "elemen" untuk daftar, "anggota" untuk set) seperti ini untuk anggota set Anda (bila mungkin - lagi, ruang lingkup untuk menggunakan kelas wrapper di mana kelas tidak di bawah kendali Anda, atau sudah memiliki kelas dasar, dll.), untuk menyembunyikan implementasi maksimal:

public abstract class AbstractSetMember implements NoVisibleConstructor {
    @Override
    public NoVisibleConstructor
            addOrGetExisting(GettableSet<? extends NoVisibleConstructor> gettableSet) {
        AbstractSetMember member = this;
        @SuppressWarnings("unchecked") // unavoidable!
        GettableSet<AbstractSetMembers> set = (GettableSet<AbstractSetMember>) gettableSet;
        if (gettableSet.contains( member )) {
            member = set.getGenuineFromImpostor( member );
            cleanUpAfterFindingGenuine( set );
        } else {
            addNewToSet( set );
        }
        return member;
    }

    abstract public void addNewToSet(GettableSet<? extends AbstractSetMember> gettableSet );
    abstract public void cleanUpAfterFindingGenuine(GettableSet<? extends AbstractSetMember> gettableSet );
}

... penggunaan cukup jelas (dalam Anda SomeClass's staticmetode pabrik):

SomeClass setMember = new SomeClass( param1, param2 ).addOrGetExisting( set );

Kontrak kode hash memperjelas bahwa:

"Jika dua objek sama menurut metode Objek, maka memanggil metode kode hash pada masing-masing dua objek harus menghasilkan hasil integer yang sama."

Jadi asumsi Anda:

"Untuk memperjelas, metode equals diganti, tetapi hanya memeriksa salah satu bidang, tidak semua. Jadi dua objek Foo yang dianggap sama sebenarnya dapat memiliki nilai yang berbeda, itu sebabnya saya tidak bisa hanya menggunakan foo."

salah dan Anda melanggar kontrak. Jika kita melihat metode "berisi" Set antarmuka, kita memiliki itu:

boolean berisi (Objek o);
Mengembalikan nilai true jika set ini berisi elemen yang ditentukan. Lebih formal, mengembalikan true jika dan hanya jika set ini mengandung elemen "e" sehingga o == null? e == null: o.equals (e)

Untuk mencapai apa yang Anda inginkan, Anda bisa menggunakan Peta tempat Anda mendefinisikan kunci dan menyimpan elemen Anda dengan kunci yang mendefinisikan bagaimana benda-benda berbeda atau sama satu sama lain.

Metode penolong cepat yang dapat mengatasi situasi ini:

<T> T onlyItem(Collection<T> items) {
    if (items.size() != 1)
        throw new IllegalArgumentException("Collection must have single item; instead it has " + items.size());

    return items.iterator().next();
}

Mengikuti bisa menjadi pendekatan

   SharedPreferences se_get = getSharedPreferences("points",MODE_PRIVATE);
   Set<String> main = se_get.getStringSet("mydata",null);
   for(int jk = 0 ; jk < main.size();jk++)
   {
      Log.i("data",String.valueOf(main.toArray()[jk]));
   }

Coba gunakan array:

ObjectClass[] arrayName = SetOfObjects.toArray(new ObjectClass[setOfObjects.size()]);