prüfen ob alle array werte gleich sind

master123

Mitglied
ich habe ein zweidimensionales array mit x (je nach Eingabe) länge und möchte prüfen ob jedes dieser Werte gleich ist. Falls ja dann true, sonst false. Weiss jemand wie ich das machen kann? Ich muss nur die Prüfung vornehmen.

zusätzlich muss ich diese Werte mit anderen Werten auf Gleichheit prüfen. Aber erstmal die Array Werte, das ich das schwierigste :)

ich wollte es irgendwie mit der for-schlaufe lösen, aber habe überhaupt keinen Anhaltspunkt.
 
Zuletzt bearbeitet:

master123

Mitglied
Ich sollte noch ergänzen:
Es ist eine Matrix, also gleiche Anzahl Spalten wie Zeilen. Die genau Anzahl wird bei Eingabe ermittelt.
Die Berechnung der Summe jeder Zeile und Spalte sowie deren Diagonalen habe ich bereits vorgenommen.
sumR(i) = summe aller Zeilen
sumC(j) = summe aller Spalten
sumDiaR = summe der diagonalen rechts nach Links
sumDiaL = summe der diagonalen links nach rechts

Wie kann ich jetzt prüfen ob all diese Werte gleich sind? Mit hundert if abfolgen könnte ich es machen, aber schön ist es nicht. Ausserdem ist die Anzahl Spalten/Zeilen nicht bekannt, darum array.
 
X

Xyz1

Gast
Java:
	public static boolean check_x_for_equality(int[][] zweidimensionalesArray) {
		for (int i = 0; i < zweidimensionalesArray.length - 1; i++) {
			if (zweidimensionalesArray[i][0] != zweidimensionalesArray[i + 1][0]) {
				return false;
			}
		}
		return true;
	}
	public static boolean check_y_for_equality(int[][] zweidimensionalesArray) {
		for (int i = 0; i < zweidimensionalesArray.length - 1; i++) {
			if (zweidimensionalesArray[i][1] != zweidimensionalesArray[i + 1][1]) {
				return false;
			}
		}
		return true;
	}
	public static void main(String[] args) {
		int[][] zweidimensionalesArray = new int[100][2];
		for (int i = 0; i < zweidimensionalesArray.length; i++) {
			zweidimensionalesArray[i][0] = 100;
			// zweidimensionalesArray[i][1] = 1;
			zweidimensionalesArray[i][1] = i + 1;
		}
		System.out.println(Arrays.deepToString(zweidimensionalesArray));
		System.out.println(check_x_for_equality(zweidimensionalesArray));
		System.out.println(check_y_for_equality(zweidimensionalesArray));
	}
 

tommysenf

Top Contributor
Java:
for ( int zeile = 0; zeile < array.length; zeile++ ) {
    for ( int spalte=0; spalte < array[zeile].length; spalte++ )
        if( array[zeile][spalte]  !=  array[0][0] ) return false;
return true;
 

master123

Mitglied
@tommysenf
ich möchte prüfen ob jede Spalte untereinander gleich ist, jede Zeile untereinander gleich ist, die beiden Diagonalen gleich sind, eigentlich jedes dieser 4 Elemente untereinander gleich ist. Erst dann ist true, sonst ist false. Wie gesagt, Summe aller Zeilen, Spalten und Diagonalen habe ich. Die Frage ist nur noch wie ich die 4 Dingen miteinander vergleichen. Zwei davon sind arrays (Spalten und Zeilen). Die anderen beiden sind nur jeweils ein Wert.

Könntest du mir das kurz aufzeigen? :)
 

Tarrew

