java中一些基础类比如String、StringBuffer和基本数据类型包装类都是非常常见且使用非常频繁的类。这些类虽然简单，但是想要熟练使用也必须要学习，虽然API文档对这些类的用法都讲的比较详细，但是我觉得还是有必要再整理一下。



 

1、概述

　　String就是字符串的意思，首先要明确一点的是String并不属于基本数据类型。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

　　注意new String() 和 newString("")都是声明一个空的字符串而不是null。

　　字符串一旦被初始化就不可以被改变。

 

2、初始化

　　对象初始化格式String s = new String("abc");　

　　　----可以简写为String  s = "abc";

 

3、字符串常量池

讲之前首先我们先来看一个例子

1. //例1   
2.       String s1 = “abc";   
3.       String s2 = "abc";   
4.       String s3 = "a" + "bc";   
5.       System.out.println(s1 == s2); // true   
6.       System.out.println(s1 == s3);// true    
7.    
8. //例2    
9. 　　　String s1 = new String("abc");    
10.  　　 String s2 = new String("abc");   
11.   　　String s3 = "a" + new String("bc");   
12.   　　System.out.println(s1==s2);        //false   
13.   　　System.out.println(s2==s3);        //false   
14.



　　运行这个2个例子的结果，我们会惊奇的发现例1和例2运行的结果竟然不同。上面不是说用new和不用new是一样的吗？

这里我们就要引入常量池的概念：常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s1和s2中的”abc”都是字符串常量，它们在编译期就被确定了，所以s1==s2为true；

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

4、常用方法

 4.1、获取：

 　　4.1.1 获取字符串中字符的个数(长度).

  　　int length();

 

 4.1.2 根据位置获取字符。

 　　 char charAt(int index);

 

 4.1.3 根据字符获取在字符串中的第一次出现的位置.

  　　int indexOf(int ch) ch为字符的Unicode编码

 　　 int indexOf(int ch,int fromIndex) 从指定位置进行ch的查找第一次出现位置

 　　 int indexOf(String str)根据字符串获取在字符串中的第一次出现的位置.

  　　int indexOf(String str,int fromIndex)从fromIndex指定位置开始，获取str在字符串中出现的位置.

 

 4.1.31反向索引，从后向前查找

  　　int lastIndexOf(int ch)

  　　int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置

 　　 int lastIndexOf(String str);

  　　int lastIndexOf(String str,int fromIndex);

 

 4.1.4 获取字符串子串。

  　　String substring(int beginIndex, int endIndex)//包含begin 不包含end 。

 　　 String substring(int beginIndex);//从beiginIndex索引开始截取字符串。

 

 4.2、转换

  　　4.2.1 将字符串变成字符串数组

 　　 String[]  split(String regex):涉及到正则表达式.

 

  4.2.2 将字符串变成字符数组。

  　　char[] toCharArray();

 

  4.2.3 将字符串变成字节数组。

 　　 byte[] getBytes();

 

  4.2.4 将字符串中的字母转成大小写。

  　　String toUpperCase():大写

  　　String toLowerCase():小写

 

　4.2.5将字符串中的内容进行替换

　　　String replace(char oldch,char newch);

  　　String replace(String s1,String s2);

 

  2.6 将字符串两端的空格去除。

  　　String trim();

 

  2.7 将字符串进行连接 。

  　　String concat(string);

 

 4.3、判断比较

  4.3.1 两个字符串内容是否相同啊？

  　　boolean equals(Object obj);

  　　boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。

  4.3.2 字符串中是否包含指定字符串？

  　　boolean contains(string str);

  4.3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。

  　　boolean startsWith(string);

  　　boolean endsWith(string);



 

1、概述

　　StringBuffer类和String一样，也用来代表字符串，只是由于StringBuffer的内部实现方式和String不同，所以StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。

所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。

在StringBuffer类中存在很多和String类一样的方法，这些方法在功能上和String类中的功能是完全一样的。

但是有一个最显著的区别在于，对于StringBuffer对象的每次修改都会改变对象自身，这点是和String类最大的区别。

 

2、StirngBuffer初始化

　　StringBuffer对象的初始化不像String类的初始化一样，Java提供的有特殊的语法，而通常情况下一般使用构造方法进行初始化。

 

3、特点　　

 　　a、长度的可变的。  　　

　　 b、可以存储不同类型数据。  　　

　　 c、最终要转成字符串进行使用。 　　

　　d、可以对字符串进行修改。

 

4、常用方法

4.1添加：

   StringBuffer append(data);//能够添加各种数据类型

   StringBuffer insert(index,data); //在索引出插入各种类型

