Java入门第三季
第1章 异常与异常处理
第2章 认识 Java 中的字符串
第3章 Java 中必须了解的常用类...
第4章 Java 中的集合框架（上）...
第5章 Java 中的集合框架（中）...
第6章 Java 中的集合框架（下）...
第7章 综合实战
String 类提供了许多用来处理字符串的方法，例如，获取字符串长度、对字符串进行截取、将字符串转换为大写或小写、字符串分割等，下面我们就来领略它的强大之处吧。
String 类的常用方法：
结合代码来熟悉一下方法的使用：
运行结果：
友情提示：
1. 字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1
2. 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1
3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符
针对如此繁杂的方法，推荐大家一个学习技巧：好记性不如烂笔头！多看的同时一定要多敲哦~~
亲，让我们赶紧来做个练习吧。
功能：判断 Java 文件名是否正确，判断邮箱格式是否正确。其中：合法的文件名应该以 .java 结尾；合法的邮箱名中至少要包含 &@& , 并要求&&@&&在 &.& 之前
请参考注释，在编辑器中的第&16、19、22、36&行中将代码填写完整
运行结果：&
?不会了怎么办
参考代码：
public class HelloWorld {
public static void main(String[] args) {
// Java文件名
String fileName = &HelloWorld.java&;
String email = &&;
// 判断.java文件名是否正确：合法的文件名应该以.java结尾
参考步骤：
1、获取文件名中最后一次出现&.&号的位置
2、根据&.&号的位置，获取文件的后缀
3、判断&.&号位置及文件后缀名
//获取文件名中最后一次出现&.&号的位置
int index =
// 获取文件的后缀
String prefix =
// 判断必须包含&.&号，且不能出现在首位，同时后缀名为&java&
System.out.println(&Java文件名正确&);
System.out.println(&Java文件名无效&);
// 判断邮箱格式是否正确：合法的邮箱名中至少要包含&@&, 并且&@&是在&.&之前
参考步骤：
1、获取文件名中&@&符号的位置
2、获取邮箱中&.&号的位置
3、判断必须包含&@&符号，且&@&必须在&.&之前
// 获取邮箱中&@&符号的位置
int index2 =
// 获取邮箱中&.&号的位置
int index3 = email.indexOf('.');
// 判断必须包含&@&符号，且&@&必须在&.&之前
if (index2 != -1 && index3 & index2) {
System.out.println(&邮箱格式正确&);
System.out.println(&邮箱格式无效&);
你发的评论可能会是问题？是否将他发到问答中
Java API下载
Copyright (C)
All Rights Reserved | 京ICP备 号-2
本次提问将花费2个积分
你的积分不足，无法发表
本次提问将花费2个积分
继续发表请点击 "确定"java&String.valueOf()的作用
在读取数据时需要对数据的强制转换，可采用String.valueOf(a)，把a强制转换成字符串类型
有时候a本来就已经是字符串类型了，但是为了代码的严谨性，也会加入String.valueOf(a)，这时String.valueOf(a)省略也不会出错的。
但有时会涉及到服务器的问题，所以还是加入String.valueOf(a)比较好。
使用 String.valueOf() 进行数据转换，如果被转换的数据为 null, 则这种方法将返回一个 "null"
String） 方法进行转换时，如果被转换的数据为 null, 则返回 null 对象而不是一个 "null" 字符串。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java 里面string 、tostring有什么用？怎么用？_IT教育论坛
&>&&>&&>&&>&Java 里面string 、tostring有什么用？怎么用？
Java 里面string 、tostring有什么用？怎么用？
Java 里面string 、tostring有什么用？怎么用？
<div class="post_detail" id="content_.String 即java中的字符串对象类型，在java中最终会转换为char[] ，即字符数组； 2.toString 是Object对象的方法，即所有类的跟类的方法，因为所有类都继承自Object根类，所以所有对象都有这个方法，因为不同对象都将对该方法重写，所以表达内容因具体对象而异，总之是返回对象的字符串表示。
string是一个对象，但也可以用基本类型创建的方式来创建，例如:
String s=&abababababa&;// 基本类型创建的方式 String s= new String(&asdsad&);//对象
另外，toString 是什么？
java里，所有的类，不管是java库里面的类，或者是你自己创建的类，全部是从object这个类继承的。object里有一个方法就是soString(),那么其实所有的类创造的时候，都有一个toString的方法。
这个方法是干什么的？ 首先我们得了解，java输出用的函数print();是不接受对象直接输出的，只接受字符串或者数字之类的输出。那么你想把一个创建好的对象拿来输出怎么办？例如： class Acccc {} Acccc s1 = new Acccc(); System.out.print(s1);
按照print接受的类型来说，s1是不能直接输出的，那么是否代表这个是不能编译运行的呢?当然不是。因为当print检测到输出的是一个对象而不是字符或者数字时，那么它会去调用这个对象类里面的soString 方法。 即使你没有创建，因为是所有的类都是集成object类，所以自然也继承了这个方法。所以默认情况下，你输出一个对象，会调用这个对象继承的toString方法,而object里的这个方法，默认的功能是返回这个对象的名称。
toString方法一般被用来重载。
也就是说，你想让这个方法实现特定的输出，所以会去重载它。
class A { String toString() return “cao”； }
class B { public static void main(String [] args)
x1 = new A();
System.out.println(x1);//输出就是&cao&……
谢谢了！！！！太感谢你们了！！！
本帖标题：
本帖地址：
注意：本论坛的任何言论仅代表发言者个人的观点，与希赛网立场无关。请对您的言论负责，遵守中华人民共和国有关法律、法规。如果您的帖子违反希赛网论坛规则，将立即删除。
&&&&&&&&&&&&
希赛网 版权所有 & &&java中String类的用法
因为需要在这里把String类涉及的各个方面总结一下，另给出了一下SCJP题目。如有不足的地方，请在评论中指教，谢谢。
一、不变模式：
一个字符串对象创建后它的值不能改变。
String str1="hello";//创建一个对象hello，不会变；
System.out.println(str1);
world!";//两个字符串对象粘粘，系统其实创建了一个新的对象，把Str1的指向改了，指向新的对象；hello就
& //变成了垃圾；
System.out.println(str1);
//如果一直这样创建会影响系统的效率；要频繁的改变字符串对象的值就用StringBuffer来描述；
StringBuffer sb=new StringBuffer("[");
sb.append("hehe");
sb.append("]");//append();不会制造垃圾，真正在改sb的值；
System.out.println(sb);
二、对象池
首先要明白，Object obj = new Object();
obj是对象的引用，它位于栈中， new Object() 才是对象，它位于堆中。
可以这样理解obj是拴在氢气球上的绳子，new Object()
是氢气球，我们通过对象的引用访问对象，就像我们那着绳子氢气球才不会跑掉。
创建一个Stirng对象，主要就有以下两种方式：
String str1 = new String("abc"); &
Stirng str2 = "abc"; &
&虽然两个语句都是返回一个String对象的引用，但是jvm对两者的处理方式是不一样的。对于第一种，jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在内部维护的strings
pool中通过String的 equels
方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象；如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings
pool中。注意：使用第一种方法创建对象时，jvm是不会主动把该对象放到strings pool里面的，除非程序调用
String的intern方法。看下面的例子：
String str1 = new String("abc"); //jvm 在堆上创建一个String对象
&//jvm 在strings pool中找不到值为“abc”的字符串，因此
&//在堆上创建一个String对象，并将该对象的引用加入至strings pool中
&//此时堆上有两个String对象
Stirng str2 = "abc"; &
//并没有创建对象，因为对象池里已经有"abc" 了
&if(str1 == str2){
& &System.out.println("str1 ==
str2"); &&
& &System.out.println("str1 !=
str2"); &&
& //打印结果是 str1 != str2,因为它们是堆上两个不同的对象
& String str3 = "abc";
&//此时，jvm发现strings
pool中已有“abc”对象了，因为“abc”equels “abc”
&//因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用
& if(str2 == str3){
& &System.out.println("str2 ==
str3"); &&
& &System.out.println("str2 !=
str3"); &&
&//打印结果为 str2 == str3
三、String / StringBuffer /
StringBuilder&
String类是字符串常量，是不可更改的常量。而StringBuffer是字符串变量，它的对象是可以扩充和修改的。
& &StringBuffer sb=new
StringBuffer("[");//创建StringBuffer对象
&sb.append("hehe");//把hehe加入字符串，变成 "[hehe"
&sb.append("]");//append();不会制造垃圾，真正在改sb的值；
&System.out.println(sb);
& &String str =
sb.toString();//把"[hehe]"，赋值给一个字符串对象str
StringBuilder,一个可变的字符序列。此类提供一个与 StringBuffer 兼容的
API，但不保证同步。该类被设计用作StringBuffer
的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比
StringBuffer 要快。
StringBuilder sb=new
StringBuilder("[");//创建StringBuilder对象
sb.append("hehe");//把hehe加入字符串，变成 "[hehe"
sb.append("]");//append();不会制造垃圾，真正在改sb的值；
System.out.println(sb);
String str = sb.toString();//把"[hehe]"，赋值给一个字符串对象str
四、String类中常用的方法
类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。不用去记，用到的时候查API，用的多了自然就熟悉了。
& java.lang.String
&char charAt (int index)
&返回index所指定的字符
&String concat(String str)
&将两字符串连接
&boolean endsWith(String str)
&测试字符串是否以str结尾
&boolean equals(Object obj)
&比较两对象
&char[] getBytes
&将字符串转换成字符数组返回
&char[] getBytes(String str)
&将指定的字符串转成制服数组返回
&boolean startsWith(String str)
&测试字符串是否以str开始
&int length()
&返回字符串的长度
&String replace(char old ,char new)
&将old用new替代
&char[] toCharArray
&将字符串转换成字符数组
&String toLowerCase()
&将字符串内的字符改写成小写
&String toUpperCase()
&将字符串内的字符改写成大写
&String valueOf(Boolean b)
&将布尔方法b的内容用字符串表示
&String valueOf(char ch)
&将字符ch的内容用字符串表示
&String valueOf(int index)
&将数字index的内容用字符串表示
&String valueOf(long l)
&将长整数字l的内容用字符串表示
&String substring(int1,int2)
&取出字符串内第int1位置到int2的字符串
view plaincopy to clipboardprint?
import java.util.C
import java.util.LinkedL
import java.util.L
public class StringUsage {
&// 几个欧不太用的方法。
&public static void main(String[] args) {
& // 判断字符串首/尾。
& String contentS = "test String again. test
& System.out.println(contentS);
System.out.println("contentS.startsWith(\"test\")\t"
contentS.startsWith("test"));
System.out.println("contentS.endsWith(\"test\")\t"
contentS.endsWith("test"));
& // 忽略大小写的字符串比较方法。
& System.out
.println("pareToIgnoreCase(contentS.toUpperCase()))\t"
pareToIgnoreCase(contentS.toUpperCase()));
& // 不区分大小写的字符串比较。
& Comparator cmprStr =
String.CASE_INSENSITIVE_ORDER;
& List lstStr = new LinkedList();
& // 准备数据。
& lstStr.add("test");
& lstStr.add("Test");
& lstStr.add("tEst");
& lstStr.add("rest");
& lstStr.add("sest");
& // 不区分大小写的排序。
& Collections.sort(lstStr, cmprStr);
& System.out.println(lstStr);
& // 区分大小写的排序。
& Collections.sort(lstStr);
& System.out.println(lstStr);
& System.out.println("\ntest
String.valueOf()"); &&
& // 用 valueOf 处理 null 对象的字符串转换。
& &String ss =
& &System.out.println(ss);
&System.out.println(String.valueOf(null)); //
比较奇怪的地方 &&
& } catch (RuntimeException e1) {
e1.printStackTrace(); &&
& BigDecimal db =
&System.out.println(((BigDecimal)db).toString());
& } catch (Exception e) {
& &e.printStackTrace();
&System.out.println(String.valueOf(db));
& } catch (Exception e) {
& &e.printStackTrace();
& db = new BigDecimal("100.00");
&System.out.println(((BigDecimal)db).toString());
& } catch (Exception e) {
& &e.printStackTrace();
五、SCJP题目
String a="Hello World!";
String b="Hello World!";
a=b? &a和b是否相等？ 为什么？
String a=new String("Hello World!");
String b="Hello World!";
a=b? &a和b是否相等 ？ 为什么？
1. 首先String不属于8种基本数据类型，String是一个对象。
因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；
3. String str="kvill";
& & String str=new String
(“kvill”);的区别： &
在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。 &
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的
一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。 &
String s0="kvill"; &
String s1="kvill"; &
String s2="kv" + "ill"; &
System.out.println( s0==s1 ); &
System.out.println( s0==s2 ); &
结果为： &
首先，我们要知道Java会确保一个字符串常量只有一个拷贝。 &
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以
s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连
接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。所以我们得出s0==s1==s2;
用new String() 创建的字符串不是常量，不能在编译期就确定，所以new
创建的字符串不放入常量池中，它们有自己的地址空间。 &
String s0="kvill"; &
String s1=new String("kvill"); &
String s2="kv"+ new String("ill"); &
System.out.println( s0==s1 ); &
System.out.println( s0==s2 ); &
System.out.println( s1==s2 ); &
结果为： &
例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创
建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译
期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。
4. String.intern()： &
再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了。
String s0= "kvill"; &
String s1=new String("kvill"); &
String s2=new String("kvill"); &
System.out.println( s0==s1 ); &
System.out.println( “**********” ); &
s1.intern();&
s2=s2.intern(); //把常量池中"kvill"的引用赋给s2 &
System.out.println( s0==s1); &
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 ); &
结果为： &
********** &
false //虽然执行了s1.intern(),但它的返回值没有赋给s1 &
true //说明s1.intern()返回的是常量池中”kvill”的引用
最后我再破除一个错误的理解： &
有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局Strin
g表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：
String s1=new String("kvill"); &
String s2=s1.intern(); &
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 ); &
System.out.println( s2==s1.intern() );
kvill kvill &
在这个类中我们没有声名一个"kvill"常量，所以s1.intern()同new
String("kvill")是不同的，当我们调用s1.intern()后就在常量池中新添加了一个"kvill"常量，原来的不在常量池中的"kvill"仍然存在，也就不是“将自己的地址注册到常量池中”了。
s1==s1.intern()为false说明原来的“kvill”仍然存在；
s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。
5. 关于equals()和==: &
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。
6. 关于String是不可变的 &
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：
String str=”kv”+”ill”+” “+”ans”; &
就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成
”kvill “存在内存中，最后又和生成了”kvill
ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的
构造方法：&
& & 初始化一个新创建的 String
对象，它表示一个空字符序列。&
String(byte[] bytes)&
& & 构造一个新的
String，方法是使用平台的默认字符集解码字节的指定数组。&
String(byte[] bytes, int offset, int
& & 构造一个新的
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
& & 分配一个新的
String，它包含来自该字符数组参数的一个子数组的字符。&
String(int[] codePoints, int offset, int
& & 分配一个新的 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 compareTo(String anotherString)&
按字典顺序比较两个字符串。&
int compareToIgnoreCase(String str)&
不考虑大小写，按字典顺序比较两个字符串。&
String concat(String str)&
将指定字符串联到此字符串的结尾。&
boolean contains(CharSequence s)&
& & 当且仅当此字符串包含 char 值的指定序列时，才返回
boolean contentEquals(CharSequence cs)&
& & 当且仅当此 String 表示与指定序列相同的 char
值时，才返回 true。&
boolean contentEquals(StringBuffer sb)&
& & 当且仅当此 String 表示与指定的
StringBuffer 相同的字符序列时，才返回 true。&
static String copyValueOf(char[] data)&
返回指定数组中表示该字符序列的字符串。&
static String copyValueOf(char[] data, int offset, int
返回指定数组中表示该字符序列的字符串。&
boolean endsWith(String suffix)&
测试此字符串是否以指定的后缀结束。&
boolean equals(Object anObject)&
比较此字符串与指定的对象。&
boolean equalsIgnoreCase(String
anotherString)&
& & 将此 String 与另一个 String
进行比较，不考虑大小写。&
static String format(Locale l, String format, Object...
使用指定的语言环境、格式字符串和参数返回一个格式化字符串。&
static String format(String format, Object...
使用指定的格式字符串和参数返回一个格式化字符串。&
byte[] getBytes()&
& & 使用平台默认的字符集将此 String
解码为字节序列，并将结果存储到一个新的字节数组中。 &
byte[] getBytes(String charsetName)&
& & 使用指定的字符集将此 String
解码为字节序列，并将结果存储到一个新的字节数组中。&
void getChars(int srcBegin, int srcEnd, char[] dst, int
dstBegin)&
将字符从此字符串复制到目标字符数组。&
int hashCode()&
返回此字符串的哈希码。&
int indexOf(int ch)&
返回指定字符在此字符串中第一次出现处的索引。&
int indexOf(int ch, int fromIndex)&
从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。&
int indexOf(String str)&
返回第一次出现的指定子字符串在此字符串中的索引。&
int indexOf(String str, int fromIndex)&
从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。&
String intern()&
返回字符串对象的规范化表示形式。&
int lastIndexOf(int ch)&
返回最后一次出现的指定字符在此字符串中的索引。&
int lastIndexOf(int ch, int fromIndex)&
从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此字符串中的索引。&
int lastIndexOf(String str)&
返回在此字符串中最右边出现的指定子字符串的索引。&
int lastIndexOf(String str, int
fromIndex)&
从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。&
int length()&
返回此字符串的长度。&
boolean matches(String regex)&
通知此字符串是否匹配给定的正则表达式。&
int offsetByCodePoints(int index, int
codePointOffset)&
& & 返回此 String 中从给定的 index 处偏移
codePointOffset 个代码点的索引。&
boolean regionMatches(boolean ignoreCase, int toffset, String
other, int ooffset, int len)&
测试两个字符串区域是否相等。&
boolean regionMatches(int toffset, String other, int ooffset,
测试两个字符串区域是否相等。&
String replace(char oldChar, char
& & 返回一个新的字符串，它是通过用 newChar
替换此字符串中出现的所有 oldChar 而生成的。&
String replace(CharSequence target, CharSequence
replacement)&
使用指定的字面值替换序列替换此字符串匹配字面值目标序列的每个子字符串。&
String replaceAll(String regex, String
replacement)&
& & 使用给定的 replacement
字符串替换此字符串匹配给定的正则表达式的每个子字符串。&
String replaceFirst(String regex, String
replacement)&
& & 使用给定的 replacement
字符串替换此字符串匹配给定的正则表达式的第一个子字符串。&
String[] split(String regex)&
根据给定的正则表达式的匹配来拆分此字符串。&
String[] split(String regex, int
根据匹配给定的正则表达式来拆分此字符串。&
boolean startsWith(String PRefix)&
测试此字符串是否以指定的前缀开始。&
boolean startsWith(String prefix, int
测试此字符串是否以指定前缀开始，该前缀以指定索引开始。&
CharSequence subSequence(int beginIndex, int
endIndex)&
返回一个新的字符序列，它是此序列的一个子序列。&
String substring(int beginIndex)&
返回一个新的字符串，它是此字符串的一个子字符串。&
String substring(int beginIndex, int
endIndex)&
返回一个新字符串，它是此字符串的一个子字符串。&
char[] toCharArray()&
将此字符串转换为一个新的字符数组。&
String toLowerCase()&
& & 使用默认语言环境的规则将此 String
中的所有字符都转换为小写。&
String toLowerCase(Locale locale)&
& & 使用给定 Locale 的规则将此 String
中的所有字符都转换为小写。&
String toString()&
返回此对象本身（它已经是一个字符串！）。&
String toUpperCase()&
& & 使用默认语言环境的规则将此 String
中的所有字符都转换为大写。&
String toUpperCase(Locale locale)&
& & 使用给定的 Locale 规则将此 String
中的所有字符都转换为大写。&
String trim()&
返回字符串的副本，忽略前导空白和尾部空白。&
static String valueOf(boolean b)&
& & 返回 boolean
参数的字符串表示形式。&
static String valueOf(char c)&
& & 返回 char
参数的字符串表示形式。&
static String valueOf(char[] data)&
& & 返回 char
数组参数的字符串表示形式。&
static String valueOf(char[] data, int offset, int
& & 返回 char
数组参数的特定子数组的字符串表示形式。&
static String valueOf(double d)&
& & 返回 double
参数的字符串表示形式。&
static String valueOf(float f)&
& & 返回 float
参数的字符串表示形式。&
static String valueOf(int i)&
& & 返回 int
参数的字符串表示形式。&
static String valueOf(long l)&
& & 返回 long
参数的字符串表示形式。&
static String valueOf(Object obj)&
& & 返回 Object 参数的字符串表示形式。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。}