PowerPoint-presentatie

January 8, 2018 | Author: Anonymous | Category: Engineering & Technology, Informatica, Java Programming
Share Embed Donate


Short Description

Download PowerPoint-presentatie...

Description

11.4. Klasse StringBuffer 



Nadat een String object gecreëerd is, kan de inhoud ervan nooit meer veranderen StringBuffer wordt gebruikt voor zogenaamde “dynamische strings” (dit is een aanpasbare versie van String)

1



Capaciteit geeft het aantal karakters die een Stringbuffer kan bevatten aan. 



Als de capaciteit overtroffen wordt, dan breidt ze zich automatisch uit, om de bijkomende karakters te kunnen opvangen

Gebruik + en += voor STRINGconcatenatie. De klasse Stringbuffer wordt gebruikt om deze operatoren te implementeren (zie 11.17).

2

11.4.1. StringBuffer constructors 

Er zijn drie constructoren voor de klasse Stringbuffer:  buffer1 = new StringBuffer() Creëert een lege buffer met capaciteit van 16 karakters  buffer2 = new StringBuffer(lengte) Creëert een lege buffer met capaciteit het aantal karakters dat door de integer lengte wordt aangegeven  buffer 3 = new StringBuffer(“tekst”) Creëert een buffer met inhoud “tekst” en met capaciteit het aantal karakters in de string “tekst” + 16 dus in het vb.: 5 + 16 = 21

3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// Fig. 11.10: StringBufferConstructors.java // Dit programma demonstreert de StringBuffer constructors. // Java extension packages import javax.swing.*; public class StringBufferConstructors { // test StringBuffer constructors public static void main( String args[] ) { StringBuffer buffer1, buffer2, buffer3;

De drie constructoren: 1.

2.

buffer1 = new StringBuffer(); buffer2 = new StringBuffer( 10 ); buffer3 = new StringBuffer( "hello" ); String output "buffer1 = "\nbuffer2 "\nbuffer3

3.

Default constructor maakt lege buffer met capaciteit 16 2e constructor maakt lege buffer met capaciteit 10 3e constructor maakt buffer met tekst “hello” en capaciteit 21

= \"" + buffer1.toString() + "\"" + = \"" + buffer2.toString() + "\"" + = \"" + buffer3.toString() + "\"";

JOptionPane.showMessageDialog( null, output, "Demonstrating StringBuffer Class Constructors", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); } }

// einde klasse StringBufferConstructors

4

12 13 14 15 16 17 18 19 20 21 22 23 24 25

StringBuffer buffer1, buffer2, buffer3; buffer1 = new StringBuffer(); buffer2 = new StringBuffer( 10 ); buffer3 = new StringBuffer( "hello" ); String output = "buffer1 = \"" + buffer1.toString() + "\"" + "\nbuffer2 = \"" + buffer2.toString() + "\"" + "\nbuffer3 = \"" + buffer3.toString() + "\""; JOptionPane.showMessageDialog( null, output, "Demonstrating StringBuffer Class Constructors", JOptionPane.INFORMATION_MESSAGE );

5

11.4.2. StringBuffer methodes length, capacity, setLength en ensureCapacity 



Methode length  Geeft het aantal karakters in de StringBuffer terug Methode capacity  Geeft de capaciteit van de StringBuffer terug  capaciteit = aantal karakters dat kan opgeslagen worden zonder meer geheugenruimte te moeten alloceren 6





Methode setLength  Verhoogt of verlaagt de lengte van de StringBuffer Methode ensureCapacity  Stelt de capaciteit van de StringBuffer in  Garandeert dat de StringBuffer een minimum capaciteit heeft  Let op: als de originele capaciteit kleiner is dan de nieuwe, dan wordt de capaciteit ofwel het getal dat aangegeven wordt in het argument ofwel 2 * de originele capaciteit + 2, naargelang wat groter is

7

1 2 3 4 5 6 7 8 10 11 12 13 14 16 17 18 20 21 23 24 25 26 27 28 29 30 31 32 33 34

