Array X-mal durchlaufen und dann N-mal durchlaufen

slitec

Mitglied
Hallo.

Mein Ziel war es die Lineare-Suche sowie die Binäre-Suche miteinander zu vergleichen. Hierzu habe ich ein Array zur Verfügung, welches mit Zahlen befüllt wird. Anschließend habe ich auch die Zeit gemessen, nur ist dies bei einer Messung nicht immer genau.

Mein Ziel ist es nun, 1000-mal durch die Liste zu gehen und eine Zahl zu suchen. Daraus dann einen Mittelwert berechnen (also Mittelwert der Suchzeit) um anschließend nochmals 30 mal diese verschiedenen Mittelwerte zusammen zu rechnen und einen endgültigen Mittelwert zu errechnen.
Kann mir da jemand behilflich sein ? Ich habe mir schon überlegt wie es vielleicht mit "for" gehen sollte aber komme nicht drauf.

Hier der Code für die Funktion :


Java:
public int suchzeitLinear(int suchzahl) {
        final long timeStart = System.currentTimeMillis();
        for (int i = 0; i < liste.length; i++) {
            if(liste[i] == suchzahl) {
                return i; //wenn gefunden wird beendet
            } 
        }
        final long timeEnd = System.currentTimeMillis(); 
        long zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
        return -1; //wenn nicht gefunden
        
    }



Ganzer Code:

Java:
package A2;

import java.util.Random;
import java.util.Arrays;



public class LineareSuche {
    
    int[] liste; //Array wird definiert als "liste"
    Random zufall = new Random();    // wird erzeugt für Klasse erzeugenUnsortiert()
    int suchzahl; //Dies ist die gesuchte Zahl
    
    public LineareSuche(){
    }
    
    public void erzeugeZufallszahl(int plätze,int oberGrenze) {
        //Erzeugt nicht gleichverteilte Zufallszahlen (doppelte sind möglich)
        
        liste = new int [plätze];
        //Anzahl an Plätze wird übergeben
        
        for (int i=0; i<liste.length;i++) {
            liste[i] = zufall.nextInt(oberGrenze);
            // Liefert eine int-Pseudo-Zufallszahl im Bereich von 0 bis oberGrenze
        }
    }
    
    public void sortieren(){
        Arrays.sort(liste);
    }
    
    
    
    public void ausgabe() {
        for (int i=0; i<liste.length; i++) {
            System.out.println(liste[i] + " || Index: " + (i));
        }
    }
    
    
    public int suchzeitLinear(int suchzahl) {
        final long timeStart = System.currentTimeMillis();
        for (int i = 0; i < liste.length; i++) {
            if(liste[i] == suchzahl) {
                return i; //wenn gefunden wird beendet
            }
        }
        final long timeEnd = System.currentTimeMillis();
        long zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
        return -1; //wenn nicht gefunden
        
    }
    
    
    
    
    public static void main(String[] args) {
        LineareSuche l1= new LineareSuche();
        l1.erzeugeZufallszahl(100, 200);
        l1.sortieren();
        l1.suchzeitLinear(10);
        
        
        l1.ausgabe();
    
    }
}


Vielen Dank schon mal für eure Hilfe.


Mit freundlichen Grüßen
 

httpdigest

