Comprobación de la contención en un conjunto de cadenas en Java

Question

Tengo un conjunto de cadenas []. Quiero comprobar si este conjunto contiene otra cadena [].

Set<String[]> s = new HashSet<String[]>(); 
s.add(new String[] {"lucy", "simon"}); 
System.out.println(s.contains(new String[] {"lucy", "simon"})); 

Sin embargo, se imprime falso. Supongo que es porque solo se están comparando las referencias y no las cadenas reales. Parece que la única opción que tengo es crear una clase, decir Frase, e implementar hashCode() y equals() (que usan Arrays.hashCode(...)).

¿Hay alguna otra manera de lograr lo que quiero?

Answer 1

Su conjetura es correcta: las matrices ([]) no es igual a implementar un profundo método: son iguales si son la misma instancia.

La solución más simple sería: la sustitución de String[] por List<String>

Otra manera (pero yo no lo recomiendo) es implementar su propio juego, que no basa en Object.equals sino en java.util.Arrays.equals(Object[]a, Object[]b)

Answer 2

Convierta String[] en List<String> y debería funcionar bastante bien.

Set<List<String>> s = new HashSet<List<String>>(); 
s.add(Arrays.asList("lucy", "simon")); 
System.out.println(s.contains(Arrays.asList("lucy", "simon"))); 

Answer 3

Uso Set<Set<String>> o Set<List<String>> en lugar de Set<String[]>

Código:

List<String> s1=Arrays.asList("1","2"),s2=Arrays.asList("1","2"); 
System.out.println(s1.equals(s2) + " "+s1.hashCode()+ " "+s2.hashCode()); 

Salida:

true 2530 2530 

Answer 4

Suena como que ya ha respondido a su pregunta. Una opción es la que ya dijiste. La otra sería utilizar Set>, ya que la API para equals (Object) dice:

compara el objeto especificado con esta colección por la igualdad.

Answer 5

que acababa de bucle a través de llamadas y Arrays.equals:

algo como esto:

boolean contains(Set<String[]> s, String[] item) { 
    for(String[] toCompare: s) { 
    if(Arrays.equals(toCompare, item)) { 
     return true; 
    } 
    } 
    return false; 
} 

no está seguro de si es el más rápido, pero debe hacer el trabajo muy bien

Answer 6

¿Pueden los elementos del String [] estar en diferentes órdenes y aún así hacer que toda la matriz se considere igual a otra matriz que contenga los mismos elementos en otro orden? En caso afirmativo, sería mejor implementar una clase de contenedor e ignorar equals y hashcode.

si no, y si el almacenamiento de los elementos internos como listas en lugar de matrices es una alternativa aceptable, entonces se podría hacer esto:

package com.stackoverflow; 


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


public class StringContainment { 

    public static void main(final String[] args) { 
    final Set<String[]> s = new HashSet<String[]>(); 
    final Set<List<String>> s2 = new HashSet<List<String>>(); 

    s.add(new String[] {"lucy", "simon"}); 
    s2.add(Arrays.asList(new String[] { "lucy", "simon" })); 

    System.out.println(s.contains(new String[] {"lucy", "simon"})); // false 
    System.out.println(s2.contains(Arrays.asList(new String[] {"lucy", "simon"}))); // true 
    } 

} 

El primer cheque falso de vuelta, la segunda verdad. Podría ser más fácil si puedes usar listas.

Si no puede, aún puede usar esto siempre que no tenga que hacer esta comparación con demasiada frecuencia (definitivamente no es una buena idea para el rendimiento).

Answer 7

Con Java8 introducción corriente puede hacerlo de la siguiente manera:

Boolean res = s.stream() 
    .anyMatch(elm -> elm.equals("lucy") || elm.equals("simon"));