# aus .txt in array einlesen



## babuschka (19. Nov 2009)

Hallo,

ja ich habe sufu benutzt. Doch für mich ist da nix dabei. Alles irgendwie zu kompliziert ^^
Bin halt noch anfänger Oo

Also ich würde gerne wissen, wie ich aus einer .txt die z.b. 10 {1,2,3,4,5,6,7,8,9,10} Zahlen enthält, diese Zahlen auslese und die dann in einem einfachem Array speichere.

in meinem buch habe ich das gefunden



```
In.open("input.txt");
int x = In.readInt();
while(In.done());{
   ...process x ...
   x = In.readInt();
}
In.close();
```

das habe ich für mein array so geändert


```
class AusDateiInArrayEinlesenUndAusgeben{

    public static void main(String[] args){

	int i = 0;
	int []a;
	a = new int[10];

	In.open("testdatei.txt");
	a[i] = In.readInt();

	while(In.done()){
	    a[i] = In.readInt();
	    Out.println(a[i]);
	    i++;
	}
        
	 In.close();
    }

}
```

als ausgabe bekomme ich 

2
3
4
5
6
7
8
9
10
0

warum die 0 und was ist mit der ersten zahl aus der datei passiert ^^
Bitte nicht zu kompliziert erklären 
Bin halt noch krasser anfänger :rtfm:


----------



## Civilazi (19. Nov 2009)

```
a[i] = In.readInt();
 
    while(In.done()){
        a[i] = In.readInt();
```

Du liest mit In.readInt() das nächste verfügbare int ein. Beim ersten Mal speicherst du das bei a[0] und beim zweiten Mal? Genau, wieder bei a[0]. Denn danach erst erhöhst du i. 
Deshalb fehlt die erste Zahl. Wo die 0 herkommt... da müsstest du genauer sagen, was das mit dem done() heißen soll, da liefert dein Stream oder was das ist anscheinend noch eine 0.


----------



## Der Müde Joe (19. Nov 2009)

Naja niemand kennt die Klasse int ausser dein Buch.
aber ich rate mal:
In der Zeile 10 liest einen int (wahrscheinlich die erste Zeile)
Dann auf Zeile 13 liest du wieder und schreibst wieder an die gleiche Stelle im Array (i)
dann geht bis ans Ende durch.
Da die ersten beiden Zeilen auf array[0] gescheriben wurden fehlt eine Zeile.
Diese (die letzte) wird per default mit 0 initialisiert.


----------



## ARadauer (19. Nov 2009)

> Naja niemand kennt die Klasse int ausser dein Buch.


du meinst In oder?


----------



## babuschka (19. Nov 2009)

hallo, danke für schnellen antworten!

Wiegesagt, will ja erstmal aus einer Datei die 10 Zahlen auslesen und in das Array reinschreiben lassen und dann wieder nacheinander auf dem bildschirm ausgeben lassen.

Dieses  

```
while(In.done()){
.....
}
```
verstehe ich garnicht wofür ich das überhaupt.


Jetzt habe ich das probiert so zu schreiben, macht aber auch nicht wie ich will ^^


```
class AusDateiInArrayEinlesenUndAusgeben{

    public static void main(String[] args){

	int i = 0;
	int []a;
	a = new int[10];
	
	for(;i<10;){
	In.open("testdatei.txt");
	a[i] = In.readInt();
	Out.println(a[i]);
	i++;
	}

	// while(In.done()){
	//     a[i] = In.readInt();
	//     Out.println(a[i]);
	//     i++;
	// }	
        
	 In.close();



    }

}
```

Ausgabe

1
1
1
1
1
1
1
1
1
1

Wie gibt er nur die 1 aus, ic hzähle doch i++


----------



## bygones (19. Nov 2009)

> Naja niemand kennt die Klasse Int ausser dein Buch.


irgendwas weiss diese Methode und sagt ob weiter eingelesen werden soll oder nicht.

obwohl der name etwas irrefuehrend ist - solange "done" ist gehts weiter ?!


