Obtendo um elemento de um conjunto

Por que não Setfornece uma operação para obter um elemento igual a outro elemento?

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

Posso perguntar se o Setcontém um elemento igual a bar, então por que não consigo obtê-lo? :(

Para esclarecer, o equalsmétodo é substituído, mas apenas verifica um dos campos, não todos. Portanto, dois Fooobjetos considerados iguais podem realmente ter valores diferentes, é por isso que não posso simplesmente usar foo.

Não faria sentido obter o elemento se ele fosse igual. A Mapé mais adequado para este caso de uso.

Se você ainda deseja encontrar o elemento, não tem outra opção senão usar o iterador:

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

Para responder à pergunta precisa " Por que não Setfornece uma operação para obter um elemento que se iguala a outro elemento?", A resposta seria: porque os designers da estrutura de coleção não eram muito prospectivos. Eles não anteciparam seu caso de uso legítimo, tentaram ingenuamente "modelar a abstração matemática do conjunto" (do javadoc) e simplesmente esqueceram de adicionar o get()método útil .

Agora, para a pergunta implícita " como você obtém o elemento então": acho que a melhor solução é usar a em Map<E,E>vez de a Set<E>, para mapear os elementos para si mesmos. Dessa forma, você pode recuperar eficientemente um elemento do "conjunto", porque o método get () do Mapencontrará o elemento usando uma tabela de hash eficiente ou um algoritmo de árvore. Se desejar, você pode escrever sua própria implementação Setque oferece o get()método adicional , encapsulando o Map.

As seguintes respostas são ruins ou erradas na minha opinião:

"Você não precisa obter o elemento, porque você já tem um objeto igual": a asserção está errada, como você já mostrou na pergunta. Dois objetos iguais ainda podem ter um estado diferente que não é relevante para a igualdade de objetos. O objetivo é obter acesso a esse estado do elemento contido no Set, não ao estado do objeto usado como uma "consulta".

"Você não tem outra opção senão usar o iterador": é uma pesquisa linear sobre uma coleção que é totalmente ineficiente para conjuntos grandes (ironicamente, internamente, ela Seté organizada como mapa ou árvore de hash que pode ser consultada com eficiência). Não faça isso! Vi sérios problemas de desempenho em sistemas da vida real usando essa abordagem. Na minha opinião, o que é terrível sobre o get()método ausente não é tanto que seja um pouco complicado contorná-lo, mas a maioria dos programadores usará a abordagem de pesquisa linear sem pensar nas implicações.

Se você tem um objeto igual, por que você precisa daquele do conjunto? Se for "igual" apenas por uma chave, uma Mapseria uma escolha melhor.

De qualquer forma, o seguinte será feito:

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

Com o Java 8, isso pode se tornar um liner:

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

Converta o conjunto em lista e use o getmétodo da lista

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

Infelizmente, o Conjunto Padrão em Java não foi projetado para fornecer uma operação "get", como o jschreiner explicou com precisão.

As soluções de uso de um iterador para encontrar o elemento de interesse (sugerido pelo dacwe ) ou para remover o elemento e adicioná-lo novamente com seus valores atualizados (sugeridos pelo KyleM ), podem funcionar, mas podem ser muito ineficientes.

Substituir a implementação de iguais para que objetos diferentes sejam "iguais", conforme afirmado corretamente por David Ogren , pode facilmente causar problemas de manutenção.

E usar um mapa como uma substituição explícita (como sugerido por muitos), imho, torna o código menos elegante.

Se o objetivo é obter acesso à instância original do elemento contido no conjunto (espero que eu entenda corretamente seu caso de uso), aqui está outra solução possível.

Pessoalmente, tive a mesma necessidade ao desenvolver um videogame cliente-servidor com Java. No meu caso, cada cliente tinha cópias dos componentes armazenados no servidor e o problema era sempre que um cliente precisava modificar um objeto do servidor.

Passar um objeto pela Internet significava que o cliente tinha instâncias diferentes desse objeto de qualquer maneira. Para combinar essa instância "copiada" com a original, decidi usar os UUIDs Java.

Então, eu criei uma classe abstrata UniqueItem, que automaticamente fornece um ID exclusivo aleatório para cada instância de suas subclasses.

Esse UUID é compartilhado entre o cliente e a instância do servidor; portanto, pode ser fácil combiná-los usando um Mapa.

No entanto, o uso direto de um mapa em um caso de uso semelhante ainda era deselegante. Alguém pode argumentar que usar um mapa pode ser mais complicado de manter e manusear.

Por esses motivos, implementei uma biblioteca chamada MagicSet, que torna o uso de um mapa "transparente" para o desenvolvedor.

https://github.com/ricpacca/magicset

Como o Java HashSet original, um MagicHashSet (que é uma das implementações do MagicSet fornecidas na biblioteca) usa um HashMap de backup, mas em vez de ter elementos como chaves e um valor fictício como valores, ele usa o UUID do elemento como chave e o próprio elemento como valor. Isso não causa sobrecarga no uso da memória em comparação com um HashSet normal.

Além disso, um MagicSet pode ser usado exatamente como um conjunto, mas com mais alguns métodos fornecendo funcionalidades adicionais, como getFromId (), popFromId (), removeFromId (), etc.

O único requisito para usá-lo é que qualquer elemento que você deseja armazenar em um MagicSet precisa estender a classe abstrata UniqueItem.

Aqui está um exemplo de código, imaginando recuperar a instância original de uma cidade de um MagicSet, dada outra instância dessa cidade com o mesmo UUID (ou mesmo apenas seu UUID).

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
}

