河南濮阳建设局网站,怎样判断网站的seo信息好坏,商贸网站源码,网站备案怎么做参考链接#xff1a; Java中的StringBuffer appendCodePoint()方法以及示例
JDK8在线Api中文手册
JDK8在线Api英文手册 Java中的字符串处理 1.1 String类的构造函数1.2 字符串的长度1.3 特殊的字符串操作1.3.1 字符串字面值1.3.2 字符串连接1.3.3 字符串和其他数据类型的连…参考链接 Java中的StringBuffer appendCodePoint()方法以及示例
JDK8在线Api中文手册
JDK8在线Api英文手册 Java中的字符串处理 1.1 String类的构造函数1.2 字符串的长度1.3 特殊的字符串操作1.3.1 字符串字面值1.3.2 字符串连接1.3.3 字符串和其他数据类型的连接1.3.4 字符串转换和toString()方法 1.4 提取字符串1.4.1 charAt()1.4.2 getChars()1.4.3 getBytes()1.4.4 toCharArray() 1.5 比较字符串1.5.1 equals()和equalsIgnoreCase()1.5.2 regionMatches()1.5.3 startsWith()和endsWith()1.5.4 equals()与1.5.6 compareTo() 1.6 查找字符串1.7 修改字符串1.7.1 substring()1.7.2 concat()1.7.3 replace()1.7.4 trim() 1.8 使用valueOf()转换数据1.9 改变字符串中字符的大小写1.10 连接字符串1.11 其他String方法1.12 StringBuffer类1.12.1 StringBuffer类的构造函数1.12.2 length() 与 capacity()1.12.3 ensureCapacity()1.12.4 setLength()1.12.5 charAt() 与 setCharAt()1.12.6 getChars()1.12.7 append()1.12.8 insert()1.12.9 reverse()1.12.10 delete() 与 deleteCharAt()1.12.11 replace()1.12.12 substring()1.12.13 其他StringBuffer方法 1.13 StringBuilder类 与大多数其他编程语言一样在Java中字符串也是一连串的字符。但是不像其他语言一样作为字符数组实现字符串Java将字符串实现为String类型的对象。 作为内置对象实现字符串使得Java可以提供许多方便字符串处理的特性。例如Java提供了用于比较两个字符串、查找子串、连接两个字符串以及改变字符串中字母大小写的方法。此外可以通过多种方式构造String对象从而当需要时可以很容易地获取字符串。 当创建String对象时创建的字符串不能修改。也就是说一旦创建一个String对象就不能改变这个字符串中包含的字符。乍一看这好像有一个严重的限制。但是情况并非如此。仍然可以执行各种字符串操作。区别是当每次需要已存在字符串的修改版本时会创建包含修改后内容的新String对象。原始字符串保持不变。使用这种方式的原因是实现固定的不能修改的字符串与实现能修改的字符串相比较效率更高。对于那些需要能够修改的字符串的情况Java提供了两个选择StringBuffer和StringBuilder,这两个类用来保存在创建之后可以进行修改的字符串。 String、StringBuffer、StringBuilder类都是在java.lang中定义的。因此所有程序自动都可以使用它们。所有这些类被声明为final,这意味着这些类不能有子类。这使得对于通用的字符串操作可以采取特定的优化以提高性能。这3个类实现了CharSequence接口。 最后一点所谓String类型对象中的字符串是不可改变的是指创建了String实例后不能修改String实例的内容。但是在任何时候都可以修改String引用变量使其指向其他String对象。 1.1 String类的构造函数 String类支持几个构造函数。为了创建空的String,可以调用默认构造函数。例如
String s new String(); 将创建内部没有任何字符的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初始化s。 使用下面这个构造函数可以构造与另外一个String对象包含相同字符的String对象
String(String strOb) 在此strObj是一个String对象。分析下面这个例子
//Construct 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 * Java */ }
} 可以看出s1和s2包含相同的字符串。 尽管Java的char类型使用16位表示基本的Unicode字符集但是在Internet上字符串的典型格式是使用从ASCII字符集构造的8位字节数组。因为8位的ASCII字符串很普遍所以String类提供了使用字节数组初始化字符串的构造函数。下面是其中的两种形式
String(byte chrs[])
String(byte chrs[],int startIndex,int numChars) 在此chrs指定字节数组。上面的第二种形式允许指定子范围。在这两个构造函数中从字节到字符的转换是使用平台的默认字符编码完成的。下面程序演示了这些构造函数的使用
//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 */ }
} Java还定义了字节到字符串(byte-to-string)构造函数的扩展版本在扩展版本中可以指定字符的编码方式这决定了如何将字节转换成字符。但是通常会希望使用平台提供的默认编码方式。 注意 无论何时从数组创建String对象都会复制数组的内容。在创建字符串之后如果修改数组的内容String对象不会发生变化。 使用下面的构造函数可以从StringBuffer构造String实例
String(StringBuffer strBufObj) 使用下面这个构造函数可以从StringBuilder构造String实例
String(StringBulider strBuildObj) 下面的构造函数支持扩展Unicode字符集
String(int codePoints[],int startIndex,int numChars) 其中codePoints是包含Unicode代码点的数组。结果字符串从startIndex开始截取numChars个字符。 Java还定义了允许指定Charset的构造函数。
1.2 字符串的长度 字符串的长度是指字符串所包含字符的数量。为了获取这个值调用length()方法如下所示
int length() 1.3 特殊的字符串操作 因为字符串在编程中十分常见也很重要所以Java语言在语法中为一些字符串操作添加了特殊的支持。这些操作包括从字符串字面值自动创建新的String实例使用运算符连接多个字符串以及将其他数据类型转换为字符串表示形式。尽管有显式的方法可以执行这些操作但是Java可以自动完成这些操作从而程序员提供便利并增加代码的清晰度。
1.3.1 字符串字面值 前面的例子显示了如何使用new运算符从字符数组显示地创建String实例。但是还有更容易的方式即使用字符串字面值。对于程序中的每个字符串字面值Java会自动构造String对象。因此可以使用字符串字面值初始化String对象。例如下面的代码段创建了两个相等的字符串
char chars[] {a,b,c};
String s1 new String(chars);
String s2 abc;//use string literal 因为会为每个字符串字面值创建String对象所以在能够使用String对象的任何地方都可以使用字符串字面值。例如可以直接对加引号的字符串调用方法就好像它们是对象引用一样如下面的语句所示。下面的代码对字符串abc调用length()方法。正如所期望的那样该语句输出3。
System.out.println(abc.length()); 1.3.2 字符串连接 一般而言Java不允许为String对象应用运算符。这个规则的一个例外是“运算符”“运算符可连接两个字符串生成一个String对象作为结果。还可以将一系列”运算符连接在一起。例如下面的代码段连接3个字符串
String age 9;
String s He is age years old.;
System.out.println(s); 上面的代码会显示字符串He is 9 years old.
1.3.3 字符串和其他数据类型的连接 可以将字符串和其他类型数据连接起来。例如分析与前面例子稍微不同的版本。
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) 该代码会显示 front: 22 而不是我们可能期望的 front: 4 下面是其中的原因。运算符优先级导致首先连接four和2的字符串等价形式然后再将这个运算的结果和2的字符串等价形式连接起来。为了首先完成整数相加运算必须使用圆括号像下面这样
String s four: (2 2); 现在s包含字符串four: 4
1.3.4 字符串转换和toString()方法 当Java在执行连接操作期间将数据转换成相应的字符串表示形式时是通过调用String定义的字符串转换方式valueOf()的某个重载版本来完成的。valueOf()针对所有基本类型以及Object类型进行了重载。对于基本类型valueOf()方法返回一个字符串该字符串包含与调用值等价的人类可以阅读的形式。对于对象valueOf()方法调用对象的toString()方法。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 height; double depth; Box(double w, double h, double d) { width w; height h; depth h; } Override 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;//concatenate Box object System.out.println(b);//convert Box to string System.out.println(s); /** * 输出 * Dimensions are 10.0 by 12.0 by 12.0. * Box b:Dimensions are 10.0 by 12.0 by 12.0. */ }
} 可以看出在连接表达式或println()调用中使用Box对象时会自动调用Box的toString()方法。
1.4 提取字符串 String类提供了大量方法用于从String对象中提取字符。在此介绍其中的几个。尽管不能向索引数组中的字符那样索引构成String对象中字符串的字符但是许多String方法为字符串使用索引(或偏移)来完成它们的操作。和数组一样字符串索引也是从0开始的。
1.4.1 charAt() 为了从字符串中提取单个字符可以通过charAt()方法直接引用某个单个字符。该方法的一般形式如下
char charAt(int where) 其中where是希望获取的字符的索引where的值必须是非负的并且能够指定字符串中的一个位置charAt()方法返回指定位置的字符。例如
char ch;
ch abc.charAt(1); 将b赋给ch。
1.4.2 getChars() 如果希望一次提取多个字符可以使用getChars()方法。它的一般形式为
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) 其中sourceStart指定了子串的开始索引sourceEnd指定了子串末尾之后下一个字符的索引。因此子串包含字符串中索引从sourceStart到sourceEnd-1之间的字符。target指定了接收字符的数组。在target中开始复制子串的索引是由targetStart传递的。注意必须确保target数组足够大以容纳指定子串的字符。
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 */ }
} 1.4.3 getBytes() getChars()的一种替代选择是将字符保存在字节数组中。这个方法是getBytes(),它使用平台提供的从字符到字节转换的默认方法。下面是getBytes()方法最简单的形式
byte[] getBytes() getBytes()方法还有其他形式。当将String值导出到不支持16位Unicode字符的环境中时最常使用getBytes()方法。例如大部分Internet协议和文本文件格式为文本交互使用8位ASCII码。
1.4.4 toCharArray() 如果希望将String对象中的所有字符转换位字符数组最简单的方法是调用toCharArray()。该方法为整个字符串返回字符数组它的一般形式如下
char[] toCharArray() 这个方法是为了方便操作而提供的因为可以使用getChars()得到相同的结果。
1.5 比较字符串 String类提供了大量用来比较字符串或字符串中子串的方法在此将介绍其中的几个。
1.5.1 equals()和equalsIgnoreCase() 为了比较两个字符串是否相等可以使用equals()方法它的一般形式如下
boolean equals(Object str) 其中str是将要与调用String对象进行比较的String对象。如果字符串以相同的顺序包含相同的字符该方法返回true,否则返回false。比较是大小写敏感的。 为了执行忽略大小写区别的比较可以调用equalsIgnoreCase()。该方法在比较两个字符串时认为A-Z和a-z是相同的它的一般形式如下
boolean equalsIgnoreCase(String str) 其中str是将要与调用String对象进行比较的String对象。如果字符串以相同的顺序包含相同的字符该方法返回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 */ }
} 1.5.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指定了调用String对象中比较部分开始的索引位置将与之进行比较的String对象是由str2指定的。str2中开始进行比较的索引位置是由str2StartIndex指定的。将要进行比较的子串的长度是由numChars传递的。在第二个版本中如果ignoreCase为true,那么忽略字符的大小写否则大小写就是有意义的。
1.5.3 startsWith()和endsWith() String定义了两个方法它们大体上是regionMatches()方法的特定形式。startsWith()方法确定给定的String对象是否以指定的字符串开始。与之相反endsWith()方法确定String对象是否以指定的字符串结束。它们的一般形式如下
boolean startsWith(String str)
boolean endsWith(String str) 其中str是将进行测试的String对象。如果字符串匹配就返回true;否则返回false。例如
Foobar.endsWith(bar) 和
Foobar.startsWith(Foo) 都返回true。 下面是startsWith()方法的第二种形式这种形式允许指定开始位置
boolean startsWith(String str,int startIndex) 其中startsIndex指定了在调用字符串中要开始查找位置的索引。例如
Foobar.startsWith(bar,3) 返回true。
1.5.4 equals()与 equals()方法与“”运算符执行不同的操作理解这一点很重要。刚才解释过equals()方法比较String对象中的字符。双等号运算符比较对两个对象的引用查看它们是否指向相同的实例。下面的程序演示了两个不同的String对象包含相同字符但是如果过对这些对象的引用进行比较就会发现它们是不相等的
//equals vs
class EqualsNotEqualTo { public static void main(String[] args) { String s1 Hello; String s2 new String(s1); System.out.println(s1 equals s2 - s1.equals(s2)); System.out.println(s1 s2 - (s1 s2)); /** * 输出 * Hello equals Hello - true * Hello Hello - false */ }
} 变量s1引用由Hello创建的String实例s2引用的对象是使用s1作为初始化器创建的。因此两个String对象的内容是相同的但它们是不同的对象。这意味着s1和s2引用的是不同的对象所以不是的关系正如前面程序的输出所展示的。
1.5.6 compareTo() 通常只知道两个字符串是否相同是不够的。对于排序应用需要知道哪个字符串小于、等于或大于下一个字符串。根据字典顺序如果一个字符串位于另一个字符串的前面那么这个字符串小于另一个字符串如果一个字符串位于另一个字符串的后面那么这个字符串大于另一个字符串。方法compareTo()就是用于这个目的该方法是由ComparableT接口定义的String实现了这个接口。compareTo()方法的一般形式如下
int compareTo(String str) 其中str是将要与调用String对象进行比较的String对象。返回的比较结果给及相应解释如下表所示 compareTo()方法的返回结果 值含义小于0调用字符串小于str大于0调用字符串大于str0两个字符串相等 下面是一个对数组中的字符串进行排序的示例程序。该程序使用compareTo()方法为冒泡排序法确定排列顺序
//A bubble sort for Strings.
class SortString {
static String arr[] {Now, is, the, 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 * is * men * of * the * the * their * to * to */ }
} 从这个例子的输出可以看出compareTo()考虑字母的大小写。单词Now出现在所有其他单词之前因为它是以大写字母开头的这意味着在ASCII字符集中它具有更小的值。 当比较两个字符串时如果希望忽略大小写区别可以使用compareToIgnoreCase(),如下所示
int compareToIgnoreCase(String str) 除了忽略大小写外这个方法的返回结果与compareTo()相同。如果在前面的程序中使用这个方法的话Now将不再是第一个单词。
1.6 查找字符串 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。 下面的例子展示了如何使用各种索引方法在String内部进行查找
//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) s.lastIndexOf(t)); System.out.println(indexOf(the) s.indexOf(the)); System.out.println(lastIndexOf(the) s.lastIndexOf(the)); System.out.println(indexOf(t,10) s.indexOf(t, 10)); System.out.println(lastIndexOf(t,60) s.lastIndexOf(t, 60)); System.out.println(indexOf(the,10) s.indexOf(the, 10)); System.out.println(lastIndexOf(the,60) s.lastIndexOf(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 */ }
} 1.7 修改字符串 因为String对象是不可改变的所以当希望修改String对象时必须将之复制到StringBuffer或StringBuilder对象中或者使用String类提供的方法来构造字符串修改后的新副本。下面介绍这些方法中的几个。
1.7.1 substring() 使用substring方法可以提取子串。它有两种形式第一种形式如下
String substring(int startIndex) 其中startIndex指定了子串开始时的位置索引。这种形式返回调用字符串中从startIndex索引位置开始到字符串末尾的子串副本。 substring()方法的第二种形式允许同时指定子串的开始索引和结束索引
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. */ }
} 1.7.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; 1.7.3 replace() replace()方法有两种形式。第一种形式在调用字符串中使用一个字符代替另一个字符的所有实例一般形式如下
String replace(char original,char replacement) 其中original指定将被替换的字符replacement指定替换字符结果字符串将被返回。例如
String s Hello.replace(1,w) 将字符串Hewwo存放到s中。 replace()方法的第二种形式使用一个字符序列代替另一个字符序列一般形式如下
String replace(CharSequence original,CharSequence replacement) 1.7.4 trim() trim()方法返回调用字符串的副本并移除开头和结尾的所有空白字符一般形式如下
String trim() 下面是一个例子
String s Hello World .trim(); 这条语句将字符创Hello World存放到s中。 当处理用户命令时trim()方法特别有用。例如下面的程序用户输入某个州的名称然后显示该州的首府。该程序使用trim()方法移除用户可能无意中输入的开头和结尾的所有空白字符。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader; //Using trim() to process commands.
class UserTrim { 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();//remove whitespace if (str.equals(Illinois)) System.out.println(Capital is Springfield.); else if (str.equals(Missouri)) System.out.println(Capital is Jefferson City); else if (str.equals(California)) System.out.println(Capital is Sacramento.); //... } while (!str.equals(stop)); }
} 1.8 使用valueOf()转换数据 valueOf()方法将数据从内部格式转换成人类可以阅读的形式。valueOf()是静态方法String针对所有Java内置类型对该方法进行了重载从而可以将每种类型正确地转换成字符串。Java还针对Object类型对valueOf()方法进行了重载从而使您创建的所有类类型的对象都可作为valueOf()方法的参数(Object是所有类的超类)。下面是valueOf()方法的几种形式
static String valueOf(double num)
static String valueOf(long num)
static String valueOf(Object ob)
static String valueOf(char chars[]) 前面讨论过当需要其他类型数据的字符串表示形式时会调用valueOf()方法例如在连接操作期间。可以使用任何数据类型直接调用valueOf()方法从而得到可读的字符串表示形式。所有简单类型都被转换成它们通用的字符串表示形式。传递给valueOf()方法的所有对象都将返回调用对象的toString()方法的结果。实际上可以直接调用toString()方法得到相同的结果。 对于大部分数组valueOf()方法会返回一个相当隐蔽的字符串以表明这是某种类型的数组。然而对于字符数组会创建包含字符数组的String对象。还有一个特殊版本的valueOf()方法允许指定字符数组的子集一般形式为
static String valueOf(char chars[],int startIndex,int numChars) 其中chars是包含字符的数组startIndex是期望子串在字符数组中何处开始的位置索引numChars指定了子串的长度。
1.9 改变字符串中字符的大小写 方法toLowerCase()将字符串中的所有字符从大写改变为小写方法toUpperCase()将字符串中的所有字符从小写改为大写。非字母字符不受影响。下面是这些方法的最简单形式
String toLowerCase()
String toUpperCase() 这些方法返回String对象其中包含与调用字符串等价的大写或小写形式。对于这两种情况下都是由默认区域设置控制转换。
//Demonstrate toUpperCase() and toLowerCase().
class ChangeCase { public static void main(String[] args) { String s This is a test.; System.out.println(Original: s); String upper s.toUpperCase(); String lower s.toLowerCase(); System.out.println(UpperCase: upper); System.out.println(LowerCase: lower); /** * 输出 * Original: This is a test. * UpperCase: THIS IS A TEST. * LowerCase: this is a test. */ }
} 另外一点toLowerCase()和toUpperCase()方法的重载版本还允许指定控制转换的Locale对象。对于某些情况指定区域非常重要和有助于国际化应用程序
1.10 连接字符串 JDK 8 为String类添加了一个新方法join(),用于连接两个或更多个字符串并使用分隔符分隔各个字符串如空格或逗号。join()方法有两种形式第一种形式如下所示
static String join(CharSequence delim,CharSequence ...strs) 其中delim指定了分隔符用于分隔strs指定的字符序列。因为String类实现了CharSequence接口所以strs可以是一个字符串列表下面的程序演示了这个版本的join()方法
//Demonstrate the join() method defined by String.
class StringJoinDemo { public static void main(String[] args) { String result String.join( , Alpha, Beta, Gamma); System.out.println(result); result String.join(, , John, ID#: 569, E-mail: 123qq.com); System.out.println(result); /** * 输出 * Alpha Beta Gamma * John, ID#: 569, E-mail: 123qq.com */ }
} 第一次调用join()时在每个字符串之间插入了空格。在第二次调时指定分隔符为一个逗号加一个空格这表明分隔符并非只能是一个字符。 join()方法的第二种形式允许连接从实现了Iterable接口的对象获取的一个字符串列表。
1.11 其他String方法 除了前面讨论的方法外String类还提供了许多其他方法。如下表所示 String类的其他方法 方法描述int codePointAt(int i)返回由i指定的位置的Unicode代码点int codePointBefore(int i)返回由i指定的位置之前的Unicode代码点int codePointCount(int start,int end)返回调用字符串处于start到end-1索引范围内的代码代码点数boolean contains(CharSequence str)如果调用字符串包含由str指定的字符串就返回true;否则返回falseboolean contentEquals(CharSequence str)如果调用字符串和str包含的字符串相同就返回true;否则返回falseboolean contentEquals(StringBuffer str)如果字符串和str包含的字符串相同就返回true;否则返回falsestatic String format(String fmtstr,Object …args)返回格式化的字符串由fmtstr指定static String format(Locale loc,String fmtstr,Object …args)返回格式化的字符串由fmtstr指定。格式化是由loc指定的区域控制的boolean isEmpty()如果调用字符串没有任何字符并且长度为0就返回trueboolean matches(String regExp)如果调用字符串和regExp传递的正则表达式匹配就返回true;否则返回falseint offsetByCodePoints(int start,int num)返回字符串中超过start所指定开始索引num个代码点的索引String replaceFirst(String regExp,String newStr)返回一个字符串在返回的这个字符串中使用newStr替换与regExp所指定正则表达式匹配的第一个子串String replaceAll(String regExp,String newStr)返回一个字符串在返回的这个字符串中使用newStr替换与regExp所指定正在表达式匹配的所有子串String[] split(String regExp)将调用字符串分解成几个部分并返回包含结果的数组。每一部分都由regExp传递的正则表达式进行界定String[] split(String regExp,int max)将调用字符串分解成几个部分并返回包含结果的数组。每一部分都由regExp传递的正则表达式进行界定。max指定分解的块数。如果max是 负数就完全分解调用字符串。否则如果max包含非零值那么结果数组中的最后一个元素是调用字符串的剩余部分。如果max是0就完全分解调用字符串但是不会包含后跟的空字符串CharSequence subSequence(int startIndex,int stopIndex)返回调用字符串的子串从startIndex索引位置开始并在stopIndex索引位置结束。该方法是CharSequence接口所需要的String类实现了CharSequence接口 注意这些方法中的多个都使用正则表达式进行工作。
1.12 StringBuffer类 StringBuffer支持可修改的字符串。我们知道String表示长度固定、不可修改的字符序列。与之相对应StringBuffer表示可增长、可写入的字符序列。StringBuffer允许在中间插入字符和子串或者在末尾追加字符和子串。StringBuffer能够自动增长从而为这类添加操作准备空间并且通常预先分配比实际需要更多的字符空间以允许空间增长。
1.12.1 StringBuffer类的构造函数 StringBuffer类定义了以下4个构造函数
StringBuffer()
StringBuffer(int size)
StringBuffer(String str)
StringBuffer(CharSequence chars) 默认构造函数(没有参数的那个)预留16个字符的空间不需要再分配。第2个版本接收一个显式设置缓冲区大小的整型参数。第3个版本接收一个设置StringBuffer对象初始化内容的String参数并额外预留16个字符的空间不需要再分配。如果没有要求特定的缓冲区长度StringBuffer会为16个附加字符分配空间因为再次分配空间是很耗时的操作。此外频繁分配空间会产生内存碎片。通过为一部分额外字符分配空间StringBuffer减少了再次分配空间的次数。第4个构造函数创建包含字符序列的对象并额外预留16个字符的空间包含的字符序列是由chars指定的。
1.12.2 length() 与 capacity() 通过length()方法可以获得StringBuffer对象的当前长度而通过capacity()方法可以获得已分配的容量。这两个方法的一般形式如下
int length()
int capacity() 下面是一个例子
//StringBuffer length vs capacity
class StringBufferDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(Hello); System.out.println(buffer sb); System.out.println(length sb.length()); System.out.println(capacity sb.capacity()); /** * 输出 * buffer Hello * length 5 * capacity 21 */ }
} 因为sb在创建时是使用字符串Hello初始化的所以它的长度是5。因为自动添加了16个附加字符的空间所以它的容量是21。
1.12.3 ensureCapacity() 在创建了StringBuffer对象后如果希望为特定数量的字符预先分配空间可以使用ensureCapacity()方法设置缓冲区的大小。如果事先知道将要向StringBuffer对象追加大量的小字符串这个方法是有用的。ensureCapacity()方法的一般形式为
void ensureCapacity(int minCapacity) 其中minCapacity指定了缓冲区的最小尺寸(处于效率方面的考虑可能会分配比minCapacity更大的缓存区)。
1.12.4 setLength() 可以使用setLength()方法设置StringBuffer中字符串的长度一般形式为
void setLength(int len) 其中len指定字符串的长度值必须非负。 当增加字符串的大小时会向末尾添加null字符。如果调用setLength()方法时使用的值小于length()方法返回的当前值那么超出新长度的字符将丢失。
1.12.5 charAt() 与 setCharAt() 通过charAt()方法可以从StringBuffer获取单个字符的值使用setCharAt()方法可以设置StringBuffer对象中某个字符的值。这两个方法的一般形式如下所示
char charAt(int where)
void setCharAt(int where,char ch) 对于charAt()方法where指定了将要获取字符的索引。对于setCharAt()方法where指定了将要设置字符的索引ch指定了字符的新值。对于这两个方法where必须是非负的并且不能超出字符串结尾的位置。下一节中的setCharAtDemo示例程序使用setLength()方法缩短了一个StringBuffer对象。 下面的例子演示了charAt()和setCharAt()方法
//Demonstrate charAt() and setCharAt()
class setCharAtDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(Hello); System.out.println(buffer before sb); System.out.println(charAt(1) before sb.charAt(1)); sb.setCharAt(1,i); System.out.println(setCharAt after sb); sb.setLength(2); System.out.println(buffer after sb); System.out.println(CharAt(1) after sb.charAt(1)); /** * 输出 * buffer before Hello * charAt(1) before e * setCharAt after Hillo * buffer after Hi * CharAt(1) after i */ }
} 1.12.6 getChars() 可以使用getChars()方法将StringBuffer对象的子串复制到数组中一般形式为
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) 其中sourceStart指定了子串开始位置的索引sourceEnd指定子串结束位置的最后一个位置的索引。这意味着子串将包含索引位置从sourceStart到sourceEnd-1之间的字符。接收字符的数组是由target指定的。targetStart指定了在target中开始复制子串的位置索引。用getChars()方法是一定要谨慎确保target足以容纳子串中的字符。
1.12.7 append() append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾。该方法有一些重载版本下面是其中的几个
StringBuffer append(String str)
StringBuffer append(int num)
StringBuffer append(Object obj) 通常调用String.valueOf()来获取每个参数的字符串表示形式结果将被添加到当前StringBuffer对象的末尾。缓冲区本身被各种版本的append()方法返回从而可以将一系列调用连接起来如下面的例子所示
//Demonstrate append().
class appendDemo { public static void main(String[] args) { String s; int a 42; StringBuffer sb new StringBuffer(40); s sb.append(a ).append(a).append(!).toString(); System.out.println(s); /** * 输出 * a 42! */ }
} 1.12.8 insert() insert()方法将一个字符串插入到另一个字符串中。Java对该方法进行了重载以接收所有基本类型以及String、Object和CharSequence类型的值。与append()类似该方法获取参数值的字符串表示形式然后将字符串插入到调用StringBuffer对象中。下面是其中的几种重载形式
StringBuffer insert(int index,String str)
StringBuffer insert(int index,char ch)
StringBuffer insert(int index,Object obj) 其中index指定了字符串插入到调用StringBuffer对象的位置索引。 下面的示例程序将like插入到I和Java之间
//Demonstrate insert()
class insertDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(I Java!); sb.insert(2,like ); System.out.println(sb); /** * 输出 * I like Java! */ }
} 1.12.9 reverse() 可以使用reverse()方法颠倒StringBuffer对象中的字符如下所示
StringBuffer reverse() 该方法返回对象的反转形式。下面的程序演示了reverse()方法
//Using reverse() to reverse a StringBuffer
class ReverseDemo { public static void main(String[] args) { StringBuffer s new StringBuffer(abcdef); System.out.println(s); s.reverse(); System.out.println(s); /** * 输出 *abcdef *fedcba */ }
} 1.12.10 delete() 与 deleteCharAt() 使用delete()和deleteCharAt()方法可以删除StringBuffer对象中的字符。写方法如下所示
StringBuffer delete(int startIndex,int endIndex)
StringBuffer deleteCharAt(int loc) delete()方法从调用对象删除一连串字符。其中startIndex指定第一个删除字符的位置索引endIndex指定要删除的最后一个字符之后的下一个字符的位置索引。因此结果是删除索引位置从startIndex到endIndex-1之间的子串。删除字符串后的StringBuffer对象作为结果返回。 deleteCharAt()方法删除由loc指定的索引位置的字符返回删除字符后的StringBuffer对象。 下面是演示delete()和deleteCharAt()方法的程序
//Demonstrate delete() and deleteCharAt()
class deleteDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(This is a test.); sb.delete(4,7); System.out.println(After delete: sb); sb.deleteCharAt(0); System.out.println(After deleteCharAt: sb); /** * 输出 * After delete: This a test. * After deleteCharAt: his a test. */ }
} 1.12.11 replace() 通过调用replace()方法可以使用一个字符集替换StringBuffer对象中的另一个字符集。该方法的签名如下所示
StringBuffer replace(int startIndex,int endIndex,String str) 索引startIndex和endIndex指定了将被替换的子串因此将替换startIndex和endIndex-1索引位置之间的子串。替换字符串是由str传入的。替换后的StringBuffer对象作为结果返回。 下面的程序演示了replace()方法
//Demonstrate replace()
class replaceDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(This is a test.); sb.replace(5,7,was); System.out.println(After replace: sb); /** * 输出 * After replace: This was a test. */ }
} 1.12.12 substring() 通过调用substring()方法可以获得StringBuffer对象的一部分。该方法有以下两种重载形式
String substring(int startIndex)
String substring(int startIndex,int endIndex) 第一种形式返回从索引位置startIndex开始到调用StringBuffer对象末尾之间的子串第二种形式返回startIndex和endIndex-1索引位置之间的子串。这些方法的工作方式与前面介绍的String类的对应方法类似。
1.12.13 其他StringBuffer方法 除了刚才介绍的方法外StringBuffer还提供了其他一些方法如下表所示 StringBuffer的其他一些方法 方法描述StringBuffer appendCodePoint(int ch)在调用对象的末尾添加一个Unicode代码点返回对调用对象的引用int codePointAt(int i)返回由i指定的位置的Unicode代码点int codePointBefore(int i)返回由i指定的位置之前位置的Unicode代码点int codePointCount(int start,int end)返回调用对象在位置start和end-1之间代码点的数量int indexOf(String str)查找str在调用StringBuffer对象中的第一次出现时的位置索引并返回索引。如果没有找到就返回-1int indexOf(String str,int startIndex)从startIndex位置索引开始查找查找str在StringBuffer对象中第一次出现时的位置索引并返回索引。如果没有找到就返回-1int lastIndexOf(String str)查找str在调用StringBuffer对象中最后一次出现时的位置索引并返回该索引。如果没有找到就返回-1int lastIndexOf(String str,int startIndex)从位置索引startIndex开始查找str在StringBuffer对象中最后一次出现时的位置索引并返回该索引。如果没有找到就返回-1int offsetByCodePoints(int start,int num)返回调用字符串中超过start所指定索引位置num个代码点的索引CharSequence subSequence(int startIndex,int stopIndex)返回调用字符串的一个子串从位置索引startIndex开始到stopIndex位置索引结束。这个方法是CharSequence接口所需要的StringBuffer实现了该接口void trimToSize()要求为调用对象减小字符缓存对的大小以更适合当前内容 下面的程序演示了indexOf()方法和lastIndexOf()方法
//下面的程序演示了indexOf()方法和lastIndexOf()方法
class IndexOfDemo { public static void main(String[] args) { StringBuffer sb new StringBuffer(one two one); int i; i sb.indexOf(one); System.out.println(First index: i); i sb.lastIndexOf(one); System.out.println(Last index: i); /** * 输出 * First index: 0 * Last index: 8 */ }
} 1.13 StringBuilder类 StringBuilder类是由JDK5引入的以增强Java的字符串处理能力。StringBuilder与StringBuffer类似只有一个重要的区别StringBuilder不是同步的这意味着它不是线程安全的。StringBuilder的优势在于能得到更高的性能。但是如果可以修改的字符串将被多个线程修改并且没有其他同步措施的话就必须使用StringBuffer,而不能使用StringBuilder。