----------



## babuschka (19. Nov 2009)

wofür ist dieses done überhaupt?


----------



## Schumi (19. Nov 2009)

Ich schätze mal done springt eine Zeile oder Stelle weiter und zeigt an sobald das File fertig ist. Da es jetzt nicht mehr drinne ist bleibst Du immer auf der gleichen Zeile.


----------



## babuschka (19. Nov 2009)

also muss ich auf jedenfall immer mit In.done arbeiten wenn ich aus einer datein in ein array einlese?!


----------



## Schumi (19. Nov 2009)

Dafür müsste man wohl etwas mehr von der In Klasse kennen. Habt ihr da keine Dokumentation vorliegen?


----------



## babuschka (19. Nov 2009)

In Klasse??? :bahnhof:
Ich weiß net ob du jetzt das meinst, also in dem Ornder wo sich auch die AusDateiInArrayEinlesenUndAusgeben.java befindet habe ich nur In.class und Out.class und In.java und Out.java und noch die testdatei.txt mit den Zahlen von 1 bis 10.
Und der Editor mit dem ich arbeite heißt emacs, falls das wichtig ist ^^
Und diese Klassen habe ich von
Sprechen Sie Java?


----------



## Schumi (19. Nov 2009)

Ja, der Quelltext (oder noch besser die Dokumentation) der "In" Klasse wäre interessant. Also der Inhalt von In.java.


----------



## babuschka (19. Nov 2009)

