ArrayList en Java et saisie

Question

Je suis habitué au python, donc c'est un peu déroutant pour moi. J'essaie de saisir, ligne par ligne, jusqu'à ce qu'un utilisateur saisisse un certain nombre. Les nombres seront stockés dans un tableau pour leur appliquer des calculs mathématiques. Actuellement, j'ai une classe principale, les classes de statistiques et une "lecture". classe.

Deux questions:

1. Je n'arrive pas à obtenir la boucle de saisie, quelle est la meilleure pratique pour le faire.

2. Quel sera le type d'objet pour la méthode de lecture? Un double [], ou un ArrayList?

   1. Comment puis-je déclarer que le type de méthode est un arraylist?

   2. Comment empêcher le tableau de contenir plus de 1000 valeurs stockées?

Permettez-moi de montrer ce que j'ai jusqu'à présent:

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;
}

Toute aide serait appréciée, excusez mon nouveau-né ...

Answer 1

Réponses:

> 1. Je n'arrive pas à obtenir la boucle de saisie, quelle est la meilleure pratique pour le faire.

Je préférerais avoir une simple boucle while plutôt qu'un do {} tant que ... et placer la condition dans le temps ... Dans mon exemple, il se lit:

tant que le numéro lu n'est pas un signal de fin et que le nombre est inférieur à la limite: do.

> 2. Quel sera le type d'objet pour la méthode de lecture? Un double [] ou une ArrayList?

Un ArrayList, cependant, je vous recommande fortement d'utiliser l'interface List (java.util.List) à la place. C'est une bonne pratique pour OO de programmer à l'interface plutôt qu'à l'implémentation.

& 2.1 Comment puis-je déclarer que le type de méthode est un arraylist?

Voir le code ci-dessous.

> 2.2. Comment empêcher le tableau de contenir plus de 1000 valeurs stockées?

En ajoutant cette restriction à la condition 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;
    }
}

Remarques finales:

Il est préférable d’utiliser des "méthodes d’instance". que les méthodes de classe. Ainsi, le cas échéant, le paramètre " readRange " pourrait être manipulé par une sous-classe sans avoir à changer la signature, ainsi, dans l'exemple, j'ai supprimé le caractère "statique" mot-clé an crée une instance de " InputTest " classe

Dans le style de code java, les noms de variable doivent être placés dans le cas de cammel, comme dans "" endSignal". plutôt que "end_signal"

Answer 2

Ce dont vous avez besoin dans votre condition de boucle est:

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

Ce que vous faites est de décrémenter la variable de compteur.

Vous devez également déclarer ArrayList comme suit:

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

Ceci rend la liste spécifique au type et autorise la condition telle que donnée. Sinon, il y a du casting supplémentaire.

Answer 3

Je pense que vous avez commencé pas mal, mais voici ma suggestion. Je soulignerai les différences et points importants sous le code:

la console du package;

import java.util. ; importer java.util.regex. ;

classe publique 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"

}

1. En Java, utiliser des génériques est une bonne chose. De cette façon, vous donnez au compilateur et à la machine virtuelle un indice sur les types que vous allez utiliser. Dans ce cas, son double et en déclarant que la liste résultante contient des valeurs doubles, vous pouvez utiliser les valeurs sans conversion / conversion de type:

   if (!readRange.isEmpty()) {
       double last = readRange.get(readRange.size() - 1);
   }
   

2. Il est préférable de renvoyer les interfaces lorsque vous travaillez avec des collections Java, car il existe de nombreuses implémentations de listes spécifiques (LinkedList, SynchronizedLists, ...). Ainsi, si vous avez besoin ultérieurement d'un autre type de liste, vous pouvez facilement modifier l'implémentation concrète dans la méthode et vous n'avez pas besoin de modifier le code suivant.

3. Vous vous demandez peut-être pourquoi l'instruction de contrôle while fonctionne, mais comme vous le voyez, des crochets entourent next = input.next (). trim () . De cette façon, l'affectation de variable a lieu juste avant le test conditionnel. De plus, un ajustement prend du temps pour éviter les problèmes d’espacement entre les blancs

4. Je n'utilise pas nextDouble () ici, car chaque fois qu'un utilisateur saisira quelque chose qui ne soit pas un double, vous obtiendrez une exception. En utilisant String, je peux analyser l’entrée donnée par un utilisateur, mais aussi tester le signal de fin.

5. Pour être sûr, un utilisateur a réellement saisi un double, j'ai utilisé une expression régulière à partir du JavaDoc de la méthode Double.valueOf () . Si cette expression correspond, la valeur est convertie, sinon un message d'erreur sera imprimé.

6. Vous avez utilisé un compteur pour des raisons que je ne vois pas dans votre code. Si vous voulez savoir combien de valeurs ont été entrées avec succès, appelez simplement readRange.size () .

7. Si vous souhaitez travailler avec un tableau, la deuxième partie du constructeur montre comment le convertir.

8. J'espère que vous ne serez pas déconcerté par le mixage des doubles et des doubles, mais grâce à la fonctionnalité Auto-Boxing de Java 1.5, ce n'est pas un problème. Et comme Scanner.next () ne renverra jamais la valeur null (autant que je sache), cela ne devrait pas poser de problème.

9. Si vous souhaitez limiter la taille du tableau, utilisez

OK, j'espère que vous trouverez ma solution et mes explications utiles. Utilisez result.size () comme indicateur et le mot clé break pour quitter l'instruction de contrôle while.

Greetz, GHad

Answer 4

**

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;
}

**

Answer 5

public static ArrayList<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;
}