Cómo ordenar una ArrayList por longitud de cadenas en la matriz

Recientemente comencé a tomar un curso de Ciencias de la Computación para entender más la programación y parece haber tocado un obstáculo con nuestro laboratorio en ArrayLists. El propósito del programa es poner x cantidad de cadenas en una ArrayList y luego generar los resultados en orden descendente.

Ej: cebra, ciervo, jirafa ciervo

Resultado: Jirafa, Cebra, Ciervo

Miré en línea y encontré algunos ejemplos usando comparadores ArrayList, pero nuestro profesor quiere que lo hagamos filtrando la palabra más grande, imprimiéndola, eliminándola y luego continuando ese ciclo hasta que se impriman todas las palabras.

Aquí está mi código hasta ahora:

public static void main(String[] args) {

    Scanner input = new Scanner(System.in);
    int length = 0;
    String longest = "";
    String currentWord = "";
    ArrayList <String> DescendArray = new ArrayList<String>();
    System.out.println("What would you like to add to the list?");
    String userInput = input.next();
    while(!userInput.equals("d"))
    {
        DescendArray.add(userInput);
        userInput = input.next();
    }
    for (int i=0; i < DescendArray.size(); i++)
    {
        if (DescendArray.get(i).length() > longest.length())
                {
                    currentWord = DescendArray.get(i);
                    if (currentWord.length() > longest.length())
                    {
                        longest = currentWord;
                        length = longest.length();
                    }
                }
        for (int j=1; j < DescendArray.size() -1 ; j++)
        {
            if (DescendArray.get(j - 1).length() > longest.length())
            {
                DescendArray.remove(j - 1);
            }
            System.out.println(longest + " " + length);
        }
    }
}

}

Supongo que mi error está en algún lugar del bucle interno, pero parece que no puedo hacer que funcione sin importar cuántas variaciones diferentes use.

Respuesta 1

Esto parece funcionar. Si no desea eliminar los animales que se repiten, elimine el distinct()método. Omití la creación de la lista.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Zoo {
    public static void main(String[] args) {
        List<String> zoo = Arrays.asList("Zebra", "Deer", "Giraffe", "Deer");
        String output = zoo.stream()
                           .distinct()
                           .sorted((x, y) -> Integer.compare(y.length(), x.length()))
                           .collect(Collectors.joining(","));
        System.out.println(output);
    }
}
Respuesta: 2

Me sorprende la verbosidad de otras soluciones. Un método mucho más simple sería usar una secuencia:

List<String> original = Arrays.asList("s1", "String 2", "ss3", "s");
List<String> sorted = original.stream()
        .sorted((s1, s2) -> s2.length() - s1.length())
        .collect(Collectors.toList());
System.out.println(sorted);

Reemplace "original" con su ArrayList.

Respuesta: 3

Bajo el supuesto de que las palabras duplicadas no necesitan eliminarse al mismo tiempo, de modo que una palabra duplicada se eliminará en orden, y que la lista no necesita hacerse en orden alfabético (uno podría ordenar la lista primero), y eso es seguro no es importante, evitaría usar los contadores de enteros y verificar el tamaño. En cambio, ejecutaría el bucle de salida hasta que todo se haya eliminado.

Como ejemplo:

public void doRemove()
{
    while (! descendArray.isEmpty()) {
        String longest = "";

        for (String s : descendArray) {
            if (s.length() > longest.length()) {
                longest = s;
            }
        }

        if (longest.length() > 0) {
            if (descendArray.remove(longest)) {
                System.out.println(longest + " (" + longest.length() + ")");
            }
        }
    } // while we stil have things to process
}
Respuesta: 4

Cuando dice orden descendente, ¿se refiere a la longitud de la cadena o a una comparación alfabética?

Vea cómo se puede usar el algoritmo QuickSort para ordenar cadenas. Puede encontrar información sobre QuickSort aquí

Respuesta: 5

El problema parece ser que para cada iteración en su bucle for, llega a Giraffe como su palabra más larga, luego verifica el resto de la lista para ver si es más larga que Giraffe. En lugar de lo que tienes ahora, escribiría algo como:

for (int i=0; i < DescendArray.size(); i++)
{
    longest = "";
    length = longest.length();
    int longestIndex = 0;
    for (int j=1; j < DescendArray.size() -1 ; j++)
    {
        currentWord = DescendArray.get(j);
        if (currentWord.length() > longest.length())
        {
            longestIndex = j;
            longest = currentWord;
            length = longest.length();
        }
    }
    DescendArray.remove(longestIndex);
    System.out.println(longest + " " + length);
}

Este bucle anidado debe encontrar primero la palabra más larga, almacenar el índice e imprimir y eliminar la entrada en ese índice antes de encontrar la siguiente entrada más larga.

Respuesta: 6

Comencé a usar Hadoop recientemente y luché por darle sentido a algunas cosas. Aquí hay un ejemplo básico de WordCount que estoy viendo (cuente la cantidad de veces que aparece cada palabra): Mapa (String docid, ...

Estoy tratando de usar restFB en Google App Engine, cuando intento obtener información sobre el usuario actual, aparece un error, javax.net.ssl.SSLHandshakeException: No se pudo verificar el certificado SSL para: https: // ...

Tengo una fecha de cadena y la convierto con la siguiente declaración: LocalDateTime datetime = LocalDateTime.parse (rs.getString ("DateIn"), DateTimeFormatter.ofPattern ("aaaa / MM / dd HH: mm: ss")); Ahora quiero ...

¿Hay alguna manera en UIMA para acceder a las anotaciones de los tokens de la misma manera que lo hacen en su GUI de depurador de CAS? Por supuesto, puede acceder a todas las anotaciones desde el repositorio de índices, pero yo ...