Methoden 1x1 Tabelle bis 20 mit der While-Schleife programmieren

[Max Mustermannnn]

Hallo,

ich muss von der Schule aus eine 1x1 Tabelle erstellen.
Komme aber nicht mehr weiter..
Mein bisheriges Programm:

public static void main(String[] args) {
   // TODO code application logic here
   int zaehler1 = 1;
   int zaehler2 = 1;

   while(zaehler1 <20) {
     while (zaehler2 <20) {
       zaehler1 = zaehler1 +1;
       {
         zaehler2 = zaehler2 +1;
         System.out.print(zaehler1*zaehler2);
         {
           System.out.println();
         }
       }
     }
   }
}

Ich kann es leider nicht als Dateinanhang hochladen..

 

[Joose]

Ich kann es leider nicht als Dateinanhang hochladen..

Dass ist auch kein Problem. Code bitte immer in Code-Tags posten!
=> [code=java] /* dein code */ [/code]

Habe es bei deinem Post geändert.

ich muss von der Schule aus eine 1x1 Tabelle erstellen.
Komme aber nicht mehr weiter..

Heißt genau was? Wo liegt das Problem? Was läuft nicht so wie erwartet?
Was soll die Ausgabe sein? Was ist die aktuell?
Eine genauer Problem-/Fehlerbeschreibung könnte man liefern

 

[Max Mustermannnn]

Dass ist auch kein Problem. Code bitte immer in Code-Tags posten!
=> [code=java] /* dein code */ [/code]

Habe es bei deinem Post geändert.



Heißt genau was? Wo liegt das Problem? Was läuft nicht so wie erwartet?
Was soll die Ausgabe sein? Was ist die aktuell?
Eine genauer Problem-/Fehlerbeschreibung könnte man liefern

Also meine Aufgabe lautet: "Es soll eine Tabelle erstellt werden, die in der ersten Zeile (Kopfzeile) und der ersten Spalte (Kopfspalte) jeweils die Zahlen 1 bis 20 enthält und in der so entstandenen Matrix das Produkt aus der Zahl in der Kopfzeile und Kopfspalte.
Entwickle einen Algorithmus mit Hilfe von Schleifen, um diese Tabelle zu erstellen.
Es empfiehlt sich zwei Schleifen in eineinander zu verschachteln. Die äußere ist für die Zeilen zuständig, die innere für die Werte der einzelnen Spalten."

Bei meinem jetzigen Programm gibt es bis jetzt nur die 1. Spalte aus.

 

[Joose]

Bei meinem jetzigen Programm gibt es bis jetzt nur die 1. Spalte aus.

Ja weil du es auch so programmiert hast

Das Problem an deinem jetztigen Programm:

1) Du erhöhst beide Zählervariablen (zaehler1 und zaehler2) in der inneren Schleife -> falsch. Je Schleife sollte eine Zählervariable erhöht werden.
2) In der inneren Schleife erzeugst du immer einen Zeilenumbruch mit "System.out.println()". Diesen willst du aber erst wenn die Zeile komplett geschrieben wurde -> daher diesen Code aus der inneren Schleife raus in die äußere

 

[Max Mustermannnn]

Ja weil du es auch so programmiert hast

Das Problem an deinem jetztigen Programm:

1) Du erhöhst beide Zählervariablen (zaehler1 und zaehler2) in der inneren Schleife -> falsch. Je Schleife sollte eine Zählervariable erhöht werden.
2) In der inneren Schleife erzeugst du immer einen Zeilenumbruch mit "System.out.println()". Diesen willst du aber erst wenn die Zeile komplett geschrieben wurde -> daher diesen Code aus der inneren Schleife raus in die äußere

Wie meinst du das mit "Je Schleife sollte eine Zählervariable erhöht werden"?
Und ist das "System.out.print()" nicht schon in der äußeren Schleife?

Sry wegen der blöden Fragen, bin noch kompletter Anfänger..

 

[Joose]

Wie meinst du das mit "Je Schleife sollte eine Zählervariable erhöht werden"?

Du hast 2 while-Schleifen.
In der äußeren prüfst du ob zaehler1 kleiner 20 ist, in der inneren prüfst du ob zaehler2 kleiner 20 ist.
Die beiden Zähler erhöhst du BEIDE in der inneren Schleife, daher hat die äußere Schleife aktuell gar keinen Sinn.

