Problem mit (etwas komplizierterem) Java Programm

mat2089119

Mitglied
Hallo,

ich habe dieses Jahr am Bundewettbewerb Informatik teilgenommen. Eine der Aufgaben habe ich nicht geschafft komplett richtig zu lösen (trotz stundenlangem Suchen und Probieren) und würde jetzt wo der Wettbewerb bewertet ist (ich habe immerhin noch 3/5 Punkten bekommen) gerne wissen wo der Fehler liegt.

Daher würde ich mich freuen wenn sich ein profi mal mein Programm anschauen würde auch wenn es vielleicht ein paar Minuten dauert sich in die Aufgabe einzuarbeiten.

Die Aufgabe kurz zusammengefasst:

Ziel ist es, gültige Anmeldelisten zu einer Veranstaltung zu generieren (hier Tutorien). Jeder Tutor soll genau ein Tutorium leiten. Den Studenten sollen aber zur Anmeldung ein Termin mehr ausgegeben werden als wirklich stattfindet damit der Termin mit den geringsten Anmeldungen gestrichen werden kann

Das Problem liegt darin dass nicht jeder Tutor an jedem Termin zur Verfügung steht.
Eine Anmeldeliste ist also gültig wenn jeder der Termine gestrichen werden könne und trotzdem für die übrigen Termine je ein Tutor zur Verfügung stellt.

Das Programm soll nun aus t möglichen Terminen und n Tutoren eine gültige Anmeldeliste aus n+1 Terminen ausgeben.

Hier ein Link zu der kompletten Aufgabe

Zu meiner Lösung:
Mit einem ersten Backtracking werden alle Teilmengen (n+1) der möglichen Termine gebildet.
Ein zweites Backtracking prüft dann die gültigkeit der Anmeldeliste, indem immer ein Termin gestrichen wird und anschließend versucht wird jedem Termin einen Tutor zuzuordnen.

Hier der Quellcode:

Java:
import java.util.*;

class Tutoren
{
  static void loesche(int[] verf, int index)
  {
    verf[index] = 0;
  }
  
  static void einfuegen(int[] verf, int merke)
  {
    verf[merke] = 1;
  }
  
  static void anmeldeliste(int[] verf, int n, int t, int[][] tutoren)
  {
    int j;
    Integer zahl = null;
    boolean gefunden, gefunden2;
    
    int stelle = 1;
    int merke = 0;
    int[] reihe = new int[t+1];
    int[] neueReihe = new int[t+1];
    
    
    do { 
      j = merke;
      
      gefunden = false;
      
      do { 
        j++;
        if (j>t) {
          break;
        } // end of if
        if (verf[j] == 1) {
          zahl = j;
          gefunden = true;
        } // end of if
        
      } while (gefunden == false);
      
      if (gefunden == true) {
        reihe[stelle] = zahl;
        
        merke = 0;
        loesche(verf, j);
        stelle++;
        
        if (stelle > t) {
          stelle = stelle-1;
          merke = reihe[stelle];
          einfuegen(verf, merke);
          
          gefunden2 = true;
          for (int i = 1; i<n+2; i++) {
            neueReihe[reihe[i]] = 1;
            if ((i > 1) && (reihe[i] < reihe[i-1])) {
              gefunden2 = false;
              break;
            } // end of if
            
          } // end of for
          if (gefunden2) { //wenn eine Kombination gefunden wurde wird die Gültigkeit überprüft        
            if (gueltig(neueReihe, tutoren, n, t)) {
              break;
            } // end of if
          } // end of if
        } // end of if
      } // end of if
      else {
        stelle = stelle - 1;
        if (stelle > 0) {
          merke = reihe[stelle];
          einfuegen(verf, merke);
        } // end of if
      } // end of if-else
    } while (stelle != 0 );
    if (stelle == 0) {
      System.out.println("Keine Anmeldeliste gefunden");
    } // end of if
  }
  