Top Contributor
Könnte z.B. so aussehen:
Java:
import java.util.Random;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class Bench {
    private static final Random random = new Random();
    private int[] liste = new int[1_000_000];
    private int suchzahl;
    @Setup(Level.Iteration)
    public void beforeIteration() {
        for (int i = 0; i < liste.length; i++)
            liste[i] = i;
    }
    @Setup(Level.Invocation)
    public void beforeInvocation() {
        suchzahl = random.nextInt(liste.length);
    }
    @Benchmark
    public int linearSearch() {
        for (int i = 0; i < liste.length; i++) {
            if (liste[i] == suchzahl) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(Bench.class.getSimpleName())
                .forks(1)
                .build();
        new Runner(opt).run();
    }
}
 

slitec

Mitglied
Könnte z.B. so aussehen:
Java:
import java.util.Random;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class Bench {
    private static final Random random = new Random();
    private int[] liste = new int[1_000_000];
    private int suchzahl;
    @Setup(Level.Iteration)
    public void beforeIteration() {
        for (int i = 0; i < liste.length; i++)
            liste[i] = i;
    }
    @Setup(Level.Invocation)
    public void beforeInvocation() {
        suchzahl = random.nextInt(liste.length);
    }
    @Benchmark
    public int linearSearch() {
        for (int i = 0; i < liste.length; i++) {
            if (liste[i] == suchzahl) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(Bench.class.getSimpleName())
                .forks(1)
                .build();
        new Runner(opt).run();
    }
}


Vielen Dank für den Code. Gibt es auch einen leichteren Weg dies zu realisieren ? Vielleicht mit Schleifen ? Für mich ist das noch etwas zu kompliziert.
 

mihe7

Top Contributor
Klar kannst Du mit Schleifen die Zeit ermitteln, das Ergebnis bringt Dir nur nicht allzu viel.

Hintergrund ist einerseits, dass Zeitmessungen in dem Bereich entsprechend fehlerbehaftet sind, andererseits - und das macht die Sache schwierig -, dass der Code sowohl zur Übersetzungszeit als auch zur Laufzeit optimiert wird. Selbst mit einem Framework wie jmh ist es alles andere als trivial, korrekte Benchmarks zu schreiben. Kurz: Microbenchmarking ist etwas, mit dem man sich intensiv beschäftigen muss, will man es richtig machen.

Andererseits muss man sagen, dass der Code von @httpdigest sehr viel einfacher ist als Deiner :)
 

jhjh

Bekanntes Mitglied
Hintergrund ist einerseits, dass Zeitmessungen in dem Bereich entsprechend fehlerbehaftet sind
Kannst du Bereich nennen wo das nicht der Fall ist ?

Hintergrund:
Für meine Bachelor Arbeit entwickel ich eine Software die u. A. eine Methode beinhaltet die Entfernung zwischen 2 Standorten (Google Maps) berechnet.
Code:
public double getDistance(double lat1, double lon1, double lat2, double lon2) {
    Location startPoint = new Location("locationA");
    startPoint.setLatitude(lat1);
    startPoint.setLongitude(lon1);

    Location endPoint = new Location("locationB");
    endPoint.setLatitude(lat2);
    endPoint.setLongitude(lon2);
    double distance = startPoint.distanceTo(endPoint);

    return distance;
}

Hier wird die Luftdistanze ermittelt

Nun kann man aber auch die Fahrtdistanz mithilfe von Json Abfragen ermitteln

Code:
private void GetDistance(GeoPoint src, GeoPoint dest) {

    StringBuilder urlString = new StringBuilder();
    urlString.append("http://maps.googleapis.com/maps/api/directions/json?");
    urlString.append("origin=");//from
    urlString.append( Double.toString((double)src.getLatitudeE6() / 1E6));
    urlString.append(",");
    urlString.append( Double.toString((double)src.getLongitudeE6() / 1E6));
    urlString.append("&destination=");//to
    urlString.append( Double.toString((double)dest.getLatitudeE6() / 1E6));
    urlString.append(",");
    urlString.append( Double.toString((double)dest.getLongitudeE6() / 1E6));
    urlString.append("&mode=walking&sensor=true");
    Log.d("xxx","URL="+urlString.toString());

    // get the JSON And parse it to get the directions data.
    HttpURLConnection urlConnection= null;
    URL url = null;

    url = new URL(urlString.toString());
    urlConnection=(HttpURLConnection)url.openConnection();
    urlConnection.setRequestMethod("GET");
    urlConnection.setDoOutput(true);
    urlConnection.setDoInput(true);
    urlConnection.connect();

    InputStream inStream = urlConnection.getInputStream();
    BufferedReader bReader = new BufferedReader(new InputStreamReader(inStream));

    String temp, response = "";
    while((temp = bReader.readLine()) != null){
        //Parse data
        response += temp;
    }
    //Close the reader, stream & connection
    bReader.close();
    inStream.close();
    urlConnection.disconnect();

    //Sortout JSONresponse
    JSONObject object = (JSONObject) new JSONTokener(response).nextValue();
    JSONArray array = object.getJSONArray("routes");
        //Log.d("JSON","array: "+array.toString());

    //Routes is a combination of objects and arrays
    JSONObject routes = array.getJSONObject(0);
        //Log.d("JSON","routes: "+routes.toString());

    String summary = routes.getString("summary");
        //Log.d("JSON","summary: "+summary);

    JSONArray legs = routes.getJSONArray("legs");
        //Log.d("JSON","legs: "+legs.toString());

    JSONObject steps = legs.getJSONObject(0);
            //Log.d("JSON","steps: "+steps.toString());

    JSONObject distance = steps.getJSONObject("distance");
        //Log.d("JSON","distance: "+distance.toString());

            String sDistance = distance.getString("text");
            int iDistance = distance.getInt("value");

}

Eigetlich wäre Variante 2 für mein Vorhaben besseer geeignet, aber da über eine Schleife ca 100. 000 Abfragen stattfinden müssen und die Json Abfrage ziemlich lange dauert, muss ich auf Variante 1 zurückgreifen. Nun muss ich das natürlich begründen und wollte dazu die Zeiten der jeweiligen Abfragen ermitteln, womit ich dies dann begründen kann.[/code]
 

mrBrown

Super-Moderator
Mitarbeiter
Eigetlich wäre Variante 2 für mein Vorhaben besseer geeignet, aber da über eine Schleife ca 100. 000 Abfragen stattfinden müssen und die Json Abfrage ziemlich lange dauert, muss ich auf Variante 1 zurückgreifen. Nun muss ich das natürlich begründen und wollte dazu die Zeiten der jeweiligen Abfragen ermitteln, womit ich dies dann begründen kann.
Grad in dem Fall kann man doch genug Begründungen liefern, ohne auf Benchmarks zurückgreifen zu müssen ;)
Ich kann natürlich nicht für deine Betreuer sprechen, aber mir wäre ein sinnvolle Erklärung deutlich lieber, als einfach nur ein Benchmark
 

