Java中String类的方法及说明

汪星人

String : 字符串类型
) |. z# B5 G& p4 w8 X
一、构造函数
     String(byte[ ] bytes)：通过byte数组构造字符串对象。
6 h6 ]) k9 S  d( T: p# t( [     String(char[ ] value)：通过char数组构造字符串对象。
     String(Sting original)：构造一个original的副本。即：拷贝一个original。
- Y1 x7 A+ |. u1 t3 o* I     String(StringBuffer buffer)：通过StringBuffer数组构造字符串对象。  
' y2 k5 T% g" L1 n7 w7 }6 p例如：
/ [4 c: G! ~+ W4 r2 v% x7 i      byte[] b = {'a','b','c','d','e','f','g','h','i','j'};
      char[] c = {'0','1','2','3','4','5','6','7','8','9'};
" s6 O) C# q. l      String sb = new String(b);                 //abcdefghij
      String sb_sub = new String(b,3,2);     //de
      String sc = new String(c);                  //0123456789
4 W( z, s6 y' X  @      String sc_sub = new String(c,3,2);    //34
0 e  w+ p+ ]( O) ^      String sb_copy = new String(sb);       //abcdefghij  
      System.out.println("sb:"+sb);
( j1 a1 z# w$ Y% Q. t+ E, ]      System.out.println("sb_sub:"+sb_sub);
      System.out.println("sc:"+sc);
/ o# u6 q6 }1 m; e( e      System.out.println("sc_sub:"+sc_sub);
      System.out.println("sb_copy:"+sb_copy);
' A2 x) \4 h& ]; U' W      输出结果：sb:abcdefghij
  r0 ~) H. @% R5 C                      sb_sub:de
                       sc:0123456789
0 ^' Y2 t% A. A& M# L/ ^) U/ f                        sc_sub:34
9 n* r, X" R8 C# v                        sb_copy:abcdefghij

  r$ U) d  \; r& v/ e二、方法：
5 B+ y& v4 e; K" Y' j! q! p$ W
     说明：①、所有方法均为public。
/ p; d/ c  ~, b( g( l           ②、书写格式： [修饰符] <返回类型><方法名([参数列表])>

1 n; n; f/ E8 v) s9 c      例如：static int parseInt(String s)
      表示此方法(parseInt)为类方法(static),返回类型为(int),方法所需要为String类型。

' G+ a! H/ Z9 K* T% i$ c1. char charAt(int index) ：取字符串中的某一个字符，其中的参数index指的是字符串中序数。字符串的序数从0开始到length()-1 。
) m: f2 [0 A" Z% ?% N


: N  r& d. D4 K) D    例如：String s = new String("abcdefghijklmnopqrstuvwxyz");
2 G$ o% o7 R8 {, [* B4 c9 @          System.out.println("s.charAt(5): " + s.charAt(5) );
          结果为： s.charAt(5): f
2. int compareTo(String anotherString) ：当前String对象与anotherString比较。相等关系返回０；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差，另一种情况，较长字符串的前面部分恰巧是较短的字符串，返回它们的长度差。
, l  i/ {. O; @3. int compareTo(Object o) ：如果o是String对象，和2的功能一样；否则抛出ClassCastException异常。
! P- G& Y$ W. A: \    例如:String s1 = new String("abcdefghijklmn");
7 \& C: T! t4 j7 @; [$ C            String s2 = new String("abcdefghij");
           String s3 = new String("abcdefghijalmn");
; [  |# t& f, i% i. Z5 x           System.out.println("s1.compareTo(s2): " + s1.compareTo(s2) ); //返回长度差
9 P$ @" e: C) a           System.out.println("s1.compareTo(s3): " + s1.compareTo(s3) ); //返回'k'-'a'的差
) G- G' Q* d& X% Z7 k! x: k9 @# Z2 o           结果为：s1.compareTo(s2): 4
' ?2 z- s. v) Y5 G  f: `                       s1.compareTo(s3): 10
& D/ _9 X, d( ?# i, z# K4. String concat(String str) ：将该String对象与str连接在一起。
5. boolean contentEquals(StringBuffer sb) ：将该String对象与StringBuffer对象sb进行比较。
6. static String copyValueOf(char[] data) ：
3 h# [7 X5 F- z& a, Y6 J7. static String copyValueOf(char[] data, int offset, int count) ：这两个方法将char数组转换成String，与其中一个构造函数类似。
6 G- P/ @, T3 T1 l! M. c8. boolean endsWith(String suffix) ：该String对象是否以suffix结尾。
    例如：String s1 = new String("abcdefghij");
! |" P/ k8 s. j0 f           String s2 = new String("ghij");
. _- ]3 Q& J5 @7 {9 o3 q- y           System.out.println("s1.endsWith(s2): " + s1.endsWith(s2) );
" J3 V( @5 v2 P           结果为：s1.endsWith(s2): true
9. boolean equals(Object anObject) ：当anObject不为空并且与当前String对象一样，返回true；否则，返回false。
+ S1 `% L) C3 o# G+ o10. byte[] getBytes() ：将该String对象转换成byte数组。
+ ^* k7 N1 R( t; c: H' f11. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：该方法将字符串拷贝到字符数组中。其中，srcBegin为拷贝的起始位置、srcEnd为拷贝的结束位置、字符串数值dst为目标字符数组、dstBegin为目标字符数组的拷贝起始位置。
0 T* j8 R6 m: T9 w     例如：char[] s1 = {'I',' ','l','o','v','e',' ','h','e','r','!'};//s1=I love her!
           String s2 = new String("you!"); s2.getChars(0,3,s1,7); //s1=I love you!
+ L+ c  u5 _' B8 n           System.out.println( s1 );
2 s7 k# T( M+ w' g8 c           结果为：I love you!
7 D# ^7 ?# X- M0 N% C# {# B12. int hashCode() ：返回当前字符的哈希表码。
' U! X# J  |( U9 B5 p13. int indexOf(int ch) ：只找第一个匹配字符位置。
14. int indexOf(int ch, int fromIndex) ：从fromIndex开始找第一个匹配字符位置。
0 H* t4 M+ M9 G15. int indexOf(String str) ：只找第一个匹配字符串位置。
16. int indexOf(String str, int fromIndex) ：从fromIndex开始找第一个匹配字符串位置。
      例如：String s = new String("write once, run anywhere!");
              String ss = new String("run");
              System.out.println("s.indexOf('r'): " + s.indexOf('r') );
              System.out.println("s.indexOf('r',2): " + s.indexOf('r',2) );
              System.out.println("s.indexOf(ss): " + s.indexOf(ss) );
              结果为：s.indexOf('r'): 1
# c& _6 w; P, U5 r( Z                      s.indexOf('r',2): 12
( I# x4 m/ W# m; h1 v& r# C; N+ n0 k                      s.indexOf(ss): 12
6 ~* M7 V/ x4 z. W1 h7 \7 Y7 P17. int lastIndexOf(int ch)
* |' n8 `$ h5 M18. int lastIndexOf(int ch, int fromIndex)
19. int lastIndexOf(String str)
+ U" C7 W. V& w7 i) d% r20. int lastIndexOf(String str, int fromIndex) 以上四个方法与13、14、15、16类似，不同的是：找最后一个匹配的内容。
. t/ h( k+ r0 `2 e% ~public class CompareToDemo {
" r! j; ]4 E1 }% _( v0 k  @      public static void main (String[] args) {
# K- h8 }1 k3 `" R: e' N' P           String s1 = new String("acbdebfg");

3 ]* A6 y7 _" c4 _3 y" {           System.out.println(s1.lastIndexOf((int)'b',7));
4 g) j, p0 I8 {) u8 T/ K3 _0 r     }
' f$ ?" t0 h# l}
运行结果：5
       （其中fromIndex的参数为 7，是从字符串acbdebfg的最后一个字符g开始往前数的位数。既是从字符c开始匹配，寻找最后一个匹配b的位置。所以结果为 5）
" P) e0 A) D) t5 H: N  ]. q
( ^7 X( \- {+ a4 [* q5 V) L8 |6 R  J
! G4 z' u; k3 S* e% r2 Y4 Z. O" s21. 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开始。
     例如：String s = new String("write once, run anywhere!");
             String ss = new String("write");
) U. q/ K) ^  [' T             String sss = new String("once");
! O1 l) q4 d0 |- I             System.out.println("s.startsWith(ss): " + s.startsWith(ss) );
; _1 F# k0 }8 ^( G' ^) u7 P             System.out.println("s.startsWith(sss,6): " + s.startsWith(sss,6) );
1 }8 ?" {: l' d. [5 N. |             结果为：s.startsWith(ss): true
                     s.startsWith(sss,6): true
25. String substring(int beginIndex) ：取从beginIndex位置开始到结束的子字符串。
26.String substring(int beginIndex, int endIndex) ：取从beginIndex位置开始到endIndex位置的子字符串。
# H7 I! D$ y1 Z. N27. char[ ] toCharArray() ：将该String对象转换成char数组。
* [# v& m8 C# G/ @+ Z# d28. String toLowerCase() ：将字符串转换成小写。
0 {2 z( j2 r: v0 s. e29. String toUpperCase() ：将字符串转换成大写。
7 t0 W6 f4 B) s5 a     例如：String s = new String("java.lang.Class String");
             System.out.println("s.toUpperCase(): " + s.toUpperCase() );
             System.out.println("s.toLowerCase(): " + s.toLowerCase() );
6 [( w  y# J/ s3 L; P# \4 \             结果为：s.toUpperCase(): JAVA.LANG.CLASS STRING
                  s.toLowerCase(): java.lang.class string
% z1 f/ k- }7 M7 R9 G$ U: E1 R30. static String valueOf(boolean b)
: Q  I/ _) r& Q$ G) I: X6 X5 K31. static String valueOf(char c)
32. static String valueOf(char[] data)
3 Q8 N( W- h' Z# f- G; e( q33. static String valueOf(char[] data, int offset, int count)
8 J. p* @# A" K: U  l3 f9 M34. static String valueOf(double d)
% i9 I6 O$ D4 J9 [' K7 k35. static String valueOf(float f)
36. static String valueOf(int i)
% l) s9 A9 }: w; ?37. static String valueOf(long l)
38. static String valueOf(Object obj)
- p$ i0 l0 E1 Q$ `     以上方法用于将各种不同类型转换成Java字符型。这些都是类方法。
6 K3 Q7 T, u  m- X6 \+ m& W8 B

! ^# M. g9 d3 X/ g0 y

; d$ Q; a# [& R4 w; }' I1 F. |/ _+ T6 B
Java中String类的常用方法:

public char charAt(int index)
& v, ^  g6 @* \2 t返回字符串中第index个字符；
2 n) {4 k% s4 f3 Epublic int length()
返回字符串的长度；
public int indexOf(String str)
* J. M0 U- k& Y- I0 X返回字符串中第一次出现str的位置；
public int indexOf(String str,int fromIndex)
返回字符串从fromIndex开始第一次出现str的位置；
) j. {# q$ w0 ~7 u% Tpublic boolean equalsIgnoreCase(String another)
比较字符串与another是否一样（忽略大小写）；
7 L# v1 h7 T8 Z; J5 ypublic String replace(char oldchar,char newChar)
在字符串中用newChar字符替换oldChar字符
public boolean startsWith(String prefix)
% h$ D" j* ]: @2 O判断字符串是否以prefix字符串开头；
% {, F' X3 P1 ^& n6 ypublic boolean endsWith(String suffix)
判断一个字符串是否以suffix字符串结尾；
public String toUpperCase()
1 L4 F, @! A2 }, m  `+ Z返回一个字符串为该字符串的大写形式；
; V  h3 v- ~9 P) Zpublic String toLowerCase()
4 o! F- M7 p* B/ S/ W( j* M; D8 O5 O返回一个字符串为该字符串的小写形式
  K$ q* Q& o0 C: p% a1 xpublic String substring(int beginIndex)
返回该字符串从beginIndex开始到结尾的子字符串；
public String substring(int beginIndex,int endIndex)
返回该字符串从beginIndex开始到endsIndex结尾的子字符串
4 x+ g2 M* _" Z4 L6 {4 |+ xpublic String trim()
返回该字符串去掉开头和结尾空格后的字符串
public String[] split(String regex)
  s6 ~3 G' [1 L- \5 q& B8 w将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组
实例：  
public class SplitDemo{
( g1 Y5 k, x$ s8 l' v     public static void main (String[] args) {

             String date = "2008/09/10";
            String[ ] dateAfterSplit= new String[3];
            dateAfterSplit=date.split("/");         //以“/”作为分隔符来分割date字符串，并把结果放入3个字符串中。
2 A& i4 w+ `( w5 r! C5 [
            for(int i=0;i<dateAfterSplit.length;i++)
8 y/ h  d" G0 D& X                       System.out.print(dateAfterSplit+" ");
1 |$ y: v; D8 z7 `      }
  R. I$ W+ {, Y' v8 S! S  r  s1 \8 A}
9 U+ K( |  X6 n: D) j- m
运行结果：2008 09 10          //结果为分割后的3个字符串
8 ?% y8 U$ W& q3 `' h$ G
实例：
7 h$ l* K1 l$ e3 W- dTestString1.java:
8 i! f1 `+ H% \$ m% r6 Q程序代码
& a' G  _; s6 Ypublic class TestString1
6 i5 @8 J( j) p* X{
    public static void main(String args[]) {
        String s1 = "Hello World" ;
0 C% v# o9 A" \7 Y9 O5 a" h        String s2 = "hello world" ;
        System.out.println(s1.charAt(1)) ;
        System.out.println(s2.length()) ;
' K6 E8 d9 `( O( [( y1 J) P* F        System.out.println(s1.indexOf("World")) ;
: ]+ H7 ?0 O9 O        System.out.println(s2.indexOf("World")) ;
, q  o/ Z4 `, s4 T. @" S        System.out.println(s1.equals(s2)) ;
5 `! B+ P: e. J8 K/ e        System.out.println(s1.equalsIgnoreCase(s2)) ;

9 [" i# I1 G  M& O5 ]7 ]# Y        String s = "我是J2EE程序员" ;
# a8 U8 X7 V  Q9 a        String sr = s.replace('我','你') ;
        System.out.println(sr) ;
! A+ x( @" P$ K# P. b5 D# e    }
}

8 i2 S; Q0 q+ p+ r( GTestString2.java:
. j0 l8 `/ `9 o$ _; K, q程序代码

+ T4 Z4 X: O* i5 ~0 a1 opublic class TestString2
{
    public static void main(String args[]) {
" D' k9 `1 k  }1 G$ ~( n; m        String s = "Welcome to Java World!" ;
        String s2 = "   magci   " ;
        System.out.println(s.startsWith("Welcome")) ;
5 z2 @& R7 O" ?3 c" {% x        System.out.println(s.endsWith("World")) ;
3 D' l: ]6 J2 C1 Y* o/ F        String sL = s.toLowerCase() ;
' N2 j$ Z' G+ B6 o! [0 _1 `! q9 e0 m        String sU = s.toUpperCase() ;
# V2 y- d  I! F4 P4 n        System.out.println(sL) ;
  t4 |0 m- H& ~: Z5 D$ _        System.out.println(sU) ;
# F, ^: }( h6 P- O# z  n        String subS = s.substring(11) ;
        System.out.println(subS) ;
        String s1NoSp = s2.trim() ;
        System.out.println(s1NoSp) ;
    }
& E, `. b9 f5 l, t4 d3 `
$ m" z- r, A1 `5 ?