Erste Schritte Einlesen der Länge eines Feldes

[Zipe]

Hey Leute!

Ich bin ein ziemlicher Anfänger wenn es um Java geht und stehe ein wenig auf dem Schlauch.
Es geht um folgendes: Ich soll ein Feld (array) der Länge n anlegen. Dieses soll dann mit Zufallszahlen des Typs Int gefüllt werden (Bereich -100 - 100). "n" soll vom Benutzer angegeben werden.

Das ist das erste mal, dass ich mit Feldern zutun habe und ich versteh nicht ganz wie ich die Länge "n" des Feldes einlesen soll. Also ich kann "n" zwar seperat mit IOTools einlesen, aber wie verbinde ich das dann mit meinem Feld.

Hier mal der Code den ich dazu geschrieben habe:

import Prog1Tools.IOTools;

public class P9 {

	public static void main(String[] args) {
		
		int n = IOTools.readInteger("Länge n: ");
		int [] feld = {-100 + (int)Math.random()*100};
		
		
		for(int i = 0;i < feld.length; i++){
			if(i > i + 1){
				i = i + 1;
				
				
			}
		}
		
		
		
	}

}

Vielleicht könnt ihr auch schonmal den Anfang der "for-Schleife" kommentieren. Diese soll 2 aufeinanderfolgende Zahlen vergleichen und tauschen, wenn die erste Zahl größer ist als die zweite. Ist das mit dem "feld.length" richtig gewählt? Ist die Schleife im Ansatz richtig? Kann ich den Inhalt des Feldes in der Schleife irgendwie immer wieder ausgeben lassen?

Mfg Zipe

 

[calousy]

Länge eines Arrays wird so gesetzt:

int[] myArray = new int[4];

Dann füllst du per Schleife dein Array.
Zugriff auf den Inhalt im Array erhältst du über den Index auf das Feld. Der Index beginnt bei 0.

int[] myArray = new int[4];
myArray[0] = 2; 
System.out.println(myArray[0]); // 2
System.out.println(myArray[4]); // ArrayIndexOutOfBoundsException, da myArray[3] das letzte Element ist

Die Schleife passt. Allerdings das tauschen geht so nicht. Siehe oben wie du den Inhalt setzen kannst. Du änderst nur den Index den die Schleife erhöht (der wird aber nie in den if-Block gehen, da i nie > i+1 )
Du musst dir eines der zu tauschenden Elemente auch noch merken und erst dann tauschen

 

[Zipe]

Schonmal danke!

oben schreibe ich also

int[] myArray = new int[n]

? nachdem ich "n" eingeben lasse? Kriege hier bei "int" von eclipse die Fehlermeldung "Syntax error on token "int", invalid ClassType" ...

Wie genau fülle ich per Schleife mein Array? Also du meinst doch, dass ich den

{-100 + (int)Math.random()*100}

Teil irgendwie in ner Schleife unterbringe richtig?


Tut mir Leid, falls das aus deinem Post hervorgeht oder selbsterklärend ist, aber ich starte halt wirklich grade erst mit Java.

 

[dehlen]

Schau dir das hier mal an.

    import Prog1Tools.IOTools;
     
    public class P9 {
     
        public static void main(String[] args) {
           
            int n = IOTools.readInteger("Länge n: ");
            int [] feld = new int[n];
           
           
            for(int i = 0;i < feld.length; i++){
                 feld[i] = Math.random....
        }
     
    }

Zuerst ein "Feld" oder Array mit der Länge n erzeugen durch den new Operator. Dann in der for-Schleife jeden "Platz" in diesem Array durchgehen und jedem Platz eine zufällige Zahl zuweisen... fertig

 

[Zipe]

Danke! Mein Code sieht nun wie folgt aus:

import Prog1Tools.IOTools;

public class P9 {

	public static void main(String[] args) {

		int n = IOTools.readInteger("Länge n: ");
		int[] feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
			feld[j] = -100 + (int) Math.random() * 100;

		}
		for (int i = 0; i < feld.length; i++) {
			if (i > i + 1) {
				int tmp = i;
				i = i + 1;
				i + 1 = tmp;
				System.out.println(feld);
			}
		}

	}

}

Allerdings gibt mir eclipse für das i + 1 = tmp eine Fehlermeldung, da das "+1" da irgendwie nicht hingehört, aber ich weiß nicht wie ichs anders lösen kann. Außerdem versteh ich immernoch nicht, wie ich nach jedem Sortierdurchgang den aktuellen Feldinhalt ausgeben kann


Edit: Kann ich das i + 1 einfach "a" nennen oder sowas?

 

[dehlen]