```
import java.io.*;
import java.util.LinkedList;

/** Simple input from the keyboard or from a file.
<p>Copyright (c) 2005 Hanspeter Moessenboeck, University of Linz</p>

<p>This class is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.</p>

<p>This class is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the <a href="http://www.gnu.org/copyleft/gpl.html">
GNU General Public License</a> for more details.</p>
<hr>

<p>This class allows reading formatted data either from the keyboard
or from a file. It is intended to be used in an introductory
programming course when classes, packages and exceptions are unknown
at the beginning. To use it, simply copy In.class into the
source file directory. </p>

<p>All input comes from the current input file, which is initially
the keyboard. Opening a file with open() makes it the new current
input file. Closing a file with close() switches back to the previous
input file.</p>

<p>When reading from the keyboard, reading blocks until the user has entered
a sequence of characters terminated by the return key. All methods read
from this input buffer (including the terminating '\r' and '\n') until the
buffer is fully consumed. When a method tries to read beyond the end
of the buffer, it blocks again waiting for the next buffer.</p>

<p>End of file detection: When reading from the keyboard, eof can be
signaled as ctrl-Z at the beginning of a new line. When reading from a file,
eof occurs when an attempt is made to read beyond the end of the file.
In either case In.done() returns false if the requested data could not
be read because of eof. </p>
*/
public class In {

/** End of file indicator returned by read() or peek() when no more
characters can be read.
*/
public  static final char eof   = '\uffff';

private static final int empty = '\ufffe';

private static final char eofChar = '\u0005';  // ctrl E
private static InputStream in;
private static LinkedList inputStack, bufferStack;
private static boolean done; // true if recent operation was successful
private static char buf;     // last read character
private static char[] LS;    // line separator (eol)

private static char charAfterWhiteSpace() {
  char c;
  do c = read(); while (done && c <= ' ');
  return c;
}

private static String readDigits() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  if (done && c == '-') {
    b.append(c);
    c = read();
  }
  while (done && Character.isDigit(c)) {
    b.append(c);
    c = read();
  }
  buf = c;
  return b.toString();
}

private static String readFloatDigits() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  if (done && (c == '+' || c == '-')) {
    b.append(c);
    c = read();
  }
  while (done && Character.isDigit(c)) {
    b.append(c);
    c = read();
  }
  if (done && (c == '.')) {
    b.append(c);
    c = read();
    while (done && Character.isDigit(c)) {
      b.append(c);
      c = read();
    }
  }
  if (done && (c == 'e' || c == 'E')) {
    b.append(c);
    c = read();
    if (done && (c == '+' || c == '-')) {
      b.append(c);
      c = read();
    }
    while (done && Character.isDigit(c)) {
      b.append(c);
      c = read();
    }
  }
  buf = c;
  return b.toString();
}


/** Read a raw character (byte).
If an attempt is made to read beyond the end of the file,
eof is returned and done() yields false. Otherwise the read byte
is in the range 0..255.
*/
public static char read() {
  char c;
  if (buf != empty) {
    c = buf;
    if (buf != eof) buf = empty;
  } else {
    try {
      c = (char)in.read();
    } catch (IOException e) {
      done = false;
      c = eof; buf = eof;
    }
  }
  if (c == eofChar && inputStack.size() == 0) { c = eof; buf = eof; }
  done = c != eof;
  return c;
}

/** Current available raw characters.
In case of an error 0 is returned and done() yields false.
*/
public static int available() {
  int avail;

  try {
    avail = in.available();
  } catch(IOException exc) {
    avail = 0;
    done = false;
  }

  return avail;
}

/** Read a character, but skip white spaces (byte).
If an attempt is made to read beyond the end of the file,
eof is returned and done() yields false. Otherwise the read byte
is in the range 0..255.
*/
public static char readChar() {
  return charAfterWhiteSpace();
}

/** Read a boolean value.
This method skips white space and tries to read an identifier. If its value
is "true" the method returns true otherwise false. If the identifier is neither
"true" nor "false" done() yields false.
*/
public static boolean readBoolean() {
  String s = readIdentifier();
  done = true;
  if (s.equals("true")) return true;
  else { done = s.equals("false"); return false; }
}

/** Read an identifier.
This method skips white space and tries to read an identifier starting
with a letter and continuing with letters or digits. If a token of this
structure could be read, it is returned otherwise the empty string is
returned and done() yields false.
*/
public static String readIdentifier() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  if (done && Character.isLetter(c)) {
    b.append(c);
    c = read();
    while (done && (Character.isLetter(c) || Character.isDigit(c))) {
      b.append(c);
      c = read();
    }
  }
  buf = c;
  done = b.length() > 0;
  return b.toString();
}

/** Read a word.
This method skips white space and tries to read a word consisting of
all characters up to the next white space or to the end of the file.
If a token of this structure could be read, it is returned otherwise
an empty string is returned and done() yields false.
*/
public static String readWord() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  while (done && c > ' ') {
    b.append(c);
    c = read();
  }
  buf = c;
  done = b.length() > 0;
  return b.toString();
}

/** Read a line of text.
This method reads the rest of the current line (including eol) and
returns it (excluding eol). A line may be empty.
*/
public static String readLine() {
  StringBuffer b = new StringBuffer();
  char c = read();
  while (done && c != LS[0]) {
    b.append(c);
    c = read();
  }

  int i = 0;
  while (c == LS[i]) {
    ++i;
    if (i >= LS.length) { break; }
    c = read();
  }

  if (i < LS.length) {
    buf = c;
  } else {
    buf = empty;
  }
  if (b.length() > 0) done = true;
  return b.toString();
}

/** Read the whole file.
This method reads from the current position to the end of the
file and returns its text in a single large string. done() yields
always true.
*/
public static String readFile() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  while (done) {
    b.append(c);
    c = read();
  }
  buf = eof;
  done = true;
  return b.toString();
}

/** Read a quote-delimited string.
This method skips white space and tries to read a string in the form "...".
It can be used to read pieces of text that contain white space.
*/
public static String readString() {
  StringBuffer b = new StringBuffer();
  char c = charAfterWhiteSpace();
  if (done && c == '"') {
    c = read();
    while (done && c != '"') {
      b.append(c);
      c = read();
    }
    if (c == '"') { c = read(); done = true; } else done = false;
  } else done = false;
  buf = c;
  return b.toString();
}

/** Read an integer.
This method skips white space and tries to read an integer. If the
text does not contain an integer or if the number is too big, the
value 0 is returned and the subsequent call of done() yields false.
An integer is a sequence of digits, possibly preceded by '-'.
*/
public static int readInt() {
  String s = readDigits();
  try {
    done = true;
    return Integer.parseInt(s);
  } catch (Exception e) {
    done = false; return 0;
  }
}

/** Read a long integer.
This method skips white space and tries to read a long integer. If the
text does not contain a number or if the number is too big, the
value 0 is returned and the subsequent call of done() yields false.
A long integer is a sequence of digits, possibly preceded by '-'.
*/
public static long readLong() {
  String s = readDigits();
  try {
    done = true;
    return Long.parseLong(s);
  } catch (Exception e) {
    done = false; return 0;
  }
}

/** Read a float value.
This method skips white space and tries to read a float value. If the
text does not contain a float value or if the number is not well-formed,
the value 0f is returned and the subsequent call of done() yields false.
An float value is as specified in the Java language description. It may
be preceded by a '+' or a '-'.
*/
public static float readFloat() {
  String s = readFloatDigits();
  try {
    done = true;
    return Float.parseFloat(s);
  } catch (Exception e) {
    done = false; return 0f;
  }
}

/** Read a double value.
This method skips white space and tries to read a double value. If the
text does not contain a double value or if the number is not well-formed,
the value 0.0 is returned and the subsequent call of done() yields false.
An double value is as specified in the Java language description. It may
be preceded by a '+' or a '-'.
*/
public static double readDouble() {
  String s = readFloatDigits();
  try {
    done = true;
    return Double.parseDouble(s);
  } catch (Exception e) {
    done = false; return 0.0;
  }
}

/** Peek at the next character.
This method skips white space and returns the next character without removing
it from the input stream. It can be used to find out, what token comes next
in the input stream.
*/
public static char peek() {
  char c = charAfterWhiteSpace();
  buf = c;
  return c;
}

/** Open a text file for reading
The text file with the name fn is opened as the new current input
file. When it is closed again, the previous input file is restored.
*/
public static void open(String fn) {
  try {
    InputStream s = new FileInputStream(fn);
    bufferStack.add(new Character(buf));
    inputStack.add(in);
    in = s;
    done = true;
  } catch (FileNotFoundException e) {
    done = false;
  }
  buf = empty;
}

/** Close the current input file.
The current input file is closed and the previous input file is
restored. Closing the keyboard input has no effect but causes
done() to yield false.
*/
public static void close() {
  try {
    if (inputStack.size() > 0) {
      in.close();
      in = (InputStream) inputStack.removeLast();
      buf = ((Character) bufferStack.removeLast()).charValue();
      done = true;
    } else {
      done = false; buf = empty;
    }
  } catch (IOException e) {
    done = false; buf = empty;
  }
}

/** Check if the previous operation was successful.
This method returns true if the previous read operation was able
to read a token of the requested structure. It can also be called
after open() and close() to check if these operations were successful.
If done() is called before any other operation it yields true.
*/
public static boolean done() {
  return done;
}

static { // initializer
  done = true;
  in = System.in;
  buf = empty;
  inputStack = new LinkedList();
  bufferStack = new LinkedList();
  LS = System.getProperty("line.separator").toCharArray();
  if (LS == null || LS.length == 0) {
    LS = new char[] { '\n' };
  }
}

}
```