// Fig. 11.11: StringBufferCapLen.java // Dit programma demonstrateert de methodes // length en capacity van de StringBuffer klasse. // Java extension packages import javax.swing.*; public class StringBufferCapLen { // test StringBuffer methodes capacity en length public static void main( String args[] ) { StringBuffer buffer = new StringBuffer( "Hello, how are you?" ); String output = "buffer = " + buffer.toString() + "\nlength = " + buffer.length() + "\ncapacity = " + buffer.capacity(); buffer.ensureCapacity( 75 ); output += "\n\nNew capacity = " + buffer.capacity(); buffer.setLength( 10 ); output += "\n\nNew length = " + buffer.length() + "\nbuf = " + buffer.toString(); JOptionPane.showMessageDialog( null, output, "StringBuffer length and capacity Methods", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); } }

// einde klasse StringBufferCapLen

8

13 14 16 17 18 20 21 23 24 25

StringBuffer buffer = new StringBuffer( "Hello, how are you?" ); String output = "buffer = " + buffer.toString() + "\nlength = " + buffer.length() + "\ncapacity = " + buffer.capacity(); buffer.ensureCapacity( 75 ); output += "\n\nNew capacity = " + buffer.capacity(); buffer.setLength( 10 ); output += "\n\nNew length = " + buffer.length() + "\nbuf = " + buffer.toString();

19+16=35

75 > 72 (= 2*35 + 2) 9

11.4.3. StringBuffer methodes charAt, setCharAt, getChars en reverse 

Om karakters in een StringBuffer te manipuleren, zijn volgende methodes ter beschikking: 

Methode charAt 



Geeft het karakter uit de StringBuffer terug dat zich op de gespecifieerde index bevindt Indien de index buiten de grenzen van de StringBuffer valt, dan krijg je een StringIndexOutOfBoundsException 10

11.4.3. StringBuffer methodes charAt, setCharAt, getChars en reverse (verv.) 

Method setCharAt 



Vult het opgegeven karakter in de StringBuffer in op de gespecifieerde index Zie charAt voor indexwaarde die buiten de grenzen valt 11

11.4.3. StringBuffer methodes charAt, setCharAt, getChars en reverse (verv.) 

Method getChars Geeft een array van karakters terug die overeenkomt met de inhoud van de StringBuffer  4 argumenten: startindex, index 1 positie voorbij laatste te kopiëren karakter, de array waarnaar moet gekopieerd worden en de beginpositie in de array 



Method reverse  Keert de inhoud van de StringBuffer om

12

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// Fig. 11.12: StringBufferChars.java // De charAt, setCharAt, getChars en reverse methodes // van de klasse StringBuffer. // Java extension packages import javax.swing.*; public class StringBufferChars { // test StringBuffer karakter methodes public static void main( String args[] ) { StringBuffer buffer = new StringBuffer( "hello there" ); String output = "buffer = " + buffer.toString() + "\nCharacter at 0: " + buffer.charAt( 0 ) + "\nCharacter at 4: " + buffer.charAt( 4 ); char charArray[] = new char[ buffer.length() ]; buffer.getChars( 0, buffer.length(), charArray, 0 ); output += "\n\nThe characters are: "; for ( int count = 0; count < charArray.length; ++count ) output += charArray[ count ]; buffer.setCharAt( 0, 'H' ); buffer.setCharAt( 6, 'T' ); output += "\n\nbuf = " + buffer.toString(); buffer.reverse(); output += "\n\nbuf = " + buffer.toString();

13

32 33 34 35 36 37 38 39 40

JOptionPane.showMessageDialog( null, output, "Demonstrating StringBuffer Character Methods", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); } }

// einde klasse StringBufferChars

14

13 14 15 16 17 18 19 20 21 22 23 24

StringBuffer buffer = new StringBuffer( "hello there" ); String output = "buffer = " + buffer.toString() + "\nCharacter at 0: " + buffer.charAt( 0 ) + "\nCharacter at 4: " + buffer.charAt( 4 );

char charArray[] = new char[ buffer.length() ]; buffer.getChars( 0, buffer.length(), charArray, 0 ); output += "\n\nThe characters are: "; for ( int count = 0; count < charArray.length; ++count ) output += charArray[ count ];

15

13

StringBuffer buffer = new StringBuffer( "hello there" );

26 27 28 29 30 31

buffer.setCharAt( 0, 'H' ); buffer.setCharAt( 6, 'T' ); output += "\n\nbuf = " + buffer.toString(); buffer.reverse(); output += "\n\nbuf = " + buffer.toString();

16

11.4.4. StringBuffer append methodes 

10 overloaded append methodes om de verschillende datatypes te kunnen aan het uiteinde van een StringBuffer plakken 

