java基础05：字符串

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

 一、String类

 

1、概述

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

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

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

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

 

2、初始化

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

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

 

3、字符串常量池

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

 

[java] view plain copy

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);

 二、StringBuffer类

 

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）；

　c、十进制转成其他进制。

         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开始。//此方法为构造方法，如下    boolean startsWith(String 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.       17. 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()。

 四、最后

 

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