Top Contributor
Kannst du das mal an einem Beispiel veranschaulichen? Ist schon schwer zu verstehen anhand der Beschreibung :p
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Java:
public boolean allEquals(boolean magic) {
    int cw = sumC(0);
    for (int spalte = 1; spalte < spalten; spalte++) {
        if (cw != sumC(spalte)) {
            return false;
        }
    }

    int rw = sumR(0);
    for (int zeile = 1; zeile < zeilen; zeile++) {
        if (rw != sumR(zeile)) {
            return false;
        }
    }
    if (magic) {
        return cw == rw && cw == sumDiaR && cw == sumDiaL;
    } else {
        return sumDiaR == sumDiaL;
    }
 

master123

Mitglied
ich habe vergessen, dass ich dieses Thema offen habe. Daher brauche ich das andere Thema nicht mehr.
@mihe7
so habe ich mir das auch vorgestellt. ABer wie kann ich das Ergebnis (true oder false) in der main Methode aufrufen? Also falls das Ergebnis false ist, dann in der Main Methode den Text ausgeben "Falsch".
 

master123

Mitglied
ich habe das Problem gelöst. Habe einfach die ganze Rechnerei in einer Methode Rechnen (boolean)... und dann in der Main nur die Ausgabe ob True oder False abgefragt.

Es fehlt mir noch eine Sache. Ich möchte aus der Methode Rechnen eine Zahl in die Main Methode übertragen. Geht das? Kann ich boolean und int übertragen?
 

master123

Mitglied
ich habe es anders gemacht.
Code:
if (Rechnen(false)) {
    System.out.println("Falsch");
}

Wie kann nun einen int Wert aus der anderen Methode übernehmen? Ich habe das Gefühl, ich muss alles nach Methoden unterteilen und das return nur einen Wert zurückgeben kann.
 

mihe7

Top Contributor
ich habe es anders gemacht.
Wenn Du das in main hast, ist Rechnen eine statische Methode. Vergiss static (außer für main).

NB: halte Dich an die Benennungskonventionen von Java: Namen für Parameter, Variablen und Methoden in lowerCamelCase, für Typen (wie Klassen) in UpperCamelCase. Das erleichtert allen das Lesen von Code.

Ich habe das Gefühl, ich muss alles nach Methoden unterteilen und das return nur einen Wert zurückgeben kann.
Das nennt man wohl strukturieren :) Und richtig, return kann nur einen Wert zurückgeben, der allerdings auch eine Objektreferenz sein kann.

Wie kann nun einen int Wert aus der anderen Methode übernehmen?
Ich verstehe nicht, was Du damit meinst. Vermutlich hängt Dein Problem damit zusammen, dass Du mit statischen Methoden arbeitest. Evtl. kannst Du mal den kompletten Code posten und daran erklären, was Du vor hast.
 

master123

Mitglied
ich möchte einfach aus einer Methode, die mir einen Boolean Wert zurückgibt (haben wir vorher gelöst), auch einen Wert des Typs int zurückgeben lassen. Geht das überhaupt oder muss ich wie du sagst, noch weiter strukturieren, damit eine Methode nur einen Typ zurückgibt? Falls ja, dann würde das den Rahmen sprengen. Jede Variable, die ich irgendwo definiert habe müsste dann in die andere Methode übergeben werden und dann das Ergebnis wiederum in die nächste usw. ist doch ein Chaos?! :D
 

mihe7

Top Contributor
ich möchte einfach aus einer Methode, die mir einen Boolean Wert zurückgibt (haben wir vorher gelöst), auch einen Wert des Typs int zurückgeben lassen.

Dazu brauchst Du einfach einen geeigneten Datentyp.

Java:
class Ergebnis {
    public final int wert;
    public final boolean korrekt;
    public Ergebnis(int wert, boolean korrekt) {
        this.wert = wert;
        this.korrekt = korrekt;
    }
}

Und dann kannst Du Deine Methode ändern zu
Java:
Ergebnis rechne(boolean magic) {
    ...
    return new Ergebnis(42, true);
}
 

master123

Mitglied
Java:
Ergebnis rechne(boolean magic) {
    ...
    return new Ergebnis(42, true);
}
Wie soll ich das verstehen? Statt nur einen return true schreibe ich return true + int Wert?
Ich habe es probiert und es geht nicht. "cannot be resolved to a type"

Kann ich den einen Wert (Summe von Zahlen) vielleicht ausserhalb der Methode speichern, damit er in allen Methoden aufrufbar ist? Sonst müsste ich hier den ganzen Code strukturieren, was bedeutet zig Stunden Arbeit um alles neu zu definieren.
 

master123

Mitglied
Ich hoffe du hast einen Überblick.
Kurz was es macht:
du gibst die grösse des Quadrats ein, z.B. 3 ( heisst 3 x 3).
Dann gibst du nacheinander 9 zahlen ein. Dann prüft das Programm ob diese Zahlen magisch sind und falls JA, dann soll es "Magisch" + die magische Zahl ausgeben. Falls nicht, dann einfach nur "nicht magisch".