  static boolean gueltig(int[] verf, int[][] tutoren, int n, int t)
  {
    int stelle;
    int merke;
    int[] reihe = new int[n+2];
    //Die Verfügungsmenge wird zur Speicherung in ein weiteres Array übertragen
    int[] verfm = new int[t+1];
    for (int i = 1 ; i<t+1; i++) {
      if (verf[i] == 1) {
        verfm[i] = 1;
      } // end of if
    } // end of for
    Integer zahl = null;    
    int j;
    int k = 0;
    boolean gefunden;
    boolean geloescht;
    Integer geloeschteZahl = null;
    
    do { 
      geloescht = false;
      //Die Verfügungsmenge wird wieder aufgefüllt
      for (int i = 1; i<t+1; i++) {
        if (verfm[i] == 1) {
          verf[i] = 1;
        } // end of if
      } // end of for
      
      //Ein Termin wird gelöscht, anschließend überprüft ob allen übrigen Terminen ein Tutor zugeordnet werden kann
      do { 
        k++;
        if (verf[k] == 1) {
          loesche(verf, k);
          geloeschteZahl = k;
          geloescht = true;
        } // end of if
      } while (! geloescht && k<t );
      
      stelle = 1;
      merke = 0;
      
      do { 
        j = merke;
        
        gefunden = false;
        
        do { 
          j++;
          if (j>t) {
            break;
          } // end of if
          if (verf[j] == 1) {
            if (tutoren[stelle][j] == 1) {
              zahl = j;      
              gefunden = true;
            } // end of if
            
          } // end of if
          
        } while (gefunden == false);
        
        if (gefunden == true) {
          reihe[stelle] = zahl;       
          merke = 0;
          loesche(verf, j);
          stelle++;
          
          if (stelle > n) {
            break; 
          } // end of if
        } // end of if
        else {
          stelle = stelle - 1;
          if (stelle > 0) {
            merke = reihe[stelle];
            einfuegen(verf, merke);
          } // end of if
        } // end of if-else
      } while (stelle != 0 );
      
      if (stelle == 0) {
        return false;
      } // end of if
      else {
        einfuegen(verf, k);
      } // end of if-else
      
    } while (k<t);
    
    reihe[n+1] = geloeschteZahl;
    System.out.println();
    for (int i = 1; i<n+2; i++) {
      System.out.print("Termin "+reihe[i] + " ");
    } // end of for
    return true;
  }
  
  
  public static void main(String [] arg)
  {
    Scanner s = new Scanner(System.in);
    
    System.out.println("Anzahl Tutoren");
    int n = s.nextInt();
    System.out.println("Anzahl möglicher Termine");
    int t = s.nextInt();
    
    
    System.out.println();
    int verfuegbar;
    
    int tutoren[][] = new int[n+1][t+1];
    int termineverf[] = new int[t+1];
    
    for (int i = 1; i<n+1; i++) {
      for (int j = 1; j<t+1; j++) {
        System.out.println("Tutor " + i + " verfügbar an Termin " + j + "? (1/0)");
        verfuegbar = s.nextInt();
        System.out.println();
        if (verfuegbar == 1) {
          tutoren[i][j] = 1;
        } // end of if
        else {
          tutoren[i][j] = 0;
        } // end of if-else
        
      } // end of for
    } // end of for
    
    System.out.println("Anmeldeliste ausgeben (1) oder Anmeldeliste überprüfen (2)?");
    int auswahl = s.nextInt();
    
    switch (auswahl) {
      case 1 : 
      for (int i = 1; i<t+1; i++) {
        termineverf[i] = 1;
      } // end of for
      anmeldeliste(termineverf, n, t, tutoren);
      break;
      case 2 : 
      for (int i = 1; i<n+2; i++) {
        System.out.println("Index von Termin " + i + " der Anmeldeliste eingeben");
        termineverf[s.nextInt()] = 1;
        System.out.println();
      } // end of for
      if (gueltig(termineverf, tutoren, n, t)) {
        System.out.println("Gültige Anmeldeliste");
      } // end of if
      else {
        System.out.println("Anmeldeliste ungültig");
      } // end of if-else
      break;
      default: 
      
    } // end of switch
    
  }
}

