黑马程序员_javaAPI之String

----- android培训、java培训、java博客、java学习型技术博客、期待与您交流！ -------

如有疑问：http://edu.csdn.net/

1.0、Sting概述

   String s1=”ABC”;//s1是一个类类型变量，“ABC”是一个对象。

                      //字符串最大特点，一旦被初始化就不可能被改变。

   例如s1=”kkk”;它是s1地址变了，但是ABC的内容并没有改变，任然在内存中。

String s2=new String(“ABC”);

s1和s2有什么区别？

s1在内存中有一个对象，s2在内存中有两个对象。

String类覆写了Object类中equals方法，该方法用于判断字符串内容是否相同。

例：System.out.print(s1==s2);-------->false

    System.out.print(s1.equals(s2));-------->true    

String s3=”ABC”;

System.out.print(s1==s3);-------->true

因为发现内存中有”ABC“所以s3就不会创建，s1与s3指向同一个”ABC“；结果是true。

2.0、Sting常见功能-获取、判断、转换

String类适用于描述字符串事物。

那么它就提供了多少个方法对字符串进行操作。

常见操作有：

1. 获取。

1.1、字符串中包含的字符数，也就是字符串的长度。

     int length();获取长度。

1.2、根据位置获取位置上某个字符。

              char charAt(int index);//如果出现不存在的角标，出现异常

                                      java.lang.StringIndexOutOfBoundsException

         1.3、根据字符获取该字符在字符串中的位置。

              int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

              int  indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串

                                                       中出现的位置。//如果没有找到返回-1

              int indexOf(String str):返回的是str在字符串中第一次出现的位置。

              int  indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str

                                                            在字符串中出现的位置。

              int lastIndexOf(int ch);//返回指定字符在此字符串中最后一次出现处的索引。

       2.判断。

          2.1、字符串中是否包含某一个子串。

                boolean contains(str):

                特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示该str不在

                                         字符串中存在。所以，也可以用于对指定指定判断是否包含。

          2.2、字符串中是否有空内容。

                boolean isEmpty();//判断字符串长度是否为0；

          2.3、字符串是否是以指定内容开头。

                boolean startsWith(str);

          2.4、字符串是否是以指定内容结尾。 

                boolean endsWith(str); 

          2.5、判断字符串内容是否相同。覆写了Object类中的equals方法。

                boolean equals(str);

          2.6、判断内容是否相同，并忽略大小写。

                boolean equalsIgnoreCase();

       3、转换。

          3.1、将字符数组转成字符串。

                构造函数：String(char[]);

                          String(char[],offset,count);将字符数组中的一部分转成字符串。

                静态方法：

                         static String copyValueOf(char[]);

                         static String copyValueOf(char[] data,int offset,int count);                    

                         static String valueOf(char[]); 

          3.2、将字符串转成字符数组。

                char[] toCharArray();

          3.3、将字节数组转成字符串。

                String(byte[]);

                String(byte[],offset,count);将字节数组中的一部分转成字符串。

          3.4、将字符串转成字节数组。

                byte[] getBytes();          

          3.5、将基本数据类型转成字符串。

                static String valueOf(int a);//3+”” 等同于 String.valueOf(3);

                static String valueOf(double d);              

                特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

      4、替换。

         String replace(oldchar,newchar);//如果要替换的字符不存在，结果还是原串。     

     5、切割

         String[] split(regex);//按照指定的符号regex分割字符串

      6、子串。获取字符串中一部分。

         String substring(int begin);//从指定位置开始到结尾s.substring(2);

         String substring(int begin,int end); //包含头，不包含尾 。s.substring(0,s.length());

      7、转换，去除空格，比较。

         7.1、将字符串转成大写或小写。

               String toUpperCase();

               String toLowerCase();

         7.2、将字符串两端多个空格去除。

               String trim();

         7.3、对两个字符串进行自然顺序的比较。

               int compareTo(String s);

      3.0、StingBuffer容器    

           StringBuffer是字符串缓冲区。

           是一个容器：

           1、长度可以变化。2、可以直接操作多个数据类型。3、最终会通过toString方法变成字符串。   

           C create U update R read D delete

1. 添加

   StringBuffer append():将制定数据作为参数添加到已有数据结尾处。

   StringBuffer insert(index,数据);可以将数据插入到指定index位置。

2. 删除

        StringBuffer delete(int start,int end);//删除缓冲区中的数据，包含start,不包含end.

        StringBuffer deleteCharAt(int index);删除指定位置的字符

        StringBuffer sb=new StringBuffer(“abcde”);

        sb.delect(0,sb.length());清空缓冲区

3. 获取

   char charAt(int index);//返回指定索引处的字符

   int indexOf(String str);//返回指定子字符串在此字符串中第一次出现处的索引。

   int lastIndexOf(String str);//返回指定子字符串在此字符串中最右边出现处的索引。

   int length();//获取长度

   String substring(int begin,int end); //包含头，不包含尾   

4. 修改

        StringBuffer replace(int start,int end,String str);

        Void setCharAt(int index,char ch);

5、反转。

   StringBuffer reverse();

6、将缓冲区中指定数据存储到指定字符数组中。

       void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

       

JDK1.5 版本之后出现了StringBuilder。

一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简单替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。

StringBuffer：是线程同步。效率低，需要判断锁。

StringBuilder：是线程不同步。效率高

将StringBuilder的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer。

升级三个因素：

1．提高效率；2.简化书写；3.提高安全性。

4.0、基本数据类型对象的包装类

          byte ------       Byte 

          short ------      Short  

           int    ------     Integer 

           long    ------    Long 

           boolean ------   Boolean 

           float  ------     Float 

           double  ------   Double 

           char    ------   Character 

           基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间的转换。

           1、基本数据类型转成字符串。

              基本数据类型+””;

              基本数据类型包装类.toString(基本数据类型值);

              如：Integer.toString(23);

           2、字符串转成基本数据类型   

1)    int num= Integer.parseInt(“123”);

2) Integer in=new Integer(“123”);

         int num2=in.intValue();          

      3、十进制转成其它进制。

         toBinaryString(); //转成二进制

         toHexString();  //转成十六进制

         toOctalString();  //转成八进制

      4、其它进制转成十进制。

         parseInt(String str,int radix);      

         int n=Integer.parseInt("110",2);

        System.out.println(n);---6;

       int n2=Integer.parseInt("3c",16);

        System.out.println(n2);---60;

基本数据类型对象包装类新特性：

  1、   public static void main(String[] args) {

Integer x=4;//自动装箱。new Integer(4);

x=x/*x.intValue()*/+2;//x自动拆箱，变成int类型。和2进行加法运算。

                      //再将和进行装箱赋给x

System.out.println(x);

}

   2、Integer m=128;

      Integer n=128;

 System.out.println(m==n);//结果为：false

     Integer a=127;

      Integer b=127;

 System.out.println(a==b);//结果为：true

因为a和b指向了同一个Integer对象。当数值在byte范围（-128~127）内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间。

 

----- android培训、java培训、java博客、java学习型技术博客、期待与您交流！ -------

如有疑问：http://edu.csdn.net/