Gelöst habe ich bisher dass es prüft ob magisch oder nicht magisch und dass "Magisch" oder "nicht magisch" ausgegeben wird. Aber die Magische Zahl selber bringe ich einfach nicht in die Main Methode kopiert. Magische Zahl ist eine der Summen, egal ob summeDiagonale1, summeSpalte etc. sie sind sowieso alle gleich, falls Wert true ist. Es soll einfach den Wert in die main Methode kopieren.

Was schlägst du mir vor, wie bringe ich das am einfachsten hin, ohne alles nochmals umzuschreiben :)

Java:
import java.util.Scanner;

public class Main {
    
    
    
    public static void main(String[] args) {
        // Ausgabe des Ergebnisses
            if (Magisch(true)) {
                System.out.println("Magisch ");
            }
            else {
                System.out.println("nicht magisch");
            }

        }

   public static boolean Magisch(boolean magisch) {
      Scanner keyScan = new Scanner(System.in);

      // Grösse einlesen
      System.out.print("Grösse des Quadrats: ");
      int groesse = keyScan.nextInt();   
      int [][] quadrat = new int[groesse][groesse];

      // Quadrat einlesen
      System.out.println("Bitte Zahlen eingeben: ");
      for (int i=0; i<groesse; i++) {
         for (int j=0; j<groesse; j++) {
            quadrat[i][j] = keyScan.nextInt();   
         }
      }
      
      keyScan.close();


  
     
      // Summe Zeile berechnen
       int [] summeZeile = new int [groesse];
      
       for (int i=0; i<groesse; i++) {
           for (int j=0; j<groesse; j++) {
               summeZeile[i] += quadrat[0][j];
           }
       }
      
       // Summe Spalte berechnen
       int [] summeSpalte = new int [groesse];
      
       for (int j=0; j<groesse; j++) {
           for (int i=0; i<groesse; i++) {
               summeSpalte[j] += quadrat[i][0];
           }
       }
      
       // Summe Diagonale 1
      int summeDiagonale1 = 0;
      for (int i=0; i<groesse; i++) {
          for (int j=0; j<groesse; j++) {
              if (i==j) {
                  summeDiagonale1 = summeDiagonale1 + quadrat[i][j];
              }
          }
      }
      
      // Summe Diagonale 2
      int summeDiagonale2 = 0;
      for (int i=0; i<groesse; i++) {
          for(int j=groesse-1; j>=0; j--) {
              if(i+j == groesse-1) {
                  summeDiagonale2 = summeDiagonale2 + quadrat[i][j];
              }
              
          }
      }
      
        
for (int i = 1; i<groesse; i++) {
    if (summeZeile[0] != summeZeile[i]) {
        return false;
    }
    
}
for (int j = 1; j<groesse; j++) {
    if (summeSpalte[0] != summeSpalte[j]) {
        return false;
    }

}

if ((summeDiagonale1 != summeSpalte[0]) || (summeDiagonale2 != summeZeile[0])) {
    return false;
}
    return true;

   }}
 

mihe7

Top Contributor
Java:
import java.util.Scanner;

public class Main {

    static class Ergebnis {
        final int summe;
        final boolean magisch;

        public Ergebnis() {
            summe = -1;
            magisch = false;
        }

        public Ergebnis(int summe) {
            this.summe = summe;
            this.magisch = true;
        }
    }
        
    public static void main(String[] args) {
        Ergebnis ergebnis = Magisch(true);
        // Ausgabe des Ergebnisses
        if (ergebnis.magisch) {
            System.out.printf("Magisch, Summe %d\n", ergebnis.summe);
        }
        else {
            System.out.println("nicht magisch");
        }

    }

