Java基础--String、StringBuffer

String类

String类概述

字符串是一个特殊的对象，字符串一旦初始化就不可以被改变（它是一个被final的类）是一个常量；
1. Java中的所有字符串字面值（如”abc”）都作为此类的实例实现；String可定义空参数内容，例：
String s=new String();等效于：String s1=”“;

• 以上两种写法的区别，例：
  String s1=”abc”;//s1是一个类类型变量，“abc”是一个对象
  String s2=new String(“abc”);
  s1和s2的区别：s1在内存中有一个对象，s2在内存中有两个对象；
• s1==s2;//false,这是两个对象
  s1.equals(s2);//true,String类复写了Object类中的equals方法，该方法用于判断字符串是否相同；

String类中的方法

String类适用于描述字符串事物，它提供了多个方法对字符串进行操作；

1. 获取

   • 字符串中包含的字符数，也就是字符串的长度：
     int length();获取长度；
   • 根据位置获取位置上的某个字符；
     char charAt(int index);//角标不存在将有异常发生；角标越界
   • 根据字符获取该字符在字符串中位置；
     
     • int indexOf(int ch);返回的是ch在字符串中第一次出现的位置；
     • int indexOf(int ch,int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置；
     • int indexOf(String str)；返回的是你str在字符串第一次出现的位置；
     • int indexOf(String str,int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置；
     • int lastIndexOf(int ch);返回指定字符在此字符串中最后一次出现处的索引，即反向查找该字符第一次出现的位置；
       注：找不到返回-1；

   //获取一个字符串在另一个字符串中出现的次数。class  StringTest2{   public static int getSubCount(String str,String key){    int count = 0;    int index = 0;    while((index=str.indexOf(key))!=-1)    {        sop("str="+str);        str = str.substring(index+key.length());        count++;        }    return count;}/*练习三，方式二。*/public static int getSubCount_2(String str,String key){    int count = 0;    int index = 0;    while((index= str.indexOf(key,index))!=-1)    {        sop("index="+index);        index = index + key.length();        count++;    }    return count;}public static void main(String[] args) {    String str = "kkabkkcdkkefkks";    ///sop("count====="+str.split("kk").length);不建议使用。    sop("count="+getSubCount_2(str,"kk"));}public static void sop(String str){    System.out.println(str);}}

2. 判断

   • 字符串中是否包含某一个子串：
     boolean contains(CharSequence str);判断字符串中是否包含str；
     特殊之处：indexOf(String str);可以索引str第一次出现的位置；如果返回-1，表示该str不在字符串中存在，所以也可以用于对指定判断是否包含：
     if(str.indexOf(“aa”)!=-1)
     而且该方法既可以判断，又可以获取出现的位置；
   • 字符串中是否有内容：
     boolean isEmpty();原理就是判断长度是否为0；
   • 字符串是否是以指定内容开头：
     boolean startsWith(str);
   • 字符串是否是以指定内容结尾：
     boolean endsWith(str);
   • 判断字符串内容是否相同，复写了Object类中的equals方法：
     boolean equals(str);
   • 判断内容是否相同，并忽略大小写：
     boolean equalsIgnoreCase();

3. 转换

   • 将字符串数组转成字符串：
     构造函数：

     • String(char[]);
     • String(char[],offset,count);将字符数组中的一部分转成字符串；
       offset-起始位；
       count-长度；

     静态方法：

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

   • 将字符串转换成字符数组：
     char[] toCharArray();

   • 将字节数组转成字符串：
     String(byte[]);
     String(byte[],offset,count);//将字节数组中的一部分转成字符串
   • 将字符串转成字节数组：
     byte[] getBytes();
   • 将基本数据类型转成字符串：
     static String valueOf(int i);
     static String valueOf(double d);
     3+”“，//String valueOf(3);俩结果都一样，都是字符串3；
     特殊：字符串和字节数组在你转换过程中，是可以指定编码表的；

4. 替换
   String replace(oldchar,newchar);

5. 切割
   String[ ] split (regex);//将切割后的文件存入数组，regex切割标识；

6. 子串，获取字符串中的一部分
   String subString(begin);
   String subString(begin,end);//包含起始位，不包含结束位；

   class  StringTest3{/*练习四。*/public static String getMaxSubString(String s1,String s2){    String max = "",min = "";    max = (s1.length()>s2.length())?s1: s2;    min = (max==s1)?s2: s1; //      sop("max="+max+"...min="+min);    for(int x=0; x<min.length(); x++)    {        for(int y=0,z=min.length()-x; z!=min.length()+1; 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 = "ab";    String s2 = "cvhellobnm";    sop(getMaxSubString(s2,s1));}public static void sop(String str){    System.out.println(str);}}

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

   • 将字符串转成大写或者小写：
     
     • String toUpperCase();
     • String toLowerCase();
   • 将字符串两端的多个空格去除：
     String trim();
   • 对两个字符串进行自然顺序的比较：
     int compareTo(String);

   class StringTest {    public static void sop(String str)    {        System.out.println(str);    }    public static void main(String[] args)     {        String s = "      ab cd      ";        sop("("+s+")");//      s = myTrim(s);//      sop("("+s+")");        sop("("+reverseString(s)+")");    }    //练习二：将字符串反转。    /*    思路：    1，将字符串变成数组。    2，对数组反转。    3，将数组变成字符串。    */    public static String reverseString(String s,int start,int end)    {        //字符串变数组。        char[] chs = s.toCharArray();        //反转数组。        reverse(chs,start,end);        //将数组变成字符串。        return new String(chs);    }    public static String reverseString(String s)    {        return reverseString(s,0,s.length());           }    private static void reverse(char[] arr,int x,int y)    {        for(int start=x,end=y-1; start<end ; start++,end--)        {            swap(arr,start,end);        }    }    private static void swap(char[] arr,int x,int y)    {        char temp = arr[x];        arr[x] = arr[y];        arr[y] = temp;    }    //练习一，去除字符串两端空格。    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--;        return str.substring(start,end+1);    }}

String方法应用示例：

class  StringMethodDemo{    public static void method_7()    {        String s = "    Hello Java     ";        sop(s.toLowerCase());        sop(s.toUpperCase());        sop(s.trim());        String s1 = "a1c";        String s2 = "aaa";        sop(s1.compareTo(s2));    }    public static void method_sub()    {        String s = "abcdef";        sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。        sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length());    }    public static void  method_split()    {        String s = "zhagnsa,lisi,wangwu";        String[] arr  = s.split(",");        for(int x = 0; x<arr.length; x++)        {            sop(arr[x]);        }    }    public static void method_replace()    {        String s = "hello java";        //String s1 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。        String s1 = s.replace("java","world");        sop("s="+s);        sop("s1="+s1);    }    public static void method_trans()    {        char[] arr = {'a','b','c','d','e','f'};        String s= new String(arr,1,3);        sop("s="+s);        String s1 = "zxcvbnm";        char[] chs = s1.toCharArray();        for(int x=0; x<chs.length; x++)        {            sop("ch="+chs[x]);        }    }    public static void method_is()    {        String str = "ArrayDemo.java";        //判断文件名称是否是Array单词开头。        sop(str.startsWith("Array"));        //判断文件名称是否是.java的文件。        sop(str.endsWith(".java"));        //判断文件中是否包含Demo        sop(str.contains(".java"));    }    public static void method_get()    {        String str = "abcdeakpf";        //长度        sop(str.length());        //根据索引获取字符。        sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。        //根据字符获取索引        sop(str.indexOf('m',3));//如果没有找到，返回-1.              //反向索引一个字符出现位置。        sop(str.lastIndexOf("a"));          }    public static void main(String[] args)     {        method_7();//      method_trans();//      method_is();//      method_get();        /*        String s1 = "abc";        String s2 = new String("abc");        String s3 = "abc";        System.out.println(s1==s2);        System.out.println(s1==s3);        */    }    public static void sop(Object obj)    {        System.out.println(obj);    }}

---

StringBuffers

StringBuffers是字符串缓冲区，是一个容器；

该类的特点：

• 长度是可变的；
• 可以直接操作多个数据类型(数组只能操作一个数据类型);
• 最终会通过toString方法变成字符串；

该类的常用操作方法

1. 存储

   • StringBuffer append(各种类型)；将指定数据作为参数添加到已有数据结尾处；
   • StringBuffer inset(index,数据);可以将数据插入到指定index位置；

2. 删除

   • StringBuffer delete(start,end);//删除缓冲区中的数据，包含start，不包含end；
   • StringBuffer deleteCharAt(index);//删除指定位置的字符；

3. 获取

   • char charAt(int index);//获取指定角标上的字符；
   • int indexOf(String str);//str 第一次出现的位置；
   • int lastIndexOf(String str);
   • int length();//缓冲区长度；
   • String Substring(int start,int end);子串

4. 修改
   StringBuffer replace(start,end,string);
   void setCharAt(int index,char ch);

5. 反转
   StringBuffer reverse();

6. 将缓冲区中指定数据存储到指定字符串数组中；
   void getChars(int secBegin,int srcEnd,char[] dst,int dstBegin);//src-源；dst-目的；

   //例：StringBuffer sb=new StringBuffer("abcdef");char[] chs=new chs[6];sb.getChars(1,4,chs,2);/*1：从StringBuffer 角标1开始（包含1）；4：到stringBuffer角标4结束（不包含4）；chs：存储到chs数组中；2：从chs的2角标位开始存；*/

7. JDK1.5版本之后出现StringBuilder，区别：

   • StringBuffer是线程同步的；
   • StringBuilder是线程不同步的；

扩展：版本升级的三个因素：提高效率；简化书写；提高安全性；

class StringBufferDemo {    public static void main(String[] args)     {        //method_update();        StringBuilder sb = new StringBuilder("abcdef");         char[] chs = new char[6];        sb.getChars(1,4,chs,1);//将        for(int x=0; x<chs.length; x++)        {            sop("chs["+x+"]="+chs[x]+";");        }        draw(3,6);        draw(8,9);//      StringBuilder sb1 = new StringBuilder();//      sb1.append(new Demo()).append(new Demo());//      sop("sb1="+sb1);    }    public static void method_update()    {        StringBuffer sb  = new StringBuffer("abcde");//      sb.replace(1,4,"java");        sb.setCharAt(2,'k');        sop(sb.toString());     }    public static void method_del()    {        StringBuffer sb  = new StringBuffer("abcde");       //      sb.delete(1,3);        //清空缓冲区。        //sb.delete(0,sb.length());        //sb.delete(2,3);        sb.deleteCharAt(2);        sop(sb.toString());    }    public static void method_add()    {        StringBuffer sb = new StringBuffer();        //sb.append("abc").append(true).append(34);//      StringBuffer sb1 = sb.append(34);//      sop("sb==sb1:"+(sb==sb1));        sb.insert(1,"qq");        sop(sb.toString());//abctrue34        //sop(sb1.toString());          }    public static void sop(String str)    {        System.out.println(str);    }    public static void draw(int row,int 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());    }}

---

基本数据类型包装类

基本数类型 基本数据类型包装类 byte Byte short Short int Integer long Long boolean Boolean float Float double Double char Character

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

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

1. 基本数据类型＋”“;
2. 基本数据类型.toString(基本数据类型值);
   如：Integer.toString(34);//将34整数变成“34”；

字符串转成基本数据类型

1. 静态方法：
   xxx a=Xxx.parseXxx(String);//只有Character没有parse方法；xxx-基本数据类型；Xxx-对应的基本数据类型包装类；
   例：int a=Integer.parseInt(“123”);
   double d=Double.parseDouble(“12.34”);
   boolean b=Boolean.parseBoolean(“true”);
2. 非静态方法：
   Integer i=new Integer(“124”);
   int num=i.intValue();//非静态方法；（对象调用方式）

十进制转成其他进制

• static String toBinaryString(int i);//Ingeter,Long
• static String toHexString(int i);//Ingeter,Long,Float,Double,
• static String toOctalString(int i);//Ingeter,Long

其他进制转十进制

• static int parseInt(String,radix);//Integer类方法；String-字符串，radix-相应进制数；
• 附：整数类型的最大值Integer.MAX_VALUE;

class IntegerDemo {    public static void sop(String str)    {        System.out.println(str);    }       public static void main(String[] args)     {        //整数类型的最大值。        //sop("int max :"+Integer.MAX_VALUE);//      将一个字符串转成整数。        int num = Integer.parseInt("123");//必须传入数字格式的字符串。        //long x = Long.parseLong("123");//      sop("num="+(num+4));//      sop(Integer.toBinaryString(-6));//      sop(Integer.toHexString(60));        int x = Integer.parseInt("3c",16);        sop("x="+x);    }}

JDK1.5版本以后出现的新特性；

1. Integer x=4；//自动装箱；等同于Integer x=new Integer(4);
   x=x+2;//x+2：x进行自动拆箱，变成了int类型和2进行加法运算，在将和进行装箱赋给x；
2. Integer m=128;Integer n=128; m==n;//false;
   Integer a=127; Integer b=127; a==b;//true;
   解释：因为a和b指向了同一个Integer对象，所以为true；因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间；

附：字符串的一个特殊方法：
boolean matches(String regex);//告诉此字符串是否匹配给定的正则表达式；