# Character einlesen



## Apfel3 (9. Sep 2011)

Hallo bis jetzt habe ich die Buchstaben als string eingelesen dann in Character gewandelt.
In meine Spript werden Buchstaben so eingelesen

s=IO.readChars("bitte string eingeben");

Funktioniert das wirklich so? oder ist das einfach Psydocode?


```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Array {
	
	   public static void main(String [] args) throws IOException
	    {

	        
	        BufferedReader input = new BufferedReader (new InputStreamReader(System.in));

	    int i=0;
	    System.out.print("Bitte einen String:");
        String zeile;
        zeile =(input.readLine());
        char [] s = zeile.toCharArray ();
        System.out.print("Bitte einen String:");
        String zeile2;
        zeile2 =(input.readLine());
        char [] t = zeile2.toCharArray ();
        System.out.print(s);
        while(true){
        	if((i==s.length)&&(i==t.length)){System.out.print(" = ");break; }
        	if(i==s.length)					{System.out.print(" < ");break; }
        	if(i==t.length)					{System.out.print(" > ");break; }
        	if(s[i]<t[i])					{System.out.print(" < ");break; }
        	if(s[i]>t[i])					{System.out.print(" > ");break; }
        	i++;
            
        }
        System.out.print(t);
        
        
	}

}
```


----------



## faetzminator (9. Sep 2011)

Was soll wie funktionieren? Bitte etwas mehr Erklärung. Abgesehen davon kannst du das Programm laufen lassen, und danach weisst du, ob es läuft oder nicht 
Auf alle Fälle scheint die Klasse [c]IO[/c] von deinem Dozenten zu sein, in der Standard API gibts keine solche Klasse.


----------



## SlaterB (9. Sep 2011)

da wird einfach eine andere Klasse vorausgesetzt, die ziemlich häufig zu sein scheint, liest man hier öfter,
ich habe jetzt gerade eine von 
Programmierkurs Java
gefunden:

```
import java.io.*;

// Hilfsklasse mit Ein-/Ausgabeanweisungen
public class IO {

	// Ausgeben eines Strings
	public static void print(String str) {
		System.out.print(str);
	}

	// Ausgeben eines Strings inklusive Zeilenvorschub
	public static void println(String str) {
		System.out.println(str);
	}

	// Ausgeben eines long
	public static void print(long number) {
		System.out.print(number);
	}

	// Ausgeben eines long inklusive Zeilenvorschub
	public static void println(long number) {
		System.out.println(number);
	}

	// Ausgeben eines double
	public static void print(double number) {
		System.out.print(number);
	}

	// Ausgeben eines double inklusive Zeilenvorschub
	public static void println(double number) {
		System.out.println(number);
	}

	// Ausgeben eines char
	public static void print(char zeichen) {
		System.out.print(zeichen);
	}

	// Ausgeben eines char inklusive Zeilenvorschub
	public static void println(char zeichen) {
		System.out.println(zeichen);
	}

	// Ausgeben eines Objektes
	public static void print(Object obj) {
		System.out.print(obj);
	}

	// Ausgeben eines char inklusive Zeilenvorschub
	public static void println(Object obj) {
		System.out.println(obj);
	}

	// Ausgeben eines Zeilenvorschub
	public static void println() {
		System.out.println();
	}

	// Einlesen eines char
	public static char readChar() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			return eingabe.charAt(0);
		} catch (Exception e) {
			return '\0';
		}
	}

	// Einlesen eines short
	public static short readShort() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			Integer String_to_short = new Integer(eingabe);
			return (short) String_to_short.intValue();
		} catch (Exception e) {
			return 0;
		}
	}

	// Einlesen eines int
	public static int readInt() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			Integer String_to_int = new Integer(eingabe);
			return String_to_int.intValue();
		} catch (Exception e) {
			return 0;
		}
	}

	// Einlesen eines long
	public static long readLong() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			Long String_to_long = new Long(eingabe);
			return String_to_long.longValue();
		} catch (Exception e) {
			return 0L;
		}
	}

	// Einlesen eines float
	public static float readFloat() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			Float String_to_float = new Float(eingabe);
			return String_to_float.floatValue();
		} catch (Exception e) {
			return 0.0F;
		}
	}

	// Einlesen eines double
	public static double readDouble() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			String eingabe = input.readLine();
			Double String_to_double = new Double(eingabe);
			return String_to_double.doubleValue();
		} catch (Exception e) {
			return 0.0;
		}
	}

	// Einlesen eines Strings
	public static String readString() {
		try {
			BufferedReader input = new BufferedReader(new InputStreamReader(
					System.in));
			return input.readLine();
		} catch (Exception e) {
			return "";
		}
	}

	// Ausgeben eines Strings und Einlesen eines char
	public static char readChar(String str) {
		System.out.print(str);
		return readChar();
	}

	// Ausgeben eines Strings und Einlesen eines short
	public static short readShort(String str) {
		System.out.print(str);
		return readShort();
	}

	// Ausgeben eines Strings und Einlesen eines int
	public static int readInt(String str) {
		System.out.print(str);
		return readInt();
	}

	// Ausgeben eines Strings und Einlesen eines long
	public static long readLong(String str) {
		System.out.print(str);
		return readLong();
	}

	// Ausgeben eines Strings und Einlesen eines float
	public static float readFloat(String str) {
		System.out.print(str);
		return readFloat();
	}

	// Ausgeben eines Strings und Einlesen eines double
	public static double readDouble(String str) {
		System.out.print(str);
		return readDouble();
	}

	// Ausgeben eines Strings und Einlesen eines string
	public static String readString(String str) {
		System.out.print(str);
		return readString();
	}
}
```

wie man sieht kocht die auch nur mit Wasser, 
dass bei jedem Einlesen ein neuer Stream angelegt wird halte ich sogar für gefährlich,
anscheinend werden die Streams nicht geschlossen, ansonsten wäre System.in für immer hinüber,
lieber nur System.in in irgendwas wrappen

edit:
eine Methode readChars(); ist hier allerdings nicht dabei


----------

