Java Ordenar una matriz de cadenas 2D ya no funciona

Ok, estoy trabajando en una forma de ordenar una matriz 2D, una de las dimensiones tiene una cadena y la otra tiene un int (Almacenado como una cadena por conveniencia) Había buscado en todas partes una solución sobre cómo ordenar las matrices en una forma en que los datos de firstArray[1] se mueven al mismo tiempo (sus índices son secundarios al movimiento de:) como firstArray[0]

Este efecto se logró mediante el uso de este

Arrays.sort(fps, new Comparator<String[]>() {
            @Override
            public int compare(final String[] entry1, final String[] entry2) {
                final String time1 = entry1[0];
                final String time2 = entry2[0];
                return time1.compareTo(time2);
            }
        });

Ahora estoy teniendo problemas con la cosa. Revisaré el código aquí y, por favor, si puede encontrar un problema, infórmeme.

Primero tengo la matriz:

String[][] fps = new String[2][15];
Arrays.fill(fps[0], "empty");
Arrays.fill(fps[1], "0");

En segundo lugar, lleno la matriz con algunas cosas que me da la otra parte del programa, para este ejemplo, uso valores basura:

fps[0][0] = "Java";
fps[1][0] = "1";

fps[0][1] = "C++";
fps[1][1] = "14";

fps[0][2] = "C#";
fps[1][2] = "21";

fps[0][3] = "Python";
fps[1][3] = "9001";

Ahora es donde llamaría al comando de clasificación anterior (tenga en cuenta que estos valores no llenan completamente la matriz, hay algunos contenedores donde no hay datos nuevos).

Arrays.sort(fps, new Comparator<String[]>() {
            @Override
            public int compare(final String[] entry1, final String[] entry2) {
                final String time1 = entry1[0];
                final String time2 = entry2[0];
                return time1.compareTo(time2);
            }
        });

Ahora tenemos la matriz ordenada y quiero buscar un valor en la matriz 2D, así que uso Arrays.search para encontrar en qué contenedor se encuentra la consulta.

int searchIndex = Arrays.binarySearch(fps[0], "Java");
System.out.println(searchIndex);

Así que ese es el código, y creo que he aislado el problema de que la parte de clasificación no funciona correctamente. Si alguno de ustedes tiene más preguntas, por favor publíquelas en los comentarios. Del mismo modo, si tiene una posible solución a este desconcertante problema, ¡me encantaría saber de ella!


PD: Para que quede claro, esto funcionaba, luego apagué mi lappy y la próxima vez que inicié (y desde entonces) no ha funcionado.

PPS: Según lo solicitado las salidas:

Salida de corriente:

-16
FPS:
    0 ---- No FPS For you!
    1 ---- Only one FPS
    2 ---- Only two FPS
    3 ---- Only three FPS
    4 ---- Only four FPS
    5 ---- Only five FPS
    6 ---- Only six FPS
    7 ---- Only seven FPS
    8 ---- Only eight FPS
    9 ---- Only nine FPS
    1 ---- Blah!

Resultado esperado/esperado:

-16
FPS:
    1 ---- Blah!
    0 ---- No FPS For you!
    8 ---- Only eight FPS
    5 ---- Only five FPS
    4 ---- Only four FPS
    9 ---- Only nine FPS
    1 ---- Only one FPS
    7 ---- Only seven FPS
    6 ---- Only six FPS
    3 ---- Only three FPS
    2 ---- Only two FPS

PPPS: si desea ver el código con el que estoy trabajando actualmente:

import java.util.*;

public class Test
{
  public static void main (String [] args)
  {

    String[][] fps = new String[2][15];
    Arrays.fill(fps[0], "empty");//Fill up all the spaces so the sort and the search dont crap out
    Arrays.fill(fps[1], "0"); 


    //fps[ROW][COLOUMN] = Value + "";
    //fps[ROW][COLOUMN] = Value Instances + "";

    fps[0][0] = "No FPS For you!";
    fps[1][0] = 0 + "";

    fps[0][1] = "Only one FPS";
    fps[1][1] = 1 + "";

    fps[0][2] = "Only two FPS";
    fps[1][2] = 2 + "";

    fps[0][3] = "Only three FPS";
    fps[1][3] = 3 + "";

    fps[0][4] = "Only four FPS";
    fps[1][4] = 4 + "";

    fps[0][5] = "Only five FPS";
    fps[1][5] = 5 + "";

    fps[0][6] = "Only six FPS";
    fps[1][6] = 6 + "";

    fps[0][7] = "Only seven FPS";
    fps[1][7] = 7 + "";

    fps[0][8] = "Only eight FPS";
    fps[1][8] = 8 + "";

    fps[0][9] = "Only nine FPS";
    fps[1][9] = 9 + "";
    /* FUMBLE WITH ARRAY AFTER THIS LINE ONLY!*/

    //Things to have inputed into the method:
    //currentValue (from the line)
    //currentVariable (so we know what the name of the array we're dealing with is named)

    String currentValue = "Blah!"; //This is the value that will be searched for in the array, if found its child int is incremented by one, if not found it is added to the array.


    //Do a binary sort then search in the fps[0] side of things, makesure that the [1] are carried with the [0] changes.

    Arrays.sort(fps, new Comparator<String[]>() {
            @Override
            public int compare(final String[] entry1, final String[] entry2) {
                final String time1 = entry1[0];
                final String time2 = entry2[0];
                return time1.compareTo(time2);
            }
        });

    int searchIndex = Arrays.binarySearch(fps[0], currentValue); //Get the index of the current search value
    System.out.println(searchIndex); //  <-- Returns a neg number each time which shows that the sorting is not working correctly, and therefore the search is being thrown off... need to somehow fix.

    if(searchIndex >= 0)// If the value is found
    {
      fps[0][searchIndex] = (Integer.parseInt(fps[0][searchIndex]) + 1) + "";  //Add one instance to the value

    } //end if
    else //Otherwise find the next open value spot and change it to the current search query (and assign its instances to 1
    {

      for(int i = 0; i < fps[1].length ; i++)
      {
        if(fps[1][i].equals("empty"))
        {
          fps[1][i] = currentValue;
          fps[0][i] = 1 + "";
          i = fps[1].length; //force the for loop to exit

          Arrays.sort(fps, new Comparator<String[]>() {
            @Override
            public int compare(final String[] entry1, final String[] entry2) {
                final String time1 = entry1[0];
                final String time2 = entry2[0];
                return time1.compareTo(time2);
            }
        }); //end Arrays.sort
        }//end if
      }//end for
    }//end else


    //... Print array in rectangular form
    System.out.println("FPS:");

    for (int i =0; (!(fps[1][i].equals("empty")) ) ; i++)
    {
      System.out.println("\t" + fps[0][i] + " ---- " + fps[1][i] );


    }//end for
  }//end main
}//end class