Se o seu conjunto é de fato um NavigableSet<Foo>(como a TreeSet) e Foo implements Comparable<Foo>você pode usar

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

(Obrigado ao comentário de @ eliran-malka pela dica.)

Com o Java 8, você pode:

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

Mas tenha cuidado, .get () lança uma NoSuchElementException, ou você pode manipular um item opcional.

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

Se você conseguir apenas isso, não terá muito desempenho, porque você fará um loop sobre todos os seus elementos, mas ao realizar várias recuperações em um grande conjunto, você notará a diferença.

Por quê:

Parece que Set desempenha um papel útil ao fornecer um meio de comparação. Ele foi projetado para não armazenar elementos duplicados.

Devido a essa intenção / design, se for necessário obter () uma referência ao objeto armazenado e depois modificá-lo, é possível que as intenções de design de Set sejam frustradas e possam causar comportamento inesperado.

Do JavaDocs

Deve-se ter muito cuidado se objetos mutáveis ​​forem usados ​​como elementos de conjunto. O comportamento de um conjunto não será especificado se o valor de um objeto for alterado de maneira a afetar comparações iguais enquanto o objeto for um elemento do conjunto.

Quão:

Agora que o Streams foi introduzido, é possível fazer o seguinte

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

Que tal usar a classe Arrays?

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

saída:
itens um, dois

É melhor usar o objeto Java HashMap para essa finalidade http://download.oracle.com/javase/1,5.0/docs/api/java/util/HashMap.html

Eu sei, isso foi perguntado e respondido há muito tempo; no entanto, se alguém estiver interessado, aqui está a minha solução - classe de conjunto personalizado apoiada pelo HashMap:

http://pastebin.com/Qv6S91n9

Você pode implementar facilmente todos os outros métodos Set.

Foi lá feito isso !! Se você estiver usando o Guava, uma maneira rápida de convertê-lo em um mapa é:

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

você pode usar a classe 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);   
 }
 }
}

Se você quer o enésimo elemento do HashSet, pode seguir a solução abaixo, aqui eu adicionei o objeto ModelClass no 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;
    }
}

Se você observar as primeiras linhas da implementação java.util.HashSet, verá:

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

Portanto, HashSetusa-o de HashMapmaneira interativa, o que significa que, se você usar HashMapdiretamente um e usar o mesmo valor da chave e do valor, obterá o efeito desejado e economizará memória.

parece que o objeto apropriado a ser usado é o Interner da goiaba:

Fornece comportamento equivalente a String.intern () para outros tipos imutáveis. Implementações comuns estão disponíveis na classe Interners .

Ele também possui algumas alavancas muito interessantes, como concurrencyLevel ou o tipo de referência usado (pode ser interessante notar que ele não oferece um SoftInterner que eu poderia considerar mais útil que um WeakInterner).

Porque qualquer implementação específica do conjunto pode ou não ser acesso aleatório .

Você sempre pode obter um iterador e percorrer o conjunto, usando o next()método dos iteradores para retornar o resultado desejado depois de encontrar o elemento igual. Isso funciona independentemente da implementação. Se a implementação NÃO for de acesso aleatório (imagine um conjunto suportado por lista vinculada), um get(E element)método na interface seria enganoso, pois teria que repetir a coleção para encontrar o elemento a ser retornado, e um get(E element)parecer implicaria que isso seria necessário, que o conjunto possa pular diretamente para o elemento a ser obtido.

contains() pode ou não ter que fazer a mesma coisa, é claro, dependendo da implementação, mas o nome não parece prestar-se ao mesmo tipo de mal-entendidos.

Sim, use HashMap... mas de maneira especializada: a armadilha que prevejo ao tentar usar a HashMapcomo pseudo- Seté a possível confusão entre elementos "reais" dos elementos Map/Set"e candidatos", ou seja, elementos usados ​​para testar se um equalelemento já está presente. Isso está longe de ser infalível, mas o afasta da armadilha:

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

Então faça o seguinte:

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

Mas ... agora você quer candidatese autodestruir de alguma forma, a menos que o programador realmente o coloque imediatamente Map/Set... você gostaria containsde "manchar" o candidatemodo que qualquer uso dele, a menos que se junte ao Mapanátema "torna" " Talvez você possa SomeClassimplementar uma nova Taintableinterface.

Uma solução mais satisfatória é um GettableSet , como abaixo. No entanto, para que isso funcione, você deve ser responsável pelo design de SomeClass, a fim de tornar todos os construtores não visíveis (ou ... capazes e dispostos a projetar e usar uma classe de wrapper para ele):

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
}

Implementação:

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

Suas NoVisibleConstructoraulas ficam assim:

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: um problema técnico com essa NoVisibleConstructorclasse: pode-se objetar que essa classe seja inerentemente final, o que pode ser indesejável. Na verdade, você sempre pode adicionar um protectedconstrutor fictício sem parâmetros :

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

... que pelo menos deixaria uma subclasse compilar. Você teria que pensar se precisa incluir outro getOrCreate()método de fábrica na subclasse.

A etapa final é uma classe base abstrata (NB "elemento" para uma lista, "membro" para um conjunto) assim para os membros do seu conjunto (quando possível - novamente, o escopo para o uso de uma classe wrapper em que a classe não está sob seu controle, ou já possui uma classe base etc.), para ocultar a implementação máxima:

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

... uso é bastante óbvio (dentro do seu SomeClass's staticmétodo de fábrica):

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

O contrato do código hash deixa claro que:

"Se dois objetos são iguais de acordo com o método Object, a chamada do método hashCode em cada um dos dois objetos deve produzir o mesmo resultado inteiro."

Então, sua suposição:

"Para esclarecer, o método equals é substituído, mas apenas verifica um dos campos, não todos. Portanto, dois objetos Foo considerados iguais podem realmente ter valores diferentes, é por isso que não posso simplesmente usar foo".

está errado e você está quebrando o contrato. Se olharmos para o método "contains" da interface Set, temos o seguinte:

booleano contém (Objeto o);
Retorna true se este conjunto contiver o elemento especificado. Mais formalmente, retorna true se e somente se este conjunto contiver um elemento "e" tal que o == null? e == null: o.equals (e)

Para realizar o que você deseja, você pode usar um Mapa no qual define a chave e armazena seu elemento com a chave que define como os objetos são diferentes ou iguais entre si.

Método de ajuda rápida que pode resolver esta situação:

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

A seguir pode ser uma abordagem

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

Tente usar uma matriz:

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