Was willst du mit der zweiten For Schleife bezwecken ?
EDIT: Ok gerade im Ausgangspost gelesen.
A: i ist immer kleiner als i+1. Was du prüfen willst ist, ob der Wert im Feld an der Stelle i größer ist als der an der Stelle i+1.
Außerdem: Du kannst nicht i+1 irgendetwas zuweisen. Auch hier wieder: nicht i+1 sondern der Platz in deinem Array an der Stelle i+1...

Du willst den Inhalt deines Feldes ausgeben. Naja wo stehen diese Daten denn ? Bei feld, oder ?
Also eben jene Information per System.out.println(); auch ausgeben. Und damit du das nicht n mal aufrufen musst, wäre es doch am schlausten du schreibst es mit in die for-Schleife, oder ?

 

[dehlen]

EDIT: Doppelpost

 

[Zipe]

import Prog1Tools.IOTools;

public class P9 {

	public static void main(String[] args) {

		int n = IOTools.readInteger("Länge n: ");
		int[] feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
			feld[j] = -100 + (int) Math.random() * 100;
			
		}
		
		
		for (int i = 0; i < feld.length; i++) {
			int[] x;
			if (x[i] > x [i + 1]) {
				int tmp = x [i];
				x [i] = x [i + 1];
				x [i + 1] = tmp;
				System.out.println(feld [j]);
			}
		}

	}

}

So schaut das ganze jetzt bei mir aus, bin mir allerdings nicht sicher, ob der Sortieralgorythmus so jetzt richtig ist.
Auf jedenfall wird mir beim aufruf von "feld [j]" ein Fehler angezeigt. Da ich j in dieser for-schleife noch nicht definiert habe oder? Das "x" im Sortieralgo. soll ich auch irgendwie initialisieren, aber mit was?

 

[dehlen]

Das System.out.println mal in die andere for-Schleife und warum ein neues Array x definieren ? Du willst die Daten ja von dem feld Array.

EDIT: Und du musst natürlich noch aufpassen mit dem i+1. Das könnte in eine ArrayOutOfBoundsException führen.

Angenommen dein Array hat 10 Plätze. Deine for Schleife geht dann also von 0 bis 9. Wenn du dann auf den Platz 10 (9+1) zugreifst bekommst du die Exception. Also das musst du noch per if Abfrage überpüfen.

 

[Zipe]

Soll ich die 2te for schleife, für den Sortieralgorythmus, dann in die erste schreiben? Weil er mir ansonsten wenn ich das "x" durch "j" ersetze Fehler anzeigt. Oder soll ich das Feld j nochmal initialisieren in der 2ten Schleife?

Wieso gebe ich eigentlich Feld [j] aus wenn "j" nur die Zählvariable der ersten for schleife ist? ???:L

 

[dehlen]

Also nochmal vielleicht von vorne.
j oder auch i sind Zählvariablen. Sie gehen das innere der Schleife durch, erhöhren dann den count und hören auf, falls die Bedingung nicht mehr erfüllt ist.

i oder auch j gehen also in deinem Beispiel also von 0 bis 9. Die zufälligen Zahlen die du generiert hast werden bei feld abgelegt. Also i=0 die zufällige Zahl wird in Platz0 des Feldes abgespeichert. i wird um 1 erhöht ==> i=1, zufällige Zahl generieren und diese bei Steckplatz 1(da i nun 1 ist) abspeichern.... bis das Array voll ist. Deine zufälligen Zahlen stehen also nun bei feld[0] feld[1]....feld[n-1].

Du sollst also das x nicht durch j sondern durch feld ersetzen. Denn du willst ja auf die Plätze des Arrays zugreifen.Warum solltest du die for-Schleife in die erste for-Schleife schreiben ? dann würde das ganze so zählen:
i=0,j=0,j=1,j=2...j=n-1,i=1,j=0....

Das würde a)überhaupt keinen Sinn machen
b)je nach n ganz schön lange dauern.
Warum du feld[j] ausgibst weiß ich auch nicht entweder du gibts in der for-Schleife wo i die Zählvariable ist eben feld aus oder du schreibst die Zeile direkt in die erste for-Schleife dann ist die Zählvariable gerade schon richtig und es macht auch ein wenig mehr Sinn.

 

[Zipe]

Schonmal danke für deine Geduld mit mir
Sieht jetzt wie folgt aus:

import Prog1Tools.IOTools;

public class P9 {

	public static void main(String[] args) {

		int n = IOTools.readInteger("Länge n: ");
		int[] feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
			feld[j] = -100 + (int) Math.random() * 100;
			System.out.println(feld [j]);
			
			
		}
		
		
		for (int i = 0; i < feld.length; i++) {
			if (feld[i] > feld [i + 1]) {
				int tmp = feld [i];
				feld [i] = feld [i + 1];
				feld [i + 1] = tmp;
			}
			
				
				
			}
		}

Jetzt tritt allerdings der Exception Fehler auf, den du bereits erwähnt hast. Muss ich da etwas an meinem "if" - Teil ändern?