Een versie voor elk van de primitieve datatypes plus een voor karakterarrays, een voor Strings en een voor Objects

17

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// Fig. 11.13: StringBufferAppend.java // Dit programma demonstreert de append // methodes van de StringBuffer klasse. // Java extension packages import javax.swing.*; public class StringBufferAppend { // test StringBuffer append methodes public static void main( String args[] ) { Object o = "hello"; String s = "good bye"; char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; boolean b = true; char c = 'Z'; int i = 7; long l = 10000000; float f = 2.5f; double d = 33.333; StringBuffer buffer = new StringBuffer(); buffer.append( o ); buffer.append( " " );

o is een object van de klasse Object en wordt eerst omgezet naar een String waarna het kan worden geplakt aan de bestaande Stringbuffer (die tot dan toe nog leeg was)

18

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append(

s ); " " ); charArray ); " " ); charArray, 0, 3 ); " " ); b ); " " ); c ); " " ); i ); " " ); l ); " " ); f ); " " ); d );

Voeg ook achtereenvolgens een String object, een karakterarray, een gedeelte van een karakterarray, een booleaanse variabele, een karakter, een integer, een long, een float en een double toe achteraan de StringBuffer

JOptionPane.showMessageDialog( null, "buffer = " + buffer.toString(), "Demonstrating StringBuffer append Methods", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 );

} }

// einde StringBufferAppend

19

13 14 15

Object o = "hello"; String s = "good bye"; char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' };

22

StringBuffer buffer = new StringBuffer();

24 25

buffer.append( o ); buffer.append( " " );

27 28 29 30 31 32

buffer.append( buffer.append( buffer.append( buffer.append( buffer.append( buffer.append(

s ); " " ); charArray ); " " ); charArray, 0, 3 ); " " );

20

16 17 18 19 20 21 33 34 35 36 37 38 39 40 41 42 43

boolean b = true; char c = 'Z'; int i = 7; long l = 10000000; float f = 2.5f; double d = 33.333; buffer.append( b ); buffer.append( " " ); buffer.append( c ); buffer.append( " " ); buffer.append( i ); buffer.append( " " ); buffer.append( l ); buffer.append( " " ); buffer.append( f ); buffer.append( " " ); buffer.append( d );

21

Gebruik + en += voor STRINGconcatenatie. De klasse StringBuffer wordt gebruikt om deze operatoren te implementeren. String string1 = “hello”; String string2 = “BC”; int value = 22; String s = string1 + string2 + value;

 new StringBuffer().append(“hello”).append( “BC”).append(22).toString(); 22

11.4.5. StringBuffer tussenvoeg- en verwijdermethodes 

Methode insert  9 overloaded methodes om de verschillende datatypes te kunnen tussenvoegen op en gegeven positie in een StringBuffer  Twee argumenten: index en het in te voegen gedeelte  StringIndexOutOfBoundsException bij verkeerde indexwaarde

23

11.4.5. StringBuffer tussenvoeg- en verwijdermethodes (verv.) 

Methode delete Wist een reeks karakters  Twee argumenten: startpositie en indexwaarde één positie voorbij het einde van de te wissen karakters  StringIndexOutOfBoundsException bij verkeerde indexwaarde 

24

11.4.5. StringBuffer tussenvoeg- en verwijdermethodes (verv.) 

Methode deleteCharAt Wist één karakter  Eén argument: positie van het te wissen karakter  StringIndexOutOfBoundsException bij verkeerde indexwaarde 

25

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// Fig. 11.14: StringBufferInsert.java // Dit programma demonstreert de insert en delete // methodes van de klasse StringBuffer. // Java extension packages import javax.swing.*; public class StringBufferInsert { // test StringBuffer insert methodes public static void main( String args[] ) { Object o = "hello"; String s = "good bye"; char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; boolean b = true; char c = 'K'; int i = 7; long l = 10000000; float f = 2.5f; double d = 33.333; StringBuffer buffer = new StringBuffer(); buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert(

0, 0, 0, 0, 0, 0, 0, 0,

o ); " " ); s ); " " ); charArray ); " " ); b ); " " );

Insert op positie 0 dus de verschillende objecten worden telkens vooraan in de buffer toegevoegd, voor alle andere

26

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert(

0, 0, 0, 0, 0, 0, 0, 0, 0,

c " i " l " f " d

); " ); " ); " ); " );

);

); ); );

