黑马程序员----4String

------- android培训、java培训、期待与您交流！ ----------

 

 

>>字符串是一个特殊的对象，lang包里面的String类final修饰，不能有子类。

 

String str = “abc”;与String str =new String(“abc”)有什么不同？以及由此引申的一些问题。

注意str是一个类类型变量，”abc”是一个对象，此对象一旦初始化，不再变化。

eg：String str =“abc”;

         str= “def”;//输出def

注意这个是str的指向变了，不是”abc”变化了。

 

另外

String str = “abc”;与String str =new String(“abc”)使用起来是一样的，但是

eg：//有如下代码

String str1 = “abc”;

String str2 =new String(“abc”)

//str1在内存中有一个对象，“”abc””是一个

//str2在内存中有两个对象，“new”是一个“”abc””是一个

System.out.println(str1==str2);

System.out.println(str1.equals(str2));

/*toString类覆盖了Object的equals方法，用于判断内容是否相同*/

//输出false

          true

另外

String str1 = “abc”;

String str3 = “abc”;

System.out.println(str1==str3);//输出true

因为创建str3时str1指向的”abc”已经在内存中存在，所以str3直接指向”abc”这个对象了。

 

另外（面试）

………………

String s1 = “abc”;

String s2 = ”ab”;

String s3 = ”c”;

String s4 = s2+s3;

String s5 = “ab”+”c”;

 

System.out.rpintln(“s1==s4?:”+s1==s4);

System.out.rpintln(“s1==s5?:”+s1==s5);

………………//输出：s1==s4?:false

                                               s1==s5?:true

 

>>构造函数

eg：classStringMethodDemo

{

         publicstatic void main(String[] args)

         {

                   consMethod();

         }

 

         publicstatic void consMethod()

{

         String s = newString();//一般不会用到这个构造函数

         String s1 = “”;//和null不同

         System.out.println(s.equals(s1));//结果：true

 

         byte[] arr = {98,99,100};//byte类型

         String s2 = newString(arr);//构造函数

         System.out.println(“s2=”+s2);//结果：bcd

 

         String s3 = newString(arr,1,2);//构造函数，1开始，取2个

         //String s3 = newString(arr,0,arr.length);//全部输出

         System.out.println(“s3=”+s3);//结果：cd

 

         int[] arr2 = {65,66,67};

         String s4 = newString(arr2,0,arr2.length);

         System.out.println(“s4=”+s4);//结果ABC

}

}

 

>>String类中提供的方法

1、获取

         1.1字符串中包含的字符数，即字符串长度：

int length();

                   注意，数组也有长度，但数组的长度是属性，其length不带括号。

         1.2根据位置获取字符：

char charAt(int index);

返回值是char，这也是API查找技巧之一。

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

int indexOf(int ch);//接受ASCII码，返回字符在串中第一次出现位置

int indexOf(int ch,fromIndex);//从指定位置获取，访问串中不存在的角标会发生越界。

int indexOf(String str);//获取字符串位置，没有找到返回-1

int lastIndexOf(int ch);//反向索引，从右往左查找，第一次出现的位置

                   注意字符角标也是从0开始的。

2、判断

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

          boolean contains(str);

         2.2字符中是否有内容

          boolean isEmpty()

          就是判断length()是否为0,1.6版才有。

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

          boolean startsWith(String str);

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

          boolean endsWish(String suffix);

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

boolean equals(str);

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

          boolean equalsIgnoreCase();

3、转换

         3.1将字符数组转成字符串

          String(char[] value)//构造函数

          String(char[] value,int offset,int count)//包含偏移量和个数

          static copyValueOf(char[] value)//静态方法

          static copyValueOf(char[] data,int offset,intcount)

          static String valueOf(char[] data)

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

         3.2将字符串转成字符数组

          char[] toCharArray()

         3.3将字节数组转成字符串

          String(byte[] value)//构造函数

          String(byte[] value,int offset,int count)//包含偏移量和个数

3.4将字符串转成字节数组

 byte[] getBytes()

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

 static String valueOf(int)

 static String valueOf(double)

eg:3+””//使用方法实现

   String.valueOf(3);

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

4、替换

         1.1Stringreplace(oldchar,newchar)

eg:……

public static void method_replace()

{

     String s = “hello java”;//注意字符串一旦被初始化就不会被改变的特性

String s1 = s.replace(‘a’,’n’);//如果要替换的字符不存在，返回原字符串

     sop(“s=”+s);

     sop(“s1=”+s1);

}//输出结果：hello java

                       hellojnvn