jhjh

Bekanntes Mitglied
Grad in dem Fall kann man doch genug Begründungen liefern, ohne auf Benchmarks zurückgreifen zu müssen ;)
Ich kann natürlich nicht für deine Betreuer sprechen, aber mir wäre ein sinnvolle Erklärung deutlich lieber, als einfach nur ein Benchmark
Ja villeicht hast du ja recht :D Allerdings wäre es so schon irgendwie "cooler" :cool::p
Wenn ich den direkten Vergleich hätte wie...
Var1 -> 1 ms
Var2 -> 1000 ms

Somit arbeitet Var1 bei gleichen Voraussetzungen (gleiche Systemumgebung) um 1000 % schneller......WOWWW!:eek:o_Oo_O
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Kannst du Bereich nennen wo das nicht der Fall ist ?
Das Problem sind hier die sehr, sehr kurzen Zeitspannen. Der relative Fehler ist natürlich enorm hoch. Mal übertrieben: wenn Du Deinen Rechner schief anschaust, stimmt das Ergebnis schon um den Faktor 10 nicht mehr :)

Umgekehrt: überall dort, wo es um lange Zeiträume geht, spielen Dinge wie der Scheduler des Betriebssystems keine (eine untergeordnete) Rolle.

Im Prinzip ist es, wie bei der Ermittlung der Laufzeitkomplexität: wenn Du z. B. einen B-Baum für DB-Indizes nimmst, dann interessieren hier nur die Zugriffe auf das Speichermedium und die Suche im Hauptspeicher wird vernachlässigt.

Nun muss ich das natürlich begründen und wollte dazu die Zeiten der jeweiligen Abfragen ermitteln, womit ich dies dann begründen kann.
Dafür, dass eine Abfrage übers Netz millionenfach langsamer ist, als eine simple Luftlinienberechnung, braucht man doch wirklich keine Messung. Unabhängig davon kannst Du die Abfrage über das Netz mit sehr einfachen Methoden (System.currentTimeMillis) messen - da spielen Optimierungen der JVM oder der Scheduler des OS weniger eine Rolle. Natürlich wirst Du auch hier unterschiedliche Ergebnisse bekommen, aber Du könntest einen Mittelwert angeben. Allerdings: ich würde das nicht messen, da reichen schon theoretische Überlegungen (Datendurchsatz).
 

jhjh

Bekanntes Mitglied
Dafür, dass eine Abfrage übers Netz millionenfach langsamer ist, als eine simple Luftlinienberechnung, braucht man doch wirklich keine Messung.
Oder tausendfach ? Oder auch nur hundertfach ? Villeicht braucht man ja gerade deswegen eine Messung ;-)
Aber gut, für meinen Anwendungsfall reicht es eigentlich zu wissen, dass das eine um einiges schneller ist als das andere. Die Dimension wird wohl nicht das entscheidende sein. Ich schätze ich werde es dann einfach anders begründen... :p
 