String output = "buffer after inserts:\n" + buffer.toString(); buffer.deleteCharAt( 10 ); buffer.delete( 2, 6 );

// delete 5 in 2.5 // delete .333 in 33.333

output += "\n\nbuffer after deletes:\n" + buffer.toString(); JOptionPane.showMessageDialog( null, output, "Demonstrating StringBufferer Inserts and Deletes", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 );

} }

// einde klasse StringBufferInsert

27

13 14 15 16 17 18

Object o = "hello"; String s = "good bye"; char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; boolean b = true; char c = 'K'; int i = 7;

22 23 24 25 26 27 28 29 30 31 32 33 34 35

StringBuffer buffer = new StringBuffer(); buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert(

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

o ); " " ); s ); " " ); charArray ); " " ); b ); " " ); c ); " " ); i ); " " );

28

19 20 21

long l = 10000000; float f = 2.5f; double d = 33.333;

36 37 38 39 40 41 42 43 44

buffer.insert( buffer.insert( buffer.insert( buffer.insert( buffer.insert(

45 46 47 48 49

buffer.deleteCharAt( 10 ); buffer.delete( 2, 6 );

0, 0, 0, 0, 0,

l ); " " ); f ); " " ); d );

String output = "buffer after inserts:\n" + buffer.toString();

// delete 5 in 2.5 // delete .333 in 33.333

output += "\n\nbuffer after deletes:\n" + buffer.toString(); 29

11.5. Klasse Character 

Primitieve variabelen als objecten behandelen:  Klasses Boolean, Character, Double, Float, Byte, Short, Integer en Long  Behalve Boolean en Character worden deze klasses afgeleid van de klasse Number  Deze 8 klassen worden “type wrappers” genoemd en maken deel uit van java.lang 30

11.5. Klasse Character (verv.) 

Klasse Character: type wrapper voor karakters  Meeste methodes zijn static en doen een test op of manipuleren een karakter  Constructor die aan de hand van een char argument een Character object maakt  Zie voorbeelden en Java API documentatie voor meer informatie 31

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// // // //

Fig. 11.15: StaticCharMethods.java Demonstreert de statische karakter test methodes en verandering van hoofd- naar kleine letters en omgekeerd van de klasse Character uit de java.lang package.

// Java core packages import java.awt.*; import java.awt.event.*; // Java extension packages import javax.swing.*; public class StaticCharMethods extends JFrame { private char c; private JLabel promptLabel; private JTextField inputField; private JTextArea outputArea; // maak de GUI public StaticCharMethods() { super( "Static Character Methods" ); Container container = getContentPane(); container.setLayout( new FlowLayout() ); promptLabel = new JLabel( "Enter a character and press Enter" ); container.add( promptLabel ); inputField = new JTextField( 5 );

32

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

inputField.addActionListener( // anonieme inner klasse new ActionListener() { // vang het event vanuit het tekstveld op public void actionPerformed( ActionEvent event ) { String s = event.getActionCommand(); c = s.charAt( 0 ); buildOutput(); } }

// einde anonieme inner klasse

); // einde oproep naar addActionListener container.add( inputField ); outputArea = new JTextArea( 10, 20 ); container.add( outputArea ); setSize( 300, 250 ); show();

// stel de venstergrootte in // toon het venster

} // toon de karakter info in de outputArea public void buildOutput() {

33

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

outputArea.setText( "is defined: " + Character.isDefined( c ) + "\nis digit: " + Character.isDigit( c ) + "\nis Java letter: " + Character.isJavaIdentifierStart( c ) + "\nis Java letter or digit: " + Character.isJavaIdentifierPart( c ) + "\nis letter: " + Character.isLetter( c ) + "\nis letter or digit: " + Character.isLetterOrDigit( c ) + "\nis lower case: " + Character.isLowerCase( "\nis upper case: " + Character.isUpperCase( "\nto upper case: " + Character.toUpperCase( "\nto lower case: " + Character.toLowerCase(

c c c c

) ) ) )

+ + + );

} // voer de applicatie uit public static void main( String args[] ) { StaticCharMethods application = new StaticCharMethods(); application.addWindowListener( // anonieme inner klasse new WindowAdapter() { // vang de event op wanneer de gebruiker het venster sluit public void windowClosing( WindowEvent windowEvent ) { System.exit( 0 ); }

34

93 94 95 96 97 98 99 100

}

// einde anonieme inner klasse

); // einde oproep naar addWindowListener } }