……

         1.2String replace(CharSequence target, CharSequence replacement)

eg:……

String s1 = s.replace(“java”,”world”);

……

其它replaceALL与replaceFirst涉及正则表达式，可以按照一定规则替换

5、切割

         5.1split(String regex)// 根据给定正则表达式的匹配拆分此字符串。

                   eg:……

                            Strings = “zhangsanmmlishimmwangwu”;

                            String[]arr = s.split(”mm”);//mm作为了一个指定的分割符

                            for(intx = 0; x<arr.length; x++)

                            {

                                     sop(arr[x]);

                            }

……

//输出：zhangsan

                   lishi

                   wangwu

6、子串

         6.1获取字符串中得一部分

         Stringsubstring(int beginIndex)//注意会发生角标越界异常

          String substring(int beginIndex,int endIndex)//输出包含beginIndex但不包含endIndex

 

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

         7.1将字符串转成大写或者小写

          String toUpperCase();//转换成大写

          String toLowerCase();//转换成小写

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

          Strin trim();

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

          int compareTo(string);

                   eg:……

                   Strings1 = “acc”;

                   Strings2 = “aaa”;

                   sop(s1.compareTo(s2));

                   ……//输出结果：2

                   //因为，c在ASCII表中比a大2，同理如果是s1 = “a1c”;s2= “aaa”,则结果为-48。注意，1和a比较过后，后面的c与a就不再比较了。

 

>>练习，去除字符串两端空格

         publicstatic String myTrim(String str)

         {

                   intstart = 0,end = str.length()-1;

 

                   while(start<=end&& str.charAt(start)==' ')

                            start++;

 

                   while(start<=end&& str.charAt(end)==' ')

                            end--;

 

                   returnstr.substring(start,end+1);//获取子串是不包含尾的，所以加1。

         }

 

>>练习，将数组变成字符串

         publicstatic String reverseString(String s,int start,int end)//方法重载，取一子串反转

         {

                   //字符串变数组。

                   char[]chs = s.toCharArray();

 

                   //反转数组。

                   reverse(chs,start,end);

 

                   //将数组变成字符串。

                   returnnew String(chs);

         }

         publicstatic String reverseString(String s)//方法重载，整串反转

         {

                   returnreverseString(s,0,s.length());

                  

         }

 

         privatestatic void reverse(char[] arr,int x,int y)

         {

                   for(intstart=x,end=y-1; start<end ; start++,end--)

//y-1取不包含尾的意义，是java的惯例，因为y一般代表长度，y-1代表最后的角标

                   {

                            swap(arr,start,end);

                   }//实现反转数组，重点start<end

         }

         privatestatic void swap(char[] arr,int x,int y)

         {

                   chartemp = arr[x];

                   arr[x]= arr[y];

                   arr[y]= temp;

         }

 

>>练习，获取一个字符串中另一个字符串出现的次数

public static int getSubCount(Stringstr,String key)

         {

                   intcount = 0;

                   intindex = 0;

 

                   while((index=str.indexOf(key))!=-1)

                   {

                            str= str.substring(index+key.length());

                            count++; 

                   }

                   returncount;

         }

/*方法二*/

public static int getSubCount_2(Stringstr,String key)

         {

                   intcount = 0;

                   intindex = 0;

 

                   while((index=str.indexOf(key,index))!=-1)

                   {

                            sop("index="+index);

                            index= index + key.length();

 

                            count++;

                   }

                   returncount;

         }

切割的方法不通用，当要查找的子串位于主串的头时，会切出一个空串，造成计数错误。

 

>>练习，获取两个字符串的最大相同子串

public staticString getMaxSubString(String s1,String s2)//假设s2是短的字符串？

         {

                   Stringmax = “”,min = “”;//判断长短串

                   max= (s1.length()>s2.length())?s1: s2;

                   min= (max==s1)?s2: s1;

                  

                   for(intx=0; x<min.length(); x++)

                   {

                            for(inty=0,z=min.length()-x; z!=min.length()+1; y++,z++)

                            {

                                     Stringtemp = min.substring(y,z);

                                    

                                     sop(temp);

                                     if(max.contains(temp))//if(s1.indexOf(temp)!=-1)

                                               returntemp;

                            }

                   }

                   return"";

         }

 

>>StringBuffer类是字符串缓冲区，是一个容器（存储、删除、获取、修改，C create U update R read D delete）；二是它的长度是可以变化的；三是可以直接操作多个数据类型；四是最终会通过toString变成字符串。

 

被final修饰，不能继承。

 

>>append（附加）方法：将制定数据作为参数添加到已有数据的末尾。