    public static Ergebnis Magisch(boolean magisch) {
        Scanner keyScan = new Scanner(System.in);

        // Grösse einlesen
        System.out.print("Grösse des Quadrats: ");
        int groesse = keyScan.nextInt();   
        int [][] quadrat = new int[groesse][groesse];

        // Quadrat einlesen
        System.out.println("Bitte Zahlen eingeben: ");
        for (int i=0; i<groesse; i++) {
            for (int j=0; j<groesse; j++) {
                quadrat[i][j] = keyScan.nextInt();   
            }
        }
     
        // Summe Zeile berechnen
        int [] summeZeile = new int [groesse];
      
        for (int i=0; i<groesse; i++) {
            for (int j=0; j<groesse; j++) {
                summeZeile[i] += quadrat[0][j];
            }
        }
      
        // Summe Spalte berechnen
        int [] summeSpalte = new int [groesse];
      
        for (int j=0; j<groesse; j++) {
            for (int i=0; i<groesse; i++) {
                summeSpalte[j] += quadrat[i][0];
            }
        }
      
        // Summe Diagonale 1
        int summeDiagonale1 = 0;
        for (int i=0; i<groesse; i++) {
            for (int j=0; j<groesse; j++) {
                if (i==j) {
                    summeDiagonale1 = summeDiagonale1 + quadrat[i][j];
                }
            }
        }
      
        // Summe Diagonale 2
        int summeDiagonale2 = 0;
        for (int i=0; i<groesse; i++) {
            for(int j=groesse-1; j>=0; j--) {
                if(i+j == groesse-1) {
                    summeDiagonale2 = summeDiagonale2 + quadrat[i][j];
                }
            }
        }
      
        
        for (int i = 1; i<groesse; i++) {
            if (summeZeile[0] != summeZeile[i]) {
                return new Ergebnis();
            }            
        }
        for (int j = 1; j<groesse; j++) {
            if (summeSpalte[0] != summeSpalte[j]) {
                return new Ergebnis();
            }
        }

        if ((summeDiagonale1 != summeSpalte[0]) || (summeDiagonale2 != summeZeile[0])) {
            return new Ergebnis();
        }
        return new Ergebnis(summeDiagonale1);
    }
}
Sinnvoller wäre es, auf static zu verzichten, dann kannst Du Dir den ganzen Käse sparen, da du das Ergebnis dann im Objekt halten kannst (wie bei Ergebnis).
 

master123

Mitglied
deine Lösung funktioniert, danke :)
aber mit dem Stoff bin ich noch nicht so weit. Ich kenne die Begriffe (this, .summe, final) noch nicht. Muss es noch lernen ;)
 

mihe7

Top Contributor
OK, dann würde ich es anders machen (Achtung: ungetestet, nur hier im Editor reingeschrieben, kann also Fehler enthalten):

Java:
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int[][] quadrat = leseQuadrat();
        boolean magisch = magisch(quadrat, true);
        // Ausgabe des Ergebnisses
        if (magisch) {
            int summe = zeilenSumme(0); // ermittelt Summe der ersten Zeile
            System.out.printf("Magisch, Summe %d\n", summe);
        }
        else {
            System.out.println("nicht magisch");
        }
    }

    static int[][] leseQuadrat() {
        Scanner keyScan = new Scanner(System.in);

        // Grösse einlesen
        System.out.print("Grösse des Quadrats: ");
        int groesse = keyScan.nextInt();   
        int [][] quadrat = new int[groesse][groesse];

        // Quadrat einlesen
        System.out.println("Bitte Zahlen eingeben: ");
        for (int i=0; i<groesse; i++) {
            for (int j=0; j<groesse; j++) {
                quadrat[i][j] = keyScan.nextInt();   
            }
        }
        return quadrat;
    }

    static boolean magisch(int[][] quadrat, boolean magisch) {
     
        // Summe Zeile berechnen
        int [] summeZeile = new int [groesse];
      
        for (int i=0; i<groesse; i++) {
            summeZeile[i] = zeilenSumme(quadrat, i);
        }
      
        // Summe Spalte berechnen
        int [] summeSpalte = new int [groesse];
      
        for (int j=0; j<groesse; j++) {
            summeSpalte[j] = spaltenSumme(quadrat, j);
        }
      
        // Summe Diagonale 1
        int summeDiagonale1 = 0;
        for (int i=0; i<groesse; i++) {
            for (int j=0; j<groesse; j++) {
                if (i==j) {
                    summeDiagonale1 = summeDiagonale1 + quadrat[i][j];
                }
            }
        }
      
        // Summe Diagonale 2
        int summeDiagonale2 = 0;
        for (int i=0; i<groesse; i++) {
            for(int j=groesse-1; j>=0; j--) {
                if(i+j == groesse-1) {
                    summeDiagonale2 = summeDiagonale2 + quadrat[i][j];
                }
            }
        }
      
        
        for (int i = 1; i<groesse; i++) {
            if (summeZeile[0] != summeZeile[i]) {
                return false;
            }            
        }
        for (int j = 1; j<groesse; j++) {
            if (summeSpalte[0] != summeSpalte[j]) {
                return false;
            }
        }

        if ((summeDiagonale1 != summeSpalte[0]) || (summeDiagonale2 != summeZeile[0])) {
            return false;
        }
        return true;
    }

    static int zeilenSumme(int[][] quadrat, int zeile) {
        int summe = 0;        
        for (int spalte = 0; spalte < quadrat[zeile].length; spalte++) {
            summe += quadrat[zeile][spalte];
        }
        return summe;
    }

    static int spaltenSumme(int[][] quadrat, int spalte) {
        int summe = 0;
        for (int zeile = 0; zeile < quadrat.length; zeile++) {
            summe += quadrat[zeile][spalte];
        }
        return summe;
    }
}