Also grundsätzlich funktioniert es auch, wenn ich das korrekte Beispiel auf Gültigkeit überprüfe wird es richtig angezeigt, wenn ich die nicht gültige Anmeldeliste angebe wird sie auch korrekt als nicht gültig angezeigt.

Will ich aber zu dem Beispiel eine Anmeldeliste ausgeben, bekomme ich eine Fehlerhafte (Termin 1, 2, 5, 4, 6) ausgegeben. Gebe ich diese jedoch wiederum zur Überprüfung an, wird sie wieder korrekt als falsch ausgegeben.

Bei simplen Eingaben funktioniert die Ausgabe einer Anmeldeliste auch.


Vielen Dank schonmal wenn sich jemand die Zeit nimmt sich das anzuschauen ;)
 

Barista

Top Contributor
Ich habe mich mal der Aufgabe angenommen.

Dabei ist etwas unfair, dass ich schon länger Java mache,
ich würde mich als Profi bzw Senior bezeichnen.

Ich habe keine Lust Deinen monolithischen Code zu analysieren.

Also fange ich neu an.

Als erstes kommen die Datenstrukturen dran:

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

/**
 * Die Tutoren.
 * 
 * @author Heiner K&uuml;cker
 */
public enum Tutor
{
    Helge ,
    Andrea ,
    Rene ,
    Denniz ;
}

Java:
/**
 * Die möglichen Termine.
 * 
 * @author Heiner K&uuml;cker
 */
public enum Termin
{
    Di_08 ,
    Di_13 ,
    Mi_08 ,
    Mi_13 ,
    Do_08 ,
    Do_13 ;

    /**
     * @see java.lang.Enum#toString()
     */
    @Override
    public String toString()
    {
        return
                // Tag vorn abschneiden
                this.name().substring( 
                        //beginIndex
                        0 ,
                        //endIndex
                        2 ) +
                        " " +
                        // Uhrzeit hinten auffuellen
                        ( this.name().endsWith( "08" )
                            ? "08:00"
                            : "13:00" );
    }

}
 
Zuletzt bearbeitet:

Barista

Top Contributor
Nun die Tabelle mit den möglichen Terminen:

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Tabelle mit möglichen Terminen.
 * 
 * @author Heiner K&uuml;cker
 */
public final class MoeglicheTermineTabelle
{
    /**
     * innere Map mit den einzelnen Zeilen der Tabelle mögliche Termine.
     */
    private final Map<Tutor, List<Termin>> innerMap = new HashMap<>();
    
    /**
     * Konstruktor.
     * 
     * @param moeglicheTermineZeileArr varargs-Parameter mit den Tabellen-Zeilen
     */
    public MoeglicheTermineTabelle(
            final MoeglicheTermineZeile... moeglicheTermineZeileArr )
    {
        for ( MoeglicheTermineZeile moeglicheTermineZeile : moeglicheTermineZeileArr )
        {
            this.innerMap.put(
                    //key
                    moeglicheTermineZeile.tutor ,
                    //value
                    Arrays.asList(
                            moeglicheTermineZeile.terminArr ) );
        }
    }

    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString()
    {
        final StringBuilder buff = new StringBuilder();
        
        buff.append( spaces( 8 ) );
        for ( Termin termin : Termin.values() )
        {
            buff.append( "|" +  termin );
        }

        buff.append( '|' );
        buff.append( '\n' );

        for ( final Tutor tutor : Tutor.values() )
        {
            buff.append( tutor );
            buff.append( spaces( 8 - tutor.toString().length() ) );
            
            for ( Termin termin : Termin.values() )
            {
                if ( this.innerMap.get( tutor ).contains( termin ) )
                {
                    buff.append( "|     X  " );
                }
                else
                {
                    buff.append( "|        " );
                }
            }
            
            buff.append( '|' );
            buff.append( '\n' );
        }
        
        return buff.toString();
    }

    private static String spaces(
            final int spaceCount )
    {
        final StringBuilder buff = new StringBuilder();

        while ( buff.length() < spaceCount )
        {
            buff.append( ' ' );
        }

        return buff.toString();
        
    }
    