Und ist das "System.out.print()" nicht schon in der äußeren Schleife?

Nein ist es nicht.
http://wikis.zum.de/zum/Java/while-Schleife

while(Schleifenbedinung) {
   Schleifeninhalt - Anweisungsblock
}

Eine while-Schleife hat einen Schleifenkopf welcher die Abbruchbedingung beinhaltet.
In den darauffolgenden { } - Klammern stehen Anweisungen. Diese werden bei jedem Schleifendurchlauf durchgeführt.

Schau dir deinen Code nochmals genau an und überlege was zur äußeren Schleife und was zur inneren gehört.
Ich habe den Code in deinem 1.Post entsprechend formatiert, damit sollte es eigentlich sofort ersichtlich sein.

Sry wegen der blöden Fragen, bin noch kompletter Anfänger..

Dann sollstest du dir nochmal die Grundlagen zu Schleifen anschauen. Vor allem wenn du nicht sicher bist was ist nun Teil von welcher Schleife!

Ansonsten versuche nicht das ganze Problem auf einmal zu lösen sondern Versuche es in einzelne Schritte aufzuteilen.
Versuche am Anfang mal nur eine Zeile des 1x1 rauszuschreiben (ohne Kopfzeile und Kopfspalte). Und das auch nicht gleich bis 20 sondern es reicht bis 5.
Der Vorteil: Du hast kleine Teilerfolge was die weiter motivieren sollte, du verstehst deinen Code besser und solltest leichter erkennen welche Änderung am Code was für Auswirkungen hat.

Wenn du dann mal einen Code hast lass ihn einfach laufen und teste ihn, falls er nicht das gewünschte Ergebnis bringt verwende entweder den Debugger um deinen Code Schritt für Schritt zu verfolgen oder mach einen einfachen SST von deinem Code damit du siehst wo dein Fehler liegt.

 

[Max Mustermannnn]

Du hast 2 while-Schleifen.
In der äußeren prüfst du ob zaehler1 kleiner 20 ist, in der inneren prüfst du ob zaehler2 kleiner 20 ist.
Die beiden Zähler erhöhst du BEIDE in der inneren Schleife, daher hat die äußere Schleife aktuell gar keinen Sinn.


Nein ist es nicht.
http://wikis.zum.de/zum/Java/while-Schleife

while(Schleifenbedinung) {
   Schleifeninhalt - Anweisungsblock
}

Eine while-Schleife hat einen Schleifenkopf welcher die Abbruchbedingung beinhaltet.
In den darauffolgenden { } - Klammern stehen Anweisungen. Diese werden bei jedem Schleifendurchlauf durchgeführt.

Schau dir deinen Code nochmals genau an und überlege was zur äußeren Schleife und was zur inneren gehört.
Ich habe den Code in deinem 1.Post entsprechend formatiert, damit sollte es eigentlich sofort ersichtlich sein.


Dann sollstest du dir nochmal die Grundlagen zu Schleifen anschauen. Vor allem wenn du nicht sicher bist was ist nun Teil von welcher Schleife!

Ansonsten versuche nicht das ganze Problem auf einmal zu lösen sondern Versuche es in einzelne Schritte aufzuteilen.
Versuche am Anfang mal nur eine Zeile des 1x1 rauszuschreiben (ohne Kopfzeile und Kopfspalte). Und das auch nicht gleich bis 20 sondern es reicht bis 5.
Der Vorteil: Du hast kleine Teilerfolge was die weiter motivieren sollte, du verstehst deinen Code besser und solltest leichter erkennen welche Änderung am Code was für Auswirkungen hat.

Wenn du dann mal einen Code hast lass ihn einfach laufen und teste ihn, falls er nicht das gewünschte Ergebnis bringt verwende entweder den Debugger um deinen Code Schritt für Schritt zu verfolgen oder mach einen einfachen SST von deinem Code damit du siehst wo dein Fehler liegt.

Hab jetzt verstanden, wies gemeint war.