Übrigens: Deine Kommentare, die Du im Code zur Strukturierung verwendest, sind sicheres Anzeichen dafür, dass Du Methoden verwenden willst :)

Beispiel:

Java:
        // Summe Zeile berechnen
        int [] summeZeile = new int [groesse];
      
        for (int i=0; i<groesse; i++) {
            summeZeile[i] = zeilenSumme(quadrat, i);
        }

Statt toten Text (=Kommentar) einzufügen, kannst Du auch gleich eine Methode einführen:
Java:
    static int[] zeilenSummen(int[][] quadrat) {
        int [] summeZeile = new int [groesse];
      
        for (int i=0; i<groesse; i++) {
            summeZeile[i] = zeilenSumme(quadrat, i);
        }
        return summeZeile;
    }
Und an der Stelle Deines Kommentars schreibst Du dann einfach:
Java:
    int[] summeZeile = zeilenSummen(quadrat);

Noch was: ich habe die Methodennamen extra umgedreht, um Dich nicht zu verwirren.
 

master123

Mitglied
Statt toten Text (=Kommentar) einzufügen, kannst Du auch gleich eine Methode einführen:
Java:
    static int[] zeilenSummen(int[][] quadrat) {
        int [] summeZeile = new int [groesse];
     
        for (int i=0; i<groesse; i++) {
            summeZeile[i] = zeilenSumme(quadrat, i);
        }
        return summeZeile;
    }
erstmal Danke für deinen zweiten Post. :)
Ja mit Methoden wäre es doch eigentlich richtig zu arbeiten oder? Aber damit habe ich ein Problem. Nämlich, wenn du ganz am Anfang durch den Scanner "groesse" definierst, wie willst du das dann in die anderen Methoden übernehen, wenn du es brauchst? Es kommt immer der Fehler: "Cannot be resolved to a variable". Damit habe ich Mühe. Wenn jede Variable nur in der gleichen Methode gebraucht wird, dann ist das kein Problem. Aber z.B. "groesse" wird in mehreren Methoden gebraucht.
 

mihe7

Top Contributor
Das ist prinzipiell mal gar kein Problem, weil Du den Methoden ja entsprechende Parameter spendieren kannst. Allerdings brauchst Du das hier nicht, weil Du die Größe über das Array quadrat ermitteln kannst: quadrat.length.

Beim Abändern hier im Editor habe ich das oben übersehen - natüüüüürlich mit voller Absicht, denn etwas Eigeninitiative kann ja wohl erwarten ;)

Änder mal
Java:
    static boolean magisch(int[][] quadrat, boolean magisch) {
    
        // Summe Zeile berechnen

zu
Java:
    static boolean magisch(int[][] quadrat, boolean magisch) {
    
        int groesse = quadrat.length;
        // Summe Zeile berechnen

und
Java:
        int [] summeZeile = new int [groesse];
zu
Java:
        int [] summeZeile = new int [quadrat.length];

dann stehen die Chancen gut, dass der Fehler weg ist :)
 

master123

Mitglied
ok, ich habe vielleicht zu wenig deutlich geschrieben. :)
Ich hätte z.B. in Methode1 eine Variable int test = 5;
wie kann ich die in der Methode2 abrufen ohne sie erneut zu definieren? Sorry, wenn das einfach ist, aber das verwirrt mich extrem an der ganzen Methodenbastelei. ;)
 

