Java编程：字符串与字符操作(第9版精华)

需积分: 5 195 浏览量更新于2024-07-19 收藏 15.81MB PDF 举报

"Java编程语言学习资源——《Java How to Program(9th Edition)》英文原版第9版，适合希望深入学习Java的同学。" 在Java编程中，字符串、字符和正则表达式是极其重要的概念，它们在各种场景下都有广泛应用。本章详细介绍了这些主题，旨在帮助学习者掌握如何有效地创建和操作这些对象。首先，关于字符串(String)，Java中的字符串是不可变的，这意味着一旦创建了一个String对象，就不能更改其内容。你将学习如何创建String对象，以及使用String类提供的各种方法进行字符串操作，如拼接、比较、查找子串、替换和截取等。此外，了解字符串的常量池和intern()方法也是必要的，这些概念对于理解字符串的内存管理和性能优化至关重要。其次，对于可变字符序列StringBuilder，当你需要频繁修改字符串时，它比String更有效率。StringBuilder允许你在不创建新对象的情况下添加、删除或修改字符，这对于处理大量文本数据尤为有用。接下来，字符(Character)类提供了处理单个字符的方法，包括转换大小写、检测字符类型（字母、数字、符号等）以及进行Unicode编码和解码。理解字符类的使用对于处理多语言文本和字符编码问题至关重要。然后，章节还涵盖了如何使用String的split()方法将一个字符串分解成多个子字符串，这在处理分隔符分隔的数据时非常实用，例如解析CSV或日志文件。最后，正则表达式(Regular Expressions)是处理和验证字符串的强大工具。学习如何构造和使用正则表达式可以有效地检查用户输入，确保其符合特定格式，如电子邮件地址、电话号码等。正则表达式还可以用于搜索、替换和提取文本中的模式。通过本章的学习，你将能够熟练地运用这些技术来实现各种文本处理任务，无论是简单的数据验证，还是复杂的文本分析和处理，都能得心应手。同时，这些技能对于开发文本编辑器、文字处理器和排版软件等应用来说，都是必不可少的基础。

686 Chapter 16 Strings, Characters and Regular Expressions

Line 20 uses

String

method

toLowerCase

to return a new

String

object with lower-

case letters where corresponding uppercase letters exist in

. The original

String

remains

unchanged. If there are no characters in the original

String

to convert,

toLowerCase

returns the original

String

Line 23 uses

String

method

trim

to generate a new

String

object that removes all

white-space characters that appear at the beginning and/or end of the

String

on which

trim

operates. The method returns a new

String

object containing the

String

without

leading or trailing white space. The original

String

remains unchanged. If there are no

whitespace characters at the beginning and/or end,

trim

returns the original

String

Line 26 uses

String

method

toCharArray

to create a new character array containing

a copy of the characters in

. L ines 29–30 output each

char

in the array.

16.3.8

String

Method

valueOf

As we’ve seen, every object in Java has a

toString

method that enables a program to obtain

the object’s string representation. Unfortunately, this technique cannot be used with

primitive types because they do not have methods. Class

String

provides

static

methods

that take an argument of any type and convert it to a

String

object. Figure 16.9 demon-

strates the

String

class

valueOf

methods.

The expression

String.valueOf(charArray)

at line 18 uses the character array

char-

Array

to create a new

String

object. The expression

String.valueOf(charArray, 3, 3)

at line 20 uses a portion of the character array

charArray

to create a new

String

object.

The second argument specifies t he starting index from which the characters are used. The

third argument specifies the number of characters to be used.

// Fig. 16.9: StringValueOf.java

// String valueOf methods.

public class StringValueOf

