ArrayList en Java e ingresando

https://stackoverflow.com/questions/116276

02-07-2019
|

Pregunta

Estoy acostumbrado a Python, así que esto me resulta un poco confuso.Estoy tratando de ingresar datos, línea por línea, hasta que un usuario ingresa un número determinado.Los números se almacenarán en una matriz para aplicarles algunas matemáticas estadísticas.Actualmente, tengo una clase principal, clases de estadísticas y una clase de "lectura".

Dos preguntas:

Parece que no puedo hacer que funcione el bucle de entrada, ¿cuál es la mejor práctica para hacerlo?
¿Cuál será el tipo de objeto para el método de lectura?¿Un doble [] o un ArrayList?
1. ¿Cómo declaro que el tipo de método es una lista de matrices?
2. ¿Cómo evito que la matriz tenga más de 1000 valores almacenados en ella?

Déjame mostrarte lo que tengo hasta ahora:

public static java.util.ArrayList readRange(double end_signal){
    //read in the range and stop at end_signal

    ArrayList input = new ArrayList();
    Scanner kbd = new Scanner( System.in );
    int count = 0;
    do{
        input.add(kbd.nextDouble());
        System.out.println(input); //debugging
        ++count;
    } while(input(--count) != end_signal);
    return input;
}

Cualquier ayuda sería apreciada, perdón por ser novato...

Solución

Respuestas:

>1.Parece que no puedo hacer que funcione el bucle de entrada, ¿cuál es la mejor práctica para hacerlo?

Preferiría tener un bucle while simple en lugar de un do{} while...y colocar la condición en el mientras...En mi ejemplo decía:

mientras el número leído no es una señal de finalización y el recuento es inferior al límite:hacer.

>2.¿Cuál será el tipo de objeto para el método de lectura?¿Un doble [] o un ArrayList?

Una ArrayList, sin embargo, le recomiendo encarecidamente que utilice la interfaz List (java.util.List) en su lugar.Es una buena práctica de OO programar en la interfaz en lugar de la implementación.

>2.1 ¿Cómo declaro que el tipo de método es una lista de matrices?

Vea el código a continuación.

>2.2.¿Cómo evito que la matriz tenga más de 1000 valores almacenados en ella?

Agregando esta restricción en la condición while.

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;

public class InputTest{

    private int INPUT_LIMIT = 10000;

    public static void main( String [] args ) {
        InputTest test = new InputTest();
        System.out.println("Start typing numbers...");
        List list = test.readRange( 2.0 );
        System.out.println("The input was " +  list );
    }

    /**
     * Read from the standar input until endSignal number is typed.
     * Also limits the amount of entered numbers to 10000;
     * @return a list with the numbers.
     */
    public List readRange( double endSignal ) {
        List<Double> input = new ArrayList<Double>();
        Scanner kdb = new Scanner( System.in );
        int count = 0;
        double number = 0;
        while( ( number = kdb.nextDouble() ) != endSignal && count < INPUT_LIMIT ){
            System.out.println( number );
            input.add( number );
        }
        return input;
    }
}

Observaciones finales:

Es preferible tener "métodos de instancia" que métodos de clase.De esta manera, si es necesario, una subclase podría manejar "readRange" sin tener que cambiar la firma, por lo que en el ejemplo eliminé la palabra clave "estática" y creé una instancia de la clase "InputTest".

En el estilo del código Java, los nombres de las variables deben ir en mayúsculas y minúsculas, como en "endSignal" en lugar de "end_signal".

Otros consejos

Lo que necesita en su condición de bucle es:

while ( input.get( input.size()-1 ) != end_signal );

Lo que estás haciendo es disminuir la variable del contador.

También deberá declarar el ArrayList al igual que:

ArrayList<Double> list = new ArrayList<Double>();

Esto hace que la lista sea específica del tipo y permite la condición tal como se proporciona.De lo contrario, hay casting adicional.

Creo que no empezaste mal, pero aquí está mi sugerencia.Destacaré las diferencias y puntos importantes debajo del código:

consola de paquetes;

importar java.util.;importar java.util.regex.;

