Kolekcje ArrayList?

Taką mam pierwszą część zadania:
W dialogach wejściowych (JOptionPane.showInputDialog(...)) podawane są:

albo napisy,
albo liczby rzeczywiste.

Po zakończeniu wprowadzania danych wypisać na konsoli po kolei wszystkie wprowadzone dane.
Liczba wprowadzanych danych jest dowolna... - I to tego momentu jest spoko ale mam właśnie taki ciąg dalszy -
ale wprowadzanie kończy się:
*gdy użytkownik wprowadzi napis "sum" - wtedy dodatkowo wypisywana ma być suma wszystkich wprowadzonych liczb,

Udało mi się wykminić coś takiego ostatecznie ale oczywiście nie działa jak powinno... Pomysłów brak a terminy gonią. Pomoże ktoś?

import java.util.ArrayList;
import javax.swing.JOptionPane;

public class zadanie_1 {
	public static void main (String[] args){

		ArrayList<String> dane = new ArrayList<String>(1);
		int suma = 0;
		
		while(true){
			String podaje = JOptionPane.showInputDialog("Podaj dane.");
			dane.add(podaje);
			if(podaje == "sum"){
				for(int i=0 ; i<dane.size(); i++){
					Integer.parseInt(podaje);
					suma = suma + podaje.codePointAt(i);
					System.out.println(suma);
					return;
				}
			}break;
		}
		for(String s : dane){
			System.out.print(s + " ");
		}
	}
}

suma = suma + podaje.codePointAt(i);

Dlaczego sumujesz poszczególne kody pól ze stringa, który wprowadziłeś? I to jeszcze 'i' jest indeksem z ArrayListy, a kod pobierasz z pozycji z ostatniego wprowadzonego stringa. Przecież to nie ma prawa działać (chyba że ja nie rozumiem zadania...).

I jeszcze ten return w 'for', w zadaniu są liczby rzeczywiste, a Ty rzutujesz na całkowite (Integer)...to chyba nie ma prawa poprawnie działać.

Tak w ogóle do tego zadania mam jeszcze jedno pytanie ale już odnoście innego podpunktu:
*gdy użytkownik wprowadzi napis "concat" - wtedy dodatkowo wypisywany ma być łańcuch znakowy, stanowiący połączenie wszystkich (rozdzielonych spacją) napisów,

kod taki napisałem:

import java.util.ArrayList;
import javax.swing.JOptionPane;
 
public class zadanie_1 {
	public static void main (String[] args){
 
		ArrayList<String> dane = new ArrayList<String>();
 
        while(true){
        	String podaje = JOptionPane.showInputDialog("Podaj dane.");
            dane.add(podaje);
            if(podaje.equals("concat")){
            	for(String b : dane){
            		System.out.print(b + " ");
            	}
            	break;
            } else if(podaje.equals(null)){
            	System.out.println("Nie podano nic");
            	break;
            }
        }
        System.out.println();
        for(String s : dane){
        	System.out.print(s + " ");
        }
	}
}

Teraz tylko jedyna trudno polega na tym by ostatnio wpisywany wyraz "concat" który ma kończyć i pokazywać wcześniej wpisane znaki nie chce by się wyświetlał.
Powinienem do tego użyć pętli for czy jak?

Ogólnie problem jest prawie rozwiązany.
Teraz tylko nie wiem jak zrobić by wypisywał mi sumę ostateczną a nie z kolejno wprowadzonych liczb i co ważniejsze by nie wyrzucał błędu gdy podaje liczby i stringi na zmianę.

import java.util.ArrayList;
import javax.swing.JOptionPane;
 
public class zadanie_1 {
	public static void main (String[] args){
 
		ArrayList<String> dane = new ArrayList<String>();
		Double suma = 0.0;
		
        while(true){
        	String podaje = JOptionPane.showInputDialog("Podaj dane.");
            dane.add(podaje);
            if(podaje.equals("sum")){
            	for(String a : dane){
            		suma += Double.parseDouble(a);
                	System.out.println(suma + " ");
            	}
            } else if(podaje.equals("concat")){
            	for(String b : dane){
            		dane.set(dane.size()-1, " ");
            		System.out.print(b + " ");
            	}      	
            } else if(podaje.equals("end")){
            	System.out.println("Zakończno podawanie");
            	break;
            }
        }
        
        System.out.println();
        for(String s : dane){
        	System.out.print(s + " ");
        }
    }
}

Jeśli chodzi o wywalenie System.out.println(suma + " "); za for-each to od razu wywala błąd po podaniu danych.

if(podaje.equals("sum")){
     suma = 0.0; //tego brakowało
     for(String a : dane){
         try
         {
               suma += Double.parseDouble(a);
         }
         catch(NumberFormatException e)
         {
         }
                        
    }
    System.out.println(suma + " "); //było w złym miejscu
}

Może to dziwne, ale ja bym to zrobił zupełnie inaczej.

package t214006;

import java.util.ArrayList;

/**
 * Created with IntelliJ IDEA.
 * User: koziolek
 * Date: 22.03.13
 * Time: 20:37
 * To change this template use File | Settings | File Templates.
 */
public class App {

	public static void main(String args[]) {
		ArrayList<UserInput<?>> inputs = new ArrayList<UserInput<?>>();
		//... tutaj kod wczytujący dane od użytkownika przykladowo już po parsowaniu:
		inputs.add(new IntegerUserInput(1));
		inputs.add(new IntegerUserInput(1));
		inputs.add(new StringUserInput("1"));
		inputs.add(new StringUserInput("1"));
		// sobie user wywoluje concate
		applyVisitorLogic(inputs, new StringVisitor());
		// a teraz dla sum
		applyVisitorLogic(inputs, new IntegerVisitor());
	}