{

public static void main( String[] args )

{

char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };

boolean booleanValue = true;

char characterValue = 'Z';

int integerValue = 7;

double doubleValue = 33.333; // no suffix, double is default

Object objectRef = "hello"; // assign string to an Object reference

System.out.printf(

"char array = %s\n",);

System.out.printf( "part of char array = %s\n",

);

System.out.printf(

"boolean = %s\n",);

System.out.printf(

"char = %s\n",);

Fig. 16.9 |

String valueOf

methods. (P art 1 of 2.)

long longValue = 10000000000L; // L suffix indicates long

float floatValue = 2.5f; // f indicates that 2.5 is a float

String.valueOf( charArray )

String.valueOf( charArray, 3, 3 )

String.valueOf( booleanValue )

String.valueOf( characterValue )

16.4 Class StringBuilder 687

There are seven other versions of method valueOf, which take arguments of type

boolean

char

int

long

float

double

and

Object

, respectively. These are demon-

strated in lines 21–30. The version of

valueOf that takes an Object as an argument can

do so because all

Object

s can be converted to

String

swithmethod

toString

[Note: Lines 12–13 use literal values

10000000000L and 2.5f as the initial values of

long

variable

longValue

and

float

variable

floatValue

, respectively. By default, Java

treats integer literals as type

int

and floating-point literals as type

double

. Appending the

letter

to the literal

10000000000

and appending letter

to the literal

2.5

indicates to the

compiler that

10000000000

should be treated as a

long

and

2.5

as a

float

.Anuppercase

or lowercase

can be used to denote a variable of type

long

and an uppercase

or low-

ercase

canbeusedtodenoteavariableoftype

float

16.4 Class

StringBuilder

We now discuss the features of class

StringBuilder

for creating and manipulating dynam-

ic string information—that is, modifiable strings. Every

StringBuilder

is capable of stor-

ing a number of characters specified by its capacity. If a

StringBuilder

’s capacity is

exceeded, the capacity expands to accommodate the additional characters.

System.out.printf( "int = %s\n",);

System.out.printf( "long = %s\n",);

System.out.printf( "float = %s\n",);

System.out.printf(

"double = %s\n",);

System.out.printf( "Object = %s",);

} // end main

} // end class StringValueOf

char array = abcdef

part of char array = def

boolean = true

char = Z

int=7

long = 10000000000

float = 2.5

double = 33.333

Object = hello

Performance Tip 16.2

Java can perform certain optimizations involving

String

objects (such as referring to one

String

object from multiple variables) because it knows these objects will not change.

String

s (not

StringBuilder

s) should be used if the data will not change.

Performance Tip 16.3

In programs that frequently perform string concatenation, or other string modifications,

it’s often more efficient to implement the modifications with class

StringBuilder

Fig. 16.9 |

String valueOf

methods. (P art 2 of 2.)

String.valueOf( integerValue )

String.valueOf( longValue )

String.valueOf( floatValue )

String.valueOf( doubleValue )

String.valueOf( objectRef )

688 Chapter 16 Strings, Characters and Regular Expressions

16.4.1

StringBuilder

Constructors

Class

StringBuilder

provides four constructors. We demonstrate three of these in

Fig. 16.10. Line 8 uses the no-argument

StringBuilder

constructor to create a

String-

Builder

with no characters in it and an initial capacity of 16 characters (the default for a

StringBuilder

). Line 9 uses the

StringBuilder

constructor that takes an integer argu-

ment to create a

StringBuilder

with no characters in it and the initial capacity specified

by the integer argument (i.e.,

). Line 10 uses the

StringBuilder

constructor that takes

String

argument to create a

StringBuilder

containing the characters in the

String

ar-

gument. The initial capacity is the number of characters in the

String

argument plus 16.

Lines 12–14 implicitly use the method

toString

of class

StringBuilder

to output

the

StringBuilder

swiththe

printf

method. In Section 16.4.4, we discuss how Java uses

StringBuilder

objects to implement the

and

operators for string concatenation.

16.4.2

StringBuilder

Methods

length

capacity

setLength

and

ensureCapacity

Class

StringBuilder

provides methods

length

and

capacity

to return the number of

characters currently in a

StringBuilder

and the number of characters that can be stored

in a

StringBuilder

without allocating m ore memory, respectively. Method

ensure-

Capacity

guarantees that a StringBuilder

has at least the specified capacity. Method

Software Engineering Observation 16.2

StringBuilder

s are not thread safe. If multiple threads require access to the same

dynamic string information, use class

StringBuffer

in your code. Classes

StringBuilder

and

StringBuffer

provide identical capabilities, but class

StringBuffer

is thread safe.

For more details o n threading, see Chapter 26.

// Fig. 16.10: StringBuilderConstructors.java

// StringBuilder constructors.

public class StringBuilderConstructors

{

public static void main( String[] args )

{

System.out.printf( "buffer1 = \"%s\"\n", buffer1 );

System.out.printf( "buffer2 = \"%s\"\n", buffer2 );

System.out.printf( "buffer3 = \"%s\"\n", buffer3 );

} // end main

} // end class StringBuilderConstructors

buffer1 = ""

buffer2 = ""

buffer3 = "hello"

Fig. 16.10 |

StringBuilder

constructors.

StringBuilder buffer1 = new StringBuilder();

StringBuilder buffer2 = new StringBuilder( 10 );

StringBuilder buffer3 = new StringBuilder( "hello" );

16.4 Class StringBuilder 689

setLength

increases or decreases the length of a

StringBuilder

. Figure 16.11 demon-

strates these methods.

The application contains o ne

StringBuilder

called

buffer

.Line8usesthe

String-

Builder

constructor that takes a

String

argument to initialize the

StringBuilder

with

"Hello, how are you?"

. Lines 10–11 print the contents, length and capacity of the

