黑马程序员——Java基础---String与StringBuilder

String类

   一、特点

String是字符串的类类型，用于描述字符串事物。字符串是一个特殊的对象并且因为String对象特别常用，所以在对String对象进行初始化时，Java提供了一种简化的特殊语法，例如：String s=”123”.以及String s=123+””;

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

例：

        String s1=“abc”；

        String s2 = new String（“abc”）；

        String s3=“abc”；

比较的结果：

        s1==s2   ( false )

        s1.equals(s2) ( true )

        //String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。

        s1==s3   ( true )  

        //因为“abc”这个字符串对象已经在内存中存在，作为字符串这种特殊的对象，这种在常量池中存在的数据。s3进行初始化时，发现abc已经在内存中存在，就不会再独立开辟空间，因为再开辟空间就比较浪费空间。因此为了节约内存，在字符串对象当中只要字符串相同，那么s1和s3就指向同一个对象。

s1和s2的区别：

按照面向对象的标准语法的格式应该是s2这般的，但是按照这种写法，在内存上存在着比较大的浪费，s1在内存中有一个对象。

        s2在内存中有两个对象。  一个是”abc”对象，存储在常量空间中，另外一个是new关键字为对象s2申请的空间          

 

二、常见操作方法

1、获取

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

               int   length（）：//获取长度。

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

               char  charAt（int  index）：//当访问到字符串中不存在的角标时，会发生字符串角标越界的错误。

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

              int  indexOf（int ch）：//返回的是ch在字符串中第一次出现的位置。//传入的是字符对应的ASCII码。//如果没有找到，返回-1。

              int  indexOf（int ch，int fromIndex）：//从fromIndex指定位置开始，获取ch在字符串中出现的位置。

              int  indexOf（String str）：//返回的是str在字符串中第一次出现的位置。

              int  indexOf（String str，int fromIndex）：//从fromIndex指定位置开始，获取str在字符串中出现的位置。

              int  lastIndexOf（）：//反向索引 ，即从字符串末尾处开始寻找。

2、判断

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

              boolean contains（str）；

        //特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。如：if（str.indexOf（“aa”）！=-1）而且该方法既可以判断，又可以获取出现的位置。如果只为判断，用contains。

        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[])；

                                 staticString copyValueOf(char[] data,int offset ,int count )；

                                              static String valueOf(char[])；

        3.2将字符串转成字符数组

              char[]toCharArray()；//该方法的作用和getBytes方法类似，即将字符串转换为对应的char数组。

        3.3将字节数组转成字符串

              String (byte[])；

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

        3.4将字符串转成字节数组

              byte[]getBytes()；//该方法的作用是将字符串转换为对应的byte数组，从而便于数据的存储和传输。

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

              StringvalueOf(int)；

              StringvalueOf(double)；

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

4、替换

        String replace(oldchar,newchar)；//返回的是一个新字符串。如果要替换的字符不存在，返回的还是原字符串。

5、切割

        String[] split(regex)；//涉及到正则表达式的点，不能作为切割字符串的regex。

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

        String substring(begin)；//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。

        Stringsubstring(begin,end)；//包含头，不包含尾。

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

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

              Stringto UpperCase();

              String toLowerCase();

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

              String trim();  //    该方法的作用是去掉字符串开始和结尾的所有空格，然后形成一个新的字符串。 

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

              int compareTo(String);// 比较两个字符串的大小，比较的原理是依次比较每个字符的字符编码,如果大于，则返回大于0的值

7.4 连接两个字符串变成一个字符串

    concat  String s= s1.concat(s2)

当然用  +（连接符）也是一样的。并且只要保证其中一个为字符串，连接后便是字符串，而不用在乎组成字符串的类型。例如

String s=”123”+4;

 

　　　　三、实例演练

 

/*
1.模拟一个trim，去掉字符串两端的kongge
    思路：1        判断字符串两端是否为空，获取两端首先不为空的角标
          2        使用subString(start,end)方法 


2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
    思路：
    1，曾经学习过对数组的元素进行反转。
    2，将字符串变成数组，对数组反转。
    3，将反转后的数组变成字符串。
    4，只要将或反转的部分的开始和结束位置作为参数传递即可。*/
class Test
{
    public static void main(String[] args)
    {
        String s="   Hello  world   ";
        String s1=MyTrim(s);
        System.out.println(s1);
        String s2="abcdefg";
        String s3=reverseString(s2,2,5);
        System.out.println(s3);
    }
    public static String MyTrim(String str)//去除空格
    {
        int start=0,end=str.length()-1;//定义字符串变成字节数组后，起始位置，以及末尾位置
        while(start<=end&&str.charAt(start)==' ')//获取字节数组中非空格的起始角标
            start++;
        while(start<=end&&str.charAt(end)==' ')//获取字节数组中末尾非空格的角标
                end--;
        String s=str.substring(start,end+1);//截取原字符串部分
        return s;
    }
    public static String reverseString(String str,int begin,int end)//自定义，反转字符串顺序
    {
        char ch[]=str.toCharArray();//将字符串转成字节数组，通过字节数组的角标互换，实现反转
        while(begin<end)
        {
            swap(ch,begin,end);
            begin++;
            end--;
        }
        String s2=new String(ch);
        return s2;
    }
    public static void swap(char arr[],int begin,int end)//数组中，交换元素的值
    {
        char temp=arr[begin];
        arr[begin]=arr[end];
        arr[end]=temp;
    }
}

/*
3，获取一个字符串在另一个字符串中出现的次数。
    "abkkcdkkefkkskk"


    思路：
    1，定义个计数器。
    2，获取kk第一次出现的位置。contains
    3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
        每获取一次就计数一次。
    4，当获取不到时，计数完成。



*/
class Test3
{
    
    public static void main(String[] args)
    {
        String s="abkkcdkkefkkskk";
        String s1="kk";
        
            System.out.print(myIndexOf(s,s1));
    

        
    }
    public static int myIndexOf(String str,String key)
    {    
        int count = 0;//定义计数器
        int index = 0;//定义位置角标

        while((index= str.indexOf(key,index))!=-1)//获取key在Str中从index位置开始首次的位置，如果index=-1，则跳出循环
        {
            System.out.println("index="+index);//打印key出现的位置
            index = index + key.length();//index出现后，在此遍历的位置则是index原有的位置加上key的字符串长度

            count++;     //计数器加1
        }
        return count;//返回计数器
    }

    public static int getSubCount(String str,String key)
    {
        int count = 0;//定义计数器
        int index = 0;//定义位置角标

        while((index=str.indexOf(key))!=-1)//获取key在Str中从index位置开始首次的位置，如果index=-1，则跳出循环
        {
            sop("str="+str);
            str = str.substring(index+key.length());// 将字符串  从得到的位置加上key的长度，截取后面的字符串
                                                    //每次遍历寻找的字符串  都是 截取后的字符串
            count++;    
        }
        return count;
    }
    public static void sop(String str)//打印字符串
    {
        System.out.println(str);
    }

}

/*

4    获取两个字符串中最大相同子串。
        第一个动作：将短的哪个串进行长度一次递减的子串打印。
        "abcwerthelloyuiodef"
        "cvhellobnm"
        思路：
            1    将短的那个子串按照长度递减的方式获取到
            2    将每获取到的子串去长串中判断是否包含
                如果包含，已经找到
*/

class  Test4
{
    /*
    练习四。
    */
    public static String getMaxSubString(String s1,String s2)
    {

        String max = "",min = "";

        max = (s1.length()>s2.length())?s1: s2;//判断s1与s2哪个字符串更大，将大的存入max

        min = (max==s1)?s2: s1;
        
    //sop("max="+max+"...min="+min);
        for(int x=0; x<min.length(); x++)//控制循环次数，外循环最多为小的字符串的长度，目的使每次循环小字符串的子串长度减1
        {
            for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)//定义y到z的长度，限定小字符串子串长度，然后通过双方都递增的情况遍历
            {
                String temp = min.substring(y,z);//取出小字符串的长度
                
                sop(temp);
                if(max.contains(temp))//判断大字符串是否包含小字符串的子串
                //if(s1.indexOf(temp)!=-1)
                    return temp;//包含则返回子串，即最大公有子串
            }
        }
        return "";
    }


    public static void main(String[] args) 
    {
        String s1 = "abcwerthelloyuiodef";//创建两个字符串
        String s2 = "cvhellobnm";
        sop(getMaxSubString(s2,s1));//调用自定义获取最大公有子串方法，将两字符串传入
    }

    public static void sop(String str)
    {
        System.out.println(str);
    }
}

 　　　　　　　　　　　　　　　　　　　　　　　　　　    StringBuffer

