PowerPoint-presentatie

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<=255; i++)
{
char kar = (char) i;
Character c = new Character(kar);
output += driecijfers.format(i) + " " + c.charValue() + "\t";
if ((i+1)%8 == 0)
output += "\n";
}
return output;
}
70
public static void main (String args[])
{
Oef11_20 app = new Oef11_20();
app.addWindowListener
(
new WindowAdapter()
{
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
}
);
}
}
71