	private static void applyVisitorLogic(ArrayList<UserInput<?>> inputs, Visitor<?> iv) {
		for (UserInput<?> ui : inputs) {
			ui.apply(iv);
		}
		System.out.println(iv.effects());
	}


	static boolean isNumber(String s) {
		try {
			Integer.parseInt(s);
			return true;
		} catch (NumberFormatException nfe) {
			return false;
		}
	}
}


abstract class UserInput<T> {
	private T input;

	protected UserInput(T input) {
		this.input = input;
	}

	public void apply(Visitor v) {
		if (v.isAcceptable(input.getClass()))
			v.makeMyDay(input);
	}
}

class IntegerUserInput extends UserInput<Integer> {

	protected IntegerUserInput(Integer input) {
		super(input);
	}
}

class StringUserInput extends UserInput<String> {
	protected StringUserInput(String input) {
		super(input);
	}
}

interface Visitor<T> {

	boolean isAcceptable(Class<?> clazz);

	void makeMyDay(T input);

	T effects();
}

class IntegerVisitor implements Visitor<Integer> {

	Integer sum = 0;

	@Override
	public boolean isAcceptable(Class<?> clazz) {
		return Integer.class.equals(clazz);
	}

	@Override
	public void makeMyDay(Integer input) {
		sum += input;
	}

	@Override
	public Integer effects() {
		return sum;
	}

}

class StringVisitor implements Visitor<String> {

	private StringBuilder stringBuilder = new StringBuilder();

	@Override
	public boolean isAcceptable(Class<?> clazz) {
		return String.class.equals(clazz);
	}

	@Override
	public void makeMyDay(String input) {
		stringBuilder.append(input).append(" ");
	}

	@Override
	public String effects() {
		return stringBuilder.toString();
	}
}

W takim układzie masz jasno rozdzielone logiki pomiędzy typami wprowadzanych danych. Oczywiście typ zmienić trzeba z integer na double...

A ja bym to zrobił tak:

        	ArrayList<String> napisy = new ArrayList<>();
        	float sum = 0.0f;
        	String input = null;
        	final String sumString = "sum";
        	final String endString = "end";
        	final String concatString = "concat";
        			
        	
        	while(!endString.equals(input)) {
        		input = JOptionPane.showInputDialog("Podaj dane:");
        		if (input == null) {
					continue;
				} 
        		try {
					float f = Float.parseFloat(input);
					sum += f;
					continue;
				} catch (NumberFormatException e) {
				}
        		
        		if (sumString.equals(input)) {
        			System.out.println(sum);
        			sum = 0.0f;
        		} else if (concatString.equals(input)) {
        			StringBuilder builder = new StringBuilder();
        			for (String s : napisy) {
        				builder.append(s);
        				builder.append(" ");
        			}
        			System.out.println(builder.toString());
        		} else {
        			napisy.add(input);
        		}
        	} 

Może nie jest to najbardziej optymalne i eleganckie, ale działa:P

Tak żebyście mieli pewność swoich rozwiązań podam całą treść zadania.

W dialogach wejściowych (JOptionPane.showInputDialog(...)) podawane są:

albo napisy,
albo liczby rzeczywiste.

Po zakończeniu wprowadzania danych wypisać na konsoli po kolei wszystkie wprowadzone dane.
Liczba wprowadzanych danych jest dowolna, ale wprowadzanie kończy się:

gdy użytkownik wprowadzi napis "sum" - wtedy dodatkowo wypisywana ma być suma wszystkich wprowadzonych liczb,
gdy użytkownik wprowadzi napis "concat" - wtedy dodatkowo wypisywany ma być łańcuch znakowy, stanowiący połączenie wszystkich (rozdzielonych spacją) napisów,
gdy użytkownik wprowadzi napis "both" - wtedy dodatkowo wypisywana jest i suma liczb i połączenie napisów,
gdy użytkownik wcisnąl "Cancel" lub zamknął dialog - nie ma dodatkowego sumowania i łączenia napisów.

Uwaga: nie wolno niepotrzebnie sumować liczb ani łączyć napisów (przed zakończeniem wprowadzania danych nie wiemy czy te operacje są potrzebne czy nie).
Rozwiązanie: użycie kolekcji.

@Koziołek lekko przesadził.

import java.util.ArrayList;
import javax.swing.JOptionPane;
 
public class Zadanie_1 
{
    public static void main (String[] args)
    {
        ArrayList<String> dane = new ArrayList<String>();
        boolean done = false; 
        while(!done)
        {
            String input = JOptionPane.showInputDialog("Podaj dane:");
            if(input == null)
            {
                done = true;
            }
            else
            {
                dane.add(input);
                if(input.equals("sum") || input.equals("both"))
                {
                    double suma = 0.0;
                    for(String a: dane)
                    {
                        try
                        {
                            suma += Double.parseDouble(a);
                        }
                        catch(NumberFormatException e)
                        {
                        }                        
                    }
                    System.out.println(suma + " ");
                    done = true;
                }
                if(input.equals("concat") || input.equals("both"))
                {
                    for(String a: dane)
                    {
                        System.out.print(a + " ");
                    }
                    done = true;
                }      
            }
        }
        for(String a: dane)
        {
            System.out.println(a);
        }
    }
}