    public static void main(
            final String[] args )
    {
        final MoeglicheTermineTabelle moeglicheTermineTabelle = 
                new MoeglicheTermineTabelle(
                        new MoeglicheTermineZeile(
                                Tutor.Helge ,
                                Termin.Di_08 ,
                                Termin.Mi_08 ) ,
                        new MoeglicheTermineZeile(
                                Tutor.Andrea ,
                                Termin.Di_13 ,
                                Termin.Mi_08 ,
                                Termin.Do_08 ) ,
                        new MoeglicheTermineZeile(
                                Tutor.Rene ,
                                Termin.Di_13 ,
                                Termin.Mi_13 ,
                                Termin.Do_08 ) ,
                        new MoeglicheTermineZeile(
                                Tutor.Denniz ,
                                Termin.Mi_13 ,
                                Termin.Do_13 ) );
        
        System.out.println( moeglicheTermineTabelle );
    }
    
}

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

/**
 * Eine Zeile der möglichen Termine.
 * Hilfsklasse für den Konstruktor
 * der Klasse {@link MoeglicheTermineTabelle}.
 * 
 * @author Heiner K&uuml;cker
 */
public final class MoeglicheTermineZeile
{
    public final Tutor tutor;
    
    public final Termin[] terminArr;

    /**
     * Konstruktor.
     * 
     * @param tutor
     * @param terminArr
     */
    public MoeglicheTermineZeile(
            final Tutor tutor ,
            final Termin... terminArr )
    {
        this.tutor = tutor;
        this.terminArr = terminArr;
    }

}
 

Barista

Top Contributor
Nun die Anmeldeliste:


Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * Eine Anmeldeliste.
 * Es wird mit Unveränderlichkeit gearbeitet.
 * 
 * @author Heiner K&uuml;cker
 */
public final class Anmeldeliste
{
    private final Termin[] terminArr;

    private final Set<Termin> terminSet; 
            
    /**
     * Konstruktor.
     * 
     * @param terminArr
     */
    public Anmeldeliste(
            final Termin... terminArr )
    {
        this.terminArr = terminArr;

        this.terminSet =
                new HashSet<>(
                        Arrays.asList(
                                terminArr ) );
    }

    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString()
    {
        return Arrays.toString( this.terminArr );
    }

}
 

Barista

Top Contributor
Um zu prüfen, ob eine Anmeldeliste Termine für alle Tutoren hat wird eine Methode hasAllTutors hinzugefügt:

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * Eine Anmeldeliste.
 * Es wird mit Unveränderlichkeit gearbeitet.
 * 
 * @author Heiner K&uuml;cker
 */
public final class Anmeldeliste
{
    private final Termin[] terminArr;

    private final Set<Termin> terminSet; 
            
    /**
     * Konstruktor.
     * 
     * @param terminArr
     */
    public Anmeldeliste(
            final Termin... terminArr )
    {
        this.terminArr = terminArr;

        this.terminSet =
                new HashSet<>(
                        Arrays.asList(
                                terminArr ) );
    }

    /**
     * @param moeglicheTermineTabelle Tabelle mit möglichen Terminen der Tutoren
     * @return ob alle Tutoren der übergebenen {@link MoeglicheTermineTabelle} in dieser Anmeldeliste einen Termin haben
     */
    public boolean hasAllTutors(
            final MoeglicheTermineTabelle moeglicheTermineTabelle )
    {
        for ( final Tutor tutor : Tutor.values() )
        {
            final Collection<Termin> tutorTerminColl =
                    moeglicheTermineTabelle.getTutorTerminColl(
                            tutor );

            // Ermittlung Existenz mindestens eines Termins für den aktuellen Tutor
            // Notlösung für fehlende Methode containsMinOneOf in Java-Collections
            boolean containsTutorTerminCollOneOfThisTermin = false;

            for ( final Termin tutorTermin : tutorTerminColl )
            {
                if ( this.terminSet.contains( tutorTermin ) )
                {
                    containsTutorTerminCollOneOfThisTermin = true;
                    break;
                }
            }

            if ( ! containsTutorTerminCollOneOfThisTermin )
            {
                return false;
            }
        }
        return true;
    }


    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString()
    {
        return Arrays.toString( this.terminArr );
    }

}
 