mihe7

Top Contributor
Ich hätte z.B. in Methode1 eine Variable int test = 5;
wie kann ich die in der Methode2 abrufen ohne sie erneut zu definieren?
Wenn Du in einer Methode eine Variable deklarierst, dann handelte es sich um eine lokale Variable. Diese ist von anderen Methoden aus nicht sichtbar.

Um den Wert einer lokalen Variable an eine andere Methode zu übergeben, muss die andere Methode einen solchen Wert als Parameter erwarten.

Java:
static void a() {
    int test = 5; // dieses test existiert nur innerhalb von a und ist von außen nicht sichtbar
    b(test);  // übergibt den Wert der Variablen test als Parameter an Methode b
}
static void b(int x) {
   System.out.println(x); // gibt den Wert des Parameters x aus
}

Man kann Variablen auch außerhalb von Methoden deklarieren, die dann allen Methoden zur Verfügung stehen. Statische Variablen heißen Klassenvariablen, nicht statische Instanzvariablen. Der Unterschied ist, dass Klassenvariablen ohne Objekt existieren, Instanzvariablen für jedes Objekt separat.

Statisch:
Java:
public class X {
    private static int test;

    public static void a() {
        X.test = 5; // das X. ist in Java leider optional
    }

    public static void b() {
        System.out.println(X.test);
    }
}

Da die Methoden statisch sind, kannst Du von überall aus z. B. X.a(); aufrufen - ohne Objekt.

Nicht-statisch:
Java:
class X {
    private int test;