mihe7

Top Contributor
OK, das war zwar eigentlich nur als Spaß gedacht, aber wenn ich es mir recht überlege: im GSM-Netz kommt es einem nicht viel schneller vor und immer ist auch das kabelgebundene Netz nicht wirklich schnell.

Was anderes: berechnest Du die Luftlinie per Pythagoras oder berücksichtigst Du die Krümmung der Erdoberfläche?
 

jhjh

Bekanntes Mitglied
berechnest Du die Luftlinie per Pythagoras oder berücksichtigst Du die Krümmung der Erdoberfläche?
Habe mal nachgeschaut, als Berechnungsgrundlage dient wohl die Krümmung der Erde.

Die distanceTo() Methode (aus Var1) ist wie folgt beschrieben
Returns the approximate distance in meters between this location and the given location. Distance is defined using the WGS84 ellipsoid.
->https://de.wikipedia.org/wiki/World_Geodetic_System_1984
 

mihe7

Top Contributor
Java:
long start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
    suche(suchzahl);
}
long millis = System.currentTimeMillis() - start;
double mittelwert = millis / 1000.0;
 

slitec

Mitglied
Java:
long start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
    suche(suchzahl);
}
long millis = System.currentTimeMillis() - start;
double mittelwert = millis / 1000.0;

Ich habe mir gedacht, dass die Zeit nur immer bei einem Suchschritt gemessen wird und diese dann addiert. Habe mal ein Code geschrieben der leider nicht funktioniert:

Java:
    public int suchzeitLinear2() {
        
        int zeit30=0; //Zeit für 30
        for (int x=0; x<30;x++) {
        int    zeit1000=0; // Zeit für 1000
        for (int j=0; j<1000;j++ ) {
            
            int suchzahl = liste[zufall.nextInt(liste.length)]; //legt eine zufällige Suchzahl im Array fest
            final long timeStart = System.nanoTime();
            for (int i = 0; i < liste.length; i++){
                if(liste[i] == suchzahl){
                    final long timeEnd = System.nanoTime();
                    zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
                    System.out.println("Suchzeit: "+zeit+ " "+ suchzahl);
                    return i; //wenn gefunden wird beendet
                }
            }
                    
            zeit1000 += zeit;
            return -1; //wenn nicht gefunden
            
        }
        zeit30 += zeit1000 /1000;
        }
        
        int zeitFinal=zeit30/30;
        return zeitFinal;
    }

Nach der innersten Schleife " for (int i = 0; i < liste.length; i++)" wird hier allerdings abgebrochen. So in etwa habe ich es mir vorstellt. Kann mir jemand sagen ob mein Code korrekt ist? Wenn nicht, woran könnte es liegen?

Danke
 

mihe7