一、概述

        StringBuffer是字符串缓冲区，同时也是一个容器，字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删改查等操作，很多方法和String相同。

 

二、特点

        1、而且长度是可变化的。（数组是固定的）

        2、可以直接操作多个数据类型。（数组只能操作一个）

        3、最终会通过toString方法变成字符串。

 

三、常见操作

1、存储

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

        StringBuffer insert(intoffset ,数据)：可以将数据插入到指定offset位置。

2、删除

        StringBufferedelete(start,end)：删除缓冲区中的数据，包含start，不包含end。

        StringBuffer deleteCharAt(index)：删除指定位置的字符。

        清空缓冲区：对象.delete(0,对象.length());

3、获取

        char charAt(int index)；

        int indexOf(String str)；

        int lastIndexOf(String str)；

        int length()；

        String substring(int start,int end)；

4、修改

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

        void setCharAt(int index,char ch)；

5、反转

        StringBuffer reverse()；

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

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

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

        StringBuffer是线程同步的。有锁。效率低

        StringBuilder是线程不同步的。无锁。效率高

以后开发，建议使用StringBuilder。如遇多线程，使用StringBuffer或自己加锁。

升级三因素：

        1、提高效率

        2、简化书写

        3、提高安全性。

四、实战演练

class StringBuilderDemo
{
    public static void main(String[] args)
    {
        //method_update();
        /*StringBuilder sb=new StringBuilder("abcdef");
        char[] chs=new char[6];
        sb.getChars(1,4,chs,1);//将数组sb中1~4位置的内容传入chs中，是从1位置开始传入。
        
        for(int x=0;x<chs.length;x++)//将数组中的元素全部打印出来
        {
            sop("chs["+x+"]="+chs[x]+";");
            
        }*/
        method_update();
        //method_del();
        //method_add();
        //draw(3,6);
        //draw(3,6);

    }
    public static void method_del()
    {
        StringBuilder sb= new StringBuilder("abcdeff");
        //sb.delete(1,3);//清空1~3的数据
        sop(sb.toString());
        sb.delete(0,sb.length());//清空容器sb中的数据
        sb.append('1').append("abv");
        sop(sb.toString());
        //sb.deleteCharAt(2);//单独删除2位置上的数据
        //sop(sb.toString());
    }

    public static void method_add()
    {

        StringBuilder sb= new StringBuilder();
        //sb.append("dafg ").append("dfas");//在容器中添加元素通过append（）
        StringBuilder sb1 = sb.append(34);
        sop("sb==sb1"+(sb==sb1));//输出结果为正确，容器为固定，只是同时两个名字指向它
        sop(sb.toString());
        sb.insert(1,"qq");//在1位置中插入qq，其他的按顺序顺延
        sop(sb.toString());//将容器变为字符串打印出来

    }
    public static void method_update()
    {
        StringBuilder sb=new StringBuilder("abcde");
        sop(sb.toString());
        sb.replace(1,4,"java");//容器sb中1~4位置中的元素用“java”替代
        sop(sb.toString());
        sb.setCharAt(2,'d');
        sop(sb.toString());
        
    }
    public static void draw(int row,int col)//将row行，col列的*存储在容器中，并打印出来
    {
        StringBuilder sb=new StringBuilder();
        for(int x=0;x<row;x++)
        {
            for(int y=0;y<col;y++)
            {
                sb.append("*");
            }
            sb.append("\r\n");
        }
        sop(sb.toString());
    }


    public static void sop(String str)
    {
        System.out.println(str);
    }
    
}