ArrayList em Java e Introdução

Question

Estou acostumado a python, então isso é um pouco confuso para mim. Estou tentando tomar de entrada, linha por linha, até que um usuário insere um determinado número. Os números serão armazenados em uma matriz para aplicar alguma matemática estatísticos a eles. Atualmente, eu tenho uma classe principal, as classes estatísticas e uma "leitura" da classe.

Duas perguntas:

1. Eu não consigo obter o loop de entrada para trabalhar fora, o que é a melhor prática para fazê-lo.

2. O que é o tipo de objeto vai ser para o método de leitura? Um duplo [], ou um ArrayList?

   1. Como faço para declarar método do tipo a ser um matrizes?

   2. Como posso evitar que a matriz de ter mais de 1000 valores armazenados dentro dele?

Deixe-me mostrar o que eu tenho até agora:

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

Qualquer ajuda seria apreciada, perdão minha newbieness ...

Answer 1

Respostas:

> 1. Eu não consigo obter o loop de entrada para trabalhar fora, o que é a melhor prática para fazê-lo.

Eu preferiria ter um simples loop while em vez de um do {} while ... e colocar a condição no tempo ... No meu exemplo lia-se:

enquanto o número de leitura não é acabar com sinal e contagem é menor do que o limite:. Fazê

> 2. Qual é o tipo de objeto vai ser para o método de leitura? Um duplo [], ou um ArrayList?

Um ArrayList, no entanto eu recomendo fortemente que você use interface List (java.util.List) em vez. É uma boa prática OO ao programa para a interface sim para a implementação.

> 2.1How faço para declarar método do tipo a ser um matrizes?

Veja código abaixo.

> 2.2. Como posso evitar que a matriz de ter mais de 1000 valores armazenados dentro dele?

Ao adicionar esta restrição no enquanto condição.

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

Considerações finais:

É preferível ter "métodos de instância" do que métodos de classe. Dessa forma, se necessário o "readRange" poderia ser tratado por uma subclasse sem ter que alterar a assinatura, consequentemente, na amostra eu removi o "estático" palavra-chave um criar uma instância de "InputTest" class

Em estilo do código java os nomes das variáveis ??devem ir em caso cammel como em "EndSignal" em vez de "end_signal"

Answer 2

O que você precisa em sua condição de loop é:

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

O que você está fazendo é diminuindo a variável do contador.

Além disso, você deve declarar a ArrayList assim:

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

Isso faz com que o tipo específico de lista e permite que a condição dada. Caso contrário, há fundição extra.

Answer 3

Eu acho que você começou não é ruim, mas aqui é a minha sugestão. Vou destacar as diferenças importantes e pontos abaixo do código:

consola pacote;

import java.util .; importação java.util.regex ;.

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

}

1. Em Java é uma coisa boa para os genéricos de uso. Desta forma, você dá o compilador e máquina virtual uma dica sobre os tipos que você está prestes a usar. Neste caso seu duplo e declarando a lista resultante para conter valores double, você é capaz de usar os valores sem conversão de fundição / tipo:

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

2. É melhor voltar Interfaces quando se trabalha com coleções Java, uma vez que existem muitas implementações de listas específicas (LinkedList, SynchronizedLists, ...). Então, se você precisa de outro tipo de lista mais tarde, você pode facilmente mudar a implementação concreta dentro do método e você não precisa alterar qualquer outro código.

3. Você pode se perguntar por que o tempo obras instrução de controle, mas como você pode ver, existem suportes em torno de next = input.next (). Trim () . Desta forma, a atribuição de variável toma o lugar certo antes de o teste condicional. Também uma guarnição leva playe a questões Evitar whitespacing

4. Eu não estou usando nextDouble () aqui porque sempre que um usuário faria algo de entrada que não é um duplo, bem, você receberá uma exceção. Usando cordas eu sou capaz de analisar qualquer entrada que um usuário dá, mas também para teste contra o sinal final.

5. Para ter certeza, um usuário realmente inputed uma dupla, eu usei uma expressão regular do JavaDoc do Double.valueOf () método. Se este jogos de expressão, o valor é convertido, se não uma mensagem de erro será impressa.

6. Você usou um contador por razões que não vê em seu código. Se você quiser saber quantos valores foram imputados com sucesso, basta ligar para readRange.size () .

7. Se você deseja trabalhar com uma variedade, a segunda parte dos shows do construtor fora como convertê-lo.

8. Eu espero que você não está confuso por mim mixin-se de casal e duplo, mas graças a Java 1.5 recurso Auto-Boxing isso não é problema. E, como Scanner.next () nunca vai retornar nulo (afaik), este should't ser um problema de todos.

9. Se você quiser limitar o tamanho da matriz, use

Ok, eu espero que você está encontrando a minha solução e explicações usefull, uso result.size () como indicador e a palavra-chave pausa para deixar a instrução de controle enquanto.

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