// einde methode main

// einde klasse StaticCharMethods

35

13 14

public class StaticCharMethods extends JFrame { private char c;

… 20 21

public StaticCharMethods() {

… 31 33 35 36 37 38 39 40 41 42 43 44 46

inputField = new JTextField( 5 ); inputField.addActionListener( // anonieme inner klasse new ActionListener() {

}

// vang het event vanuit het tekstveld op public void actionPerformed( ActionEvent event ) { String s = event.getActionCommand(); c = s.charAt( 0 ); buildOutput(); } // einde anonieme inner klasse 36

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// toon de karakter info in de outputArea public void buildOutput() { outputArea.setText( "is defined: " + Character.isDefined( c ) + "\nis digit: " + Character.isDigit( c ) + "\nis Java letter: " + Character.isJavaIdentifierStart( c ) + "\nis Java letter or digit: " + Character.isJavaIdentifierPart( c ) + "\nis letter: " + Character.isLetter( c ) + "\nis letter or digit: " + Character.isLetterOrDigit( c ) + "\nis lower case: " + Character.isLowerCase( "\nis upper case: " + Character.isUpperCase( "\nto upper case: " + Character.toUpperCase( "\nto lower case: " + Character.toLowerCase( }

c c c c

) ) ) ) 37

+ + + );

38

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// Fig. 11.15: StaticCharMethods2.java // Demonstreert de statische karakterconversie methodes // van de klasse Character uit de java.lang package. // Java core packages import java.awt.*; import java.awt.event.*; // Java extension packages import javax.swing.*; public class StaticCharMethods2 extends JFrame { private char c; private int digit, radix; private JLabel prompt1, prompt2; private JTextField input, radixField; private JButton toChar, toInt; public StaticCharMethods2() { super( "Character Conversion Methods" ); // maak de GUI en stel de event handling in Container container = getContentPane(); container.setLayout( new FlowLayout() ); prompt1 = new JLabel( "Enter a digit or character " ); input = new JTextField( 5 ); container.add( prompt1 ); container.add( input );

39

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

prompt2 = new JLabel( "Enter a radix " ); radixField = new JTextField( 5 ); container.add( prompt2 ); container.add( radixField ); toChar = new JButton( "Convert digit to character" ); toChar.addActionListener( // anonieme inner klasse new ActionListener() { // vang de event op komende van de JButton toChar public void actionPerformed( ActionEvent actionEvent ) { digit = Integer.parseInt( input.getText() ); radix = Integer.parseInt( radixField.getText() ); JOptionPane.showMessageDialog( null, Converteer een getal digit "Convert digit to character: " + naar een karakter volgens het Character.forDigit( digit, radix ) ); getallenstelsel met basis } aangegeven door radix }

// einde anonieme inner klasse

Vb. Radix = 16 is het hexadecimaal getallenstelsel

); // einde oproep naar addActionListener container.add( toChar ); toInt = new JButton( "Convert character to digit" );

40

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

toInt.addActionListener( // anonieme inner klasse new ActionListener() { // vang de event op komende van de JButton toInt public void actionPerformed( ActionEvent actionEvent ) { String s = input.getText(); c = s.charAt( 0 ); Converteer een karakter c radix = naar een getal volgens het Integer.parseInt( radixField.getText() ); getallenstelsel met basis JOptionPane.showMessageDialog( null, aangegeven door radix "Convert character to digit: " + Vb. Radix = 16 is het Character.digit( c, radix ) ); hexadecimaal getallenstelsel } }

// einde anonieme inner klasse

); // einde oproep naar addActionListener container.add( toInt ); setSize( 275, 150 ); show();

// stel de venstergrootte in // toon het venster

}

41

90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

// voer de applicatie uit public static void main( String args[] ) { StaticCharMethods2 application = new StaticCharMethods2(); application.addWindowListener( // anonieme inner klasse new WindowAdapter() { // vang de event op wanneer de gebruiker het venster sluit public void windowClosing( WindowEvent windowEvent ) { System.exit( 0 ); } }

// einde anonieme inner klasse

); // einde oproep naar addWindowListener } }

// einde methode main

// einde klasse StaticCharMethods2

42

12 13 14 … 19 20 …

37 39 41 42 45 46 47 48 49 50 51 52 53 55 57

