HEUTE. Unterschiede Pseudocode / Programmcode. Rundung und modulo (Tafel) Pseudocode: findprimeswithdifference. Strings in JAVA.

Transkript

1 HEUTE Unterschiede Pseudocode / Programmcode Rundung und modulo (Tafel) Pseudocode: findprimeswithdifference Strings in JAVA Pseudocode: kontextfrei Variablentyp passend Schleifen nach Sinn klare mathematische Struktur passender Rückgabetyp man erklärt Menschen Programmcode: braucht Klassen-/Methodenkontext Variablen mit Typ, muss deklarieren konkrete do-/for-/while-schleifen Effizienztricks Rückgabetyp zu definieren Sicherheitsabfragen evtl. redundante Statements man erklärt dem Computer Pseudocode findprimeswithdifference: algorithmische Ideen exakte Art, Algorithmen zu beschreiben Form zwischen Fließtext und Programmcode: sprachlich direkt wie Text übersichtlich strukturiert wie Code Kompromiss zwischen beiden Extremen Vorteile: mathematische Klarheit Unabhängigkeit von Programmiersprachen viele Fachbücher verwenden Pseudocode Bedingungen für Lösung: Paar von Primzahlen die benachbart sind mit gegebener Differenz Idee A: erzeuge aufsteigend alle Paare von benachbarten Primzahlen prüfe jeweils, ob sie die gegebene Differenz haben Idee B: (alternativ): erzeuge aufsteigend Paare von Primzahlen mit der gegebenen Differenz prüfe jeweils, ob sie benachbart sind

2 Idee A: bildliche Funktionsweise mit diff = Idee B: bildliche Funktionsweise mit diff = prim Tests 57 prim Tests Primzahltest mit positivem Ergebnis Primzahltest mit negativem Ergebnis lo hi Primzahltest mit positivem Ergebnis Primzahltest mit negativem Ergebnis Primzahltest in der i Schleife lo i hi Idee A: Pseudocode findprimeswithdifference( diff ) Input: diff Æ Output: lo, hi Æ benachbarte Primzahlen mit hi lo = diff, wenn existent { Sonderfälle überprüfen } if diff = 1 then return ( 2, 3 ) else if diff ist ungerade then return kein solches Paar endif { hi mit kleinster ungerader Primzahl initialisieren } hi := 3 do { while hi lo diff } lo := hi hi := lo + 2 while hi ist keine Primzahl do hi := hi + 2 endwhile while hi lo diff return ( lo, hi ) Idee B: Pseudocode findprimeswithdifference( diff ) Input: Output: wie Idee A { Sonderfälle: wie Idee A } { lo mit kleinster ungerader Primzahl initialisieren } lo := 3 while true do hi := lo + diff if lo prim and hi prim then i := lo + 2 while i < hi and i nicht prim do i := i + 2 endwhile if i hi then { erfolgreich } return ( lo, hi ) endif lo := hi else lo := lo + 2 endif endwhile

3 Idee B: bildliche Funktionsweise mit diff = 8 ohne Doppelte Strings in JAVA Textverarbeitung ist eine der wichtigsten Computeraufgaben, z.b. Editor: , Programme, Briefe, Artikel, Bücher Compiler, Shell autom. Datenein- und Ausgabe Texte liegen in zwei Formen vor: 43 prim Tests im externen Speichermedium Datei (engl. file) im Arbeitsspeicher String (dt. Zeichenkette) wiederholter = eingesparter Primzahltest lo i hi Strings in JAVA string engl.: Schnur, Saite string bag engl.: Einkaufsnetz string orchestra engl.: Streichorchester bedeutet Hintereinanderreihung von Zeichen, also eigentlich character string: Z_e_i_c_h_e_n_k_e_t_t_e Strings in JAVA sind eine eigene Klasse keine Information über inneren Aufbau (black box) Zugriff nur über public-methoden (tool box)

4 Eigenschaften von Strings Verkettung (Konkatenation) von Strings Strings werden zur Laufzeit angelegt String mystr3 = "die " + ; // einfache Verkettung Strings sind unveränderlich Strings können literal initialisiert werden, z.b.: "die " String hello = "Hallo Freunde! - Hallo Otto!" ; String steuernr = "4 / / 210" ; String antwort = "\"Ach ja?\"\n\"bl\u00f6d!\"\n\"richtig.\"\n" ; mystr3 "die TU Berlin" String + String String-Variablen haben Referenztyp: "Hallo Freunde! Hallo Otto!" Konstruktoren von Strings Verkettung (Konkatenation) von Strings String mystr0 = new String () ; // leerer String String mystr1 = new String ( ) ; // literale Init. String mystr3 = "die " + ; // einfache Verkettung += " 10623" ; // am Ende anhängen String = new String ( mystr1 ) ; // kopierter String "die " mystr0 "" mystr3 "die TU Berlin" String + String mystr1 vorher " 10623" nachher String += String

5 get-methoden von Strings get-methoden von Strings int length ( ) // Länge in Anzahl Zeichen String substring ( int begin, int end ) // Teilstring ausgeben int length0 = mystr0.length() ; // = 0 int length2 =.length() ; // = 15 = größter Index + 1 String mystr4 = mystr3.substring( 4, 8 ) ; // = "TU B" mystr0 "" mystr3 "d i e _ T U _ B e r l i n" ( 1) + 1 = "T U _ B e r l i n _ " mystr4 "T U _ B" = get-methoden von Strings get-methoden von Strings char charat ( int index ) char letter0 = mystr0.charat( 3 ) ; char letter2 =.charat( 3 ) ; // Zeichen an Pos. index // (ab 0) // ungültig => Exception! // = B int indexof ( char letter ) // Pos. des 1. Zeichens int indexof ( String str ) // Pos. des 1. Teilstrings int index1 = mystr3.indexof( e ) ; // = 2 int index2 = mystr3.indexof( "Berlin" ) ; // = 7 int index3 = mystr3.indexof( "10623" ) ; // = -1 (nicht gefunden) mystr0 "" ( ) mystr3 "d i e _ T U _ B e r l i n" "T U _ B e r l i n _ " indexof( e ) indexof( "Berlin" )

6 set-methoden von Strings Vergleichsmethoden von Strings String tolowercase ( ) // alles in Kleinbuchstaben boolean equals ( String str ) // inhaltlich gleich zu str? String touppercase ( ) // alles in Großbuchstaben String mystr5 =.tolowercase() ; // = "tu berlin 10623" String mystr6 =.touppercase() ; // = "TU BERLIN 10623" String mystr8 = new String( ) ; boolean isequal1 =.equals( mystr3 ) ; boolean isequal2 =.equals( mystr8 ) ; // = false // = true mystr3 "die TU Berlin" false mystr5 "tu berlin 10623" false true mystr8 mystr6 "TU BERLIN 10623" == mystr8.equals( mystr8 ) set-methoden von Strings Vergleichsmethoden von Strings String replace ( char old, char new ) // jedes old -> new boolean startswith ( String str ) // beginnt mit str? String mystr7 = mystr3.replace( e, \u00e4 ) ; // = "diä TU Bärlin" boolean endswith ( String str ) // endet mit str? boolean isprefix =.startswith( mystr4 ) ; // = true boolean ispostfix =.endswith( "Berlin" ) ; // = false mystr3 "d i e _ T U _ B e r l i n" mystr4 "TU B" mystr7 "d i ä _ T U _ B ä r l i n" true startswith( "TU B" ) false endswith( "Berlin" ) "Berlin"