Jetzt sieht es so aus:

 /*
 public static void main(String[] args) {
        // TODO code application logic here
        int zaehler1 = 0;
        int zaehler2 = 0;
       
        while(zaehler1 <20) 
           
          {
             
                zaehler1 = zaehler1 +1;
             
               
                    while (zaehler2 <20)
             
            {
                 zaehler2 = zaehler2 +1;
               
                 System.out.print("  "+zaehler1*zaehler2);
              }
           
        System.out.println();
      }
    }
}
 */

Funktioniert aber immer noch nicht.

 

[thecain]

Ist ja auch alles auskommentiert?

 

[strußi]

was du wahrscheinlich brauchst ist ein Array( int[][] matrix =new int[ 2][ 20]
//befüllen der Kopfzeile
for( int i =0; i <maxtrix.length; i++){
matrix[0][ i] =i+1;
}
matrix[ 1][ 0] =matrix[ 0][0];
//berechnen des Produktes (Produkt =Multiplikation)
for( ...){
matrix.... *= matrix....;
}
.... =Eigenleistung

 

[thecain]

wieso ein array? und wieso nur 2*20 wenn er eine 20*20 tabelle erstellen soll?

so wie ichs verstanden habe muss er einfach diese:

0    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15    16    17    18    19    20   
1    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15    16    17    18    19    20
2    2    4    6    8    10    12    14    16    18    20    22    24    26    28    30    32    34    36    38    40
3    3    6    9    12    15    18    21    24    27    30    33    36    39    42    45    48    51    54    57    60
4    4    8    12    16    20    24    28    32    36    40    44    48    52    56    60    64    68    72    76    80
5    5    10    15    20    25    30    35    40    45    50    55    60    65    70    75    80    85    90    95    100
6    6    12    18    24    30    36    42    48    54    60    66    72    78    84    90    96    102    108    114    120
7    7    14    21    28    35    42    49    56    63    70    77    84    91    98    105    112    119    126    133    140
8    8    16    24    32    40    48    56    64    72    80    88    96    104    112    120    128    136    144    152    160
9    9    18    27    36    45    54    63    72    81    90    99    108    117    126    135    144    153    162    171    180
10    10    20    30    40    50    60    70    80    90    100    110    120    130    140    150    160    170    180    190    200
11    11    22    33    44    55    66    77    88    99    110    121    132    143    154    165    176    187    198    209    220
12    12    24    36    48    60    72    84    96    108    120    132    144    156    168    180    192    204    216    228    240
13    13    26    39    52    65    78    91    104    117    130    143    156    169    182    195    208    221    234    247    260
14    14    28    42    56    70    84    98    112    126    140    154    168    182    196    210    224    238    252    266    280
15    15    30    45    60    75    90    105    120    135    150    165    180    195    210    225    240    255    270    285    300
16    16    32    48    64    80    96    112    128    144    160    176    192    208    224    240    256    272    288    304    320
17    17    34    51    68    85    102    119    136    153    170    187    204    221    238    255    272    289    306    323    340
18    18    36    54    72    90    108    126    144    162    180    198    216    234    252    270    288    306    324    342    360
19    19    38    57    76    95    114    133    152    171    190    209    228    247    266    285    304    323    342    361    380
20    20    40    60    80    100    120    140    160    180    200    220    240    260    280    300    320    340    360    380    400

ausgabe haben

 

[Max Mustermannnn]

wieso ein array? und wieso nur 2*20 wenn er eine 20*20 tabelle erstellen soll?

so wie ichs verstanden habe muss er einfach diese:

0    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15    16    17    18    19    20  
1    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15    16    17    18    19    20
2    2    4    6    8    10    12    14    16    18    20    22    24    26    28    30    32    34    36    38    40
3    3    6    9    12    15    18    21    24    27    30    33    36    39    42    45    48    51    54    57    60
4    4    8    12    16    20    24    28    32    36    40    44    48    52    56    60    64    68    72    76    80
5    5    10    15    20    25    30    35    40    45    50    55    60    65    70    75    80    85    90    95    100
6    6    12    18    24    30    36    42    48    54    60    66    72    78    84    90    96    102    108    114    120
7    7    14    21    28    35    42    49    56    63    70    77    84    91    98    105    112    119    126    133    140
8    8    16    24    32    40    48    56    64    72    80    88    96    104    112    120    128    136    144    152    160
9    9    18    27    36    45    54    63    72    81    90    99    108    117    126    135    144    153    162    171    180
10    10    20    30    40    50    60    70    80    90    100    110    120    130    140    150    160    170    180    190    200
11    11    22    33    44    55    66    77    88    99    110    121    132    143    154    165    176    187    198    209    220
12    12    24    36    48    60    72    84    96    108    120    132    144    156    168    180    192    204    216    228    240
13    13    26    39    52    65    78    91    104    117    130    143    156    169    182    195    208    221    234    247    260
14    14    28    42    56    70    84    98    112    126    140    154    168    182    196    210    224    238    252    266    280
15    15    30    45    60    75    90    105    120    135    150    165    180    195    210    225    240    255    270    285    300
16    16    32    48    64    80    96    112    128    144    160    176    192    208    224    240    256    272    288    304    320
17    17    34    51    68    85    102    119    136    153    170    187    204    221    238    255    272    289    306    323    340
18    18    36    54    72    90    108    126    144    162    180    198    216    234    252    270    288    306    324    342    360
19    19    38    57    76    95    114    133    152    171    190    209    228    247    266    285    304    323    342    361    380
20    20    40    60    80    100    120    140    160    180    200    220    240    260    280    300    320    340    360    380    400

ausgabe haben

Ja, genau, diese Aufgabe sollte sein.

 

[Max Mustermannnn]

Ja, genau, diese Ausgabe sollte sein.

 

[strußi]

sry, dann habe ich etwas falsch verstanden. aber eure Ausgabe ist für eine 21x21 weil ich glaube gelesen zu haben Zahlen 1 bis 20
dann schachtel die for-schleifen und alles wird gut ;-) zähler beginnt bei 0 werte bei 1

 