clase pública ArrayListInput {

public ArrayListInput() {
    // as list
    List<Double> readRange = readRange(1.5);

    System.out.println(readRange);
    // converted to an array
    Double[] asArray = readRange.toArray(new Double[] {});
    System.out.println(Arrays.toString(asArray));
}

public static List<Double> readRange(double endWith) {
    String endSignal = String.valueOf(endWith);
    List<Double> result = new ArrayList<Double>();
    Scanner input = new Scanner(System.in);
    String next;
    while (!(next = input.next().trim()).equals(endSignal)) {
        if (isDouble(next)) {
            Double doubleValue = Double.valueOf(next);
            result.add(doubleValue);
            System.out.println("> Input valid: " + doubleValue);
        } else {
            System.err.println("> Input invalid! Try again");
        }
    }
    // result.add(endWith); // uncomment, if last input should be in the result
    return result;
}

public static boolean isDouble(String in) {
    return Pattern.matches(fpRegex, in);
}

public static void main(String[] args) {
    new ArrayListInput();
}

private static final String Digits = "(\\p{Digit}+)";
private static final String HexDigits = "(\\p{XDigit}+)";
// an exponent is 'e' or 'E' followed by an optionally
// signed decimal integer.
private static final String Exp = "[eE][+-]?" + Digits;
private static final String fpRegex = ("[\\x00-\\x20]*" + // Optional leading "whitespace"
        "[+-]?(" + // Optional sign character
        "NaN|" + // "NaN" string
        "Infinity|" + // "Infinity" string

        // A decimal floating-point string representing a finite positive
        // number without a leading sign has at most five basic pieces:
        // Digits . Digits ExponentPart FloatTypeSuffix
        // 
        // Since this method allows integer-only strings as input
        // in addition to strings of floating-point literals, the
        // two sub-patterns below are simplifications of the grammar
        // productions from the Java Language Specification, 2nd
        // edition, section 3.10.2.

        // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
        "(((" + Digits + "(\\.)?(" + Digits + "?)(" + Exp + ")?)|" +

        // . Digits ExponentPart_opt FloatTypeSuffix_opt
        "(\\.(" + Digits + ")(" + Exp + ")?)|" +

        // Hexadecimal strings
        "((" +
        // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
        "(0[xX]" + HexDigits + "(\\.)?)|" +

        // 0[xX] HexDigits_opt . HexDigits BinaryExponent
        // FloatTypeSuffix_opt
        "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +

        ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*");// Optional
                                                                        // trailing
                                                                        // "whitespace"

}

En Java es bueno utilizar genéricos.De esta manera, le da al compilador y a la máquina virtual una pista sobre los tipos que está a punto de utilizar.En este caso, su doble y al declarar que la lista resultante contiene valores dobles, puede usar los valores sin conversión de fundición/tipo:
```
if (!readRange.isEmpty()) {
    double last = readRange.get(readRange.size() - 1);
}
```
Es mejor devolver Interfaces cuando se trabaja con colecciones de Java, ya que hay muchas implementaciones de listas específicas (LinkedList, SynchronizedLists, ...).Entonces, si necesita otro tipo de Lista más adelante, puede cambiar fácilmente la implementación concreta dentro del método y no necesita cambiar ningún código adicional.
Quizás se pregunte por qué funciona la declaración de control while, pero como puede ver, hay corchetes alrededor siguiente = entrada.siguiente().trim().De esta manera, la asignación de variables se realiza justo antes de la prueba condicional.También es necesario un recorte para evitar problemas de espacios en blanco.
No estoy usando siguienteDoble() aquí porque cada vez que un usuario ingresa algo que no es un doble, obtendrá una excepción.Al usar String, puedo analizar cualquier entrada que proporcione un usuario, pero también probarla con la señal final.
Sin duda, un usuario realmente ingresó un doble, utilicé una expresión regular del JavaDoc del Doble.valorDe() método.Si esta expresión coincide, el valor se convierte; de lo contrario, se imprimirá un mensaje de error.
Usaste un contador por razones que no veo en tu código.Si desea saber cuántos valores se han ingresado correctamente, simplemente llame rango de lectura.tamaño().
Si desea trabajar con una matriz, la segunda parte del constructor muestra cómo convertirla.
Espero que no te confunda al mezclar double y Double, pero gracias a la función Auto-Boxing de Java 1.5 esto no es un problema.Y como Escáner.siguiente() nunca devolverá nulo (que yo sepa), esto no debería ser un problema en absoluto.
Si desea limitar el tamaño de la matriz, utilice

Bien, espero que mi solución y mis explicaciones te resulten útiles. Usa resultado.tamaño() como indicador y la palabra clave romper para salir de la declaración de control while.

Greetz, G Had

public static java.util.ArrayList readRange(double end_signal) {

    //read in the range and stop at end_signal

    ArrayList input = new ArrayList();

    Scanner kbd = new Scanner(System. in );
    int count = 0;

    do {
        input.add(Double.valueOf(kbd.next()));
        System.out.println(input); //debugging
        ++count;
    } while (input(--count) != end_signal);
    return input;
}

public static ArrayList&lt;Double> readRange(double end_signal) {

    ArrayList<Double> input = new ArrayList<Double>();
    Scanner kbd = new Scanner( System.in );
    int count = 0;
    do{
        input.add(kbd.nextDouble());
        ++count;
    } while(input(--count) != end_signal);
return input;
}

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow