Java中String类的方法及说明

汪星人

String : 字符串类型

% y  M0 Y6 \# I2 K; Z0 y/ X一、构造函数
  T+ p! r* `" Q+ l9 K# g) z6 l     String(byte[ ] bytes)：通过byte数组构造字符串对象。
     String(char[ ] value)：通过char数组构造字符串对象。
# f( y2 n  l7 Y4 [( l     String(Sting original)：构造一个original的副本。即：拷贝一个original。
* J9 b: W1 d: T- N4 J* I* M& D1 J+ h% d     String(StringBuffer buffer)：通过StringBuffer数组构造字符串对象。  
例如：
      byte[] b = {'a','b','c','d','e','f','g','h','i','j'};
3 K6 Z; E8 R" v      char[] c = {'0','1','2','3','4','5','6','7','8','9'};
      String sb = new String(b);                 //abcdefghij
      String sb_sub = new String(b,3,2);     //de
      String sc = new String(c);                  //0123456789
      String sc_sub = new String(c,3,2);    //34
: r/ D1 Z  @% s3 k' ]      String sb_copy = new String(sb);       //abcdefghij  
# h, ]: x- o* ~2 k6 A      System.out.println("sb:"+sb);
, j6 o0 Z- B6 K0 O  z+ @# o& S. s+ i0 |      System.out.println("sb_sub:"+sb_sub);
      System.out.println("sc:"+sc);
      System.out.println("sc_sub:"+sc_sub);
      System.out.println("sb_copy:"+sb_copy);
      输出结果：sb:abcdefghij
                      sb_sub:de
                       sc:0123456789
                        sc_sub:34
& D. G$ \, f5 v                        sb_copy:abcdefghij

( ?2 o2 i; C: M二、方法：

( N; r/ ~7 \8 N! U$ d8 [) v0 D     说明：①、所有方法均为public。
           ②、书写格式： [修饰符] <返回类型><方法名([参数列表])>

6 Y& J, ]  `( z  |/ }# G2 u      例如：static int parseInt(String s)
  u. w( }0 E4 B7 _. k, i, ^      表示此方法(parseInt)为类方法(static),返回类型为(int),方法所需要为String类型。