public class StaticCharMethods2 extends JFrame { private char c; private int digit, radix; public StaticCharMethods2() {

toChar = new JButton( "Convert digit to character" ); toChar.addActionListener( // anonieme inner klasse new ActionListener() { public void actionPerformed( ActionEvent actionEvent )

{ digit = Integer.parseInt( input.getText() ); radix = Integer.parseInt( radixField.getText() ); JOptionPane.showMessageDialog( null, "Convert digit to character: " + Character.forDigit( digit, radix ) ); } } // einde anonieme inner klasse ); // einde oproep naar addActionListener

43

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 80 82

toInt = new JButton( "Convert character to digit" ); toInt.addActionListener ( // anonieme inner klasse new ActionListener() { // vang de event op komende van de JButton toInt public void actionPerformed( ActionEvent actionEvent ) { String s = input.getText(); c = s.charAt( 0 ); radix = Integer.parseInt( radixField.getText() ); JOptionPane.showMessageDialog( null, "Convert character to digit: " + Character.digit( c, radix ) ); } } // einde anonieme inner klasse ); // einde oproep naar addActionListener 44

45

1 2 3 4 5 6 7 8 10 11 13 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 35

// Fig. 11.19: OtherCharMethods.java // Demonstreert de non-static methodes van de klasse // Character uit de java.lang package. // Java extension packages import javax.swing.*; public class OtherCharMethods { // test de non-static Character methodes public static void main( String args[] ) { Character c1, c2; c1 = new Character( 'A' ); c2 = new Character( 'a' ); String output = "c1 = " + c1.charValue() + "\nc2 = " + c2.toString() + "\n\nhash code for c1 = " + c1.hashCode() + "\nhash code for c2 = " + c2.hashCode(); if ( c1.equals( c2 ) ) output += "\n\nc1 and c2 are equal"; else output += "\n\nc1 and c2 are not equal"; JOptionPane.showMessageDialog( null, output, "Demonstrating Non-Static Character Methods", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); }

} // einde klasse OtherCharMethods

46

11 13 15 16 18 19 20 21 23

public static void main( String args[] ) { Character c1, c2; c1 = new Character( 'A' ); c2 = new Character( 'a' ); String output = "c1 = " + c1.charValue() + "\nc2 = " + c2.toString() + "\n\nhash code for c1 = " + c1.hashCode() + "\nhash code for c2 = " + c2.hashCode(); if ( c1.equals( c2 ) )

24

output += "\n\nc1 and c2 are equal";

25 26

else output += "\n\nc1 and c2 are not equal";

47

11.6. Klasse StringTokenizer 

Token  Cfr. Lezen van een zin We delen de zin op in woorden en leestekens  Elk onderdeel (=token) heeft een mening voor ons 



Compiler deelt statement op in keywords, identifiers, operators en andere elementen van de programmeertaal 48

11.6. Klasse StringTokenizer (verv.) 

Token 

Klasse StringTokenizer (uit package java.util) deelt een String op in onderdeeltjes (substrings) die van elkaar gescheiden zijn door een afbakening (delimiter). Dit zijn typisch whitespace karakters of een ander teken. 49

11.6. Klasse StringTokenizer (vervolg) 

Constructoren van klasse StringTokenizer  Uit het voorbeeld: constructor met één argument 



Neemt als afbakening voor de tokens de default delimiter string “ \n\t\r” bestaande uit een spatie, een newline karakter, een tab en een carriage return

Constructor met twee String argumenten 

Tweede String is de delimiter string 50

11.6. Klasse StringTokenizer (vervolg) 

Constructoren van klasse StringTokenizer  Constructor met drie argumenten (2 Strings en een boolean)  

Tweede String is opnieuw de delimiter string Boolean bepaalt of de delimiters ook als tokens moeten teruggekeerd worden (ja indien true, nee indien false). Dit laatste is handig als je wilt weten wat de afbakeningen waren. 51

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// Fig. 11.18: TokenTest.java // Test van de StringTokenizer klasse uit de java.util package // Java core packages import java.util.*; import java.awt.*; import java.awt.event.*; // Java extension packages import javax.swing.*; public class TokenTest extends JFrame { private JLabel promptLabel; private JTextField inputField; private JTextArea outputArea; // maak de GUI en vang de events op public TokenTest() { super( "Testing Class StringTokenizer" ); Container container = getContentPane(); container.setLayout( new FlowLayout() ); promptLabel = new JLabel( "Enter a sentence and press Enter" ); container.add( promptLabel ); inputField = new JTextField( 20 ); inputField.addActionListener(

52

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// anonieme inner klasse new ActionListener() { // vang het event vanuit het tekstveld op public void actionPerformed( ActionEvent event ) { String stringToTokenize = event.getActionCommand(); StringTokenizer tokens = new StringTokenizer( stringToTokenize );

}

actionPerformed wordt uitgevoerd wanneer de gebruiker op Enter drukt in het JTextField inputField

Methode nextToken: outputArea.setText( "Number of elements: " + Zonder argumenten: tokens.countTokens() + "\nThe tokens are:\n" ); bepaalt het volgende token volgens dezelfde while ( tokens.hasMoreTokens() ) delimiter string outputArea.append( tokens.nextToken() + "\n" ); Met 1 argument (String): } stelt de nieuwe delimiter string in volgens dewelke de tokens worden bepaald // einde anonieme inner klasse

); // einde oproep naar addActionListener container.add( inputField ); outputArea = new JTextArea( 10, 20 ); outputArea.setEditable( false ); container.add( new JScrollPane( outputArea ) ); setSize( 275, 260 ); show(); }