Ich soll ja den Inhalt des Arrays nach jedem Sortierdurchlauf ausgeben. Muss dann das System.out.println nicht in die 2te for-schleife?

 

[dehlen]

DU musst deinen if Teil nicht ändern, du musst einen weiteren if-Teil schreiben der eben prüft bei welchem i du angekommen bist und dann musst du eben entsprechend handeln, wenn i+1 == feld.length entspricht.

Ja, wenn du das Array auch nach jedem Tauschvorgang neu ausgeben musst, musst du das natürlich in der zweiten Schleife machen.

Vielleicht schaust du mal nach dem Sortieralgorithmus BubbleSort. Das ist eigentliche das ähnliche Prinzip wie du es nun runtergebrochen versuchst.

 

[Zipe]

Ja habe mir Bubblesort mal angeschaut und mich daran orientiert. Mit diesem Ergebnis:

public class P9 {

	public static void main(String[] args) {

		int n = IOTools.readInteger("Länge n: ");
		int[] feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
			feld[j] = -100 + (int) Math.random() * 100;
			System.out.println(feld [j]);
		}

		for (int i = 1; i < feld.length; i++) {
			for (int l = 0; l < feld.length - i; l++) {
				if (feld[l] > feld[l + 1]) {
					int tmp = feld[l];
					feld[l] = feld[l + 1];
					feld[l + 1] = tmp;
				
				}

			}

		}
		
	}

}

Gebe ich nun zB. für n "5" ein gibt er mir 5 mal "-100" aus ... Ist bei der Definition des Feldinhaltes irgendwas falsch?

Wenn ich System.out.println in die 2te Klammer schreibe gibt er mir garnichts aus ???:L

 

[dehlen]

Das mit BubbleSort hab ich nur erwähnt, damit du dir mal anschaust wie man das lösen kann mit Zahlen eines Arrays vergleichen etc. Die for-Schleife in der for-Schleife brauchst du für deine Zwecke nicht, es sei denn du willst BubbleSort jetzt implementieren. Du bekommst immer -100 ausgegeben weil deine Math.random Geschichte auch noch nicht stimmt.

 Random rand = new Random();
            feld[j]= (int) rand.nextInt(max-min) + min;

Das sollte funktionieren.
Wo schreibst du das ganze in die zweite Klammer ?

 

[Zipe]

Sorry meinte "in die zweite Schleife". Also kann ich den Sortieralgorythmus wieder zurückändern?

Muss ich "random" noch irgendwo als "type" definieren? Also das "random" für den Zahlenbereich?

 

[dehlen]

java.util.Random importieren

 

[Zipe]

Okay ich komme näher

import Prog1Tools.IOTools;
import java.util.Random;

public class P9 {

	public static void main(String[] args) {

		int n = IOTools.readInteger("Länge n: ");
		int[] feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
		    Random rand = new Random();
            feld[j]= (int) rand.nextInt(100 - (-100)) + (-100);
			
		}

		for (int i = 1; i < feld.length; i++) {
			for (int l = 0; l < feld.length - i; l++) {
				if (feld[l] > feld[l + 1]) {
					int tmp = feld[l];
					feld[l] = feld[l + 1];
					feld[l + 1] = tmp;
					System.out.println(feld [i]);
				}

			}

		}
		
	}

}

Er sortiert irgendwas und gibt mir auch irgendwas aus, aber so wirklich richtig scheint das Ganze nicht zu sein. Du sagtest ja ich brauche bubblesort hier garnicht. Wenn ich allerdings das Ganze wieder nur in einer "for"-Schleife schreibe kommt noch was falscheres raus.

 

[dehlen]

Ja du brauchst die ineinander geschachtelten for Schleifen gar nicht (außer du willst wirklich BubbleSort implementieren). Aber du schriebst ja zu Beginn, dass nur aufeinanderfolgende Zahlen verglichen werden sollen. In dem Fall brauchst du nur eine for-Schleife... und da gehst du dann wie folgt vor:

1.Prüfen ob i+1 == feld.length ist --> falls ja gäbe es eine ArrayOutOfBoundsException weil wir nur mit Index 0 bis feld.length-1 auf das Array zugreifen können. In der Folge würde also die Exception fliegen--> Darauf reagieren indem du nicht i und i+1 vergleichst sondern i-1 und i.

2.Falls das nicht der Fall ist wie bisher tauschen. Also mit tmp, i und i+1.

3.Das neue Array ausgeben.

 

[Zipe]

Ich versteh nicht genau wie du das meinst. Soll ich also vor dem if noch ein zweites "if" setzen und da dann sowas wie

 if ( i+1 == feld.length){
....
}

reinschreiben? aber was schreibe ich dann darein? bzw soll ich den vergleich "i -1 < i" in die klammer dahinter setzen?

 

[DrZoidberg]