sorry


----------



## MiDniGG (19. Nov 2009)

Benutze bitte die [JAVA ] [/code]-Tags, da sonst keiner mehr durchblickt...


----------



## Schumi (19. Nov 2009)

```
class AusDateiInArrayEinlesenUndAusgeben{

    public static void main(String[] args){

	int i = 0;
	int []a;
	a = new int[10];
	
	for(;i<10;){
	In.open("testdatei.txt");
	a[i] = In.readInt();
	Out.println(a[i]);
	i++;
	}

	// while(In.done()){
	//     a[i] = In.readInt();
	//     Out.println(a[i]);
	//     i++;
	// }	
        
	 In.close();



    }

}
```

 Nimm mal das In.open(...) aus der Schleife heraus. Dann wird die Datei nicht jedes mal aufs Neue geöffnet. Das done() brauchst Du dann nicht unbedingt. Sagt Dir nur, ob das readInt() geklappt hat. Ist dann ganz hilfreich, wenn Du z.B. nicht weißt, wieviele Einträge Du lesen willst.


----------



## ARadauer (19. Nov 2009)

Die Linzer Studis habens einfach nicht drauf! Ich weiß schon warum ich nach Hagenberg gegangen bin ;-)

So Spaß beiseite:

```
for(;i<10;){
    In.open("testdatei.txt");
    a[i] = In.readInt();
    Out.println(a[i]);
    i++;
    }
```