// stel de venstergrootte in // toon het venster

53

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// voer de applicatie uit public static void main( String args[] ) { TokenTest application = new TokenTest(); application.addWindowListener( // anonieme inner klasse new WindowAdapter() { // vang het event op wanneer de gebruiker het venster sluit public void windowClosing( WindowEvent windowEvent ) { System.exit( 0 ); } }

// einde anonieme inner klasse

); // einde oproep naar addWindowListener } }

// einde methode main

// einde klasse TokenTest

54

12 public class TokenTest extends JFrame

… { //…… 18 public TokenTest() 19 { …

31 33 34 37 39 40 41 42

inputField.addActionListener( // anonieme inner klasse new ActionListener() { public void actionPerformed( ActionEvent event ) { String stringToTokenize = event.getActionCommand(); StringTokenizer tokens = new StringTokenizer( stringToTokenize );

43

44 45

outputArea.setText( "Number of elements: " + tokens.countTokens() + "\nThe tokens are:\n" );

46

47 48 49 51 53

while ( tokens.hasMoreTokens() ) outputArea.append( tokens.nextToken() + "\n" ); } } // einde anonieme inner klasse ); // einde oproep naar addActionListener

55

56

11.7. Simulatie kaarten schudden en delen 

DeckOfCards applicatie 



 

Creëert een boek met 52 speelkaarten aan de hand van Card objecten “Deal card” button deelt de kaarten één voor één. De gedeelde kaart wordt in een JTextField getoond. “Shuffle cards” button schudt de kaarten Maakt gebruik van random getallen 57

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// Fig. 11.19: DeckOfCards.java // Programma voor het schudden en delen van kaarten // Java core packages import java.awt.*; import java.awt.event.*; // Java extension packages import javax.swing.*; public class DeckOfCards extends JFrame { private Card deck[]; private int currentCard; private JButton dealButton, shuffleButton; private JTextField displayField; private JLabel statusLabel;

currentCard geeft het nummer van de laatst gedeelde kaart aan, -1 als er nog geen kaarten gedeeld werden

// maak een boek kaarten en de GUI public DeckOfCards() { super( "Card Dealing Program" ); String faces[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" }; String suits[] = { "Hearts", "Diamonds", "Clubs", "Spades" }; deck = new Card[ 52 ]; currentCard = -1;

58

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// vul het boek speelkaarten met Card objecten for ( int count = 0; count < deck.length; count++ ) deck[ count ] = new Card( faces[ count % 13 ], suits[ count / 13 ] );

deck[] wordt geïnitialiseerd als een array bestaande uit de kaarten van aas tot en met koning in volgorde voor elke kleur

// maak de GUI en vang de events op Container container = getContentPane(); container.setLayout( new FlowLayout() ); dealButton = new JButton( "Deal card" ); dealButton.addActionListener( // anonieme inner klasse new ActionListener() { // deel één kaart public void actionPerformed( ActionEvent actionEvent ) { Card dealt = dealCard(); if ( dealt != null ) { displayField.setText( dealt.toString() ); statusLabel.setText( "Card #: " + currentCard ); } else { displayField.setText( "NO MORE CARDS TO DEAL" ); statusLabel.setText( "Shuffle cards to continue" ); } }

59

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

}