7 Vergleichsmethoden von Strings Eigenschaften von StringBuffer s int compareto ( String str ) // lexikogr. Vergleich int compval1 =.compareto( mystr6 ) ; // = 32 int compval2 =.compareto( mystr8 ) ; // = 0 // compval1 = e - E = (char)101 - (char)69 = 32 // str1.compareto( str2 ) == 0 str1.equals( str2 ) mystr6 "T U _ B E R L I N _ " werden zur Laufzeit angelegt sind veränderliche Zeichenkettenobjekte unterstützen im Wesentlichen Veränderungsmethoden müssen in String umgewandelt werden, um die String-Methoden zu nutzen e E = 32 "T U _ B e r l i n _ " 0 mystr8 "T U _ B e r l i n _ " Umwandlungsmethoden von Strings Konstruktoren von StringBuffer s static String valueof ( <type> var ) static String valueof ( Object obj ) // <type> -> String // Object -> String int intval = ; String intstr = String.valueOf( intval ) ; // = "10623" String doublestr = String.valueOf( e4 ) ; // = " " StringBuffer mybuf0 = new StringBuffer () ; // leer StringBuffer = new StringBuffer ( );// literal StringBuffer mybuf2 = new StringBuffer ( mystr1 ) ; // kopiert // es gibt KEINEN Konstruktor StringBuffer( StringBuffer )! // String.valueOf( <type> var ) == new <Type>( var ).tostring() // String.valueOf( Object obj ) == obj.tostring() mybuf0 "" mystr1 intval intstr "10623" mybuf2

8 Ausgabe / Umwandlung von StringBuffer s Einfügen von Elementen int length ( ) // Länge der Zeichenkette int capacity ( ) // Größe des belegten Speichers StringBuffer insert ( int begin, String str ) StringBuffer insert ( int begin, <type> var ) // einfügen // ab begin String tostring ( ) String mystr9 =.tostring() ; // Umwandlung in einen String.insert( 9, ", PLZ" ) ; // = "TU Berlin, PLZ 10623" mybuf2.insert( 9,, ) ; // = "TU Berlin, " vorher ", PLZ" nachher "TU Berlin, PLZ 10623" mystr Anfügen von Elementen Löschen von Elementen StringBuffer append ( String str ) // am Ende anhängen StringBuffer deletecharat ( int index ) // Zeichen löschen StringBuffer append ( <type> var ) // primitiver Typ StringBuffer delete ( int begin, int end ) // Teilstr. löschen.append( " 10623" ) ; // = mybuf2.append( e4 ) ; // = "TU Berlin ".delete( 2, 9 ) ; // = "TU, PLZ 10623" mybuf2.deletecharat( 16 ) ; // = "TU Berlin,106230" vorher " 10623" vorher "T U _ B e r l i n, _ P L Z _ " nachher nachher "T U, _ P L Z _ "

9 Verändern von Elementen Zerlegen von Strings: die Klasse StringTokenizer StringBuffer setcharat ( int index, char letter ) StringBuffer replace ( int begin, int end, String str ) boolean hasmoretokens ( ) // noch weitere Wörter? String nexttoken ( ) // nächstes Wort ausgeben.setcharat( 2, : ) ; // = "TU: PLZ 10623" mybuf2.replace( 3, 10, "Dresden " ) ; // = "TU Dresden " StringTokenizer strtok = new StringTokenizer( text ) ; while ( strtok.hasmoretokens() ) System.out.println( strtok.nexttoken() ) ; vorher nachher mybuf2 mybuf2 "T U _ B e r l i n, " "T U _ D r e s d e n _ " "Dies ist ein Text." Zerlegen von Strings: die Klasse StringTokenizer import java.util.stringtokenizer ; String text1 = "Dies ist ein Text." ; String text2 = "Dies,ist,ein:Text." ; // normale Trennzeichen // andere Trennzeichen StringTokenizer strtok1 = new StringTokenizer ( text1 ) ; StringTokenizer strtok2 = new StringTokenizer ( text2, ",:" ) ; "Dies ist ein Text." "Dies,ist,ein:Text." "Dies" "ist" "ein" "Text."