4.2删除：

   StringBuffer delete(start,end):包含头，不包含尾。

   StringBuffer deleteCharAt(int index):删除指定位置的元素

4.3查找：

    char charAt(index); //在该索引出的char值

　 int codePointAt //索引处的字符

    int indexOf(string); //

    int lastIndexOf(string);

 　int capacity() //返回当前Buffer的容量（初始16）

 　int length()  //长度

4.4修改：

      StringBuffer replace(start,end,string);

　　 void setCharAt(index,char);

　　StringBuffer reverse() 将此字符序列用其反转形式取代(String类中没有反转)  

　　void trimToSize()  尝试减少用于字符序列的存储空间。

 

5、StringBuilder

 jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

 这里就不详细介绍了。注意一下它们的不同点就好了。

 不同的是：

 StringBuffer是线程同步的。通常用于多线程。

 StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。

 



 

 1、概述

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。

 2、对应关系

byte ——Byte

short ——Short

int ——Integer

long-----Long

float-----Float

double----Double

char----Character

boolean---Boolean

3、Integer类内部的常用方法

     事实上这几种数据类型包装内是比较相似，我只以Integer为例简单介绍一下。

    a、parseInt方法

        //将数字字符串转换为int数值。         String s = “123”；         int n = Integer.parseInt（s）；

         //将字符串”120”按照十进制转换为int，则结果为120          int n = Integer.parseInt(“120”,10);

         //将字符串”12”按照十六进制转换为int，则结果为18          int n = Integer.parseInt(“12”,16);

         //将字符串”ff”按照十六进制转换为int，则结果为255          int n = Integer.parseInt(“ff”,16);    

 

    b、int转字符串

　　可以直接用+号连接，也可以用toString函数。

   //将int类型转换为对应的String类型。     int m = 1000；     String s = Integer.toString（m）；

         toBinaryString();

         toHexString();

         toOctalString();


一、string


 


1. int length() ：返回当前字符串长度。


2. char[ ] toCharArray() ：将该String对象转换成char数组。


3. char charAt(int index) ：取字符串中的某一个字符。如下：



 

String s = new String("abcdefghijklmnopqrstuvwxyz");
System.out.println("s.charAt(5): " + s.charAt(5) );//结果为：f

4. byte[] getBytes() ：将该String对象转换成byte数组。



5. int indexOf(String str) ：只找第一个匹配字符串位置。//此方法为构造方法。如下：

int indexOf(int ch) ：只找第一个匹配字符位置

int indexOf(int ch, int fromIndex) ：从fromIndex开始找第一个匹配字符位置

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
                      s.indexOf('r',2): 12
                      s.indexOf(ss): 12

6.public String trim()：返回该字符串去掉开头和结尾空格后的字符串

7.String substring(int beginIndex)：取从beginIndex位置开始到结束的子字符串。//此方法为构造方法，如下
  String substring(int beginIndex, int endIndex) ：取从beginIndex位置开始到endIndex位置的子字符串。

8.String toLowerCase() ：将字符串转换成小写。
9.String toUpperCase() ：将字符串转换成大写。
10.boolean startsWith(String prefix) ：该String对象是否以prefix开始。//此方法为构造方法，如下
prefix, int toffset) ：该String对象从toffset位置算起，是否以prefix开始。
     例如：String s = new String("write once, run anywhere!");
             String ss = new String("write");
             String sss = new String("once");
             System.out.println("s.startsWith(ss): " + s.startsWith(ss) );
             System.out.println("s.startsWith(sss,6): " + s.startsWith(sss,6) );
             结果为：s.startsWith(ss): true
                     s.startsWith(sss,6): true

      例如：String s = new String("java.lang.Class String");
             System.out.println("s.toUpperCase(): " + s.toUpperCase() );
             System.out.println("s.toLowerCase(): " + s.toLowerCase() );
             结果为：s.toUpperCase(): JAVA.LANG.CLASS STRING
                  s.toLowerCase(): java.lang.class string

11.public boolean endsWith(String suffix)：判断一个字符串是否以suffix字符串结尾；
12.String replace(char oldChar, char newChar) ：将字符号串中第一个oldChar替换成newChar。

 

 

 

4. int compareTo(String anotherString) ：当前String对象与anotherString比较。相等关系返回０；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差，另一种情况，较长字符串的前面部分恰巧是较短的字符串，返回它们的长度差。
3. 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) ); //返回长度差
           System.out.println("s1.compareTo(s3): " + s1.compareTo(s3) ); //返回'k'-'a'的差
           结果为：s1.compareTo(s2): 4
                       s1.compareTo(s3): 10