Das siehst du doch selber, dass das nicht passt. Warum willst du den die Datei 10 mal aufmachen?
Was steht jetzt genau im File? Das  
10 {1,2,3,4,5,6,7,8,9,10}

natürlich schlecht, da du nicht einfach zahlen lesen kannst, {,}.. hast ja auch noch drinn....

Naja wenigstens lernens euch nicht mehr Jana ;-)


----------



## babuschka (19. Nov 2009)

ARadauer hat gesagt.:


> Die Linzer Studis habens einfach nicht drauf! Ich weiß schon warum ich nach Hagenberg gegangen bin ;-)
> 
> So Spaß beiseite:
> 
> ...



In meiner Datei steht das genau so da. GENAU SO ^^

```
1
2
3
4
5
6
7
8
9
10
```



Schumi hat gesagt.:


> ```
> class AusDateiInArrayEinlesenUndAusgeben{
> 
> public static void main(String[] args){
> ...




meinst du so

```
class AusDateiInArrayEinlesenUndAusgeben{

    public static void main(String[] args){

	int i = 0;
	int []a;
	a = new int[10];
	
    In.open("testdatei.txt");
	for(;i<10;){
	a[i] = In.readInt();
	Out.println(a[i]);
	i++;
	}

	// while(In.done()){
	//     a[i] = In.readInt();
	//     Out.println(a[i]);
	//     i++;
	// }	
        
	 In.close();



    }

}
```

Das einlesen ist er der anfang später muss ich noch vom benutzer zwei zahlen abfragen. Und dann soll ich von der ersten abgefragt bis zu zweiten abgefragten Zahl lesen was im Arrayy steht.
Aber erstmal muss ich ja richtig einlesen und zu probe ausgeben


----------



## Schumi (19. Nov 2009)

noise hat gesagt.:


> Aber erstmal muss ich ja richtig einlesen und zu probe ausgeben



Klappt das denn jetzt so? (Es sollte)


----------



## babuschka (19. Nov 2009)

Schumi hat gesagt.:


> Klappt das denn jetzt so? (Es sollte)



Das klappt schon mal, danke!

EDIT: Da ich ja eine Datei habe mit 10 Zahlen. Und meine Arraygroesse von 10 auf 9 verkleinere also

```
a = new int[8];
```

Dann kommt ja der Fehler
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 9 at .........
Den bekomme ich nur weg, wenn die array groesse stimmt?


----------



## ARadauer (19. Nov 2009)

for schreibt man eher so..


```
int []a = new int[10];
      In.open("testdatei.txt");
      for(int i = 0; i <10; i++){
         a[i] = In.readInt();
         System.out.println(a[i]);
      }
```


----------



## babuschka (19. Nov 2009)

ARadauer hat gesagt.:


> for schreibt man eher so..
> 
> 
> ```
> ...



Da ich noch ein richtiger newb bin :rtfm: weis ich leider noch net genau wie man alles eher schreibt 
Aber natürlich danke für den tip :toll:


----------



## Schumi (19. Nov 2009)

Bzw. wenn sich die Anzahl der Schleifendurchläufe eigentlich nur durch die Arraygröße definieren:

```
for(int i=0; i < a.length; i++)
```