[Max Mustermannnn]

sry, dann habe ich etwas falsch verstanden. aber eure Ausgabe ist für eine 21x21 weil ich glaube gelesen zu haben Zahlen 1 bis 20
dann schachtel die for-schleifen und alles wird gut ;-) zähler beginnt bei 0 werte bei 1

Müsste es eben mit While-Schleifen machen, da wir die For-Schleife in der Schule noch nicht gelernt haben..

Habs jetzt aber geschaft:

  public static void main(String[] args) {
        // TODO code application logic here
        int zaehler1 = 0;
        int zaehler2 = 0;
       
        while(zaehler1 <20) 
           
          {
             
                zaehler1 = zaehler1 +1;
             
                zaehler2 = 0;
                    while (zaehler2 <20)
             
            {
                 zaehler2 = zaehler2 +1;
               
                 System.out.print("  "+zaehler1*zaehler2);
                 
               
              }
                   
           
        System.out.println();
      }
    }
}

Jetzt fehlt nur noch der richtige Abstand zwischen den Zahlen, damit sie schön angeordnet sind, hat da jemand eine Idee, wie das funktioniert?

 

[strußi]

String.format( parameter1, parameter2 );
http://openbook.rheinwerk-verlag.de...tml#dodtp502391df-4eac-4eb6-a246-312c07a323f4

solltest du schenll hinbekommen

bitte achte ein wenig auf deine Formatierung des Codes. So ist er etwas besser lesbar

public static void test(){
        int zaehler1 = 0;
        int zaehler2;
      
        while(zaehler1 <20){            
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
           
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
            }
            System.out.println();
        }
    }

 

[Max Mustermannnn]

String.format( parameter1, parameter2 );
http://openbook.rheinwerk-verlag.de...tml#dodtp502391df-4eac-4eb6-a246-312c07a323f4

solltest du schenll hinbekommen

bitte achte ein wenig auf deine Formatierung des Codes. So ist er etwas besser lesbar

public static void test(){
        int zaehler1 = 0;
        int zaehler2;
     
        while(zaehler1 <20){           
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
          
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
            }
            System.out.println();
        }
    }

Danke, aber check jetzt trotzdem noch nicht wie ich das mit den richtigen Abständen zwischen Zahlen machen kann.

Find ich das unter den Punkt "Positionsangaben" oder?

 

[strußi]

hast du dir den link angeschaut? da sind sogar beispiele wie man das macht ;-) Etwas Eigeninitiative

 

[Max Mustermannnn]

hast du dir den link angeschaut? da sind sogar beispiele wie man das macht ;-) Etwas Eigeninitiative

Ja, hab ich, geht das in die richtige Richtung?

public static void main(String[] args) {
        int zaehler1 = 0;
        int zaehler2;
    
        while(zaehler1 <20){           
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
          
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
              
                String.format(zaehler1 zaehler2 <10); System.out.print(" ");
              
              
              
            }
            System.out.println();
        }
    }
}

 

[strußi]

leider nicht
du kannst dem sysOut den formatierten String mitgeben (schachteln).
String formatierterString =String.format( formatierung, parameter);
für die Formatierung musst du noch mal auf der genannten Seite suchen, den Parameter findest du sicher herraus. ;-)

 

[Max Mustermannnn]

leider nicht
du kannst dem sysOut den formatierten String mitgeben (schachteln).
String formatierterString =String.format( formatierung, parameter);
für die Formatierung musst du noch mal auf der genannten Seite suchen, den Parameter findest du sicher herraus. ;-)

Hää, ich versteh 0^^

Wie meinst du das mit dem formatierten String?

 

[strußi]

link die Grafik unter 4.26
System.out.print( formatierterString); oder System.out.print( String.format( WieSollDieAusgabeAussehen, WasWirdAusgegeben));

Wenn die der erste link nicht zusagt, kannst du die klinische api nutzen
http://docs.oracle.com/javase/8/doc...#format-java.lang.String-java.lang.Object...-

näher an eine Lösung kann ich dich nicht bringen, ohne deine Eigeninitiative weiter zu gefährden. :-(

 

[Max Mustermannnn]

Habs jetzt so geschafft:

public static void main(String[] args) {
        int zaehler1 = 0;
        int zaehler2;
    
        while(zaehler1 <20){           
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
          
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
              
                    if (zaehler1*zaehler2 <10) System.out.print(" ");
                    if (zaehler1*zaehler2 <100) System.out.print(" ");
            }
            System.out.println();
        }
    }
}

Aber mich würde interessieren, wie es anders möglich ist.

Könntest du da ein Beispiel machen?

Und stimmt die Formatierung so, oder kann man die noch übersichtlicher machen?

 

[strußi]

kann man so machen, ist aber fürs lesen etwas unglücklich, weil Einer- über den Zehnerwerten bzw. HunderterWerten stehen.
http://openbook.rheinwerk-verlag.de...tml#dodtpc2c16909-1067-42cb-b079-f9644c983574
schau dir die Grafik unterhalb des Textes von Listing 4.26 an.
Ich kann ein Beispiel machen, aber dann ist deine EIGENINITIATIVE und der AHA-Effekt vom finden der Lösung weg. Ich Stoße dich mit der Angabe des Links und der genauen Stelle schon direkt auf die Lösung.

Anschauen, überlegen wie es funktioniert, testen ->AHA-Effekt ;-)

 

[Max Mustermannnn]

kann man so machen, ist aber fürs lesen etwas unglücklich, weil Einer- über den Zehnerwerten bzw. HunderterWerten stehen.
http://openbook.rheinwerk-verlag.de...tml#dodtpc2c16909-1067-42cb-b079-f9644c983574
schau dir die Grafik unterhalb des Textes von Listing 4.26 an.
Ich kann ein Beispiel machen, aber dann ist deine EIGENINITIATIVE und der AHA-Effekt vom finden der Lösung weg. Ich Stoße dich mit der Angabe des Links und der genauen Stelle schon direkt auf die Lösung.

Anschauen, überlegen wie es funktioniert, testen ->AHA-Effekt ;-)

Ja, stimmt, ist mir gerade erst jetzt aufgefallen.

Bei der Grafik 4.26 müsste ich anhand des 1. Absatzes die Lösung herausfinden, oder?

Und wo muss ich die Ausgabe hinschreiben, in die 1. Schleife, 2. oder ist es egal, wohin ich es schreibe?

 

[Max Mustermannnn]

 public static void main(String[] args) {
        int zaehler1 = 0;
        int zaehler2;
     
        while(zaehler1 <20){            
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
           
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
                System.out.printf("%n", +zaehler1, zaehler2);
               
            }                  
            System.out.println();
        }  
    }
}

Geht das in die richtige Richtung?

Jetzt gibt es aber alles untereinander aus und ich versteh nicht wieso.

 