Barista

Top Contributor
Für die Methode Anmeldeliste.hasAllTutors(MoeglicheTermineTabelle) benötigen wir in der Klasse MoeglicheTermineTabelle die Methode getTutorTerminColl:

Java:
    /**
     * @param tutor gewünschter Tutor
     * @return alle Termine des übergebenen Tutors
     */
    public Collection<Termin> getTutorTerminColl(
            final Tutor tutor )
    {
        return
                // TODO Achtung, hier fehlt die Absicherung der Unveränderlichkeit
                this.innerMap.get( tutor );
    }
 

Barista

Top Contributor
Die Methode Anmeldeliste.hasAllTutors sichern wir mit einem Unit-Test ab
(JUnit4 zum Projekt hinzufügen):

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

import static org.junit.Assert.*;
import junit.framework.Assert;

import org.junit.Test;

/**
 * JUnit4-Testcase für die Klasse {@link Anmeldeliste}.
 * 
 * @author Heiner K&uuml;cker
 */
public class AnmeldelisteTest
{
    private static final MoeglicheTermineTabelle exampleMoeglicheTermineTabelle =
            new MoeglicheTermineTabelle(
                    new MoeglicheTermineZeile(
                            Tutor.Helge ,
                            Termin.Di_08 ,
                            Termin.Mi_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Andrea ,
                            Termin.Di_13 ,
                            Termin.Mi_08 ,
                            Termin.Do_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Rene ,
                            Termin.Di_13 ,
                            Termin.Mi_13 ,
                            Termin.Do_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Denniz ,
                            Termin.Mi_13 ,
                            Termin.Do_13 ) );

    /**
     * Test method for {@link Anmeldeliste#hasAllTutors}.
     */
    @Test
    public final void testHasAllTutorsPositiv()
    {
        Assert.assertTrue(
                new Anmeldeliste(
                        Termin.values() ).hasAllTutors(
                                exampleMoeglicheTermineTabelle ) );
    }

    /**
     * Test method for {@link Anmeldeliste#hasAllTutors}.
     */
    @Test
    public final void testHasAllTutorsNegativ()
    {
        Assert.assertFalse(
                new Anmeldeliste().hasAllTutors(
                                exampleMoeglicheTermineTabelle ) );
    }

}
 

Barista

Top Contributor
Nun benötigen wir in der Klasse Anmeldeliste eine Methode isBrauchbar:

Java:
    /**
     * Prüfen, ob diese Anmeldeliste brauchbar ist,
     * also jeder Termin entfernt werden kann, ohne
     * dass die Methode {@link #hasAllTutors} nach dem
     * Entfernen <code>false</code> liefert.
     * 
     * @param moeglicheTermineTabelle Tabelle mit möglichen Terminen der Tutoren
     * @return ob brauchbar
     */
    public boolean isBrauchbar(
            final MoeglicheTermineTabelle moeglicheTermineTabelle )
    {
        if ( this.terminArr.length < 1 )
        {
            return false;
        }

        for ( Termin terminToRemove : this.terminArr )
        {
            // Anlegen Kopie für Unveränderlichkeit
            final List<Termin> thisTerminList =
                    new ArrayList<>(
                            Arrays.asList(
                                    this.terminArr ) );

            // Veränderung Kopie
            thisTerminList.remove( terminToRemove );
            
            final Anmeldeliste terminRemovedAnmeldeliste =
                    new Anmeldeliste(
                            thisTerminList.toArray(
                                    new Termin[ thisTerminList.size() ] ) );

            if ( ! terminRemovedAnmeldeliste.hasAllTutors( moeglicheTermineTabelle ) )
            {
                return false;
            }
        }

        return true;
    }

Am Beginn der Methode ist eine Abfrage, ob es überhaupt Termine in dieser Anmeldeliste gibt.

Ohne diese Abfrage wäre auch eine leer Anmeldeliste brauchbar.
 

Barista

Top Contributor
Der Unit-Test wird entsprechend erweitert:

Java:
package bundeswettbewerb_informatik_tutoren_aufgabe;

import static org.junit.Assert.*;
import junit.framework.Assert;

import org.junit.Test;

/**
 * JUnit4-Testcase für die Klasse {@link Anmeldeliste}.
 * 
 * @author Heiner K&uuml;cker
 */
public class AnmeldelisteTest
{
    private static final MoeglicheTermineTabelle exampleMoeglicheTermineTabelle =
            new MoeglicheTermineTabelle(
                    new MoeglicheTermineZeile(
                            Tutor.Helge ,
                            Termin.Di_08 ,
                            Termin.Mi_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Andrea ,
                            Termin.Di_13 ,
                            Termin.Mi_08 ,
                            Termin.Do_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Rene ,
                            Termin.Di_13 ,
                            Termin.Mi_13 ,
                            Termin.Do_08 ) ,
                    new MoeglicheTermineZeile(
                            Tutor.Denniz ,
                            Termin.Mi_13 ,
                            Termin.Do_13 ) );

    /**
     * Test method for {@link Anmeldeliste#hasAllTutors}.
     */
    @Test
    public final void testHasAllTutorsPositiv()
    {
        Assert.assertTrue(
                new Anmeldeliste(
                        Termin.values() ).hasAllTutors(
                                exampleMoeglicheTermineTabelle ) );
    }

    /**
     * Test method for {@link Anmeldeliste#hasAllTutors}.
     */
    @Test
    public final void testHasAllTutorsNegativ()
    {
        Assert.assertFalse(
                new Anmeldeliste().hasAllTutors(
                                exampleMoeglicheTermineTabelle ) );
    }

    /**
     * Test method for {@link Anmeldeliste#isBrauchbar}.
     */
    @Test
    public final void testIsBrauchbarPositiv()
    {
        Assert.assertTrue(
                new Anmeldeliste(
                        Termin.values() ).isBrauchbar(
                                exampleMoeglicheTermineTabelle ) );
    }

    /**
     * Test method for {@link Anmeldeliste#isBrauchbar}.
     */
    @Test
    public final void testIsBrauchbarNegativEmpty()
    {
        Assert.assertFalse(
                new Anmeldeliste().isBrauchbar(
                                exampleMoeglicheTermineTabelle ) );
    }

    /**
     * Test method for {@link Anmeldeliste#isBrauchbar}.
     */
    @Test
    public final void testIsBrauchbarNegativOneTermin()
    {
        Assert.assertFalse(
                new Anmeldeliste(
                        Termin.Di_08 ).isBrauchbar(
                                exampleMoeglicheTermineTabelle ) );
    }

}
 

Barista

Top Contributor
Vielen Dank für die Arbeit.

Danke, freut mich.

Wahrscheinlich habe ich die Aufgabe nicht ganz korrekt gelöst.

Ich habe keine Benutzer-Oberfläche, nicht mal für die Konsole.

Die Eingabe- Ausgabe-Formate habe ich nicht dokumentiert.

Es sollte noch mehr Testfälle geben.

Wenn Du mir eine E-Mail sendest, die Adresse findest Du auf meiner Homepage, kann ich Dir den aktuellen Stand zusenden.

Falls Du wie ich Eclipse benutzt, musst Du noch JUnit4 zuschalten:

Project -> Properties -> Java-Build-Path -> Add Library -> JUnit -> JUnit4
 

mat2089119

Mitglied
Danke, aber ich denke das ist nicht notwendig (der Wettbewerb ist ja vorbei).
Wollte eigentlich nur wissen wo mein Fehler lag, den hab ich jetzt durch deine Lösung auch gefunden, mein erster Teil funktionierte nicht richtig.
 

Barista

Top Contributor
Hast Du mal die anderen Aufgaben angesehen,
da ist noch einiges Interessantes dabei:

Vortänzer

Fotoforensik
weisst Du, wo man die Fotos runterladen kann?