preguntado el 08 de marzo de 13 a las 21:03

Bien, pero ¿cuál es el resultado de tu ejemplo con Java, C++, etc.? -

Me encanta la referencia a Seinfeld. No soup for you!! - Esto es lo que pasa cuando codificas en un lappy.... -

"PD: Para que quede claro, esto funcionó, luego apagué mi lappy y la próxima vez que inicié (y desde entonces) no ha funcionado". Conozco ese sentimiento -

3 Respuestas

Creo que tienes tus índices al revés. usted está clasificando fps. fps tiene solo 2 elementos que se están ordenando. Creo que estás tratando de ordenar los 15 elementos. Si invierte sus índices, creo que obtendrá la clasificación deseada.

String[][] fps = new String[15][2];

En este caso, podría considerar una matriz de objetos en lugar de una matriz 2D. Parece ser una estructura más lógica y evitaría este tipo de confusión.

respondido 08 mar '13, 21:03

Lo que necesito son 2 arreglos con 15 elementos, la configuración que tienes es 15 arreglos con dos elementos. No estoy seguro de cómo podría hacer una búsqueda de las matrices. Y al segundo punto (<-- Newb programador) ¿tiene algún recurso sobre los objetos (cuando se usa en una instancia similar a esta) que me podrías indicar? ¡Gracias! ^_^/ - MagikEh

Además del problema señalado en esta respuesta, hay un problema en esto:

int searchIndex = Arrays.binarySearch(fps[0], "Java");

Dado que ordenó utilizando un comparador personalizado, debe usar el mismo comparador personalizado para realizar la búsqueda binaria. Usar binarySearch(T[] a, T key, Comparator<? super T> c). (Si usa la versión de 2 argumentos, debería obtener una excepción porque String[] no implementa Comparable.)

contestado el 23 de mayo de 17 a las 13:05

¿Te importaría mostrar de dónde sacaste esto? O (si es posible) puede mostrar para qué sirve cada uno de los parámetros en binarySearch. Muchas gracias por la sugerencia. También para tener en cuenta la segunda parte, estoy un poco confundido, si uso la búsqueda binaria en la matriz (cuando la matriz está en el orden correcto), el Arrays.binarySearch(fps[0], query); trabajó. Nuevamente, si tiene algún recurso al que pueda señalarme, se lo agradecería mucho. - MagikEh

@MagikEh: obtuve esta información de la documentación estándar de la API de Java, que forma parte de cada distribución de JDK, y también está disponible públicamente y es fácil de encontrar en el sitio web de Oracle. Si su profesor no le explicó cómo encontrar los Javadocs en su primera clase de Java, ¡QUEJARSE! - Stephen C

Aquí está la URL de la copia en línea del árbol de documentación de Java 7 SE: docs.oracle.com/javase/7/docs - Stephen C

¿Tiene algún recurso sobre los objetos (cuando se usa en una instancia similar a esta

Ver: Clasificación usando Comparator- Orden descendente (Clases definidas por el usuario) para ver un ejemplo de cómo hacer esto cuando se usa un objeto personalizado.

una de las dimensiones tiene una cadena y la otra tiene un int (almacenado como una cadena por conveniencia)

No es conveniente, ya que ordenar una representación de Cadena de un número es diferente a ordenar un número. El uso de un objeto personalizado le permitirá almacenar los datos correctamente para que pueda ordenarlos correctamente.

contestado el 23 de mayo de 17 a las 12:05

Gracias por los enlaces, ¡me aseguraré de investigar un poco sobre el lado del objeto de las cosas! ^_^/ - MagikEh

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.