Dann hast Du kein IndexooB.


----------



## babuschka (19. Nov 2009)

jetzt komme ich wieder net weiter.
Wiegesagt ich frage vom Benutzer 2 Zahlen ab.
Aus der datei will jetzt nur von der ersten abgefragten bis zur zweiten abgefragten Zahl ausgeben.
Bitte keine lösungen, will das selber ausarbeiten ^^ Tips aber immer gut :toll:

meine erste überlegung wieder was mit einer for schleife und weiter weis ich net ???:L
Also die abbruchbedingung müsste ja irgendwie so sein
zahl2<=a.length


----------



## Schumi (19. Nov 2009)

Was heißt denn genau von der ersten bis zur zweiten Zahl. Soll man eine Folge an ints in der Datei annehmen und Du willst die davor und die danach ignorieren? Also zB. Inhalt Datei: 1 2 3 4 5 6 7, eingegebene Zahlen 3 und 6, dann willst Du 3, 4, 5, 6 rausholen? Dafür musst Du Dir halt überlegen: 1. Wie groß soll Dein Array sein, 2. Wie findest Du die Stelle ab der Du beginnen sollst und dann 3. musst Du achten, dass Du nicht zu viel einliest.
Und wenn Dir dann langweilig wird, kannst Du Dir noch Gedanken machen über die ganzen Sachen die schief laufen können. (Menge an Zahlen zu klein, 1. Zahl größer als 2., ...) Da kann Dir dann auch das done() vom Anfang wieder helfen.


----------



## JPM (19. Nov 2009)

Hast du denn immer 10 Zahlen die eingelesen werden sollen? Oder willst du unterschiedliche Anzahlen von Zahlen aus der txt Datei einlesen?
Weil wenn dem so ist, kannst du kein Array benutzen, da man die Größe vorher definieren muss und diese ja variabel sein müsste.


----------



## babuschka (20. Nov 2009)

Schumi hat gesagt.:


> Was heißt denn genau von der ersten bis zur zweiten Zahl. Soll man eine Folge an ints in der Datei annehmen und Du willst die davor und die danach ignorieren? Also zB. Inhalt Datei: 1 2 3 4 5 6 7, eingegebene Zahlen 3 und 6, dann willst Du 3, 4, 5, 6 rausholen?


Ja sowas meine ich, oder auch wenn die eingebene Zahlen -5 und 7 ist.



Schumi hat gesagt.:


> Dafür musst Du Dir halt überlegen: 1. Wie groß soll Dein Array sein, 2. Wie findest Du die Stelle ab der Du beginnen sollst und dann 3. musst Du achten, dass Du nicht zu viel einliest.


Ja, diese überlegungen habe ich ja alle. Mein prob ist die umsetzung in java code 



Schumi hat gesagt.:


> Und wenn Dir dann langweilig wird, kannst Du Dir noch Gedanken machen über die ganzen Sachen die schief laufen können. (Menge an Zahlen zu klein,


Menge an Zahlen zu klein, wie meinst du das? Die Menge in der datei?



Schumi hat gesagt.:


> 1. Zahl größer als 2., ...) Da kann Dir dann auch das done() vom Anfang wieder helfen.


Das muss ich auch erfüllen.
Hab das erstmal so gemacht. Und dieses done() verstehe ich halt nicht wofür man das braucht :rtfm:


```
if(zahl2<zahl1){
	}
	else{
	for(int i = 0; i<a.length; i++){

	a[i] = In.readInt();
	Out.println(a[i]);
	}

	In.close();
	}
```



JPM hat gesagt.:


> Hast du denn immer 10 Zahlen die eingelesen werden sollen?


Nein, in der Datei stehen immer 10 Zahlen.



JPM hat gesagt.:


> Oder willst du unterschiedliche Anzahlen von Zahlen aus der txt Datei einlesen?
> Weil wenn dem so ist, kannst du kein Array benutzen, da man die Größe vorher definieren muss und diese ja variabel sein müsste.