StringBuilder

. Note in the output window that the capacity of the

StringBuilder

is ini-

tially 35. Recall that the

StringBuilder

constructor that takes a

String

argument initial-

izes the capacity to the length of the string passed as an argument plus 16.

Line 13 uses method

ensureCapacity

to expand the capacity of the

StringBuilder

to a minimum of 75 characters. Actually, if the original capacity is less than the argument,

the method ensures a capacity that’s the greater of the number specified as an argument

and twice the original capacity p lus 2. The

StringBuilder

’s current capacity remains

unchanged if it’s more than the specified capacity.

// Fig. 16.11: StringBuilderCapLen.java

// StringBuilder length, setLength, capacity and ensureCapacity methods.

public class StringBuilderCapLen

{

public static void main( String[] args )

{

StringBuilder buffer = new StringBuilder( "Hello, how are you?" );

System.out.printf( "buffer = %s\nlength = %d\ncapacity = %d\n\n",

buffer.toString(), , );

System.out.printf( "New capacity = %d\n\n",);

System.out.printf( "New length = %d\nbuffer = %s\n",

, buffer.toString() );

} // end main

} // end class StringBuilderCapLen

buffer = Hello, how are you?

length = 19

capacity = 35

New capacity = 75

New length = 10

buffer = Hello, how

Fig. 16.11 | StringBuilder length

setLength

capacity

and

ensureCapacity

methods.

Performance Tip 16.4

Dynamically increasing the capacity of a

StringBuilder

can take a relatively long time.

Executing a large number of these operations can degrade the performance of an applica-

tion. If a

StringBuilder

is going to increase greatly in size , possibly multiple times, setting

its capacity high at the beginning will increase performance.

buffer.length() buffer.capacity()

buffer.ensureCapacity( 75 );

buffer.capacity()

buffer.setLength( 10 );

buffer.length()

690 Chapter 16 Strings, Characters and Regular Expressions

Line 16 uses method

setLength

to set the length of the

StringBuilder

to 10. If the

specified length is less than the current number of characters in the

StringBuilder

,the

buffer is truncated to the specified length (i.e., the characters in the

StringBuilder

after

the specified length are discarded). If the specified length is greater than the number of

characters currently in the

StringBuilder

null

characters (characters with the numeric

representation 0) are appended until the total number of characters in the

StringBuilder

is equal to the specified length.

16.4.3 StringBuilder Methods charAt, setCharAt, getChars and

reverse

Class

StringBuilder

provides methods

charAt

setCharAt

getChars

and

reverse

manipulate the characters in a

StringBuilder

(Fig. 16.12). Method

charAt

(line 12)

takes an integer argument and returns the character in the

StringBuilder

at that index.

Method

getChars

(line 15) copies characters from a

StringBuilder

into the character ar-

ray passed as an argument. This method takes four arguments—the starting index from

which characters should be copied in the

StringBuilder

, the index one past the last char-

acter to be copied from the

StringBuilder

, the character array into which the characters

are to be copied and the starting location in the character array where t he first character

should be placed. Method

setCharAt

(lines 21 and 22) takes an integer and a character

argument and sets the character at the specified position in the

StringBuilder

to the char-

acter argument. Method

reverse

(line 25) reverses the contents of the

StringBuilder

Common Programming Error 16.3

Attempting to access a character that’s outside the b ounds of a

StringBuilder

(i.e., with

an index less than 0 or greater than or equal to the

StringBuilder

’s length) results in a

StringIndexOutOfBoundsException

// Fig. 16.12: StringBuilderChars.java

// StringBuilder methods charAt, setCharAt, getChars and reverse.

public class StringBuilderChars

{

public static void main( String[] args )

{

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

System.out.printf( "buffer = %s\n", buffer.toString() );

System.out.printf( "Character at 0: %s\nCharacter at 4: %s\n\n",

,);

char[] charArray = new char[ buffer.length() ];

System.out.print( "The characters are: " );

for ( char character : charArray )

System.out.print( character );

Fig. 16.12 |

StringBuilder

methods

charAt

setCharAt

getChars

and

reverse

.(Part1

of 2.)

buffer.charAt( 0 ) buffer.charAt( 4 )

buffer.getChars( 0, buffer.length(), charArray, 0 );

剩余826页未读，继续阅读

Persuitor

粉丝: 0
资源: 2

Java编程：字符串与字符操作(第9版精华)

（英文）Java How to Program Early Objects 9TH Edition

Java How To Program Ninth Edition

Java: How to Program, 9th Edition (Deitel)

java how to program 11th

java how to program, 10 late objects pdf

java how to program

java how to program中文

c++ how to program 10th 英文版

java how to program deitel and deitel jhpt11幻灯片

c how to program电子版

最新资源