// einde anonieme inner klasse

); // einde oproep naar addActionListener container.add( dealButton ); shuffleButton = new JButton( "Shuffle cards" ); shuffleButton.addActionListener( // anonieme inner klasse new ActionListener() { // schud de kaarten public void actionPerformed( ActionEvent actionEvent ) { displayField.setText( "SHUFFLING ..." ); shuffle(); displayField.setText( "DECK IS SHUFFLED" ); } }

// einde anonieme inner klasse

); // einde oproep naar addActionListener container.add( shuffleButton ); displayField = new JTextField( 20 ); displayField.setEditable( false ); container.add( displayField );

60

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116

statusLabel = new JLabel(); container.add( statusLabel ); setSize( 275, 120 ); show();

// stel de venstergrootte in // toon het venster

} // schud de kaarten met een algoritme dat deze taak in één beweging uitvoert

public void shuffle() { currentCard = -1; // voor elke kaart, trek een andere random kaart en verwissel de twee

for ( int first = 0; first < deck.length; first++ ) { int second = ( int ) ( Math.random() * 52 ); Card temp = deck[ first ]; deck[ first ] = deck[ second ]; deck[ second ] = temp; }

dealButton.setEnabled( true ); }

61

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 144 146 148 150 151

// deel één kaart public Card dealCard() { if ( ++currentCard < deck.length ) return deck[ currentCard ]; else { dealButton.setEnabled( false ); return null; } } // voer de applicatie uit public static void main( String args[] ) { DeckOfCards app = new DeckOfCards(); app.addWindowListener( // anonieme inner klasse new WindowAdapter() {

}

// beëindig de applicatie als de gebruiker het venster sluit public void windowClosing( WindowEvent windowEvent ) { System.exit( 0 ); } } // einde anonieme inner klasse ); // einde oproep naar addWindowListener } // einde methode main // einde klasse DeckOfCards

62

152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170

// klasse die een kaart representeert class Card { private String face; private String suit; // constructor om een kaart te initialiseren public Card( String cardFace, String cardSuit ) { face = cardFace; suit = cardSuit; } // geef de String represenatie van het Card object terug

public String toString() { return face + " of " + suit; } }

// einde klasse Card

63

Oefening 1 

Schrijf een applicatie die een regel tekst als invoer krijgt, de tekst in tokens opdeelt met behulp van een StringTokenizer en de tokens in omgekeerde volgorde weergeeft.

64

Oefening 1 import java.util.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Oef10_13 extends JFrame { private JLabel inputlbl, outputlbl; private JTextField inputfld, outputfld; public Oef11_13() { super ("Tokens in een zin omkeren"); Container c = getContentPane(); c.setLayout(new FlowLayout()); 65

inputlbl = new JLabel("Geef een zin en druk op Enter:"); c.add(inputlbl); inputfld = new JTextField(20); inputfld.addActionListener ( new ActionListener() { public void actionPerformed(ActionEvent e) { String outputstr = ""; String inputstr = e.getActionCommand(); StringTokenizer tokens = new StringTokenizer(inputstr); while (tokens.hasMoreTokens()) outputstr = tokens.nextToken() + " " + outputstr; outputfld.setText(outputstr); } }

66

outputfld = new JTextField(20); outputfld.setEditable(false); c.add(outputfld); setSize(275,200); show(); } public static void main (String args[]) { Oef11_13 app = new Oef11_13(); app.addWindowListener ( new WindowAdapter() { public void windowClosing(WindowEvent we) { System.exit(0); } } ); } }

67

Oefening 2 

Schrijf een applicatie die alle mogelijke codes van 0 tot 255 omzet naar het bijhorende karakter uit de Unicode-tabel. De resultaten worden getoond in een JTextarea.

68

import java.text.*;

Oefening 2

import java.awt.*; import java.awt.event.*; import javax.swing.*;

public class Oef11_20 extends JFrame { private JTextArea outputarea; public Oef11_20() { super ("De Unicode tabel van karakters"); Container c = getContentPane(); c.setLayout(new FlowLayout()); outputarea = new JTextArea(15,25); c.add(outputarea); outputarea.setText(buildOutput()); outputarea.setEditable(false); setSize(750,600); show(); }

69

public String buildOutput() { String output = ""; DecimalFormat driecijfers = new DecimalFormat("000");

for (int i=0; i
View more...

Comments

Copyright � 2017 NANOPDF Inc.
SUPPORT NANOPDF