Das verstehe ich nicht, warum kein Array. Sorry wenn ich manchmal so fragen stelle ^^
Also in der Datei stehen 10 Zahlen. Ich frage den benutzer nach 2 Zahlen. Die erste Zahl gibt ab welcher stelle er anfangen soll auszulesen und die 2 zahl gibt an bis zur welcher stelle er lesen soll. Auch wenn die erste Zahl eine negative zahl, muss ich halt von der ersten zahl auslesen und wenn die zweite Zahl größer ist als die letzte stelle in der Datei, dann soll er nur bis zur lerzten zahl ausgeben und das wars.
Ach noch was, falls die erste Zahl kleiner als 1, probiere ich das wieder durch eine if zu lösen


```
In.open("zahlen.txt");

	if(zahl1<1){
	    zahl1 = 1;
	   
	    if(zahl2<zahl1){
	    }
	    else{
		for(int i = 0; i<a.length; i++){

		    a[i] = In.readInt();
		    Out.println(a[i]);
		}

		In.close();
	    }
	}
	else{
	    if(zahl2<zahl1){

	    }
	    else{
		for(int i = 0; i<a.length; i++){

		    a[i] = In.readInt();
		    Out.println(a[i]);
		}

		In.close();
	    }
	}
```
kein guter programmierstil!!!! :rtfm:

Nur tips, kein lösung :toll:

Danke an alle für die schnellen antworten!


----------



## JPM (20. Nov 2009)

Ne dann hat sich mein Post schon erledigt xD
Wenn du immer 10 Zahlen in der Datei stehen hast dann ist das schon in Ordnung so. 
Ich habe nur nachgefragt, da ich selber einmal so ein ähnliches Programm erstellen musste, nur dass dort die Anzahl der Zahlen in der txt nicht immer 10 waren sondern beliebig lang..


----------



## babuschka (24. Nov 2009)

```
int []a;
	int zahl1, zahl2;

	Out.print("Von Zeile ");
	zahl1 = In.readInt();
	Out.print("Bis Zeile ");
	zahl2 = In.readInt();

	a = new int[zahl2];

	In.open("zahlen.txt");

	if(zahl1>zahl2){
	    Out.println("Zahl1 groesser als Zahl2");

	}
	else{
	    for(int i = 0 ;zahl1 == zahl2;zahl1++){
		a[i] = In.readInt();
		Out.println(a[zahl1]);
		i++;

	    }
	    In.close();
	}
```

so sieht das jetzt aus bei mir ^^
mein jetziger Gedanke will aber nicht so wie ich will ???:L
die else sollte meiner Meinung nach, einlesen an der stelle a_ abspeichern und dann i++.
dann die stelle a[zahl1] ausgeben und zahl1++ und das solange bis zahl1 == zahl2 ist.
Da stimmt aber borne und hinten nix ;(_


----------



## Mofi (24. Nov 2009)

noise hat gesagt.:


> Das klappt schon mal, danke!
> 
> EDIT: Da ich ja eine Datei habe mit 10 Zahlen. Und meine Arraygroesse von 10 auf 9 verkleinere also
> 
> ...



von 10 auf 9 verkleinern ergibt nicht 8 *hust*

wenn du 10 zahlen in ein array einlesen willst brauchst du ein array was 10 felder groß ist. in diesem falle halt

```
int[] a = new int[10];
```

dann hat dein array 10 felder und du kannst 10 zahlen drin speichern.

das "Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 9" kommt immer, wenn man auf ein arrayindex zugreifen will, was es nicht gibt


----------



## babuschka (24. Nov 2009)

Mofi hat gesagt.:


> von 10 auf 9 verkleinern ergibt nicht 8 *hust*
> 
> wenn du 10 zahlen in ein array einlesen willst brauchst du ein array was 10 felder groß ist. in diesem falle halt
> 
> ...



dachte, dass die 0 sozusagen die erstelle ist im array?!
also bei ....int[10] hätte ich dann 11 stellen :rtfm:


----------

