Arraylist in Java und Eingeben

Question

Ich bin auf Python verwendet, so ist dies für mich ein wenig verwirrend. Ich versuche, in Eingang, Line-by-line zu nehmen, bis ein Benutzer eine bestimmte Anzahl eingibt. Die Zahlen werden in einem Array gespeichert werden einige statistische Mathematik auf sie anzuwenden. Derzeit habe ich eine Hauptklasse, die Statistiken Klassen und eine „Lesen“ Klasse.

Zwei Fragen:

1. Ich kann nicht scheinen, um die Eingangsschleife, um aus zu arbeiten, was die beste Praxis ist so zu tun.

2. Was ist das Objekt-Typ für die Leseverfahren sein? A double [] oder eine Arraylist?

   1. Wie erkläre ich Methode Typ ein Arraylist sein?

   2. Wie verhindere ich das Array von mehr als 1000 Werte in ihr gespeichert sind?

Lassen Sie mich zeigen, was ich habe, so weit:

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

Jede mögliche Hilfe geschätzt, verzeihen Sie meine newbieness ...

Answer 1

Antworten:

> 1. Ich kann nicht zu arbeiten scheinen, um die Eingangsschleife zu bekommen, was die beste Praxis ist so zu tun.

ich eher eine einfache while-Schleife anstelle eines do {} while ... und legen Sie den Zustand, in dem während ... In meinem Beispiel hätte es lesen:

, während die Lesenummer nicht beenden Signal und Zählung niedriger als Grenze. Do

> 2. Was ist das Objekt-Typ für die Leseverfahren sein? A double [] oder eine Arraylist?

Ein Arraylist, aber ich würde empfehlen Ihnen dringend, stattdessen List (java.util.List) Schnittstelle zu verwenden. Es ist eine gute OO Praxis an die Schnittstelle zu programmieren, eher auf die Umsetzung.

> 2.1How erkläre ich Methode Typ ein Arraylist sein?

Siehe Code unten.

> 2.2. Wie verhindere ich das Array aus, die mehr als 1000 Werte in sie gespeichert?

Durch diese Einschränkung in der while Bedingung hinzugefügt wird.

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

Schlussbemerkung:

Es ist bevorzugt „Instanzmethoden“ als Klassenmethoden zu haben. Auf diese Weise, wenn die „Readrange“ erforderlich könnte die Signatur zu ändern, so dass in der Probe, ohne durch eine Unterklasse behandelt werden habe ich das „statische“ Schlüsselwort entfernt eine eine Instanz von „InputTest“ Klasse erstellen

In Java-Code-Stil die Variablennamen in cammel Fall wie in "endSignal" gehen sollten und nicht als "end_signal"

Answer 2

Was Sie brauchen in Ihrer Schleifenbedingung ist:

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

Was Sie tun, um die Zählervariable dekrementiert.

Auch sollten Sie die ArrayList erklären, wie so:

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

Dies macht die Liste typspezifischen und ermöglicht den Zustand als gegeben. Ansonsten gibt es zusätzlichen Guss.

Answer 3

Ich glaube, Sie begann nicht schlecht, aber hier ist mein Vorschlag. Ich werde die wichtigen Unterschiede und Punkte unter dem Code hervorheben:

Paket-Konsole;

import java.util . . Import java.util.regex ;

public class 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. In Java ist es eine gute Sache, Generika zu verwenden. Auf diese Weise können die Compiler und virtuelle Maschine einen Hinweis über die Typen geben, sind Sie zu verwenden. In diesem Fall seine Doppel und durch die daraus resultierende Liste erklärt doppelte Werte enthalten, Sie sind in der Lage, die Werte ohne Gießen / Typumwandlung zu verwenden:

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

2. Es ist besser, Schnittstellen zurückzukehren, wenn sie mit Java Sammlungen arbeiten, da es viele Implementierungen von spezifischen Listen (LinkedList, SynchronizedLists, ...). Also, wenn Sie eine andere Art von Liste müssen später, können Sie einfach die konkrete Umsetzung in der Methode ändern, und Sie keinen weiteren Code ändern müssen.

3. Sie fragen sich vielleicht, warum die während Steueranweisung funktioniert, aber wie Sie sehen, gibt es Klammern um next = input.next (). Trim () . Auf diese Weise wird die Variable Zuordnung erfolgt direkt vor dem bedingten Test. Auch eine trim nimmt playe whitespacing Fragen

zu vermeiden

4. Ich bin nicht mit nextdouble () hier, weil, wenn ein Benutzer würde Eingabe etwas, das nicht eine doppelte, gut ist, werden Sie eine Ausnahme erhalten. Durch die Verwendung von String Ich bin in der Lage zu analysieren, was Eingang ein Benutzer gibt, sondern auch gegen das Endsignal zu testen.

5. Um sicher zu sein, inputed ein Benutzer wirklich eine doppelte, habe ich einen regulären Ausdruck aus der JavaDoc der Double.valueOf () Methode. Wenn dieser Ausdruck übereinstimmt, wird der Wert umgewandelt, wenn nicht eine Fehlermeldung ausgegeben wird.

6. Sie verwendet einen Zähler für Gründe, warum ich in Ihrem Code nicht sehen. Wenn Sie wissen möchten, wie viele Werte erfolgreich inputed wurden, rufen Sie einfach readRange.size () .

7. Wenn Sie mit einem Array arbeiten wollen, der zweite Teil des Konstrukteurs zeigt, wie es zu konvertieren.

8. Ich hoffe, Sie von mir nicht zu verwechseln mixin bis doppelt und Doppel, aber dank Java 1.5-Funktion Auto-Boxen ist das kein Problem. Und wie Scanner.next () wird nie null zurück (afaik), das should't ein Problem sein.

9. Wenn Sie die Größe des Arrays zu begrenzen, verwenden Sie

Okay, ich hoffe, dass Sie meine Lösung sind zu finden und Erklärungen usefull, verwenden Sie result.size () als Indikator und das Schlüsselwort Pause , um die während Steueranweisung zu verlassen.

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