Top Contributor
Habe mal ein Code geschrieben der leider nicht funktioniert:
Kann mir jemand sagen ob mein Code korrekt ist? Wenn nicht, woran könnte es liegen?
Wieso sollte der Code korrekt sein, wenn er nicht funktioniert?!? Trenn doch einfach mal die Suchfunktion von der Zeitmessung (wie in der Skizze von mir), das macht die Sache schon wesentlich einfacher. Abgesehen davon ist es keine gute Idee ein long auf ein int zu addieren.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
1 Array rekursiv durchlaufen Java Basics - Anfänger-Themen 8
TimoN11 Array -> Schleife wieder von vorne durchlaufen lassen Java Basics - Anfänger-Themen 1
W Eigener Iterator soll mehrdimensionales Array durchlaufen Java Basics - Anfänger-Themen 4
C Laufzeitverhalten beim zeilenweise durchlaufen eines 2 dimensional array Java Basics - Anfänger-Themen 6
A Array wird nicht durchlaufen Java Basics - Anfänger-Themen 10
M Zweidimensionales Array durchlaufen Java Basics - Anfänger-Themen 4
B Array durchlaufen und sortieren Java Basics - Anfänger-Themen 9
K 2D Array spaltenweise durchlaufen Java Basics - Anfänger-Themen 4
G Array mit Schleife durchlaufen - guter Stil? Java Basics - Anfänger-Themen 20
T Array verkleinern Java Basics - Anfänger-Themen 2
J Array aus Numberfield Eingaben Java Basics - Anfänger-Themen 7
D Array List mit Objekten sortieren Java Basics - Anfänger-Themen 2
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
Ü Java Array - Buchstaben als Zahlen ausgeben Java Basics - Anfänger-Themen 22
Ü Zweidimensionales Array in der ersten Zeile deklarieren Java Basics - Anfänger-Themen 13
Thomas Uppe 2D Array Reihenfolge vermischen Java Basics - Anfänger-Themen 4
T array auslesen Java Basics - Anfänger-Themen 2
Nitrogames Variablen Variable aus JOptionPane Abfrage in Array einfügen Java Basics - Anfänger-Themen 4
moini Auf Array aus Superklasse zugreifen? Java Basics - Anfänger-Themen 2
J ArrayList in 2D-Array konvertieren. Java Basics - Anfänger-Themen 48
M NullPointerException: Cannot read the array length because "this.Kinder" is null Java Basics - Anfänger-Themen 1
P Wieso kann ich als Index für einen Array einen Char angeben? Java Basics - Anfänger-Themen 3
Finn_lol Fehlermeldung bei Schleife mit Array Java Basics - Anfänger-Themen 4
Proxy Chars vor array übergabe toLowerUpcase Java Basics - Anfänger-Themen 14
iAmFaiinez Primzahlen Tester ohne Array Java Basics - Anfänger-Themen 4
S array 2 dimensional treppe Java Basics - Anfänger-Themen 3
S Array 2x2 Blöcke mit 0 und 1 Java Basics - Anfänger-Themen 10
C Array von Klassen Java Basics - Anfänger-Themen 2
julian0507 2Dim-Array Spaltensummen Java Basics - Anfänger-Themen 1
XWing Doppelte Zahlen im Array Java Basics - Anfänger-Themen 8
melisax Java 2D-Array Tabelle Java Basics - Anfänger-Themen 4
melisax Java Array Wert an bestimmtem Index angeben Java Basics - Anfänger-Themen 14
W Items löschen aus String Array vom Custom Base Adapter Java Basics - Anfänger-Themen 2
Proxy Stack erweitern mit neuem Array falls der alte voll ist!? Java Basics - Anfänger-Themen 5
E Array, nächste Zahl zur 5 ausgeben, wie? Java Basics - Anfänger-Themen 42
J Array.list vergleichen Java Basics - Anfänger-Themen 1
W Java-Code mit Array Java Basics - Anfänger-Themen 14
D Reflections & Generisches Array Java Basics - Anfänger-Themen 4
T Array Java Basics - Anfänger-Themen 2
T Array Java Basics - Anfänger-Themen 15
T Wörteranzahl im Array zählen Java Basics - Anfänger-Themen 9
Ostkreuz Zweidimensionaler Array Index Java Basics - Anfänger-Themen 2
S String Array Buchstaben um einen gewissen Wert verschieben Java Basics - Anfänger-Themen 4
R Images aus einem Array ausgeben Java Basics - Anfänger-Themen 3
R 2d Array individuell machen Java Basics - Anfänger-Themen 4
D 2D Char Array into String Java Basics - Anfänger-Themen 2
J Array Median bestimmen Java Basics - Anfänger-Themen 6
S Array Maximum bestimmen mit for und foreach Java Basics - Anfänger-Themen 7
S Prüfen ob ein zweidimensionales Array rechteckig ist Java Basics - Anfänger-Themen 4
N Array Java Basics - Anfänger-Themen 1
J Array Mittleren Wert bestimmen Java Basics - Anfänger-Themen 2
D OOP Array einem Objekt zuweisen Java Basics - Anfänger-Themen 2
O Zahlen aus einem char-array per char + Zeichen addieren Java Basics - Anfänger-Themen 2
S leeres Array statt Null Pointer Exception ausgeben Java Basics - Anfänger-Themen 20
S Inhalte aus Array vergleichen und Max ausgeben Java Basics - Anfänger-Themen 3
M 2d array ohne längen anlegen Java Basics - Anfänger-Themen 4
S Bestimmte werte aus einem Array löschen Java Basics - Anfänger-Themen 2
S Ausgeben wie oft ein Wert in einem Array vorkommt Java Basics - Anfänger-Themen 7
E Reihenfolge der Werte umdrehen (mittels statischem int-Array Java Basics - Anfänger-Themen 3
O 2 Dimensionales Array Java Basics - Anfänger-Themen 6
M Bubble Sort - Int[] Array sortieren Java Basics - Anfänger-Themen 2
javaBoon86 Array mehrere Dimensionen Java Basics - Anfänger-Themen 10
B Array nach Elementwerten sortieren? Java Basics - Anfänger-Themen 1
B Explizit Array definieren geht nicht? Java Basics - Anfänger-Themen 14
D Kleinste Zahl in Array finden die vorher noch errechnet werden müssen. Java Basics - Anfänger-Themen 4
L Gegebenes Array sortieren, indem zufällige Zahlenpaare aus Array ausgewählt werden Java Basics - Anfänger-Themen 14
Say 2-DIM Array Code lesen und verstehen Java Basics - Anfänger-Themen 5
N Array beim erstellen mit Werten füllen Java Basics - Anfänger-Themen 6
C Java Array Struktur, welche ist wann besser? Java Basics - Anfänger-Themen 12
Temsky34 Array IndexOf nicht verfügbar Java Basics - Anfänger-Themen 18
belana wie am besten 2D Array von String to Integer Java Basics - Anfänger-Themen 18
S Array mit Methode löschen Java Basics - Anfänger-Themen 2
J Java To String Methode, Array mit For-Schleife Java Basics - Anfänger-Themen 2
E Durch Muster in Array iterieren Java Basics - Anfänger-Themen 3
L Frage zum Array Java Basics - Anfänger-Themen 1
C 2D Array Ausgabe mit for-Schleife i,j Java Basics - Anfänger-Themen 4
D Methode: Array Reihenfolge tauschen Java Basics - Anfänger-Themen 3
julian0507 Array aus Methode in anderer Methode sichtbar machen Java Basics - Anfänger-Themen 10
P Array vom Typ Klasse Java Basics - Anfänger-Themen 18
Lion.King Array deklarieren und initialisieren Java Basics - Anfänger-Themen 5
P Array-Objekte-Aufruf Java Basics - Anfänger-Themen 22
A CSv.Datei einlesen und die werte in zweidemosional Int Array speichern Java Basics - Anfänger-Themen 9
M Methoden Zweidimensionaler Array mit Setter Methode ändern Java Basics - Anfänger-Themen 4
AkiJou Zeile in 2d Array löschen Java Basics - Anfänger-Themen 2
LilliCherry Array in einer Zeile ausgeben Java Basics - Anfänger-Themen 6
A Elemente in einem Array Java Basics - Anfänger-Themen 5
A Vorkommende Farben ermittel und als Array zurückgeben Java Basics - Anfänger-Themen 7
AhmadSlack Array Java Basics - Anfänger-Themen 7
Jambolo Kartenhand Array Java Basics - Anfänger-Themen 14
ravenz Schleife mit for über String Array „zahlen“und prüfen ob Wert „a“ oder „b“ oder „c“ entspricht (mittels || ) Java Basics - Anfänger-Themen 4
S Eine Variable in einem Array speichern Java Basics - Anfänger-Themen 5
T Methode, die prüft ob in einem Int-Array maximal 2 Zahlen enthalten sind, die größer als ihr Vorgänger sind Java Basics - Anfänger-Themen 5
T String Array Fehler beim Index Java Basics - Anfänger-Themen 3
krgewb byte-Array, das ein Bild repräsentiert Java Basics - Anfänger-Themen 1
I Methoden Wieso wird mein Array "a" verändert und meine Variable "a" nicht? Java Basics - Anfänger-Themen 4
EykS 3D Druckdatei basierend auf 3D Array? Java Basics - Anfänger-Themen 3
sserio Array funktioniert nicht Java Basics - Anfänger-Themen 2
sserio Iterierung über ein zweidimensionales Array Java Basics - Anfänger-Themen 16
sserio Zweidimensionales Array [][] wird untereinander ausgegeben Java Basics - Anfänger-Themen 14
Chris.089 2 Werte im Array tauschen Java Basics - Anfänger-Themen 6

Ähnliche Java Themen

Neue Themen


Oben