[Max Mustermannnn]

Habs jetzt so:

 public static void main(String[] args) {
        int zaehler1 = 0;
        int zaehler2 = 0;
     
        while(zaehler1 <20){            
            zaehler1 = zaehler1 +1;
            zaehler2 = 0;
           
            while (zaehler2 <20){
                zaehler2 = zaehler2 +1;
                System.out.print("  "+zaehler1*zaehler2);
               
               
            }      
            System.out.println();
            System.out.printf("%n", zaehler1, zaehler2);
           
        }  
    } 
}

Das verändert aber nur den Abstand zwischen den einzelnen Zeilen...

Ich versteh nicht wie das gehen soll, dass es ab bestimmten Zahlen den Abstand verändert.

Bräuchte noch nen Tipp, muss das Programm bis spätestens 22.00 Uhr fertig haben.

 

[Max Mustermannnn]

Ich habs!

public static void main(String[] args) {
        int zaehler1 = 0;
        int zaehler2;
        int a;
        int b;

        String eingabea = JOptionPane.showInputDialog(null,
                "Bitte erste Zahl eingeben");
        a = Integer.parseInt(eingabea);

        String eingabeb = JOptionPane.showInputDialog(null,
                "Bitte zweite Zahl eingeben");
        b = Integer.parseInt(eingabeb);

        while (zaehler1 < a) {
            zaehler1 = zaehler1 + 1;
            zaehler2 = 0;

            while (zaehler2 < b) {
                zaehler2 = zaehler2 + 1;
                System.out.printf("%3d \t", zaehler1 * zaehler2);

            }
            System.out.println();

        }
    }
}

Stimmt so, oder?

 

[strußi]

Jetzt hast du eine Lerneffekt, das freut mich für dich.
Das ist eine Möglichkeit die Ausgabe zu machen

ich habe das so gemacht

public static void nice(){
        int valR =1, valC =1;
        int cR =0, cC =0;
        while( cR <20){
            while( cC <20){
                System.out.print( String.format( "%5d", valR*valC));
                valC++;
                cC++;
            }
            cC =0;   cR++;
            valC =1; valR++;
            System.out.println( "");
        }
    }

 

[Max Mustermannnn]

Wie kann man diesen Schritt mit einfachen Worten erklären, was da genau passiert und wieso da ...printf kommt und nicht normal print

System.out.printf("%3d \t", zaehler1 * zaehler2);

 

[kneitzel]

printf ist halt eine andere Funktion. printf bietet im Gegensatz zu print andere Möglichkeiten. Wenn man den genauen Unterschied wissen will, dann schaut man in die Referenz - die Klassen der Library sind alle genau dokumentiert und diese Dokumentation nutzt man am Besten.
https://docs.oracle.com/javase/8/docs/api/

Ansonsten wurdest Du ja schon auf Seiten geschickt, in dem die Formatierung erklärt wurde, somit sollte klar sein, was dieses "%3d \t" bedeutet.
Aber noch ein paar Links diesbezüglich:

Formatierung von Zahlen: https://docs.oracle.com/javase/tutorial/java/data/numberformat.html
Spezielle Zeichen (z.B. \t): https://docs.oracle.com/javase/tutorial/java/data/characters.html

Konrad

 

[Max Mustermannnn]

Also kann ich es so sagen: Die Zeile bewirkt das nach jedem Produkt von zaehler1 zaehler2 ein Tab gesetzt wird der in diesem Fall 3 Stellen lang ist.

Stimmt das so?

 

[kneitzel]

Nein. %3d und \t sind in der Zeichenkette vom printf getrennt zu sehen. %3d gibt an, dass eine Zahl mit 3 Stellen angezeigt werden soll. Das sorgt für ggf. notwendige Leerzeichen. Also ergibt es sowas wie " 1" (bei der Zahl 1) oder "123" (Bei der Zahl 123). Dann kommt ein Leerzeichen (Das ist ja dazwischen). Dann kommt ein Tab-Zeichen.

Das ganze könnte man bei der Ausgabe in eine Datei z.B. mit einem Hex-Editor verifizieren, so Du das machen möchtest.

Konrad

 

[Max Mustermannnn]