方法调用链

sb.append(“abc”).append(true).append(34);//关键是其返回的还是本类对象。

输出：abctrue34

 

>>insert(int offset, String str)方法，可以插入字符串

eg：在a后面插入qq

sb.insert(1,”qq”);//输出aqqbctrue34

 

>>StringBuffer delete(int start,intend)//删除缓冲区的数据，同样，包含头，不包含尾

 StringBuffer deleteCharAt(int index)//删除指定位置的字符，delete(x,x+1);删除x

 

         怎么清空缓冲区呢？

         sb.delete(0,sb.length());注意不是length-1。

 

>>charAt(int index)
          返回此序列中指定索引处的char值。

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

         indexOf(String str, int fromIndex)
          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。

        

 

>>替换方法

         StringBufferreplace(int start,int end,String str)//开始，结尾，替换内容

         voidsetChatAt(int index,String str)//替换完不返回数据

 

>>反转方法

StringBuffer reverse()
          将此字符序列用其反转形式取代。

 

>>StringBuffer其它方法

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

//将字符从此序列复制到目标字符数组dst。

eg：…………

         StringBuffersb = new StringBuffer(“abcdef”);

         char[]chs = new char[4];//不够大运行时会报角标越界异常

         sb.getChars(1,4,chs,1);

         for(intx=0;x<chs.length;x++)

         {

                   System.out.println(“chs[”+x+”]”+chs[x]+”;”);

}

…………

输出：chs[0]=  ;

           chs[1]=b;

           chs[2]=c;

           chs[3]=d;

 

>>JDK1.5 版本之后出现了StringBuilder其提供与StringBuffer相同的API

不同的是StringBuffer是线程同步，StringBuilder是线程不同步。

（升级三因素：提高效率，简化书写，提高安全性）

 

>>基本数据类型对象包装类

byte          Byte

short         short

int              Integer

long          Long

boolean  Boolean

float          Float

double      Double

char          Character

 

基本数据类型对象包装类的最常见作用，

就是用于基本数据类型和字符串类型之间做转换

 

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

         基本数据类型+""

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

         如：Integer.toString(34);//将34整数变成"34";

 

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

         xxxa = Xxx.parseXxx(String);

/*

int a =Integer.parseInt("123");//如果传a123，报数字格式异常

         doubleb = Double.parseDouble("12.23");

         booleanb = Boolean.parseBoolean("true");

         注意Character类没有parse方法

*/

         Integeri = new Integer("123");

         intnum = i.intValue();

        

十进制转成其他进制。

         toBinaryString();//二进制

         toHexString();//十六进制

         toOctalString();//八进制

 

其他进制转成十进制。

         parseInt(string,radix);//radix表示string是什么进制的表现形式

eg：int x =Integer.parseInt(“110”,10);//输出110

         intx = Integer.parseInt(“110”,2);//输出6，不能写(“120”,2)，这样很2

         注意16进制不用表示成(“0x110”,16)，否则报异常

另外：也可以先封装，后用方法转换

eg：Integer I = new Integer(“123”);

/*

构造方法，构造一个新分配的Integer对象，

它表示String参数所指示的int值。

*/

       int num = i.intValue();//静态方法

 

>>eg：比较例子

…………

Integer x = new Integer("123");

Integer y = new Integer(123);

 

sop("x==y:"+(x==y));

sop("x.equals(y):"+x.equals(y));

…………

//结果为：

x==y:false         //因为xy不是同一个对象

x.equals(y):true        //因为Integer覆盖了equals方法，方法只是判断数值是否相等

 

注意：这个是JDK1.5后出现的新特性，可以这样写

Integer y = new Integer(123);//等同于

Integer y = 123//注意“123”必然是对象，叫做“自动装箱”

而且，可以直接进行运算：y= y + 2;/*叫做“自动拆箱”，y变成int类型，和2进行运算，再将结果（和）进行自动装箱赋给y。*/  其实是这样的：y = y/*y.intValue()*/ + 2;

由于是Integer可以这样写：Integery = null;/*这个时候再进行运算，调用intValue方法会出现空指针异常,所以最好做适当的判断动作*/

 

eg：新特性的特殊比较例子(JDK1.5版本以后)

…………

Integer m = 128;

                   Integern = 128;

 

                   sop("m==n:"+(m==n));//无疑问，结果为false

 

                   Integera = 127;

                   Integerb = 127;

 

                   sop("a==b:"+(a==b));//结果为true。为什么呢？

/*

因为a和b指向了同一个Integer对象。

因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。

*/

…………