Versteigerung
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
krgewb Problem mit Umlauten und Eszett bei InputStream Allgemeine Java-Themen 3
Max246Sch Backtracking Problem Box Filler Allgemeine Java-Themen 6
NightVision402 VisualVM Startskript Problem Allgemeine Java-Themen 3
javaBoon86 Email Server Connection Problem Allgemeine Java-Themen 1
F Problem mit PDFBOX Library Allgemeine Java-Themen 1
A Java modul Problem Allgemeine Java-Themen 4
D Read JSON File Problem Allgemeine Java-Themen 9
urmelausdemeis Exception in thread "main" java.lang.Error: Unresolved compilation problem: Allgemeine Java-Themen 7
J Problem mit JasperReports Allgemeine Java-Themen 8
M log4j Problem mit jlink Allgemeine Java-Themen 19
8u3631984 Problem beim Mocken von Record Klassen Allgemeine Java-Themen 4
torresbig Website login Problem - Jsoup, wie bisher, klappt nicht! Allgemeine Java-Themen 31
P Selenium . getText Problem Allgemeine Java-Themen 9
A Jar zu Exe Problem Allgemeine Java-Themen 13
sserio Variablen Liste erstellt und ein Problem mit dem Index Allgemeine Java-Themen 6
S Folgendes Problem bei einem Programm Allgemeine Java-Themen 1
stormyark Problem beim Klassen erstellen Allgemeine Java-Themen 1
A Thread.sleep Problem Allgemeine Java-Themen 2
A Problem bei der Nachbarschafttest Allgemeine Java-Themen 11
Splayfer Problem: no main manifest attribute Allgemeine Java-Themen 3
G javamail Problem beim Empfangen von Nachrichten Allgemeine Java-Themen 3
Splayfer JDA Problem mit MessageCounter Allgemeine Java-Themen 0
Splayfer Problem mit BufferedWriter Allgemeine Java-Themen 3
F Streams als Alternative für dieses Problem ? Allgemeine Java-Themen 15
N Maven Problem mit Datenbanktreiber (H2 Embedded) Allgemeine Java-Themen 12
T Problem beim Umwandeln in eine Jar-Datei Allgemeine Java-Themen 3
B Einfach Elemente zweier Arraylisten kreuz und quer vergleichen, min und max Problem? Allgemeine Java-Themen 16
C ArrayList Problem Allgemeine Java-Themen 3
kev34 nim-Spiel problem Allgemeine Java-Themen 1
D Firebase retrieve data Problem, Child Element wird nicht angesprochen Allgemeine Java-Themen 0
G Welches Problem besteht bei den Typparametern? Allgemeine Java-Themen 5
temi Problem mit Aufrufreihenfolge bei Vererbung Allgemeine Java-Themen 3
Sumo_ow "ArrayIndexOutofBoundsException: 2" Array Problem Allgemeine Java-Themen 6
T PIM basierend auf netbeans via AnyDesk Problem Allgemeine Java-Themen 3
xGh0st2014 Problem mit Java Array Allgemeine Java-Themen 1
Kirby.exe Verständnis Problem bei Rucksack Problem Allgemeine Java-Themen 6
B Eclipse-Lombok-Problem Allgemeine Java-Themen 19
I Input/Output ObjectOutputStream - Problem Allgemeine Java-Themen 7
1 Multiple Choice Knapsack- Problem Allgemeine Java-Themen 2
kodela Problem mit strukturiertem Array Allgemeine Java-Themen 18
E Problem mit Gridlayout und Button Allgemeine Java-Themen 2
A Array Problem Allgemeine Java-Themen 8
bueseb84 Problem Allgemeine Java-Themen 0
S Problem mit Arrays Allgemeine Java-Themen 1
D Nullpointer Exception Problem Allgemeine Java-Themen 5
B Problem mit meinen Klassen Allgemeine Java-Themen 6
A HashMap Methode "get()"-Problem Allgemeine Java-Themen 28
J Problem beim Umstellen auf Java jdk 13 Allgemeine Java-Themen 3
J Problem bei Install java 13 Allgemeine Java-Themen 3
X Profitable Reise Problem Allgemeine Java-Themen 32
A Problem beim öffnen von Java-Installern Allgemeine Java-Themen 1
Dann07 Problem mit JavaMail API Allgemeine Java-Themen 26
J Problem beim Generischen Klassen und Interfaces Allgemeine Java-Themen 2
L Klassen Algorithmus für das folgende Problem entwickeln? Allgemeine Java-Themen 30
J Clear-Problem Allgemeine Java-Themen 10
B Problem zu einem Java Projekt Allgemeine Java-Themen 6
S JFileChooser Problem Allgemeine Java-Themen 4
M Traveling Salesman - MST Heuristik Problem Allgemeine Java-Themen 4
J Traveling Salesman Problem Allgemeine Java-Themen 14
E Java Editor Problem mit 2er Exceptions Allgemeine Java-Themen 12
C code oder Bibliotheken für 2-Center Problem Allgemeine Java-Themen 4
M Salesman Problem - Bruteforce Algorithmus Allgemeine Java-Themen 23
S Methoden Problem mit NullPointerException Allgemeine Java-Themen 9
Javafan02 Problem mit if-clause Allgemeine Java-Themen 17
J Lombok Problem mit Konstruktoren bei Verberbung Allgemeine Java-Themen 1
kodela Event Handling Problem mit der Alt-Taste Allgemeine Java-Themen 16
W Threads Problem Allgemeine Java-Themen 15
D (Verständnis-)Problem mit Unterklasse Allgemeine Java-Themen 4
S Problem mit Generic bei unmodifiableCollection Allgemeine Java-Themen 4
S jserialcomm Problem Allgemeine Java-Themen 1
Flynn Thread-Problem... Allgemeine Java-Themen 2
J Generische Interface - Problem Allgemeine Java-Themen 3
G Problem beim GUI Allgemeine Java-Themen 9
L Applet Problem "security: Trusted libraries list file not found" ? Allgemeine Java-Themen 7
A OOP Problem beim Berechnen der größten Fläche eines Ringes Allgemeine Java-Themen 19
T Problem mit externen Datenbankzugriff über SSH Tunnel Allgemeine Java-Themen 4
F Problem beim Einlesen einer Textdatei Allgemeine Java-Themen 12
S Java OpenOffice Problem mit Windows-Benutzerwechsel Allgemeine Java-Themen 19
K Threads RAM Problem Allgemeine Java-Themen 20
P Operatoren Problem mit Zähler in recursiver Schleife Allgemeine Java-Themen 2
C Int Problem Allgemeine Java-Themen 8
C J2V8 NodeJs Java Bride Problem und Frage!?!? Allgemeine Java-Themen 1
J Problem bei Hashmap Key-Abfrage Allgemeine Java-Themen 4
C Webseiten Programm problem Allgemeine Java-Themen 5
M LocalDate Problem Allgemeine Java-Themen 4
J "Problem Objektorientierung" Allgemeine Java-Themen 20
geekex Problem Meldung! Was tun?! Allgemeine Java-Themen 19
T Klassen Override Problem Allgemeine Java-Themen 7
L Unbekanntes Problem Allgemeine Java-Themen 1
FrittenFritze Problem mit einer JComboBox, Event temporär deaktivieren Allgemeine Java-Themen 11
Blender3D Java Swing Programm Windows 10 Autostart Problem Allgemeine Java-Themen 2
F HTTPS Zertifikat Problem Allgemeine Java-Themen 3
M OpenCV KNearest Problem Allgemeine Java-Themen 0
Tommy Nightmare Project Euler: Problem 22 Allgemeine Java-Themen 2
C Abstrakte Klasse, lokale Variable-Problem Allgemeine Java-Themen 1
N Vererbung Design-Problem mit vorhandenen, von der Klasse unabhängigen Methoden Allgemeine Java-Themen 12
P Eclipse Projekt anlegen macht Problem Allgemeine Java-Themen 1
RalleYTN META-INF/services Problem Allgemeine Java-Themen 3
F Java Mail Problem: Authentifizierung wird nicht immer mitgeschickt Allgemeine Java-Themen 1
I Problem beim Aufrufen, von Objektmethoden/ -variablen Allgemeine Java-Themen 6

Ähnliche Java Themen

Neue Themen


Oben