Nein. %3d und \t sind in der Zeichenkette vom printf getrennt zu sehen. %3d gibt an, dass eine Zahl mit 3 Stellen angezeigt werden soll. Das sorgt für ggf. notwendige Leerzeichen. Also ergibt es sowas wie " 1" (bei der Zahl 1) oder "123" (Bei der Zahl 123). Dann kommt ein Leerzeichen (Das ist ja dazwischen). Dann kommt ein Tab-Zeichen.

Das ganze könnte man bei der Ausgabe in eine Datei z.B. mit einem Hex-Editor verifizieren, so Du das machen möchtest.

Konrad

Das kann ja nicht sein, denn wenn ich "%8d" schreibe, ist der Abstand zwischen den einzelnen Spalten viel größer.

Und noch ne Frage. Wieso muss ich in der innere Schleife nochmal "zaehler2 = 0;" schreiben?

Denn wenn ich das weck lasse, gibt es nur die 1. Zeile aus. Also die Zahlen von 1-20.

 

[kneitzel]

??? Wenn %3d sagt, dass etwas mit 3 Stellen geschrieben werden soll, dann sagt %8d, dass es 8 Stellen sein sollen. Und wenn das Füllen mit Leerzeichen gemacht wird, dann passiert nun was? Die Abstände werden größer. Wo siehst Du hier den Widerspruch?

Und wenn Du zaehler2 nicht auf 0 setzt, dann bleibt zaehler2 auf dem wert von b und damit wird die innere while-Schleife nur noch ein einziges Mal ausgeführt.

Konrad

 

[kneitzel]

Evtl. wirst Du verwirrt durch den Tabulator. Die Anzeige ist normalerweise so, dass damit immer zu einer Spalte gesprungen wird. Vielleicht wird das Verhalten deutlich, wenn wir vor, zwischen und nach den einzelnen Elementen ein | schreiben und dann einmal verschiedene Breiten ausprobieren:

System.out.printf("|%d|\t|\n", 1);
System.out.printf("|%1d|\t|\n", 1);
System.out.printf("|%2d|\t|\n", 1);
System.out.printf("|%3d|\t|\n", 1);
System.out.printf("|%4d|\t|\n", 1);
System.out.printf("|%5d|\t|\n", 1);
System.out.printf("|%6d|\t|\n", 1);
System.out.printf("|%7d|\t|\n", 1);
System.out.printf("|%8d|\t|\n", 1);

Dann wird evtl. sowas gezeigt:

|1| |
|1| |
| 1|    |
|  1|   |
|   1|  |
|    1| |
|     1|    |
|      1|   |
|       1|  |

(Ist jetzt etwas getrickst, denn beim copy&paste macht er aus dem Tab immer genau 4 Leerzeichen. Aber bei meiner Ausgabe ist da halt ein Tab und der erzeugt halt auch eine Art saubere Spalte.)

Konrad

 

[Max Mustermannnn]

Ja, das mit den "%3d" ist mir jetzt klar, aber für was ist das "/t" gut und das mit dem "zaehler2 = 0;" ist mir auch noch nicht ganz klar.

public static void main(String[] args) {
    int zaehler1 = 0;
    int zaehler2 = 0;
//   int a;
//   int b;

/*   String eingabea = JOptionPane.showInputDialog(
        null, "Bitte erste Zahl eingeben");
    a = Integer.parseInt(eingabea); */
  
   /* String eingabeb = JOptionPane.showInputDialog(
        null, "Bitte zweite Zahl eingeben");
    b = Integer.parseInt(eingabeb); */

    while(zaehler1 < 20){                                        // äußere Schleife
        zaehler1 = zaehler1 + 1;
       // zaehler2 = 0;
      
      
        while (zaehler2 < 20) {                                  // innere Schleife
            zaehler2 = zaehler2 + 1;
            System.out.printf("%3d \t", zaehler1 * zaehler2);   //
        }                                   
        System.out.println();                                 
    }
}
}

Also wenn das mit dem "zaehler2 = 0;" nicht wäre, müsste es ja theoretisch immer 1x1, 2x2, 3x3 usw.. zusammenzählen, bis es bei 20 ist und dann wäre fertig.

Check jetzt grad auch nicht, wie es ohne den "zaehler2 = 0;" auf 1,2,3,4...20 kommt.

 

[kneitzel]

