首页 > 代码库 > 黑马程序员-字符串

黑马程序员-字符串

 

字符串最大的特点是:一旦被初始化就不可以被改变

方法区:方法区,静态区,常量池。

       String s =new String();

       String s0= "";//两者效果一样,但这个方便,

       String s1 = "abc"//s1是什么?s1是一个类类型变量(应指向对象),"abc"是一个对象,字符串是一个特殊的对象

       String s2 = new Stirng("abc");//存于常量池

       System.out.println(s1=s2);//false

       System.out.println(s1.equals(s2));//true(覆盖了Object的equals方法),

       //String类覆盖了object类中的equals方法,用于判断字符串是否相同,object中的equals方法比较内存地址值

       s1和s2有什么区别?面试

              ;s1在内存中有一个对象

              ;s2在内存中有两个对象。      

常见才操作有哪些?

1.获取

       1.1 int length()

       1.2 charAt(int index)                 

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

              int indexOf(int ch,int fromIndex) 从制定位置开始索引,第一次出现的字符的位置                 int indexOf(String str)返回的是str在字符串中第一次出现的位置。

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

2.判断

       2.1  boolean contains(str)

       特殊之处;indexOf(str):索引str第一次出现的位置,如果返回-1,表示字符不存在。也可以判断是否包含

                     即判断又获取位置:if(str.indexOf("aa")!=-1),该方法也可以判断,有可以获取出现的位置

       2.2 字符串中是否有内容 boolean isEmpty();原理是length是否为零 "" null 的区别 一个是对象,一个指向空

       2.3  boolean startsWith(String prefix)

       2.4  boolean endsWith(String prefix)

       2.5  Boolean equals(sts)

       2.6  Boolean equalsIgnoreCase(str)判断内容是否相同,并忽略大小写

3.转换

       3.1将字符数组转成字符串

              构造函数:String(char[])

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

              静态方法:static String copyValue(char[] date);

                              static String copyValue(char[] date,int,offset);

                              static String Value(char[] date);与上面的没区别,但是其功能更多

       3.2将字符串转成字符数组

                            char[] toCharArray();可以直接调用,因为字符串是对象

       3.3字节数组转成字符串

              构造函数:String(byte[])

                              String(byte[],offset,count)

       3.4将字符串转成字节数组

                            byte[]getBytes()    

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

              static String valueOf(int,double)

              s+"" String valueof(3),结果一样。

4.替换

       4.1 String replace(oldchar,newchar);

              String replace(CharSequence target,CharSequence replacement)

5.切割

       5.String[] split(regex)

6.子串;获取字符串中的一部分

       String substring(int begin);

       String subsgeing(int begin,int end);不包含尾。

7.1转换

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

              String toUpperCase();

              String toLowerCase();

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

              String trim();

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

              int compareTo(another string)

              如果参数字符串等于此字符串,则返回值 0;

              如果此字符串按字典顺序小于字符串参数,则返回一个小于 0 的值;

              如果此字符串按字典顺序大于字符串参数,则返回一个大于 0 的值。

练习1:模拟一个trim,去除字符串两端的空格

思路:通过startWith和endsWith来控制两端的角标。

练习2.将一个字符串进行反转。将字符串中指定部分进行反转 

思路:

       1.将字符串变成数组

       2.对数组进行反转

       3.将数组变成字符串

练习3获取一个字符串的出现次数。kk

"abkkcdkkefkkskk"

思路:

       1.定义计数器

       2.indexOf()获取kk第一次出现的位置,并记住其脚标,返回-1,表示不存在

       3.获取KK后面的KK

       4.当获取不到时,计数完成

练习4:获取两个字符串中最大相同的子串。abcdhelloabd" "whellom"

public class Demo1 {

       /**

        * @param args

        */

       public static void main(String[] args) {

              String s1="sdfsdfdfdf";

              String s2 = "122000";

              System.out.println(show(s1,s2));

       }

       public static String show(String s1,String s2){

              String max=" ";

              String min=" ";

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

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

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

              {//尾角标z=s2.length+1时结束。取到最后一个substring(5.6)时,s2.length=5(不包含尾字符),z=6=5+1

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

                     {

                            System.out.println(z);

                            String temp = min.substring(y,z);//不包含尾                           

                            if(max.contains(temp)){

                                   System.out.println(temp);

                                   return temp;

                            }     }            }

              return "不存在";//这个return不执行

              }

}

