职友集：让就业决策更聪明Java中String类的常用方法
我的图书馆
Java中String类的常用方法
Java创建一个String类的对象后，使用相应类的成员方法对创建的对象进行处理，以完成编程所需要的功能。Java中文网整理java.lang.String常用成员方法如下所示：
成员方法 功能说明 -----------public int length()返回当前串对象的长度
public char charAt(int index)返回当前串对象下标int index处的字符 public int indexof(int ch)返回当前串内第一个与指定字符ch相同的下标，若找不到，则返回-1
public int indexOf(String str,int fromIndex)从当前下标fromIndex处开始搜索，返回第一个与指定字符串str相同的第一个字母在当前串中的下标，若找不到，则返回-1 public String substring(int beginIndex)返回当前串中从下标beginIndex开始到串尾的子串
public String substring(int beginIndex,int endIndex)返回当前串中从下标beginIndex开始到下标endIndex-1的子串 public boolean equals(Object obj)当且仅当obj不为null且当前串对象与obj有相同的字符串时，返回true否则返回flase
public boolean equalsIgnoreCase(String s)功能与quals类似，equalsIgnoreCase在比较字符串时忽略大小写 public int compareTo(String another_s)比较两字符串的大小。返回一个小于、等于或大于零的整数。返回的值取决于此字符串是不小于、等于或大于another_s
public String toString ()返回当前字符串public static String valueOf(Object obj)返回对象obj的字符串
public String toLowerCase()将字符串中的大写字符转换为小写字符 public String toUpperCase()将字符串中的小写字符转换为大写字符
public String replace(char oldCh,char newCh)将字符串的字符oldCh替换为 字符串newCh public String concat(String str)将字符串str连接在当前串的尾部，返回新的字符串
public static String valueOf(type variable)返回变量variable值的字符串形式。Type可以是字符数组 public static String valueOf(char[] data, int offset,int count)返回字符数组data从下标offset开始的count个字符的字符串
文章转自Java中文网:http://www.javaweb.cc/language/java/092161.shtml
TA的最新馆藏[转]&[转]&[转]&[转]&
喜欢该文的人也喜欢java的String类,equals函数和比较操作符==的区别
我的图书馆
java的String类,equals函数和比较操作符==的区别
整理关于java的String类,equals函数和比较操作符的区别
作者：yourblog 来源：yourblog 整理日期：
初学 Java 有段时间了，感觉似乎开始入了门，有了点儿感觉但是发现很多困惑和疑问而且均来自于最基础的知识折腾了一阵子又查了查书，终于对 String 这个特殊的对象有了点感悟大家先来看看一段奇怪的程序： public class TestString {&&&& & public static void main(String[] args) {&&&&&&&& & String s1 = "Monday";&&&&&&&& & String s2 = "Monday";&&&& & } } 这个程序真是简单啊！可是有什么问题呢？ 1. 来自 String 的忧虑上面这段程序中，到底有几个对象呢？ 可能很多人脱口而出：两个，s1 和 s2为什么？String 是 final 类，它的值不可变。看起来似乎很有道理，那么来检测一下吧，稍微改动一下程序就可以看到结果了： public class TestString {&&&& public static void main(String[] args) {&&&& &&& String s1 = "Monday";&&&& &&& String s2 = "Monday";&& &&&& if (s1 == s2)&&&&&& &&&&&& System.out.println("s1 == s2");&&&&&& &&& else&&&&&& &&&&& System.out.println("s1 != s2"); &&& } } 呵呵，很多人都会说已经不止两个对象了编译并运行程序，输出：s1 == s2啊！ 为什么 s1 == s2 ? == 分明是在说：s1 与 s2 引用同一个 String 对象 -- "Monday"! 2. 千变万化的 String再稍微改动一下程序，会有更奇怪的发现： public class TestString {&&&& & public static void main(String[] args) {&&&&&&&& &&& String s1 = "Monday";&&&&&&&& &&& String s2 = new String("Monday");&&&&&&&& &&& if (s1 == s2)&&&&&&&&&&&& &&&&&& System.out.println("s1 == s2");&&&&&&&& &&& else&&&&&&&&&&&& &&&&&& System.out.println("s1 != s2");&&&&&&&& &&& if (s1.equals(s2))&&&&&&&&&&&& &&&&&&& System.out.println("s1 equals s2");&&&&&& &&& else&&&&&&&&&&&& &&&&&&& System.out.println("s1 not equals s2");&&&& & } } 们将 s2 用 new 操作符创建程序输出： s1 != s2s1 equals s2 嗯，很明显嘛s1 s2分别引用了两个"Monday"String对象 可是为什么两段程序不一样呢？ 3. 在 String 的游泳池中游泳哈哈，翻了翻书终于找到了答案： 原来，程序在运行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1将 s2 引用 s1 所引用的对象"Monday"第二段程序中，使用了 new 操作符，他明白的告诉程序：“要一个新的！不要旧的！”与是一个新的"Monday"Sting对象被创建在内存中。他们的值相同，但是位置不同，一个在池中游泳一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？ 4. 继续潜水再次更改程序： public class TestString { &&& public static void main(String[] args) { &&&&&&& String s1 = "Monday"; &&&&&&& String s2 = new String("Monday"); &&&&&&& s2 = s2.intern(); &&&&&&& if (s1 == s2) &&&&&&&&&&& System.out.println("s1 == s2"); &&&&&&& else &&&&&&&&&&& System.out.println("s1 != s2"); &&&&&&& if (s1.equals(s2)) &&&&&&&&&&& System.out.println("s1 equals s2"); &&&&&&& else &&&&&&&&&&& System.out.println("s1 not equals s2"); &&& } } 这次加入：s2 = s2.intern(); 哇！程序输出：s1 == s2 s1 equals s2原来，程序新建了 s2 之后，又用intern()把他打翻在了池里哈哈，这次 s2 和 s1 有引用了同样的对象了们成功的减少了内存的占用5. == 与 equals() 的争斗String 是个对象，要对比两个不同的String对象的值是否相同明显的要用到 equals() 这个方法可是如果程序里面有那么多的String对象，有那么多次的要用到 equals ，哦，天哪，真慢啊更好的办法：把所有的String都intern()到缓冲池去吧最好在用到new的时候就进行这个操作String s2 = new String("Monday").intern();嗯，大家都在水池里泡着了吗？哈哈现在可以无所顾忌的用 == 来比较 String 对象的值了真是爽啊，又快又方便！
String 啊 String ，让说你什么好呢？你为们 Java 程序员带来所有的困扰还不够吗？ 看看 String 这一次又怎么闹事儿吧 1. 回顾一下坏脾气的 String 老弟 例程1：class Str { &&& public static void main(String[] args) { &&&&&&& String s = "Hi!"; &&&&&&& String t = "Hi!"; &&&&&&& if (s == t) &&&&&&&&&&& System.out.println("equals"); &&&&&&& else &&&&&&&&&&&& System.out.println("not equals"); &&& } } 程序输出什么呢？ 如果看客们看过的《来自 String 的困惑》之一相信你很快会做出正确的判断：程序输出：equals 2. 哦，天哪，它又在搅混水了 例程2：class Str { &&& public static void main(String[] args) { &&&&&&& String s = "HELLO"; &&&&&&& String t = s.toUpperCase(); &&&&&&& if (s == t) &&&&&&&&&&& System.out.println("equals"); &&&&&&& else &&&&&&&&&&& System.out.println("not equals"); &&& } } 那么这个程序有输出什么呢？ 慎重！再慎重！不要被 String 这个迷乱的家伙所迷惑！ 它输出：equalsWHY!!! 把程序简单的更改一下： class Str2 { &&& public static void main(String[] args) { &&&&&&& String s = "Hello"; &&&&&&& String t = s.toUpperCase(); &&&&&&& if (s == t) &&&&&&&&&&& System.out.println("equals"); &&&&&&& else &&&&&&&&&&& System.out.println("not equals"); &&& } } 你可能会说：不是一样吗？不！千真万确的，不一样！这一次输出： not equalsOh MyGOD!!! 谁来教训一下这个 String 啊！
3. 你了解你的马吗？ “要驯服脱缰的野马，就要了解它的秉性”牛仔们说道。 你了解 String 吗？解读 String 的 API ，可以看到：toUpperCase() 和 toLowerCase() 方法返回一个新的String对象，它将原字符串表示字符串的大写或小写形势；但是要注意：如果原字符串本身就是大写形式或小写形式，那么返回原始对象。这就是为什么第二个程序中 s 和 t 纠缠不清的缘故对待这个淘气的、屡教不改的 String ，似乎没有更好的办法了让们解剖它，看看它到底有什么结构吧： (1) charAt(int n) 返回字符串内n位置的字符，第一个字符位置为0，最后一个字符的位置为length()-1，访问错误的位置会扔出一块大砖头：StringIndexOutOfBoundsException 真够大的 (2) concat(String str) 在原对象之后连接一个 str ，但是返回一个新的 String 对象 (3) EqualsIgnoreCase(String str) 忽略大小写的 equals 方法这个方法的实质是首先调用静态字符方法toUpperCase() 或者 toLowerCase() 将对比的两个字符转换，然后进行 == 运算 (4) trim() 返回一个新的对象，它将原对象的开头和结尾的空白字符切掉同样的，如果结果与原对象没有差别，则返回原对象 (5) toString() String 类也有 toString() 方法吗？真是一个有趣的问题，可是如果没有它，你的 String 对象说不定真的不能用在System.out.println() 里面啊小心，它返回对象自己String 类还有很多其他方法，掌握他们会带来很多方便也会有很多困惑，所以坚持原则，是最关键的
4. 想买一匹更好的马来购买更驯服温和的 String 的小弟 StringBuffer 吧 这时候会有人反对： 它很好用，它效率很高，它怎么能够是小弟呢？ 很简单，它的交互功能要比 String 少，如果你要编辑字符串它并不方便，你会对它失望但这不意味着它不强大public final class String implements Serializable, Comparable, CharSequencepublic final class StringBuffer implements Serializable, CharSequence很明显的，小弟少了一些东东，不过这不会干扰它的前途StringBuffer 不是由 String 继承来的不过要注意兄弟它也是 final 啊，本是同根生看看他的方法吧，这么多稳定可靠的方法，用起来比顽皮的 String 要有效率的多? Java 为需要改变的字符串对象提供了独立的 StringBuffer 类它的实例不可变（final），之所以要把他们分开是因为，字符串的修改要求系统的开销量增大，占用更多的空间也更复杂，相信当有10000人挤在一个狭小的游泳池里游泳而岸边又有10000人等待进入游泳池而焦急上火又有10000人在旁边看热闹的时候，你这个 String 游泳池的管理员也会焦头烂额在你无需改变字符串的情况下，简单的 String 类就足够你使唤的了，而当要频繁的更改字符串的内容的时候，就要借助于宰相肚里能撑船的StringBuffer 了
5. 宰相肚里能撑船 (1) length() 与 capacity()String 中的 length() 返回字符串的长度兄弟 StringBuffer 也是如此，他们都由对象包含的字符长度决定capacity()呢？ public class TestCapacity { &&& public static void main(String[] args)｛ &&&& StringBuffer buf = new StringBuffer("it was the age of wisdom,"); &&&&&& System.out.println("buf = " + buf); &&&&&&& System.out.println("buf.length() = " + buf.length()); &&&&&&& System.out.println("buf.capacity() = " + buf.capacity()); &&&&&&& String str = buf.toString(); &&&&&&& System.out.println("str = " + str); &&&&&&& System.out.println("str.length() = " + str.length()); &&&&&&& buf.append(" " + str.substring(0,18)).append("foolishness,"); &&&&&&& System.out.println("buf = " + buf); &&&&&&& System.out.println("buf.length() = " + buf.length()); &&&&&&& System.out.println("buf.capacity() = " + buf.capacity()); &&&&&& System.out.println("str = " + str); && } } 程序输出： buf = it was the age of wisdom.buf.length() = 25 buf.capacity() = 41 str = it was the age of wisdomstr.length() = 25 buf = it was the age of wisdom, it was the age of foolishness, buf.length() = 56 buf.capacity() = 84 str = it was the age of wisdom,
可以看到，在内容更改之后，capacity也随之改变了长度随着向字符串添加字符而增加而容量只是在新的长度超过了现在的容量之后才增加StringBuffer 的容量在操作系统需要的时候是自动改变的程序员们对capacity所能够做的仅仅是可以在初始化 StringBuffer对象的时候。
TA的最新馆藏[转]&[转]&[转]&
喜欢该文的人也喜欢Java String 类
字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串
创建字符串最简单的方式如下:
String greeting = &菜鸟教程&;
在代码中遇到字符串常量时，这里的值是 "菜鸟教程""，编译器会使用该值创建一个 String 对象。
和其它对象一样，可以使用关键字和构造方法来创建 String 对象。
String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
StringDemo.java 文件代码：
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);
System.out.println( helloString );
以上实例编译运行结果如下：
注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。
如果需要对字符串做很多修改，那么应该选择使用 。
字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
下面的代码执行后，len变量等于14:
StringDemo.java 文件代码：
public class StringDemo {
public static void main(String args[]) {
String site = &&;
int len = site.length();
System.out.println( &菜鸟教程网址长度 : & + len );
以上实例编译运行结果如下：
菜鸟教程网址长度 : 14
连接字符串
String 类提供了连接两个字符串的方法：
string1.concat(string2);
返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：
"我的名字是 ".concat("Runoob");
更常用的是使用'+'操作符来连接字符串，如：
"Hello," + " runoob" + "!"
"Hello, runoob!"
下面是一个例子:
StringDemo.java 文件代码：
public class StringDemo {
public static void main(String args[]) {
String string1 = &菜鸟教程网址：&;
System.out.println(&1、& + string1 + &&);
以上实例编译运行结果如下：
1、菜鸟教程网址：
创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。如下所示：
System.out.printf(&浮点型变量的值为 & +
&%f, 整型变量的值为 & +
& %d, 字符串变量的值为 & +
&is %s&, floatVar, intVar, stringVar);
你也可以这样写
String fs;
fs = String.format(&浮点型变量的值为 & +
&%f, 整型变量的值为 & +
& %d, 字符串变量的值为 & +
& %s&, floatVar, intVar, stringVar);
String 方法
下面是 String 类支持的方法，更多详细，参看
返回指定索引处的 char 值。
把这个字符串和另一个对象比较。
按字典顺序比较两个字符串。
按字典顺序比较两个字符串，不考虑大小写。
将指定字符串连接到此字符串的结尾。
当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
返回指定数组中表示该字符序列的 String。
返回指定数组中表示该字符序列的 String。
测试此字符串是否以指定的后缀结束。
将此字符串与指定的对象比较。
将此 String 与另一个 String 比较，不考虑大小写。
&使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
将字符从此字符串复制到目标字符数组。
返回此字符串的哈希码。
返回指定字符在此字符串中第一次出现处的索引。
返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
&返回指定子字符串在此字符串中第一次出现处的索引。
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
&返回字符串对象的规范化表示形式。
&返回指定字符在此字符串中最后一次出现处的索引。
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
返回指定子字符串在此字符串中最右边出现处的索引。
&返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
返回此字符串的长度。
告知此字符串是否匹配给定的正则表达式。
测试两个字符串区域是否相等。
测试两个字符串区域是否相等。
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
&使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
根据给定正则表达式的匹配拆分此字符串。
根据匹配给定的正则表达式来拆分此字符串。
测试此字符串是否以指定的前缀开始。
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
&返回一个新的字符序列，它是此序列的一个子序列。
返回一个新的字符串，它是此字符串的一个子字符串。
返回一个新字符串，它是此字符串的一个子字符串。
将此字符串转换为一个新的字符数组。
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
&使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
&返回此对象本身（它已经是一个字符串！）。
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
返回字符串的副本，忽略前导空白和尾部空白。
返回给定data type类型x参数的字符串表示形式。
8个月前 (02-27)
记住登录状态
重复输入密码Java String.concat()方法
当前位置：
>> Java String.concat()方法
Java String.concat()方法
Java String.concat()方法用法实例教程, 连接指定的字符串到该字符串的尾部（结束位置）
java.lang.String.concat()&方法连接指定的字符串到该字符串的尾部（结束位置）
以下是java.lang.String.concat()方法的声明
public String concat(String str)
str&-- 这是字符串被连接到该字符串的结束位置
此方法返回一个字符串，表示此对象的字符的字符串参数的字符的串联
下面的示例演示使用的java.lang.String.concat()方法
package com.
import java.lang.*;
public class StringDemo {
public static void main(String[] args) {
// print str1
String str1 = "self";
System.out.println(str1);
// print str2 concatenated with str1
String str2 = str1.concat(" learning");
System.out.println(str2);
// prints str3 concatenated with str2(and str1)
String str3 = str2.concat(" center");
System.out.println(str3);
让我们来编译和运行上面的程序，这将产生以下结果：
self learning
self learning center