Du kannst es doch einfach auf einem Blatt Papier durchspiele:
- Du nimmst zwei Blatt Papier, eines für Deine Variablen und eines für die Ausgabe.
- Nun geht es los. zaehler1 wird definiert und auf 0 gesetzt, also zaehler1: 0 schreiben auf Blatt 1
- nun kommt zaehler2 - also unter zaehler1 kommt nun zaehler2: 0
- Nun sind wir bei while (zaehler1 < 20) - wir schauen auf zaehler1 und da steht 0 - also 0<20: Ok, wir gehen in die while schleife rein.
- zaehler1 wird um 1 erhöht, also 0 streichen und 1 hinschreiben.
- nun kommt die zweite while scleife - wie oben schauen wir nach und ja - wird ausgeführt.
- nun erhöhen wir zaehler2 - 0 streichen und 1 hinschreiben.
- Nun kommt eine Ausgabe - die schreiben wir einfach auf das andere Blatt (oder da wir wenig Variablen haben einfach auf die untere Hälfte des ersten Blattes)
Das machst Du jetzt einfach weiter. Siehst Du was passiert und warum es passiert?

Konrad

 

[VfL_Freak]

Moin,

noch ein kleiner Tipp zur Übersichtlichkeit! Statt:

zaehler1 = zaehler1 + 1;

kannst Du auch kürzer

zaehler1 += n;  // n = beliebige Schrittweite

schreiben - oder, wenn es immer genau '1' sein soll, einfach mit PostInkrement

zaehler1++;

Gruß Klaus

 

[Max Mustermannnn]

Du kannst es doch einfach auf einem Blatt Papier durchspiele:
- Du nimmst zwei Blatt Papier, eines für Deine Variablen und eines für die Ausgabe.
- Nun geht es los. zaehler1 wird definiert und auf 0 gesetzt, also zaehler1: 0 schreiben auf Blatt 1
- nun kommt zaehler2 - also unter zaehler1 kommt nun zaehler2: 0
- Nun sind wir bei while (zaehler1 < 20) - wir schauen auf zaehler1 und da steht 0 - also 0<20: Ok, wir gehen in die while schleife rein.
- zaehler1 wird um 1 erhöht, also 0 streichen und 1 hinschreiben.
- nun kommt die zweite while scleife - wie oben schauen wir nach und ja - wird ausgeführt.
- nun erhöhen wir zaehler2 - 0 streichen und 1 hinschreiben.
- Nun kommt eine Ausgabe - die schreiben wir einfach auf das andere Blatt (oder da wir wenig Variablen haben einfach auf die untere Hälfte des ersten Blattes)
Das machst Du jetzt einfach weiter. Siehst Du was passiert und warum es passiert?

Konrad

Aber rechnet es nicht erst zusammen, wenn beide Schleifen durchgelaufen sind.

Also müsste es immer 1x1 2x2 3x3..20x20 zusammen zaehlen

 

[kneitzel]

Dann scheinst Du es nicht durchgespielt zu haben. Wie kommst Du denn auf dieses 1x1, 2x2 und so weiter? Wenn Du es durchspielst, dann siehst Du doch, dass die innere Schleife nur ein einziges Mal durchlaufen wird mit zaehler1 = 1, so dass einmal 1*1 1*2 1*3 u.s.w. ausgegeben wird.

Später wird die innere Schleife nicht mehr durchlaufen, da zaehler2 nicht geändert wird und daher immer 20 < 20 geprüft wird - was falsch ist und daher das Innere der Schleife nicht mehr ausgeführt wird.

Wenn Du Probleme hast, solche trivialen Dinge zu sehen, dann wäre meine Empfehlung, da wirklich mehr auf einem Blatt zu üben. Mit etwas Übung spielt man solche Dinge im Kopf ganz problemlos durch.

Bei komplizierteren Dingen hilft dann ein Compiler, aber der macht etwas nicht so gut sichtbar wie eben eine graphische Darstellung auf einem Blatt Papier.

Konrad

 

[Joose]

Aber rechnet es nicht erst zusammen, wenn beide Schleifen durchgelaufen sind.

Sobald eine Code Zeile erreicht wird wird diese auch ausgeführt. Wenn dort "a*b" steht dann wird das auch berechnet.