4. String concat(String str) ：将该String对象与str连接在一起。
5. boolean contentEquals(StringBuffer sb) ：将该String对象与StringBuffer对象sb进行比较。
6. static String copyValueOf(char[] data) ：
7. static String copyValueOf(char[] data, int offset, int count) ：这两个方法将char数组转换成String，与其中一个构造函数类似。
    例如：String s1 = new String("abcdefghij");
           String s2 = new String("ghij");
           System.out.println("s1.endsWith(s2): " + s1.endsWith(s2) );
           结果为：s1.endsWith(s2): true
9. boolean equals(Object anObject) ：当anObject不为空并且与当前String对象一样，返回true；否则，返回false。
11. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：该方法将字符串拷贝到字符数组中。其中，srcBegin为拷贝的起始位置、srcEnd为拷贝的结束位置、字符串数值dst为目标字符数组、dstBegin为目标字符数组的拷贝起始位置。
     例如：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!
           System.out.println( s1 );
           结果为：I love you!
12. int hashCode() ：返回当前字符的哈希表码。
13. 。
14. 。
16. int lastIndexOf(int ch)18. int lastIndexOf(int ch, int fromIndex)19. int lastIndexOf(String str)20. int lastIndexOf(String str, int fromIndex) 以上四个方法与13、14、15、16类似，不同的是：找最后一个匹配的内容。

public class CompareToDemo {
       public static void main (String[] args) {
            String s1 = new String("acbdebfg");
       
            System.out.println(s1.lastIndexOf((int)'b',7));
      }
 }


运行结果：5       （其中fromIndex的参数为 7，是从字符串acbdebfg的最后一个字符g开始往前数的位数。既是从字符c开始匹配，寻找最后一个匹配b的位置。所以结果为 5）


22. 23.30. static String valueOf(boolean b)31. static String valueOf(char c)32. static String valueOf(char[] data)33. static String valueOf(char[] data, int offset, int count)34. static String valueOf(double d)35. static String valueOf(float f)36. static String valueOf(int i)37. static String valueOf(long l)38. static String valueOf(Object obj)

Java中String类的常用方法:

public boolean equalsIgnoreCase(String another)
比较字符串与another是否一样（忽略大小写）；
public String[] split(String regex)
将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组
实例：  
public class SplitDemo{
     public static void main (String[] args) {

             String date = "2008/09/10";
            String[ ]dateAfterSplit= new String[3];
            dateAfterSplit=date.split("/");        //以“/”作为分隔符来分割date字符串，并把结果放入3个字符串中。
            for(int i=0;i<dateAfterSplit.length;i++)
                       System.out.print(dateAfterSplit[i]+" ");
      }
}

运行结果：2008 09 10          //结果为分割后的3个字符串

实例：
TestString1.java:
程序代码

public class TestString1
 {
     public static void main(String args[]) {
         String s1 = "Hello World" ;
         String s2 = "hello world" ;
         System.out.println(s1.charAt(1)) ;
         System.out.println(s2.length()) ;
         System.out.println(s1.indexOf("World")) ;
         System.out.println(s2.indexOf("World")) ;
         System.out.println(s1.equals(s2)) ;
         System.out.println(s1.equalsIgnoreCase(s2)) ;        String s = "我是J2EE程序员" ;
         String sr = s.replace('我','你') ;
         System.out.println(sr) ;
     }
 }

TestString2.java:
程序代码

public class TestString2
 {
     public static void main(String args[]) {
         String s = "Welcome to Java World!" ;
         String s2 = "   magci   " ;
         System.out.println(s.startsWith("Welcome")) ;
         System.out.println(s.endsWith("World")) ;
         String sL = s.toLowerCase() ;
         String sU = s.toUpperCase() ;
         System.out.println(sL) ;
         System.out.println(sU) ;
         String subS = s.substring(11) ;
         System.out.println(subS) ;
         String s1NoSp = s2.trim() ;
         System.out.println(s1NoSp) ;
     }

 

 

二、StringBuffer

1.概念

缓存区，本身也是操作字符串，但是与String不同，StringBuffer是可以更改到。StringBuffer是一个操作类，所以必须通过实例化进行操作。

 

2.常用方法

append()、insert()、replace()、indexOf()。

 

 

三、StringBuilder

1.概念

一个可变的字符序列，该类被设计作用StringBuffer的一个简易替换，用字符串缓存区被单个线程使用的时候。建议优先考虑，速度比StringBuffer要快。但是如果设计到线程安全方面，建议使用StringBuffer。

 

2.常用方法

append()、insert()。



 

 即使是简单的东西，我们也要把它重视起来，坚持每天进步一点点，最后我们就是成功的。