Wie genau lautet denn die Aufgabenstellung? Ich vermute mal du sollst keinen kompletten BubbleSort schreiben, sondern nur die innere Schleife, so dass das Feld nur teilweise sortiert wird und dann halt das Ergebnis ausgeben. Da kannst du dann statt "feld.length - i" einfach "feld.length - 1" schreiben.

 

[Zipe]

Also ich soll ein Array der Länge n anlegen (n wird hierbei vom Nutzer eingegeben). Dieses Array dann mit Zufallszahlen des Typs int füllen (diese sollen im Bereich -100 - +100 liegen. Nun sollen diese Zahlen im Array sortiert werden. Nach jedem Durchgang n soll ich den Inhalt des Arrays ausgeben.

Sprich die Zahlen sollen sortiert sein am Ende, aber man soll anhand der Ausgabe des Inhalts nach jedem Durchgang sehen können, wie sortiert wurde.

 

[dehlen]

Hier weil ich sehe das du es wirklichen lernen willst und nicht irgendwie nach Code gefragt hast oder so:

import java.util.Scanner;
import java.util.Random;

public class P9 {
	
	
		static int[] feld;

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		feld = new int[n];

		for (int j = 0; j < feld.length; j++) {
			feld[j] = generiere(-100, 100);
			if (j == feld.length - 1) {
				System.out.println(feld[j] + "\n");
			} else {

				System.out.println(feld[j]);
			}

		}

		for (int i = 0; i < feld.length; i++) {
			if (i + 1 == feld.length) {
				if (feld[i - 1] > feld[i]) {
					swap(i-1,i);
				}

			} else if (feld[i] > feld[i + 1]) {
				swap(i,i+1);
			}

			printArray(feld);
		}
	}
	
	public static void swap(int a, int b) {
		int tmp = feld[a];
		feld[a] = feld[b];
		feld[b] = tmp;
	}

	public static void printArray(int[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i == array.length - 1) {
				System.out.println("Neu: " + array[i] + "\n");
			} else {
				System.out.println("Neu: " + array[i]);
			}
		}
	}

	public static int generiere(int min, int max) {
		Random rand = new Random();
		return (int) rand.nextInt(max - min) + min;
	}
}

Aber
a) versuch es mal zu verstehen
b) das ist kein wirklicher schöner code - was könnte man vielleicht verbessern ?
c) die sortierung macht nicht wirklich viel sinn -> wie kann man das erweitern.... dann in Richtung Bubblesort... was fehlt hier um den Algorithmus zu implementieren...

Versuch das mal für dich umzusetzen

 

[DrZoidberg]

Sprich die Zahlen sollen sortiert sein am Ende, aber man soll anhand der Ausgabe des Inhalts nach jedem Durchgang sehen können, wie sortiert wurde.

In dem Fall war dein Code schon fast richtig. Du brauchst eine extra Schleife für die Augabe und zwar hinter der inneren Schleife (die mit dem l als Zählervariable).

 

[Zipe]

Danke dehlen! Allerdings hatte ich gehofft, bei meinem Code nur ein wenig ergänzen zu müssen.
Werde trotzdem mal versuchen deine Lösung zu verstehen.

Wie genau meinst du das DrZoidberg?

[Java]public class P9 {

public static void main(String[] args) {

int n = IOTools.readInteger("Länge n: ");
int[] feld = new int[n];

for (int j = 0; j < feld.length; j++) {
Random rand = new Random();
feld[j] = (int) rand.nextInt(100 - (-100)) + (-100);

}

for (int i = 1; i < feld.length; i++) {
for (int l = 0; l < feld.length - i; l++) {
if (feld[l] > feld[l + 1]) {
int tmp = feld[l];
feld[l] = feld[l + 1];
feld[l + 1] = tmp;
System.out.println(feld);
}

}

}

}
} [/code]

also das hier ist fast richtig? wie sieht denn so eine Schleife zur Ausgabe aus? Kenne eigentlich fast nur System.out.println um irgendetwas auszugeben ???:L

 

[DrZoidberg]

So könnte es gehen.

public class P9 {
 
    public static void main(String[] args) throws Exception {
        
        int n = IOTools.readInteger("Länge n: ");
        int[] feld = new int[n];

        Random rand = new Random();
        for (int j = 0; j < feld.length; j++) {
            feld[j]= (int) rand.nextInt(200) - 100;
            
        }
 
        for (int i = 1; i < feld.length; i++) {
            for (int l = 0; l < feld.length - i; l++) {
                if (feld[l] > feld[l + 1]) {
                    int tmp = feld[l];
                    feld[l] = feld[l + 1];
                    feld[l + 1] = tmp;
                }
            }
            for(int j = 0; j < feld.length; j++) {
                System.out.println(feld[j]);
            }
            System.out.println();
        }
        
    }
 
}