StringBuffer是字符缓冲区,是一个容器。特点:

一个容器:

1.长度是可以变化的。

2.可以直接操作多种数据类型。

3.最终会通过tostring()方法变成字符串。

什么时候用:类型不确定,个数不确定。

CURD   create updade read lelete

1.存储

       返回值类型StringBuffer  append();将数据添加到已有数据的[结尾处]。//append都是从结尾处添加

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

2.删除

       返回值类型:StringBuffer delete(start,end):删除缓冲区中的数据,含头不含尾

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

3.获取

       返回值类型:StringBuffer charAt(int index):获取指定索引处的char值

              int   indexOf(String,str);获取第一次出现指定的字符串在字符串中的索引

              int   indexOf(String str,int fromindex):从指定位置开始,第一次出现该字符                      int length():返回长度(字符数)

       注意返回值类型String   substring(int start,int end):返回子串,包含头,不包含尾巴

                String  substring(int start):返回子串,从指定位置到结尾。              

4.修改

       返回值类型:StringBuffer replace(int start,int end,String)//从start到end-1,替换成string

       注意返回值类型:void    void setCharAt(int index,char ch);将制定位置的字符设置成ch

5.反转

       返回值类型:StringBuffer reversre();

6. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):将指定 srcBegin到srcEnd的char[]类型数组,存放到char[] ds中,从char[] ds开始存。

jdk1.5版本之后出现了StringBuilder.

StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发建议使用StringBuilder.

java 升级三个要素:

1.提高效率

2.简化书写

3.提高安全性

例外;

StringBuffer sb1 = sb.replace(0,5,"b");

//StringBuffer无法获取指定字符和short的索引(没有char和short方法)。

indexOf():(int b = sb.indexOf(‘a‘):错误,int b = sb.indexOf("a"):正确)

练习:

public static void main(String[] args) {

              // TODO Auto-generated method stub

              StringBuffer sb = new StringBuffer("hellojava");

              StringBuffer sb1 = new StringBuffer("java");

              show(sb,sb1);

              System.out.println(sb+"...."+sb1);

//hellojavajava....java

       }

       public static void show(StringBuffer sb1,StringBuffer sb2){

              sb1.append(sb2);

              sb1=sb2;

              sb1=null;

       }

JDK1.5之后,出现的新特性。

旧: Integer x = new Integer(4);

新: Integer x= 4;//自动装箱 x是引用数据类型。类类型必然指向对象。

        x=x+4;x+4进行自动拆箱。Integer型x变成了int型。和2进行加法运算,再将和进行装箱赋值给x

              拆箱过程;x.intValue();            intValue() 以 int 类型返回该 Integer 的值。

缺点;Integer x= null时,x.intValue(拆箱过程失败),报异常,停掉。要先判断。

Integer m = 128;

Integer n = 128;

m==n//falese

Integer a = 127;

Integer b = 127;

a==b//true; 

因为a和b指向了同一个Integer对象。因为当数值在byte范围内,

对于新特性,如果该数值已经存在,则不会开辟新空间.

 

小知识点:

              String s="a";

              String s1 ="a";

              String s7 ="b";

              String s2 = "b"+s;

              String s8 = s+"b";

              String s3 = new String("ab");//new 新建了一个对象,s3在内存中有两个对象,面试

              String s4 = new String("ab");

              String s5 = new String("a");

              String s6 ="ab";

              System.out.println(s2.hashCode()+"...."+s6.hashCode()+".."+s8.hashCode());

              System.out.println(s==s1);//ture,指向同一个地址值,只有在没有new的情况下

              System.out.println(s==s5);//flase

              System.out.println(s2==s3);//有new

              System.out.println(s3==s4);//flase,有new

              System.out.println(s2==s6);//

              System.out.println(s8==s6);flase

       //s 和s1相等的原因,s存于常量池中,s1直接引用。        

       new String()创建的字符串不放入常量池中,他们有自己的地址空间。