    public void a() {
        test = 5; // ist gleichbedeutend mit this.test = 5
    }
    public void b() {
        System.out.println(test);
    }
}
Hier musst Du ein Objekt erzeugen, um a() aufrufen zu können:
Java:
X x = new X(); // neues X-Objekt erzeugen
x.a(); // die Methode a() auf dem Objekt x (= Instanz der Klasse X) aufrufen
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
B Frage zur Effizienz - alle Array-Felder initialisieren oder jedes Feld auf null prüfen? Java Basics - Anfänger-Themen 4
S Alle 60min prüfen ob eine Datei da ist Java Basics - Anfänger-Themen 6
P Prüfen ob alle zellen der tabelle leer sind Java Basics - Anfänger-Themen 9
D Wie kann man in Java nach Arrays auf Duplikate prüfen Java Basics - Anfänger-Themen 12
J Schlüsselworte Prüfen, ob ein bestimmtes, ganzes Wort in einem String enthalten ist. Java Basics - Anfänger-Themen 6
Ostkreuz Int Scanner auf Enter Eingabe prüfen Java Basics - Anfänger-Themen 4
S Prüfen ob ein zweidimensionales Array rechteckig ist Java Basics - Anfänger-Themen 4
M Prüfen on eine Zahl im String enthalten ist Java Basics - Anfänger-Themen 3
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
Fiedelbambu Prüfen von Komma stelle beim Taschenrechner Java Basics - Anfänger-Themen 5
sserio Prüfen, ob eine Zahl eine periodische Zahl ist Java Basics - Anfänger-Themen 20
I Auf vollen Monat prüfen? Java Basics - Anfänger-Themen 22
A Dateiname auf Vorkommen prüfen Java Basics - Anfänger-Themen 29
I Prüfen, ob Anzahl an Monate ein Jahr ergeben Java Basics - Anfänger-Themen 4
K Warum gibt mir z. B. 40^128 eine Zahl? Ich dachte mit xor kann man nur booleanwerte erhalten, also prüfen ob etwas whar oder falsch ist? Java Basics - Anfänger-Themen 1
W Klasse existiert prüfen Java Basics - Anfänger-Themen 5
Q Prüfen ob Zahl als Summe von Potenzen dargestellt werden kann. Java Basics - Anfänger-Themen 20
U Kann man bei Java gleich mehrere Bedingungen prüfen in der If, aber in einem "Satz"? Java Basics - Anfänger-Themen 1
O Ich ahbe einen char und diesen soll ich bei .matches prüfen, also ob der char in meiner Zeichenkette vorhanden ist, wie mache ich das? Java Basics - Anfänger-Themen 9
B Array nach Wert prüfen rekursiv Java Basics - Anfänger-Themen 5
G Strings auf Gleichheit prüfen - Aufgabe vom Prof. Java Basics - Anfänger-Themen 5
M Array auf Primzahlen prüfen Java Basics - Anfänger-Themen 7
K Wie String prüfen ob drei mal das gleiche Zeichen vorkommt? Java Basics - Anfänger-Themen 7
J ArrayList auf bereits vorhanden eintrag prüfen Java Basics - Anfänger-Themen 5
X Zwei Dimensionales Array prüfen Java Basics - Anfänger-Themen 1
B Prüfen, ob Zeit Überschreitung Java Basics - Anfänger-Themen 2
B Sudoku prüfen Java Basics - Anfänger-Themen 13
M Prüfen auf null ohne NPE Java Basics - Anfänger-Themen 1
X Array auf Leerstellen prüfen Java Basics - Anfänger-Themen 1
FelixN Prüfen, ob ein 2D-Array rechteckig ist Java Basics - Anfänger-Themen 42
C Erste Schritte JComboBox Einträge auf Duplikat prüfen Java Basics - Anfänger-Themen 4
C Array auf Null-Inhalte prüfen Java Basics - Anfänger-Themen 9
B Prüfen, ob Country Code in Europa ist? Java Basics - Anfänger-Themen 24
L Prüfen ob Fax (Tif-Datei) vollständig angekommen ist Java Basics - Anfänger-Themen 15
O Datenstruktur auf SET prüfen in O(n) Java Basics - Anfänger-Themen 32
O Einzelne Bits umwandeln und prüfen Java Basics - Anfänger-Themen 23
U Mehrfacheingabe auf bestimmte Parameter prüfen Java Basics - Anfänger-Themen 8
B Prüfen, ob Datum2 der gleiche Tag ist wie Datum1 Java Basics - Anfänger-Themen 10
Dimax Erste Schritte String Eingabe Prüfen Java Basics - Anfänger-Themen 11
S char auf buchstabe/zeichen prüfen Java Basics - Anfänger-Themen 1
S Array doppelter Wert prüfen Java Basics - Anfänger-Themen 7
B Prüfen, ob es schon einen Termin gibt in einem Zeitraum Java Basics - Anfänger-Themen 5
K Linux Speicherplatz mit Java prüfen Java Basics - Anfänger-Themen 4
O Array nach gleichen Zahlen prüfen und ausgeben Java Basics - Anfänger-Themen 6
G Compiler-Fehler Auf Anagramm prüfen Java Basics - Anfänger-Themen 1
B Excel File einlesen und Überschrift prüfen Java Basics - Anfänger-Themen 8
DaCrazyJavaExpert Input/Output Prüfen wie oft etwas eingegeben wurde Java Basics - Anfänger-Themen 2
K Operatoren 2D Int Array auf Null-Referenzen prüfen Java Basics - Anfänger-Themen 18
S Prüfen ob Zelle in Excel leer ist funktioniert nicht (Apache POI) Java Basics - Anfänger-Themen 18
C Klassen Reguläre Ausdrücke auf Gleichheit prüfen Java Basics - Anfänger-Themen 5
M Erste Schritte Java prüfen ob eine der Möglichkeiten erfüllt ist Java Basics - Anfänger-Themen 2
R Auf Nachkommastellen prüfen. Java Basics - Anfänger-Themen 2
P Argumente auf plausibilität prüfen... Java Basics - Anfänger-Themen 8
F LimitedQueue auf Datum prüfen Java Basics - Anfänger-Themen 6
B Passwort prüfen bis eindeutig - while Schleife? Java Basics - Anfänger-Themen 11
Tommy Nightmare Variable auf mehrere Ungleichheiten prüfen Java Basics - Anfänger-Themen 18
B String mit Emailadresse prüfen Java Basics - Anfänger-Themen 11
E 2D Arrays auf Ungleichheit prüfen! Java Basics - Anfänger-Themen 5
MrSnake Prüfen ob TitledPane schon besteht Java Basics - Anfänger-Themen 2
B Serial Key prüfen -> String mit privatem Key und dann abgleichen; Summe = 0 Java Basics - Anfänger-Themen 8
N Compiler-Fehler Iban prüfen Java Basics - Anfänger-Themen 7
J Prüfen ob Arrays nur mit einem Wert belegt sind Java Basics - Anfänger-Themen 3
M String prüfen Java Basics - Anfänger-Themen 7
E Prüfen ob Sammlung gesetzt wurde - Lebensmittelsammlung Java Basics - Anfänger-Themen 8
H Zufällig generierte Zahlen auf Eingabe prüfen Java Basics - Anfänger-Themen 5
S Prüfen ob bestimmter Ordner geöffnet ist (Windows XP) Java Basics - Anfänger-Themen 5
Ruvok Prüfen ob bestimmtest Element existiert im Array Java Basics - Anfänger-Themen 11
DeVolt Java8 Paket Time: Datum prüfen / try-catch Java Basics - Anfänger-Themen 1
W char-Array auf bestimmte Zeichen prüfen Java Basics - Anfänger-Themen 10
S String auf Pallindromeigenschaft prüfen Java Basics - Anfänger-Themen 15
AssELAss Datums-Objekt prüfen ob im gleichen Monat? Java Basics - Anfänger-Themen 5
Screen Input/Output Wie prüfen ob Stream1 in Stream2 enthalten ist (on-the-fly) ? Java Basics - Anfänger-Themen 5
P Seite auf Inhalt prüfen Java Basics - Anfänger-Themen 2
I Prüfen ob Webseite existiert Java Basics - Anfänger-Themen 3
Z Inputs prüfen Java Basics - Anfänger-Themen 6
G Textdatei auf Dubletten prüfen Java Basics - Anfänger-Themen 8
I Prüfen von zwei Listen Java Basics - Anfänger-Themen 1
K zwei Rechtecke auf Berührung prüfen Java Basics - Anfänger-Themen 2
G String auf Format prüfen Java Basics - Anfänger-Themen 3
J Eingabewert übergeben und prüfen von showInputDialog Java Basics - Anfänger-Themen 4
L 6stellige Zufallszahlen erzeugen & auf einzigartigkeit prüfen Java Basics - Anfänger-Themen 3
S Array befüllen & auf doppelte werte prüfen Java Basics - Anfänger-Themen 6
M Prüfen, ob Zeichen eine Zahl ist Java Basics - Anfänger-Themen 3
M Punkt auf eine Farbe prüfen Java Basics - Anfänger-Themen 8
C Datentypen Prüfen of eine Zahl Quadratzahl ist Java Basics - Anfänger-Themen 2
K Eindimensionalen Array prüfen Java Basics - Anfänger-Themen 5
M Konstruktor auf null prüfen, Arrays Java Basics - Anfänger-Themen 9
O Prüfen ob ein String den selben Namen hat wie eine Booleanreihe? Java Basics - Anfänger-Themen 17
J Arrays prüfen und über if Bedingung ausgeben Java Basics - Anfänger-Themen 15
B Interface Generics: prüfen ob Interface deklariert wird Java Basics - Anfänger-Themen 18
L Erste Schritte Einträge in ArrayList prüfen Java Basics - Anfänger-Themen 4
S OOP long prüfen Java Basics - Anfänger-Themen 5
H Prüfen, ob jpg image schon vorhanden ist, bevor es geladen wird Java Basics - Anfänger-Themen 13
L Eine ArrayList auf gleiche Inhalte prüfen Java Basics - Anfänger-Themen 10
Rayo Eingelesene Ascii Zahlen wie normale Zahlen prüfen Java Basics - Anfänger-Themen 4
K HashMap auf leere Key-Value-Paare prüfen Java Basics - Anfänger-Themen 14
N Prüfen ob Objekt existiert Java Basics - Anfänger-Themen 6
I Mehrere ArrayLists mit einer for( : ) Schleife auf Inhalt prüfen Java Basics - Anfänger-Themen 6
A Prüfen ob Datei existiert Java Basics - Anfänger-Themen 9
G Verfügbare Clients prüfen ohne ping Java Basics - Anfänger-Themen 12

Ähnliche Java Themen

Neue Themen


Oben