Tengo una matriz de matrices, similar a esta:
import java.util.Arrays; public class test { public static void main(String[] args) { String[][] A = { { "a", "b", "c" }, { "d", "e", "f" }, { "g", "h", "-" } }; String[][] B = { { "-", "e", "b" }, { "a", "h", "c" }, { "d", "g", "f" } }; String[][] C = { { "a", "b", "c" }, { "d", "e", "f" }, { "g", "h", "-" } }; String[][][] myArray = { A, B}; for (String[][] s : myArray) { System.out.println(Arrays.deepToString(s)); if (Arrays.deepToString(s).equals(Arrays.deepToString(C))) { System.out.println("true"); } } } }Necesito verificar si hay un valor en la matriz, sin embargo, este es el único método que he encontrado que funciona y es muy ineficiente.
¿Hay una mejor manera de hacer esto ya que la mayoría de los métodos integrados no parecen funcionar?
También traté de usar un Set y tenía los mismos problemas.
Esto es fácil: nunca conviertas a cadenas. Prueba deepEquals , debería hacer lo que quieras, aunque, por supuesto, primero tienes que sumergirte en myArray e iterar sobre los elementos.
public static boolean contains(String[][][] set, String[][] obj) { for (String[][] elt : set) { if (Arrays.deepEquals(elt, obj)) { return true; } } return false; }Esto realiza la función contiene para su conjunto de prueba en aproximadamente el 4,5% del tiempo.
Java tiene borrado de tipo cuando se trata de matrices sobre objetos (incluidas otras matrices). Como tal, puede ser un poco más rápido crear deepEquals(String[][], String[][]) donde usa Arrays.equals(String[], String[]) , ya que no tendría que verificar si los objetos son matrices de String en tiempo de ejecución, ni tendría que verificar si hay matrices anidadas aún más profundas.
public static boolean fasterContains(String[][][] set, String[][] obj) { for (String[][] elt : set) { if (deepEquals(elt, obj)) { return true; } } return false; } private static boolean deepEquals(String[][] a, String[][] b) { int n = a.length; if (b.length != n) { return false; } for (int i = 0; i < n; i++) { if (!Arrays.equals(a[i], b[i])) { return false; } } return true; }Esto realiza la función de contenido para su conjunto de prueba en aproximadamente el 3,5% del tiempo, mientras que es solo un poco más complejo que la prueba anterior.
Como sugerencia general: las computadoras no son eficientes cuando se trata de cadenas (aunque las versiones más nuevas de Java abordaron esto de alguna manera). De todos modos, nunca convierta a cadena para ninguna comparación, cálculo, concatenación o lo que sea. Siempre compare bytes, enteros u objetos (es decir, los datos originales) a menos que realmente no haya otra forma.
Si solo tiene una lista de caracteres, entonces hay dos observaciones:
char[][] también debería funcionar;String[] , por supuesto, donde el String consta de varios caracteres (que puede recuperar usando String#charAt(index) y comparar usando String#equals(other) .Con este último, puede reducir el tiempo de búsqueda a aproximadamente un 2%.
Otra forma sería almacenar/hacer hash de sus arreglos como StringBuilder y compararlo con el StringBuilder formado en el arreglo multidimensional.
StringBuilder es más rápido para las operaciones de cadenas en comparación con las cadenas. Aquí está el código:
import java.util.Arrays; public class test { public static void main(String[] args) { String[][] A = { { "a", "b", "c" }, { "d", "e", "f" }, { "g", "h", "-" } }; String[][] B = { { "-", "e", "b" }, { "a", "h", "c" }, { "d", "g", "f" } }; String[][] C = { { "a", "b", "c" }, { "d", "e", "f" }, { "g", "h", "-" } }; String[][][] myArray = { A, B}; StringBuilder str = new StringBuilder(); StringBuilder str1 = new StringBuilder(); for(String[] ss : C){ for(String s : ss){ for(char p : s.toCharArray()){ str1.append(p); } } } String cc = str1.toString(); for(String[][] s : myArray){ for(String[] ss : s){ for(String sss : ss){ for(char p : sss.toCharArray()){ str.append(p); } if(str.toString().equals(cc)){ System.out.println("true"); } } } } } }