% s3 s3 ]* _; S! x1. char charAt(int index) ：取字符串中的某一个字符，其中的参数index指的是字符串中序数。字符串的序数从0开始到length()-1 。
9 X3 m* _/ A0 h4 g* {% u+ c

! V2 C( A$ V! J3 C4 _* D' g
1 W( |% q$ n) M7 ~( V% J5 y; Z    例如：String s = new String("abcdefghijklmnopqrstuvwxyz");
          System.out.println("s.charAt(5): " + s.charAt(5) );
0 J& D8 F' n; O( ?0 [# u& ?; E% p          结果为： s.charAt(5): f
( T1 I( Z( x& `; P2. int compareTo(String anotherString) ：当前String对象与anotherString比较。相等关系返回０；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差，另一种情况，较长字符串的前面部分恰巧是较短的字符串，返回它们的长度差。
8 ^! T; L. A8 v" g5 g3. int compareTo(Object o) ：如果o是String对象，和2的功能一样；否则抛出ClassCastException异常。
    例如:String s1 = new String("abcdefghijklmn");
            String s2 = new String("abcdefghij");
           String s3 = new String("abcdefghijalmn");
           System.out.println("s1.compareTo(s2): " + s1.compareTo(s2) ); //返回长度差
; h: A0 y7 ]; h- N0 `& n           System.out.println("s1.compareTo(s3): " + s1.compareTo(s3) ); //返回'k'-'a'的差
# U1 K/ n: x) N) m: \& L1 g           结果为：s1.compareTo(s2): 4
                       s1.compareTo(s3): 10
: |- R( y$ i3 C' J4. String concat(String str) ：将该String对象与str连接在一起。
+ N& d+ H5 l" L- C, [3 |& a* i5. boolean contentEquals(StringBuffer sb) ：将该String对象与StringBuffer对象sb进行比较。
( I) ]! d' ~5 u: @& @% K6. static String copyValueOf(char[] data) ：
7. static String copyValueOf(char[] data, int offset, int count) ：这两个方法将char数组转换成String，与其中一个构造函数类似。
8. boolean endsWith(String suffix) ：该String对象是否以suffix结尾。
+ T7 [( _4 Z" G    例如：String s1 = new String("abcdefghij");
           String s2 = new String("ghij");
5 y3 Q! w* h0 s. U0 c6 b0 N           System.out.println("s1.endsWith(s2): " + s1.endsWith(s2) );
           结果为：s1.endsWith(s2): true
5 t* ~$ Y! \! A9. boolean equals(Object anObject) ：当anObject不为空并且与当前String对象一样，返回true；否则，返回false。
+ j2 l: F6 T. s& _5 f10. byte[] getBytes() ：将该String对象转换成byte数组。
; b8 r- e% m2 ?' `" N& }3 B11. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：该方法将字符串拷贝到字符数组中。其中，srcBegin为拷贝的起始位置、srcEnd为拷贝的结束位置、字符串数值dst为目标字符数组、dstBegin为目标字符数组的拷贝起始位置。
2 W! |8 Y1 b8 r     例如：char[] s1 = {'I',' ','l','o','v','e',' ','h','e','r','!'};//s1=I love her!
2 r" g4 Q7 p/ `4 T           String s2 = new String("you!"); s2.getChars(0,3,s1,7); //s1=I love you!
7 I4 Z1 d8 t8 k! B  d7 y           System.out.println( s1 );
           结果为：I love you!
12. int hashCode() ：返回当前字符的哈希表码。
6 o, k  f+ p3 [0 V" S4 g& F13. int indexOf(int ch) ：只找第一个匹配字符位置。
14. int indexOf(int ch, int fromIndex) ：从fromIndex开始找第一个匹配字符位置。
15. int indexOf(String str) ：只找第一个匹配字符串位置。
16. int indexOf(String str, int fromIndex) ：从fromIndex开始找第一个匹配字符串位置。
' m& d  J9 t1 M+ \7 Q/ G! v+ e      例如：String s = new String("write once, run anywhere!");
! u* @6 c0 d3 o% l% C2 d              String ss = new String("run");
% }( M/ O$ l( q4 L. E              System.out.println("s.indexOf('r'): " + s.indexOf('r') );
/ `! e1 S4 ^. N/ ~; S              System.out.println("s.indexOf('r',2): " + s.indexOf('r',2) );
              System.out.println("s.indexOf(ss): " + s.indexOf(ss) );
- M0 X$ d2 Y& E              结果为：s.indexOf('r'): 1
- F( p! C9 {2 A- K; }! z: S+ J0 h8 L                      s.indexOf('r',2): 12
                      s.indexOf(ss): 12
17. int lastIndexOf(int ch)
18. int lastIndexOf(int ch, int fromIndex)
6 c# O" l- c" B9 Z4 n" G, ]! k# ^, K19. int lastIndexOf(String str)
20. int lastIndexOf(String str, int fromIndex) 以上四个方法与13、14、15、16类似，不同的是：找最后一个匹配的内容。
4 E9 Z  @- u4 H- |- O7 t7 Cpublic class CompareToDemo {
- m2 k, h  N9 G( F      public static void main (String[] args) {
$ h' r# x  W- ^4 F5 }$ @           String s1 = new String("acbdebfg");

8 a6 K8 d& f1 d           System.out.println(s1.lastIndexOf((int)'b',7));
     }
8 @, F: l8 k: x$ ~) t}
运行结果：5
       （其中fromIndex的参数为 7，是从字符串acbdebfg的最后一个字符g开始往前数的位数。既是从字符c开始匹配，寻找最后一个匹配b的位置。所以结果为 5）
1 P8 W; M" f! Z! w4 P+ V; R

21. int length() ：返回当前字符串长度。
22. String replace(char oldChar, char newChar) ：将字符号串中第一个oldChar替换成newChar。
23. boolean startsWith(String prefix) ：该String对象是否以prefix开始。
24. boolean startsWith(String prefix, int toffset) ：该String对象从toffset位置算起，是否以prefix开始。
3 N' R/ U% A* y6 @: s# j     例如：String s = new String("write once, run anywhere!");
- ~$ I* j; G# m9 M             String ss = new String("write");
3 h# a3 \0 y, R3 k) K( U* R; w             String sss = new String("once");
- z- d0 d# l0 h: S* t7 O0 C             System.out.println("s.startsWith(ss): " + s.startsWith(ss) );
             System.out.println("s.startsWith(sss,6): " + s.startsWith(sss,6) );
, x$ l* b/ V, L" v             结果为：s.startsWith(ss): true
                     s.startsWith(sss,6): true
25. String substring(int beginIndex) ：取从beginIndex位置开始到结束的子字符串。
5 J3 R5 M2 i4 H1 O2 `0 k26.String substring(int beginIndex, int endIndex) ：取从beginIndex位置开始到endIndex位置的子字符串。
9 B0 u  \  ~! I- j" v/ Q6 P27. char[ ] toCharArray() ：将该String对象转换成char数组。
28. String toLowerCase() ：将字符串转换成小写。
29. String toUpperCase() ：将字符串转换成大写。
9 g2 M: G$ _8 E: M     例如：String s = new String("java.lang.Class String");
3 N" `$ m3 F6 b( B' t             System.out.println("s.toUpperCase(): " + s.toUpperCase() );
             System.out.println("s.toLowerCase(): " + s.toLowerCase() );
1 S1 O: I- r. r( L$ w+ r' h; ?             结果为：s.toUpperCase(): JAVA.LANG.CLASS STRING
  A' R% R6 r. r+ \/ t1 N/ G                  s.toLowerCase(): java.lang.class string
30. static String valueOf(boolean b)
1 j5 g+ h6 }8 J* b9 v8 P: v4 @31. static String valueOf(char c)
, n# q. a9 q  K% Q/ d5 c32. static String valueOf(char[] data)
33. static String valueOf(char[] data, int offset, int count)
0 L9 }+ ?' y0 T$ A34. static String valueOf(double d)
1 u7 D7 o! T; u. t% H9 G: ^35. static String valueOf(float f)
0 G$ x# q8 E6 ~* k8 @; h1 Z5 S36. static String valueOf(int i)
37. static String valueOf(long l)
38. static String valueOf(Object obj)
     以上方法用于将各种不同类型转换成Java字符型。这些都是类方法。
7 a. J8 f1 l9 O

* r& W% ~; e; o


Java中String类的常用方法:

9 T' v: }) U) Y+ L1 e  Qpublic char charAt(int index)
* o$ a3 e& q; Q3 ?* {* N* w返回字符串中第index个字符；
6 v' k1 }( p8 E) D, Mpublic int length()
! n! s6 o1 C  c; `6 z返回字符串的长度；
! Y' t6 w- D6 H9 rpublic int indexOf(String str)
1 N8 l0 j: i3 ~返回字符串中第一次出现str的位置；
public int indexOf(String str,int fromIndex)
返回字符串从fromIndex开始第一次出现str的位置；
2 U+ v& B0 ~7 [! rpublic boolean equalsIgnoreCase(String another)
比较字符串与another是否一样（忽略大小写）；
public String replace(char oldchar,char newChar)
在字符串中用newChar字符替换oldChar字符
6 Q+ U1 _; {5 C6 v5 wpublic boolean startsWith(String prefix)
判断字符串是否以prefix字符串开头；
+ t0 M# ^  s& ?public boolean endsWith(String suffix)
- i  }& a. M# L; k3 Y+ w判断一个字符串是否以suffix字符串结尾；
0 B% n  y% f% S6 X# e9 @- Fpublic String toUpperCase()
! H5 M4 \9 Z% n  C6 q. e7 `返回一个字符串为该字符串的大写形式；
public String toLowerCase()
4 D9 x' b& [' m5 M& e返回一个字符串为该字符串的小写形式
8 P1 K1 S# _! ]) [+ ]5 @( E8 C, Upublic String substring(int beginIndex)
返回该字符串从beginIndex开始到结尾的子字符串；
public String substring(int beginIndex,int endIndex)
返回该字符串从beginIndex开始到endsIndex结尾的子字符串
) c9 E/ v# k7 q3 }8 D# A" F+ Tpublic String trim()
  ~  S0 W; l; T返回该字符串去掉开头和结尾空格后的字符串
% F# s; Z, _2 |public String[] split(String regex)
将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组
5 c. A+ B  m) l实例：  
: ]* t# x) N+ ^! ]7 A- ~/ D* U* [  Npublic class SplitDemo{
     public static void main (String[] args) {

             String date = "2008/09/10";
3 h% q4 W# u. i% b1 O- X            String[ ] dateAfterSplit= new String[3];
            dateAfterSplit=date.split("/");         //以“/”作为分隔符来分割date字符串，并把结果放入3个字符串中。
$ a- Z+ d; T" l) B1 W
6 }; E0 Z& G0 j/ C) M            for(int i=0;i<dateAfterSplit.length;i++)
. _- J+ ^: u  v0 a; C/ F4 d6 L  [3 N                       System.out.print(dateAfterSplit+" ");
: x: `+ M4 O1 V* ~) w1 z      }
2 j$ W9 u  Y: V6 c; w9 H}
/ z# [0 |8 X7 K. n
运行结果：2008 09 10          //结果为分割后的3个字符串

实例：
TestString1.java:
程序代码
public class TestString1
2 q" W2 \+ v' [( j2 r3 ]{
    public static void main(String args[]) {
0 S! I( `$ X( q. u        String s1 = "Hello World" ;
6 ^2 X$ y2 e  A4 N: e1 q! Y! L. O& E        String s2 = "hello world" ;
. I3 f9 }5 S6 ^  y6 l% ?        System.out.println(s1.charAt(1)) ;
3 f' c8 A) q' H* [/ l: e1 X# k. p$ K        System.out.println(s2.length()) ;
3 c2 E) S: f6 p6 j; @- ^        System.out.println(s1.indexOf("World")) ;
        System.out.println(s2.indexOf("World")) ;
: g2 I4 Q/ i# L# e% {        System.out.println(s1.equals(s2)) ;
* E$ o; h* V* ~* h* L        System.out.println(s1.equalsIgnoreCase(s2)) ;

5 L  |2 Q# K, T" ~6 C7 k: Y        String s = "我是J2EE程序员" ;
6 p+ i* I* B  N9 I3 E        String sr = s.replace('我','你') ;
        System.out.println(sr) ;
8 [3 V7 E3 `7 y7 N    }
}

, {* `# [, U$ d! |) w/ W7 c$ g0 ~" \3 PTestString2.java:
/ `/ Q$ n" k, f0 V程序代码
! L+ E2 }$ g! b* _# d. T! P8 C
9 B5 p8 V% O8 q1 Spublic class TestString2
{
    public static void main(String args[]) {
' Z# |9 q& B, C/ u& @        String s = "Welcome to Java World!" ;
# B6 @7 R' r2 m2 W5 ^6 u0 a        String s2 = "   magci   " ;
) r0 `3 D. h/ B5 L" f$ t        System.out.println(s.startsWith("Welcome")) ;
        System.out.println(s.endsWith("World")) ;
        String sL = s.toLowerCase() ;
" G) h- ~8 d0 U6 q" a1 w3 Y        String sU = s.toUpperCase() ;
        System.out.println(sL) ;
9 I' A9 x+ R' A* Q; l, [$ \" }% g7 |        System.out.println(sU) ;
        String subS = s.substring(11) ;
        System.out.println(subS) ;
1 K: n/ j+ d& u        String s1NoSp = s2.trim() ;
$ B3 u5 E" Y' l& }' m        System.out.println(s1NoSp) ;
3 M( N( W2 u( d+ F$ P& N    }
. ]$ j% \* n" G7 }
5 c9 u; Y) f5 G. W6 b. O( E