当前位置：文档之家› Java字符串处理

Java字符串处理

字符串处理

第1章概述 (2)

第2章 String构造函数 (2)

第3章字符串的长度 (4)

第4章特殊的字符串操作 (5)

4.1 字符串字面量 (5)

4.2 字符串的连接 (5)

4.3 字符串和其他数据类型的连接 (6)

4.4 字符串的转换和toString() (7)

第5章字符截取 (8)

5.1 charAt() (8)

5.2 getChars() (9)

5.3 getBytes() (9)

5.4 toCharArray() (9)

第6章字符串比较 (10)

6.1 equals()和equalsIgnoreCase() (10)

6.2 redionMatches() (11)

6.3 startsWith()和endsWith() (11)

6.4 equals()与== (12)

6.5 compareTo() (12)

第7章搜索字符串 (14)

第8章修改字符串 (16)

8.1 substring() (16)

8.2 concat() (17)

8.3 replace() (17)

8.4 trim() (18)

第9章使用valueOf()进行数据转换 (19)

第10章改变字符串中字符的大小写 (19)

第11章附加的String方法 (20)

第12章 StringBuffer (21)

12.1 StringBuffer构造函数 (21)

12.2 length()和capacity() (22)

12.3 ensureCapacity() (22)

12.4 setLength() (23)

12.5 charAt()和setCharAt() (23)

12.6 getChars() (24)

12.7 append() (24)

12.8 insert() (25)

12.9 reverse() (26)

12.10 delete()和deleteCharAt() (26)

12.11 replace() (27)

12.12 substring() (27)

12.13 附加的StringBuffer方法 (28)

第13章 StringBuilder (29)

第1章概述

像大多数编程语言一样，在Java中，字符串是字符的序列。但是与许多其他以字符数组实现字符串处理的编程语言不同，Java是以String类型的对象来实现字符串的。

Java将字符串作为内置的对象处理，就提供了丰富的特性来处理字符串。例如：Java 语言有多种方法用于比较两个字符串、查找字串、连接字符串以及改变字符串中字母的大小写。而且，可以通过多种方式来构造String对象，这样在需要时可以很容易地获得一个字符串。

有些出乎意料的是，当创建一个String对象时，所创建的字符串是不可改变的。也就是说，一旦创建了一个String对象，就不能改变里面的字符。这给人的初步印象好像是严格约束，但实际上并不是这样的，你仍可以完成各种类型的字符串操作。不同之处在于，每次需要修改现有的字符串时，一个包含修改结果的String对象被创建，而原来的字符串不变。只用这种方式是因为固定不变的字符串执行效率比变化的字符串要高。在需要使用可修改的字符串时，Java提供两个选项，StringBuffer和StringBuilder。它们包含的字符串在创建后可以修改。

String、StringBuffer和StringBuilder类都是在https://www.doczj.com/doc/bd702920.html,ng中定义的。因此，它们能被所有程序使用。它们都被声明为final类型，这意味着它们不能产生子类。这允许某些增强性能的优化可作用于普通的字符串操作。这三个类都实现CharSequence接口。

最后声明一点：String类型的字符串不能改变意味着String实例的内容在创建后不能改变。然而，声明为String对象引用的变量在任何时候都可以改变，以指向一些其他的String 对象。

第2章 String构造函数

String类支持几种构造函数，调用默认的构造函数可以创建一个空字符串。例如：String s = new String();

将创建一个String实例，该实例中不包含字符。

如果创建有初始值的字符串，String类提供了一系列构造函数来完成该功能。为了创建由字符数组初始化的字符串，可以使用下面的构造函数：

String(char chars[])

下面是一个例子：

char chars[] = {'a', 'b', 'c'};

String s = new String(chars);

这个构造函数用字符串“abc”来初始化s。

可以使用下面的构造函数指定字符数组的一个范围为初始化值。

String(char chars[], int startIndex, int numChars)

这里，startIndex指定子范围开始的下标，numChars指定所用字符的个数。这里有一个例子：

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

String s = new String(chars, 2, 3);

它使用cde初始化。

用下面的构造函数可以构造一个String对象，该对象包括了与另一个String对象相同的字符序列。

String(String strObj)

这里，strObj是String对象，请看下面的例子：

// Construst one String from another.

class MakeString {

public static void main(String[] args) {

char c[] = {'J', 'a', 'v', 'a'};

String s1 = new String(c);

String s2 = new String(s1);

System.out.println(s1);

System.out.println(s2);

}

程序输出如下：

Java

可以看到s1和s2包含相同的字符串。

Java的Char类型使用16位（bit）Unicode字符集，在Internet中，字符串的典型是使用从ASCII字符集构造的8位字节数组。因为一般使用8位ASCII字符串，当给定一个字节数组时，String类提供了初始化字符串的构造函数。它们形式如下：

String(byte asciiChars[])

String(byte asciiChars[], int startIndex, numChars)

这里，asciiChars指定字节数组。第二种形式允许指定一个范围。在每一种构造函数中，字节到字符的转换是通过使用平台默认的字符编码完成的。下面的程序说明了这些构造函数：

// Construct string from subset of char array.

class SubStringCons {

public static void main(String[] args) {

byte ascii[] = {65, 66, 67, 68, 69, 70};

String s1 = new String(ascii);

System.out.println(s1);

String s2 = new String(ascii, 2, 3);

System.out.println(s2);

}

程序输出如下：

ABCDEF

CDE

字节—字符转换构造函数的扩展版本是通过指定字节到字符转换的字符编码来定义的。但大多数时间使用的是平台默认编码。

第3章字符串的长度

字符串的长度是指包含的字符个数。为了获取该值，调用length()方法，如下所示：int length()

下面程序结果是3，因为s中有3 个字符。

char chars[] = {'a', 'b', 'c'};

String s = new String(chars);

System.out.println(s.length());

第4章特殊的字符串操作

因为字符串是编程中一个通用而且重要的部分，Java在语法中为字符串操作添加了特殊的支持。这些操作包括从字符串的字面量中自动创建的新字符串实例。通过+运算符连接多个字符串对象，转换其他数据类型为字符串形式等。尽管有显示的方法可以执行这些函数，但是Java可以自动完成这些操作以方便编程人员，同时增加代码的清晰度。

4.1 字符串字面量

前面的例子是使用new操作从字符数组显示的创建一个String实例，但是有一种更容易的实现方式，即使用字符串字面量。对于程序中的每个字符串字面量，Java自动的构造一个String对象，因此可以使用字符串字面量初始化一个String对象。例如，下面的代码片段创建两个相等的字符串。

char chars[] = {'a', 'b', 'c'};

String s1 = new String(chars);

String s2 = "abc";

因为Java自动为每个字符串字面量创建String对象，所以可以在能够用String对象的任何地方使用字符串字面量。例如，可以直接用引号内的字符串，就像是一个对象的引用，如下面的语句所示。该条语句调用“abc”字符串的length()方法，结果是打印“3”。

System.out.println("abc".length());

4.2 字符串的连接

一般情况下Java不允许运算符直接应用于String对象，唯一的例外是+运算符，它用来连接两个字符串，结果产生一个新的字符串。同时，也允许使用一连串的+运算符。

例如：

String age = "9";

String s = "He is " + age + " years old.";

System.out.println(s);

它显示字符串“He is 9 years old.”。

字符串连接的是一个实际应用是，当要创建一个很长的字符串时，可以将其拆开，然后使用+将各子串连接起来，以避免源代码中长字符串的换行。下面是一个例子：// Using concatenation to prevent long lines.

class ConCat {

public static void main(String[] args){

String longStr = "This could have bean " +

"a very long line that would have " +

"wrapped arround. But string concatenation " +

"prevents this.";

System.out.println(longStr);

}

4.3 字符串和其他数据类型的连接

在Java中，还可以把字符串和其他的数据类型相连接。例如，考虑与前面例子略有差别的一个例子：

int age = 9;

String s = "He is " + age + " years old.";

System.out.println(s);

本例中，age是一个整型（int）而不是另一个String型值，但是产生的输出与前面一样。这是因为age的int值在String对象中会自动转化为它的字符串形式，然后这个字符串和前面一样被连接。这是因为只要+运算符的一个操作数是String实例，编译器就会将另一个操作数转换为它的字符串形式。

对于其他类型的数值，在于字符串连接表达式混合时应当谨慎，因为有时会得到很意外的结果。如下面的情况：

String s = "four: " + 2 + 2;

System.out.println(s);

它的结果显示：

four: 22

而不是预期的：

four: 4

原因是这样的：由于运算符的优先级高，所以“four: ”与2的字符串形式的连接首先发生，然后，它的结果再与2的字符串形式再连接一次。若要先完成整数的加法，必须使用括号，如下所示：

String s = "four: " + (2 + 2);

现在s包含了字符串“four: 4”。

4.4 字符串的转换和toString()

在连接过程中，当Java将数据转换为字符串形式时，它是通过调用一个字符串转换方法valueOf()的重载版本来完成的。valueOf()是String类定义的方法，valueOf()被重载后用于所有的简单数据类型的Object类型。对于简单数据类型，valueOf()返回一个字符串，该字符串包含了被调用的值的可读值。对于Object类型，valueOf()调用该对象的toString()方法。

每一个类都实现了toString()方法，它是由Object类定义的，但toString()的默认实现往往是不够的。因为对大多数自创建的重要的类来说，通常要重写toString()并提供自己的字符串表单形式。幸运的是，这很容易做到。toString()方法的一般形式如下：String toString()

要实现toString()方法，只需要返回一个String对象，该对象包含描述类对象的可读字符串。

通过重写所创建类的toString()，可以将其完全集成到Java的编程环境中。例如，它可用于print()和println()语句以及连接表达式中。下面程序重写了类Box的toString()方法。

// Override toString() for Box class.

class Box {

double width;

double heoght;

double depth;

Box(double w, double h, double d){

width = w;

height = h;

depth = d;

}

public String toString(){

return "Dimensions are " + width + " by " + depth + " by " + height + ".";

}

class ToStringDemo{

public static void main(String[] args){

Box b = new Box(10, 12, 14);

String s = "Box b: " + b;

System.out.println(b);

System.out.println(s);

}

程序的输出结果如下：

Dimensions are 10.0 by 14.0 by 12.0

Box b: Dimensions are 10.0 by 14.0 by 12.0

可以看到，当Box对象在连接表达式中使用或出现在调用println()中时，Box的toString()方法被自动调用。

第5章字符截取

String类提供了几个从字符串中截取字符的方法，下面逐一介绍。尽管在String对象中构成字符串的字符不能像字符数组一样被索引，但利用下标（或偏移）可以对字符串进行操作。就像数组一样，String的下标从0开始。

5.1 charAt()

为了从一个字符串（String）中截取一个字符，可以通过charAt()方法直接引用单个字符。其一般形式如下：

char charAt(int where)

这里，where是想要获取的字符下标。where的值必须为非负，因为它指定了在字符串中的位置。charAt()返回指定位置的字符。例如：

char ch;

ch = "abc".charAt(1);

将“b”赋值给ch。

5.2 getChars()

如果需要一次截取多个字符，可以使用getChars()方法。它的一般形式如下：

void getChars(int sourceStart, int sourceEnd, char target[], int targetStart)

这里sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target 指定，target中开始复制了串的下标值是targetStart。注意，要确保target数组足够大，以便容纳指定的子串。下面的程序演示了getChars()：

class GetCharsDemo{

public static void main(String[] args){

String s = "This is a demo of the getChars method.";

int start = 10;

int end = 14;

char buf[] = new char[end – start];

s.getChars(start, end, buf, 0);

System.out.println(buf);

}

输出结果如下：

demo

5.3 getBytes()

替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()，它使用平台提供的默认的字符转换到字节的方法。下面是它的最简形式：

byte[] getBytes()

也可以使用其他形式的getBytes()。getBytes()经常用于将字符串值输入一个不支持16位Unicode字符的环境中，例如，多数Internet协议和文本格式使用8位ASCII进行文本交换。

5.4 toCharArray()

如果想将字符串对象的所有字符转换到一个字符数组中最简单的方法就是调用

toCharArray()。它返回输入字符串的字符数组。

char[] toCharArray()

这是一种简洁方法。使用getChars()也可以达到同样的目的。

第6章字符串比较

String类包括几种比较字符串或子串的方法，下面分别进行介绍。

6.1 equals()和equalsIgnoreCase()

要比较两个字符串是否相等，使用equals()。它的形式如下：

boolean equals(Object str)

这里str是与调用字符串对象进行比较的字符串对象。如果字符串包含同样顺序的同样字符，它返回true。否则，返回false。比较时是区分大小写的。

如果要进行忽略大小写的比较，可以调用equalsIgnoreCase()。当它比较两个字符串时，它认为A-Z和a-z是一样的。它的一般形式如下：

boolean equalsIgnoreCase(Object str)

这里，str是与调用字符串比较的字符串对象。如果两个字符串包含同样顺序字符，啊返回true。否则，返回false。

下面是一个演示equals()和equalsIgnoreCase()的例子：

// Demonstrate equals() and equalsIgnoreCase().

class EqualsDemo{

public static void main(String[] args){

String s1 = "Hello";

String s2 = "Hello";

String s3 = "Good-bye";

String s4 = "HELLO";

System.out.println(s1 + " equals " + s2 + " --> " + s1.equals(s2));

System.out.println(s1 + " equals " + s3 + " --> " + s1.equals(s3));

System.out.println(s1 + " equals " + s4 + " --> " + s1.equals(s4));

System.out.println(s1 + " equalsIgnoreCase " + s4 + " --> " +

s1.equalsIgnoreCase(s4));

}

程序输出部分如下：

Hello equals Hello --> true

Hello equals Good-bye --> false

Hello equals HELLO --> false

Hello equalsIgnoreCase HELLO --> true

6.2 regionMatches()

regionMatches()方法用于比较一个字符串中特定区域与另一个字符串的另一特定区域，它有一个重载的形式允许在比较中忽略大小写。下面是这方法的两种常用形式：boolean regionMatches(int startIndex, String str2, int str2StartIndex, int numChars)

boolean regionMatches(boolean ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars)

两种版本中，startIndex都是指字符串的区域的开始点，被比较的字符串由str2指定，str2的开始由str2StartIndex指定，numChars是指被比较的子串的长度，如果ignoreCase为true，字符比较忽略大小写，否则区分大小写。

6.3 startsWith()和endsWith()

String定义了两个例程，它们可以说是regionMatches()的特殊形式。startsWith()方法决定字符串是否特定字符开始，endsWith()方法决定给字符串是否是以特定字符串结果。它们的一般形式如下：

boolean startsWith(String str)

boolean endsWith(String str)

这里，str是被测试的字符串。如果字符串匹配，返回true，否则返回false。例如："Foobar".endsWith("bar")

和

"Foobar".startsWith("Foo")

都返回true。

第二种形式的startsWith()如下所示，需要指定起始点：

boolean startsWith(String str, int startIndex)

这里，startIndex指调用字符串搜索的开始点，例如：

"Foobar".startsWith("bar", 3)

将返回true。

6.4 equals()与==

equals()方法和==运算符完成的是两个不同的操作。equals()方法是比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。在下面的程序中，两个不同的字符串包含同样的字符，但是对引用的比较是不相等的。

// equals() vs ==

class EqualsNotEqualsTo {

public static void main(String[] args){

String s1 = "Hello";

String s2 = "Hello";

System.out.println(s1 + " equals " + s2 + " --> " + s1.equals(s2));

System.out.println(s1 + " == " + s2 + " --> " + (s1 == s2));

}

变量s1引用值是为“Hello”的一个字符串实例。s2引用的对象是以s1作为初始化字符串的实例。因此，两个字符串的内容是相同的，但他们是不同的对象。这也就意味着s1和s2不是引用同一对象，因此，不是==，程序的输出如下：

Hello equals Hello --> true

Hello == Hello --> false

6.5 compareTo()

通常，简单的知道两个字符串是否相等是不够的。对需要排序的应用来说，还需要知道哪一个小于、相等、大于另一个。在字典编排法中，如果一个字符串排在另一个的前面，它就是小于，如果排在另一个的后面，就是大于。String的compareTo()方法正是用于比较的。它的一般形式如下：

int compareTo(String str)

这里，str是与调用字符串进行比较的字符串。比较的结果解释如下：

下面是在字符串数组中进行排序的程序，使用compareTo()来确定冒泡排序的顺序号：// A bubble sort for Strings.

class SortString {

static String arr[] = {

"Now", "is", "the", "time", "for", "all", "good", "men",

"to", "come", "to", "the", "aid", "of", "their", "country"

};

public static void main(String[] args){

for(int j = 0; j < arr.length; j++){

for(int i = j + 1; i < arr.length; i++){

if(arr[i].compareTo(arr[j]) < 0){

String t = arr[j];

arr[j] = arr[i];

arr[i] = t;

}

System.out.println(arr[j]);

}

程序输出下列单词：

Now

aid

all

come

country

for

good

men

the

their

time

从程序是输出可以看到，compareTo()考虑了大小写字母。单词“Now”在所有其他单词中先出来是因为它以大写字母开头，而大写字母在ASCII字符集中具有更小的值。

如果想在比较字符串时忽略大小写，可以使用如下的compareToIgnoreCase()方法：int compareToIgnoreCase(String str)

该方法返回与compareTo()同样的结果，但会除了忽略大小写。如果在前面的例子中使用这个方法，“Now”将不会最先显示出来。

第7章搜索字符串

String类提供了两个方法，用于在字符串中查找特定字符或者子串。

indexOf() 查找字符或者子串第一次出现的地方。

lastIndexOf() 查找字符或者子串最后一次出现的地方。

这两个方法以多种方式被重载。在所有情况下，这些方法都将返回字符或者子串出现的下标，如果失败，返回-1。

要查找字符第一次出现的地方，用

int indexOf(int ch)

要查找字符最后出现的地方，用

int lastIndexOf(int ch)

这里ch是被搜索的字符。

要查找子串第一次或最后一次出现的地方，用

int indexOf(String str)

int lastIndexOf(String str)

这里，str指要被搜索的子串。

也可以指定查找的起点：

int indexOf(int ch, int startIndex)

int lastIndexOf(int ch, int startIndex)

int indexOf(String str, int startIndex)

int lastIndexOf(String str, int startIndex)

这里，startIndex指定查找的起点，对于indexOf()，查找是从startIndex开始到字符串结束。对于lastIndexOf()，查找从startIndex开始到0。

下面的例子是在字符串中进行查找的各种索引方法：

// Demonstrate indexOf() and lastIndexOf()

class IndexOfDemo {

public static void main(String[] args){

String s = "Now is the time for all good men to come to the aid of their country."

System.out.println(s);

System.out.println("indexOf(t) = " + s.indexOf('t'));

System.out.println("lastIndexOf(t) = " + https://www.doczj.com/doc/bd702920.html,stIndexOf('t'));

System.out.println("indexOf(the) = " + s.indexOf("the"));

System.out.println("lastIndexOf(the) = " + https://www.doczj.com/doc/bd702920.html,stIndexOf("the"));

System.out.println("indexOf(t, 10) = " + s.indexOf('t', 10));

System.out.println("lastIndexOf(t, 60) = " + https://www.doczj.com/doc/bd702920.html,stIndexOf('t', 60));

System.out.println("indexOf(the, 10) = " + s.indexOf("the", 10));

System.out.println("lastIndexOf(the, 60) = " + https://www.doczj.com/doc/bd702920.html,stIndexOf("the", 60));

}

程序的输出结果如下：

Now is the time for all good men to come to the aid of their country.

indexOf(t) = 7

lastIndexOf(t) = 65

indexOf(the) = 7

lastIndexOf(the) = 55

indexOf(t, 10) = 11

lastIndexOf(t, 60) = 55

indexOf(the, 10) = 44

lastIndexOf(the, 60) = 55

第8章修改字符串

因为String对象是不变的，当想修改一个字符串时，就必须把它复制到一个StringBuffer 中或者使用下面String方法之一，它在修改后会构造一个新的字符串副本。

8.1 substring()

可以使用substring()截取一个子串。它有两种形式，第一种是：

String substring(int startIndex)

这里，startIndex指定substring的开始点。这种形式返回从startIndex开始到调用字符串结束的子串的一个副本。第二种形式允许指定子串的起点和终点：

String substring(int startIndex, int endIndex)

这里，startIndex指定起点，endIndex指定终点。返回子串包括从起点到终点但不包括终点的所有字符。

下面的程序使用substring()方法在一个字符串内用一个子字符串替换另一个子字符串的所有方式：

// Substring replacement.

class StringReplace {

public static void main(String[] args){

String org = "This is a test. This is , too.";

String search = "is";

String sub = "was";

String result = "";

int i;

do{ // replace all matching substrings

System.out.println(org);

i = org.indexOf(search);

if(i != -1){

result = org.substring(0, i);

result = result + sub;

result = result + org.substring(i +search.length());

org = result;

}

}while(i != -1);

}

程序的输出如下所示：

This is a test. This is, too.

Thwas is a test. This is, too.

Thwas was a test. This is, too.

Thwas was a test. Thwas is, too.

Thwas was a test. Thwas was, too.

8.2 concat()

可以使用concat()连接两个字符串，如下所示：

String concat(String str)

该方法创建一个新对象，这个对象包含调用字符串，而str内容跟在调用字符串后面。concat()与+运算符的功能相同。例如：

String s1 = "one";

String s2 = s1.concat("two");

将“onetwo”放到s2中。下面的程序产生同样的结果：

String s1 = "one";

String s2 = s1 + "two";

8.3 replace()

replace()方法有两种形式。第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换。它的一般形式如下：

String replace(char original, char replacement)

这里，original指定被replacement替换的字符，结果字符串被返回。例如：

String s = "Hello".replace('l', 'w');

放置“Hewwo”到s中。

replace()的第二种形式是一个字符序列替换到另一个字符序列。它的一般形式如下：String replace(CharSequence original, CharSequence replacement)

此形式是在J2SE 5中添加的。

8.4 trim()

trim()方法返回调用字符串对象的一个副本，但是所有起始和结尾的空格都被删除了。它的一般形式如下：

String trim()

下面是一个例子：

String s = " Hello World ".trim();

这把“Hello World”放到s中。

trim()方法在执行用户命令时十分有用。例如，下面的程序提示用户输入一个国家的名字，然后显示那个国家的首都。它使用trim()可以删除用户无意输入的起始和结尾的空格。

// Using trim() to process commands.

import java.io.*;

class UseTrim {

public static void main(String[] args) throws IOException {

// Create a BufferedReader using System.in

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

System.out.println("Enter 'stop' to quit.");

System.out.println("Enter State: ");

do {

str = br.readLine();

str = str.trim();

if(str.equals("Illinois"))

System.out.println("Capital is Springfield.");

else if(str.equals("Missouri"))

System.out.println("Capital is Jefferson city.");

// ...

}while(!str.equals("stop");

}

第9章使用valueOf()进行数据转换

valueOf()方法是把数据从它的内部形式转换到人们易读的形式。它是在String中为所有Java内置的数据类型重载的静态方法，以便每一种数据都可以转换为字符串。valueOf()也为Object类型重载，因此任何形式类型的对象都可以作为参数（记住，Object是所有类型的超类）。下面是它的几种形式：

static String valueOf(double num)

static String valueOf(long num)

static String valueOf(Object ob)

static String valueOf(char chars[])

正如前面所讨论的，当需要其他数据类型的字符串表达式时，例如连接时，调用valueOf()。对各种数据类型，可以直接调用这种方法并得到一个合理的字符串表示。所有的简单类型被转换为它们公共的字符串形式，传送到valueOf()的任何对象都返回调用对象的toString()方法的结果。事实上，直接调用toString()可以得到同样的结果。

对于大多数数组而言，valueOf()返回一个相当晦涩的字符串，说明它是某种类型的数组。但是，对字符数组而言，创建的是包含字符数组的字符串。valueOf()有一个特殊的版本，允许指定char数组的子集。它的形式如下：

static String valueOf(char chars[], int startIndex, int numChars)

这里，chars是字符数组，startIndex是字符数组中所需子串的开始下标，numChars指定子串的长度。

第10章改变字符串中字符的大小写

toLowerCase()方法将字符串中所有字符从大写转换为小写，toUpperCase()方法将字符串中所有字符从小写字母转换为大写字母，非字母的字符（如数字）不受影响。这些方法的一般形式如下：

String toLowerCase()

String toUpperCase()

这两种方法返回与调用字符串对应的大写或小写的字符串对象。

JAVA字符串格式化-String.format()的使用

JAVA字符串格式化-String.format()的使用常规类型的格式化 String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()方法，两者有类似之处。format()方法有两种重载形式。 format(String format, Object... args) 新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。 format(Locale locale, String format, Object... args) 使用指定的语言环境，制定字符串格式和参数生成格式化的字符串。显示不同转换符实现不同数据类型到字符串的转换，如图所示。转换符说明示例 %s 字符串类型"mingrisoft" %c 字符类型'm' %b 布尔类型true %d 整数类型（十进制）99 %x 整数类型（十六进制）FF %o 整数类型（八进制）77 %f 浮点类型99.99 %a 十六进制浮点类型FF.35AE %e 指数类型9.38e+5 %g 通用浮点类型（f和e类型中较短的） %h 散列码 %% 百分比类型％ %n 换行符 %tx 日期与时间类型（x代表不同的日期与时间转换符测试用例 [java]view plaincopy 1.public static void main(String[] args) { 2. String str=null;

3. str=String.format("Hi,%s", "王力"); 4. System.out.println(str); 5. str=String.format("Hi,%s:%s.%s", "王南","王力","王张"); 6. System.out.println(str); 7. System.out.printf("字母a的大写是：%c %n", 'A'); 8. System.out.printf("3>7的结果是：%b %n", 3>7); 9. System.out.printf("100的一半是：%d %n", 100/2); 10. System.out.printf("100的16进制数是：%x %n", 100); 11. System.out.printf("100的8进制数是：%o %n", 100); 12. System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85); 13. System.out.printf("上面价格的16进制数是：%a %n", 50*0.85); 14. System.out.printf("上面价格的指数表示：%e %n", 50*0.85); 15. System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85); 16. System.out.printf("上面的折扣是%d%% %n", 85); 17. System.out.printf("字母A的散列码是：%h %n", 'A'); 18.} 输出结果 [plain]view plaincopy 1.Hi,王力 2.Hi,王南:王力.王张 3.字母a的大写是：A 4.3>7的结果是：false 5.100的一半是：50 6.100的16进制数是：64 7.100的8进制数是：144 8.50元的书打8.5折扣是：42.500000 元 9.上面价格的16进制数是：0x1.54p5 10.上面价格的指数表示：4.250000e+01 11.上面价格的指数和浮点数结果的长度较短的是：42.5000 12.上面的折扣是85% 13.字母A的散列码是：41 搭配转换符的标志，如图所示。标志说明示例结果+ 为正数或者负数添加符号("%+d",15) +15 ?左对齐("%-5d",15) |15 | 0 数字前面补0 ("%04d", 99) 0099 空格在整数之前添加指定数量的空格 ("% 4d", 99) | 99| , 以“,”对数字分组("%,f", 9999.99) 9,999.990000

Java统计字符串中每个字符出现次数

Java统计字符串中每个字符出现次数package com.perry.test; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * * @author perry_zhao * 统计一个字符串中每个字符出现的次数（不忽略大小写） */ public class CountStr { public Map count(String str){ System.out.println("需要统计的字符串:"+str+"准备开始统计每个字符出现的次数..."); Map map = new HashMap(); String temp =""; for(int i=0; i

Java分割字符串

https://www.doczj.com/doc/bd702920.html,ng.String 的 split() 方法, JDK 1.4 or later public String[] split(String regex,int limit) 示例代码 public class StringSplit { public static void main(String[] args) { String sourceStr = "1,2,3,4,5"; String[] sourceStrArray = sourceStr.split(","); for (int i = 0; i < sourceStrArray.length; i++) { System.out.println(sourceStrArray[i]); } // 最多分割出3个字符串 int maxSplit = 3; sourceStrArray = sourceStr.split(",", maxSplit); for (int i = 0; i < sourceStrArray.length; i++) { System.out.println(sourceStrArray[i]); } } } 输出结果： 1 2 3 4 5 1 2 3,4,5

split 的实现直接调用的 matcher 类的 split 的方法。在使用String.split方法分隔字符串时，分隔符如果用到一些特殊字符，可能会得不到我们预期的结果。在正则表达式中有特殊的含义的字符，我们使用的时候必须进行转义，示例： public class StringSplit { public static void main(String[] args) { String value = "192.168.128.33"; // 注意要加\\,要不出不来,yeah String[] names = value.split("\\."); for (int i = 0; i < names.length; i++) { System.out.println(names[i]); } } } split分隔符总结 1.字符"|","*","+"都得加上转义字符，前面加上"\\"。 2.而如果是"\"，那么就得写成"\\\\"。 3.如果一个字符串中有多个分隔符，可以用"|"作为连字符。比如：String str = "Java string-split#test",可以用Str.split(" |-|#")把每个字符串分开。这样就把字符串分成了3个子字符串。 java.util.Tokenizer JDK 1.0 or later StringTokenizer StringTokenizer 类允许应用程序将字符串分解为标记。StringTokenizer 是出于兼容性的原因而被保留的遗留类（虽然在新代码中并不鼓励使用它）。建议所有寻求此功能的人使用String 的 split 方法或 java.util.regex 包。代码示例 public class StringSplit { public static void main(String[] args) { String ip = "192.168.128.33"; StringTokenizer token=new StringTokenizer(ip,"."); while(token.hasMoreElements()){

Java字符串查找

Java中字符串中子串的查找共有四种方法，如下： 1、int indexOf(String str) ：返回第一次出现的指定子字符串在此字符串中的索引。 2、int indexOf(String str, int startIndex)：从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。 3、int lastIndexOf(String str) ：返回在此字符串中最右边出现的指定子字符串的索引。 4、int lastIndexOf(String str, int startIndex) ：从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。 indexof()用法说明 indexof() 返回String 对象内第一次出现子字符串的字符位置。 string.indexOf(subString[, startIndex]) 参数 string 必选项。String 对象或文字。 subString 必选项。要在String 对象中查找的子字符串。 starIndex 可选项。该整数值指出在String 对象内开始查找的索引。如果省略，则从字符串的开始处查找。说明 indexOf 方法返回一个整数值，指出String 对象内子字符串的开始位置。如果没有找到子字符串，则返回-1。如果startindex 是负数，则startindex 被当作零。如果它比最大的字符位置索引还大，则它被当作最大的可能索引。从左向右执行查找。否则，该方法与lastIndexOf 相同。示例下面的示例说明了indexOf 方法的用法。 function IndexDemo(str2){ var str1 = "BABEBIBOBUBABEBIBOBU" var s = str1.indexOf(str2); return(s); }

java代码_去掉重复字符

注：此篇文档是转载别人的，对原作者表示感谢。 import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; //去掉重复字符串的工具类 public class RemoveDuplicateChar { static StringBuffer sb = new StringBuffer(); // 普通的方法，不使用集合 static void removeDuplicateByOriginalMethod(String str) { System.out.println("方法一：普通方法"); char[] cy = str.toCharArray(); String temp = ""; for (int i = 0; i < cy.length; i++) { if (temp.indexOf(cy[i]) == -1) { temp += cy[i]; } } System.out.println("去除重复字符后：" + temp); sb.setLength(0); } // 方法二,使用LinkedHashSet可以在去掉重复字符后按照原字符顺序排列字符 static void removeDuplicateByLinkedHashSet(String str, String[] ss, int len) { System.out.println("方法二：LinkedHashSet"); Set set = new LinkedHashSet(); iterate(set, ss, len); System.out.println("去除重复字符后：" + sb.toString()); // 清空StringBuffer对象sb sb.setLength(0); } // 方法三，使用ArrayList可以在去掉重复字符后按照原字符顺序排列字符 static void removeDuplicateByArrayList(String str, String[] ss, int len) { System.out.println("方法三：ArrayList"); List list = new ArrayList<>(); iterate(list, ss, len); System.out.println("去除重复字符后：" + sb.toString());

Java中截取字符串

Java中截取字符串——经本人验证通过考题题干编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该输出"我ABC"，而不是"我ABC+汉的半个"。试题分析本面试题容易产生困惑的是中文字符和英文字符，在这里需要考虑汉字和英文字符的占用字节数问题，中文字符占两个字节，英文字符占一个字节，理解了这个，就很容易完成本题了。参考答案具体代码实现如下： //package core_java; import java.util.Scanner; public class jiequzichuan { static String ss; // 要进行截取操作的字符串 static int n; // 截取的字符串的字节数 public static void main(String[] args) { System.out.println("请输入字符串："); Scanner scStr = new Scanner(System.in); // 从键盘获取字符串 ss = scStr.next(); // 将Scanner对象中的内容以字符串的形式取出来 System.out.println("请输入字节数："); Scanner scByte = new Scanner(System.in);// 从键盘获取字符串 n = scByte.nextInt(); // 将Scanner对象中的内容以数值的形式取出来 Interception(setValue()); // 方法与方法间的套用 } public static String[] setValue() { // 此方法的作用是将字符串转换成字符串数组 String[] string = new String[ss.length()];// 创建一个字符数组string for (int i = 0; i < string.length; i++) { string[i] = ss.substring(i, i + 1); // 将字符串ss中的第i个字符取出，放入字符数组中string中 } return string; // 将这个字符数组返回 } public static void Interception(String[] string) { int count = 0; String m = "[\u4e00-\u9fa5]"; // 汉字的正则表达试 System.out.println("以每" + n + "字节划分的字符串如下所示："); for (int i = 0; i < string.length; i++) { if (string[i].matches(m)) {

java 字符串常用函数及其用法

java中的字符串也是一连串的字符。但是与许多其他的计算机语言将字符串作为字符数组处理不同，Java将字符串作为String类型对象来处理。将字符串作为内置的对象处理允许Java提供十分丰富的功能特性以方便处理字符串。下面是一些使用频率比较高的函数及其相关说明。 String相关函数 1)substring() 它有两种形式，第一种是：String substring(int startIndex) 第二种是：String substring(int startIndex,int endIndex) 2)concat() 连接两个字符串例:String s="Welcome to "; String t=s.concat("AnHui"); 3)replace() 替换它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下： String replace(char original,char replacement) 例如：String s=”Hello”.replace(’l',’w'); 第二种形式是用一个字符序列替换另一个字符序列，形式如下： String replace(CharSequence original,CharSequence replacement) 4)trim() 去掉起始和结尾的空格 5)valueOf() 转换为字符串 6)toLowerCase() 转换为小写 7)toUpperCase() 转换为大写 8)length() 取得字符串的长度例：char chars[]={’a',’b’.’c'}; String s=new String(chars); int len=s.length(); 9)charAt() 截取一个字符例：char ch; ch=”abc”.charAt(1); 返回值为’b’ 10)getChars() 截取多个字符 void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) sourceStart 指定了子串开始字符的下标 sourceEnd 指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。

java字符串属性入门

1 join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。语法 arrayObject.join(separator ) 参数描述 separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。返回值返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。实例例子 1 在本例中，我们将创建一个数组，然后把它的所有元素放入一个字符串：输出： George,John,Thomas 例子 2 在本例中，我们将使用分隔符来分隔数组中的元素：

输出： George.John.Thomas 2 lastIndex 属性用于规定下次匹配的起始位置。语法 https://www.doczj.com/doc/bd702920.html,stIndex 说明该属性存放一个整数，它声明的是上一次匹配文本之后的第一个字符的位置。上次匹配的结果是由方法 RegExp.exec() 和 RegExp.test() 找到的，它们都以lastIndex 属性所指的位置作为下次检索的起始点。这样，就可以通过反复调用这两个方法来遍历一个字符串中的所有匹配文本。该属性是可读可写的。只要目标字符串的下一次搜索开始，就可以对它进行设置。当方法 exec() 或 test() 再也找不到可以匹配的文本时，它们会自动把lastIndex 属性重置为 0。提示和注释重要事项：不具有标志 g 和不表示全局模式的 RegExp 对象不能使用 lastIndex 属性。提示：如果在成功地匹配了某个字符串之后就开始检索另一个新的字符串，需要手动地把这个属性设置为 0。

java程序：String字符串处理算法

public class MyString{ public MyString(){ } public int indexOf(String content,String find){ return indexOf(content,find,0); } public int indexOf(String content,String find,int beginIndex){ char[]ca_content=content.toCharArray(); int len_content=content.length(); int len_find=find.length(); for(int i=beginIndex;i

JAVA字符串转日期或日期转字符串

JAVA字符串转日期或日期转字符串(转) 2010-08-16 16:34:03| 分类：java |字号订阅 JAVA字符串转日期或日期转字符串(转) 文章中，用的API是SimpleDateFormat，它是属于 java.text.SimpleDateFormat，所以请记得import进来！用法： SimpleDateFormat sdf = new SimpleDateFormat( " yyyy-MM-dd HH:mm:ss " ); 这一行最重要，它确立了转换的格式，yyyy是完整的公元年，MM是月份，dd是日期，至于HH:mm:ss 就不需要我再解释了吧！ PS：为什么有的格式大写，有的格式小写，那是怕避免混淆，例如MM 是月份，mm是分；HH是24小时制，而hh是12小时制。 1.字符串转日期 2008-07-10 19:20:00 要把它转成日期，可以用 Date date = sdf.parse( " 2008-07-10 19:20:00 " ); 2.日期转字符串假如把今天的日期转成字符串可用 String str = sdf.format(new Date()); 这个字符串内容的格式类似2008-07-10 19:20:00。透过这个API我们便可以随心所欲的将日期转成我们想要的字符串格式，例如希望将日期输出成2008 年7月10日，我们可以这么写： SimpleDateFormat sdf = new SimpleDateFormat( " yyyy年MM月dd日 " ); String str = sdf.format(new Date());

java中String的“==”和equals判断相等性

1. 首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。 2. ne w String()和ne w String(“”)都是申明一个新的空字符串，是空串不是null； 3. String str=”kvill”与String str=ne w String (“kvill”)的区别：在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。常量池(consta nt pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。看例1： String s0=”kvill”; String s1=”kvill”; String s2=”kv”+ “ill”; Syste m.out.println( s0==s1 ); Syste m.out.println( s0==s2 ); 结果为： true

true 首先，我们要知道Java会确保一个字符串常量只有一个拷贝。因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。所以我们得出s0==s1==s2; 用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。看例2： String s0=”kvill”; String s1=ne w String(”kvill”); String s2=”kv”+ ne w String(“ill”); Syste m.out.println( s0==s1 ); Syste m.out.println( s0==s2 ); Syste m.out.println( s1==s2 );

Java语言中String和StringBuffer的分析比较

［收稿日期］ 2012－02－01［作者简介］郑霞（1978－），女，讲师，主要从事统计自然语言处理。 Java 语言中字符串常量和变量的分析与比较郑霞，郭磊（安阳师范学院计算机与信息工程学院，河南安阳455000）［摘要］字符串是所有编程语言中都经常需要处理的问题之一。通过对Java 语言中两类字符串，即字符串常量 String 和字符串变量StringBuffer 的分析和比较，分析了它们的特点和区别，便于程序员在以后的编程中更有效地使用它们。［关键词］ String ；StringBuffer ；常量；变量［中图分类号］ TP312JA ［文献标识码］ A ［文章编号］ 1671－5330（2012）02－0046－030引言字符串是由零个或多个字符组成的有限序列。一般记为s =“a 1a 2…a n ” （n ＞=0）。它是编程语言中表示文本的数据类型，代表具有一定意义的信息，现实世界的大部分信息都以字符串的形式表示。对于一种编程语言来说，字符串处理是许多需要进行的重要任务之一，如用户程序输入信息、程序向用户显示信息等。所以几乎每一种编程语言都要有专门针对字符串的表示和操作。Java 语言是纯粹的面向对象的语言，所以它的字符串是用对象表示的， Java 语言的字符串分为字符串常量（用String 类的对象表示）和字符串变量（用StringBuffer 类的对象表示），它们都位于java．lang 包中，他们除了能够表示字符串外，还定义了很多专门进行字符串的处理方法。本文主要讨论定义两类字符串的特点和区别。 1 字符串常量String 类 1．1 字符串常量的创建和创建其它的任一种对象的方式相同，创建String 对象也需要调用它的构造方法来完成，如：String s =new String （“abc ”）；也可用另一种直接赋值的方式来创建String 对象，如：String s =“abc ”；虽然通过以上两种方式都可以创建String 对象，但是二者在创建对象时采用的内存分配方式是不同的。如果是按照以下调用构造方法的形式来创建String 对象：String s1=new String （“abc ”）；String s2=new String （“abc ”）；s1和s2的内存分配如图1所示。s1和s2分别占有独立的内存空间，利用“==”相比较的话，则s1==s2的结果为false 。但是由于在程序中经常出现大量String 对象的值相同的情况，造成内存空间的冗余。为了有效地利用内存， Java 中预留了一块特殊的内存区域，称为String 常量池。当编译器遇到一个String 常量时，先检查常量池中是否存在值相同的String 常量，如果存在，则把该常量的引用指向常量池中的String 常量。下面是利用直接赋值的方式创建字符串的内存分配方式，如图2所示：图1 字符串常量创建举例 String 对象被称为字符串常量，这表明一旦为String 对象赋值，它的值就会保持不变。但是String 引用变量的值却可以改变。如String s =

Java中String的用法总结

构造方法： String() 初始化一个新创建的String 对象，它表示一个空字符序列。 String(byte[] bytes) 构造一个新的String，方法是使用平台的默认字符集解码字节的指定数组。String(byte[] bytes, int offset, int length) 构造一个新的String，方法是使用指定的字符集解码字节的指定子数组。String(byte[] bytes, int offset, int length, String charsetName) 构造一个新的String，方法是使用指定的字符集解码字节的指定子数组。String(byte[] bytes, String charsetName) 构造一个新的String，方法是使用指定的字符集解码指定的字节数组。 String(char[] value) 分配一个新的String，它表示当前字符数组参数中包含的字符序列。 String(char[] value, int offset, int count) 分配一个新的String，它包含来自该字符数组参数的一个子数组的字符。String(int[] codePoints, int offset, int count) 分配一个新的String，它包含该Unicode 代码点数组参数的一个子数组的字符。 String(String original) 初始化一个新创建的String 对象，表示一个与该参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的一个副本。 String(StringBuffer buffer) 分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。String(StringBuilder builder) 分配一个新的字符串，它包含当前包含在字符串生成器参数中的字符序列方法总结： char charAt(int index) 返回指定索引处的char 值。 int codePointAt(int index) 返回指定索引处的字符（Unicode 代码点）。 int codePointBefore(int index) 返回指定索引之前的字符（Unicode 代码点）。 int codePointCount(int beginIndex, int endIndex) 返回此String 的指定文本范围中的Unicode 代码点数。 int compareT o(String anotherString) 按字典顺序比较两个字符串(区分大小写)。 int compareT oIgnoreCase(String str) 不考虑大小写，按字典顺序比较两个字符串。 String concat(String str) 将指定字符串联到此字符串的结尾。 boolean contains(CharSequence s) 当且仅当此字符串包含char 值的指定序列时，才返回true。 boolean contentEquals(CharSequence cs) 当且仅当此String 表示与指定序列相同的char 值时，才返回true。

java中常用的字符串截取方法(非常好的一篇文档)

标签：字符串构造函数替换缓冲区截取it 1、length() 字符串的长度例：char chars[]={'a','b'.'c'}; String s=new String(chars); int len=s.length(); 2、charAt() 截取一个字符例：char ch; ch="abc".charAt(1); 返回'b' 3、getChars() 截取多个字符 void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子串的下标值是targetStart。例：String s="this is a demo of the getChars method."; char buf[]=new char[20]; s.getChars(10,14,buf,0); 4、getBytes() 替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。 5、toCharArray() 6、equals()和equalsIgnoreCase() 比较两个字符串 7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。 boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars) boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars) 8、startsWith()和endsWith() startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束 9、equals()和== equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。例：String s1="Hello"; String s2=new String(s1); s1.eauals(s2); //true s1==s2;//false 10、compareTo()和compareToIgnoreCase() 比较字符串

Java字符串的方法

Java字符串的方法1 、length() 字符串的长度例：char chars[]={'a','b'.'c'}; String s=new String(chars); int len=s.length(); 2、charAt() 截取一个字符例：char ch; ch="abc".charAt(1); 返回'b' 3、getChars() 截取多个字符 void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此，子串包含从 sourceStart到 sourceEnd-1的字符。接收字符的数组由target 指定，target中开始复制子串的下标值是targetStart。例：String s="this is a demo of the getChars method."; char buf[]=new char[20]; s.getChars(10,14,buf,0); 4、getBytes() 替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。 5、toCharArray() 6、equals()和equalsIgnoreCase() 比较两个字符串 7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。 boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars) boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars) 8、startsWith()和endsWith() startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束 9、equals()和== equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。例：String s1="Hello"; String s2=new String(s1);

字符串的处理实验

字符串的处理一、实验目的了解Java语言中字符串的操作和处理。二、实验要求 1．掌握String类的特点及常用方法的使用 2．掌握StringBuffer类的特点及常用方法的使用三、实验内容 1. 请将如下代码补充完整，String类中常用方法的使用。StringExample.java class StringExample { public static void main(String args[]) { String s1=new String("you are a student"); String s2=new String("how are you"); if(【代码1】) // 使用equals方法判断s1与s2是否相同 { System.out.println("s1与s2相同"); } else { System.out.println("s1与s2不相同"); } String s3=new String("22030219851022024"); if(【代码2】) //判断s3的前缀是否是“220302”。 { System.out.println("吉林省的身份证"); } int position=0; String path="c:\\java\\jsp\\A.java"; position=【代码3】//获取path中最后出现目录分隔符号\\ 的位置 System.out.println("c:\\java\\jsp\\A.java中最后出现\\的位置:"+position); String fileName=【代码4】//获取path中“A.java”这个子字符串。 System.out.println("c:\\java\\jsp\\A.java中含有的文件名:"+fileName); String s6=new String("100");

Java中String中类的常用方法

Java中String中类的常用方法 1）public String(char [] value):将字符数组转成字符串； char c[]={…f?,?w?,?s?,?w?,?g?,?a?}; String s=new String(c); System.out.println(s); 结果为：fwswga 2）public String(cahr [] value,开始位置,新字符串的长度):将指定位置长度的字符数组转成字符串； char c[]={…f?,?w?,?s?,?w?,?g?,?a? } String s=new String(c,2,2); System.out.println(c); 结果为：sw 3) public String (byte [ ] value):将字节数组转成字符串； byte b[]={…w?,?o?,?r?,?l?,?d?,?!?}; String s=new String(b); System.out.println(s); 结果为：world! 4) public String (byte [] value, 开始位置，新字符串长度);将指定位置长度的字节数组转成字符串； byte b[]={…w?,?o?,?r?,?l?,?d?,?!?}; String s=new String(b,2,3); System.out.println(s); 结果为：rl 5)public char[] toCharArray();将字符数组转成字符串 String s=”Hello”; Char c[]=s.toCharArray(); for (int i=0;i