[2017.10.28-29]String类&StringBuffer

String类

1.String类:
代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变

2.String类常用的构造方法:
String():表示一个空字符序列。
public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
public String(char[] value):将字符数组构造成一个字符串
public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
public String(String original):通过字符串常量构造一个字符串对象
public int length():获取字符串的长度功能:

3.面试题:
数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
数组没有length(),length属性
字符串中有length()
集合中没有length(),获取集合中元素数量:size()

4.编码和解码:一定要保证编码格式一致
编码:
把能看懂的东西转换成一个看不懂的东西:String—–>byte[]:public byte[] getBytes(String charsetName)
解码:
把当前的byte[]转成能看懂的东西(String):byte[]—–>String :pu blic String(byte[] bytes,CharsetName ch)

5.举例:
今天老地方见
编码:”今”—–>字节数组:byte[]—->字节类型:形成一种二进制数据
解码:二进制数据—->十进制进制数据—–>String:”今”

6.演示:

public class StringDemo {

    public static void main(String[] args) throws UnsupportedEncodingException {
        //创建一个String对象
        String s1 = new String() ;
        System.out.println("s1.length():"+s1.length());
        System.out.println("s1:"+s1);
        System.out.println("----------------------");

        //public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
        //创建一个字节数组
        byte[] bys = {97, 98, 99, 100, 101} ; 
        String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符
        System.out.println("s2:"+s2);
        //abcde
        System.out.println("s2.length():"+s2.length());//5
        System.out.println("----------------------");

        /**
         * 编码和解码
         */
        //定义一个字符串:
        String s = "你好" ;
        //[-60, -29, -70, -61]  :GBK
        //[-28, -67, -96, -27, -91, -67]:utf-8
//      byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码     utf-8:一个中文:对应三个字节
        byte[] bys2 = s.getBytes() ;
//      System.out.println(bys2);
        //Arrays:数组工具类:toString(byte[] bys)
        System.out.println(Arrays.toString(bys2));

        System.out.println("-------");
//      String str = new String(bys2, "utf-8") ;
        String str = new String(bys2) ;
        System.out.println("str:"+str);

        System.out.println("------------------");
        //public String(char[] value):将字符数组构造成一个字符串
        //定义一个字符数组
        char[] chs = {'我','爱','高','圆','圆'} ;
        String s3 = new String(chs) ;
        System.out.println("s3.length():"+s3.length());
        System.out.println("s3:"+s3);

        System.out.println("--------------------");
        String s4 = new String(chs, 1, 4) ;
        System.out.println("s4:"+s4);
        System.out.println("s4.length():"+s4.length());

        System.out.println("--------------------");
        //public String(String original):通过字符串常量构造一个字符串对象
        String s5 = new String("hello") ;
        System.out.println("s5:"+s5);
        System.out.println("s5.length():"+s5.length());


        String s6 = "hello" ;
        System.out.println("s6:"+s6);
        System.out.println("s6.length():"+s6.length());


    }
}

7.字符串的一个特点:
一旦被赋值,其值不能被改变(不可变的字符序列)

8.面试题:
String s = “hello”
和String s = new String(“hello”) 两个有什么区别?分别创建了几个对象?
第一个创建了一个对象;第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))

9.演示:

public class StringDemo {
    public static void main(String[] args) {

        String s = "hello" ;    // String s = "abc" ;

        /*s += "world" ;

        System.out.println("s:"+s);*/

        change(s) ;

        //输出字符串变量
        System.out.println("s:"+s);

    }

    public static void change(String s) {//String类型作为形式参数和基本数据类型的效果一样

        s += "javaweb" ;
    }
}

看程序写结果:

public class StringDemo2 {

    public static void main(String[] args) {
        //创建字符串对象
        String s1 = new String("hello") ;
        String s2 = new String("hello") ;

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

        String s3 = "hello" ;
        String s4 = "hello" ;
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));

        String s5 = new String("world") ;
        String s6 = "world" ;
        System.out.println(s5==s6);
        System.out.println(s5.equals(s6));
    }
}

import java.util.Scanner;
//提供猜数字游戏的类
public class GuessNumberGame {

    //构造私有,通过静态功能
    private GuessNumberGame(){

    }

    //静态功能
    public static void start(){
        //生成一个随机数:Math.random() ;
        int number = (int) (Math.random()*100 +1) ;

        //定义一个统计变量
        int count = 0 ;
        //由于多次录入
        while(true){
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入一个数据:");
            int guessNumber = sc.nextInt() ;

            //统计变量++
            count ++ ;

            //判断
            if(guessNumber > number){
                System.out.println("您猜的数据"+guessNumber+"大了");
            }else if(guessNumber < number){
                System.out.println("您猜的数据"+guessNumber+"小了");
            }else {
                System.out.println("恭喜您"+count+"次猜中了...");
                break ;
            }
        }
    }
}

10.String类的中常用的判断功能:
boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空
String s = “” ;空字符
String s = ” ” ;字符串”空格”
String s = null ;当前字符串对象为空

11.演示:

public class StringDemo {

    public static void main(String[] args) {

        //定义一个字符串
        String s1 = "helloworld" ;
        String s2 = "HelloWorld" ;

//      boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
        System.out.println("equals:"+s1.equals(s2));
        //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
        System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));

        //boolean contains(String str):判断str这个字符串是否包含在当前字符串中
        System.out.println("contains:"+s1.contains("owo"));
        System.out.println("contains:"+s1.contains("ak47"));

        //boolean startsWith(String str):是否以str子字符串开头
        System.out.println("starsWith:"+s1.startsWith("hel"));
        //boolean endsWith(String str):判断是否以str子字符串结尾  自己测试

        //boolean isEmpty():判断字符串是否为空
        System.out.println("isEmpty:"+s1.isEmpty());
    }
}

看程序,写结果

/**
 * 字符串变量相加,先开辟空间,在相加
 *  字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!
 */
public class StringDemo2 {

    public static void main(String[] args) {
        String s1 = "hello";  
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);// false
        //System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());
//      s1+s2 ====>new String("helloworld")
        System.out.println(s3.equals((s1 + s2)));//true , 

        System.out.println(s3 == "hello" + "world");//true
        System.out.println(s3.equals("hello" + "world"));//true

        /**
         * 通过反编译工具查看第三个输出语句:
         * System.out.println(s3 == "helloworld");
            System.out.println(s3.equals("helloworld"));
         * */
    }
}

import java.util.Scanner;

/**
 * 需求:模拟用户登陆,给3次机会,并给提示
 *      
 *  分析:
 *      假设:定义一个用户和密码
 *      String name = "admin" ;
 *      String password = "admin" ;
 *      2)创建键盘录入对象,录入用户名和密码
 *      3)给3次机会,使用for循环进行操作for(int x = 0 ; x <3 ; x ++){}
 *          
 *      录入:录入的用户和密码来和已经存在的用户名和密码进行比较,
 *          判断:如果一致:
 *              登陆成功
 *          不一致:
 *              有一个不符合,就登陆不成功
 *              if((2-x)==0){
 *              }else{
 *                  //输出还有(2-x)次机会
 *              }
 * */
public class StringTest {

    public static void main(String[] args) {

        //定义用户名和密码
        String name = "admin" ;
        String password = "admin" ;

        //给3次机会
        for(int x = 0 ; x <3 ; x ++){
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in) ;
            System.out.println("请输入用户名: ");
            String newUserName = sc.nextLine() ;
            System.out.println("请输入密码:");
            String newPassword = sc.nextLine() ;

            //判断
            if(name.equals(newUserName) && password.equals(newPassword)){
                //一致了
                System.out.println("登陆成功,开始玩游戏....");
                //加入猜数字游戏
                GuessNumberGame.start() ;
                break ;
            }else{
                //登陆不成功
                //2,1,0
                //如果是0次机会了,换一种提示
                if((2-x)==0){
                    System.out.println("速与管理员联系...");
                }else{
                    //不是0次
                    System.out.println("你还有:"+(2-x)+"次机会");
                }
            }
        }
    }
}

12.String类的获取功能:
int length() :获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义: 97 ‘a’
int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
String substring(int start):从指定位置开始截取字符串,默认截取到末尾
String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

13.演示:

public class StringDemo {

    public static void main(String[] args) {
        //定义一个字符串:
        String str = "helloworld" ;

        //int length()  :获取字符串长度功能
        System.out.println("length:"+str.length());

        //char charAt(int index):返回的是索引处对应的字符
        System.out.println("charAt:"+str.charAt(1));
        System.out.println("charAt:"+str.charAt(8));
        System.out.println("-------------------------------");

        //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
        System.out.println("indexof:"+str.indexOf('l'));
        System.out.println("indexof:"+str.indexOf('k'));//-1

        //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
        System.out.println("indexOf:"+str.indexOf("owo"));
        System.out.println("-------------------------------");
        //int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
        System.out.println("indexOf:"+str.indexOf('l', 4));

        //int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试)

        //String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
        System.out.println("substring:"+str.substring(5));

        //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
        System.out.println("substring:"+str.substring(4, 8));//owor
    }
}

14.字符串的遍历
String str = “helloworld” ;

15.演示:

public class StringTest {

    public static void main(String[] args) {

        //定义字符串
        String s = "helloworld" ;
        //最原始的做法
    /*  System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println(s.charAt(2));
        System.out.println(s.charAt(3));
        System.out.println(s.charAt(4));
        System.out.println(s.charAt(5));
        System.out.println(s.charAt(6));
        System.out.println(s.charAt(7));
        System.out.println(s.charAt(8));
        System.out.println(s.charAt(9));*/

        /**
         * 由于代码的重复度高,所以使用for循环
         * 使用String类的length()和charAt()相结合
         */
        for(int x = 0 ; x < s.length() ; x ++){
            System.out.print(s.charAt(x)+" ");
        }
    }
}

/**
 * 把数组中的数据按照指定个格式拼接成一个字符串举例：
 *      int[] arr = {1,2,3};    输出结果：[1, 2, 3]
 *      
 * 分析:
 *      1)定义数组:int[] arr = {1, 2, 3}
 *      2)定义空字符串:String s = "" ;
 *      3)用空串拼接一个"["
 *      4)遍历int类型的数组,获取到每一个数组中的元素
 *          判断当前某一个索引是否是最大索引
 *          如果是:用空串+= arr[x] ;
 *              用空串 +="]";
 *          不是:
 *              用空串+= arr[x]
 *              用空串+= ", "
 *          
 */
public class StringTest2 {

    public static void main(String[] args) {
        //1)定义一个数组,静态初始化
        int[] arr = {1, 2, 3} ;

        //将这个数组转换成字符串最终来封装成功能
        String result = arrayToString(arr);

        //直接输出
        System.out.println("result:"+result);
    }

    /**
     * 两个明确
     *      明确返回值类型:String类型
     *      明确参数类型:int   int[] arr
     * */
    public static String arrayToString(int[] arr){
        //定义一个空字符串
        String result = "" ;

        //拼接左中括号
        result += "[" ;

        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断
            if(x==arr.length-1){
                result += arr[x] ;
                result += "]" ;
            }else{
                result += arr[x] ;
                result += ", " ;
            }
        }
        return result ;
    }



}

import java.util.Scanner;

/**
 * 需求：使用键盘录入一个字符串:统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 * 
 * 举例:
 *      "Hello123World"
 * 
 *      大写字母字符:2个
 *      小写字母字符:8个
 *      数字字符:3个
 * 
 * 分析:
 *      1)定义三个统计变量
     *      int bigCount = 0 ;
     *      int smallCount = 0 ;
     *      int numberCount = 0 ;
 *      2)创建键盘录入对象,录入一个字符串
 *      3)使用for循环遍历字符串
 *      4)
 *          ASCII码表中
 *                  'a'         97
 *                  'A'         65
 *                  '0'         48  
 *      遍历的时候获取到字符
 *          ch>='a' && ch<='z'
 *              属于小写字母字符
 *              smallCount++;
 *          ch>='A' && ch<='Z'
 *              属于大写字母字符
 *              bigCount++
 *          ch>='0' && ch<='9'
 *              属于数字字符
 *              numberCount++
 *
 *      5)输出
 * 
 * */
public class StringTest3 {

    public static void main(String[] args) {

        //创建三个统计遍历
        int bigCount = 0 ;
        int smallCount = 0 ;
        int numberCount = 0 ;

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入并接收
        System.out.println("请输入一个字符串:");
        String line = sc.nextLine() ;

        //遍历字符串
        for(int x = 0 ; x <line.length() ; x++){
            //获取每一个字符
            char ch = line.charAt(x) ;

            //对当前的这个字符进行判断
            if(ch>='a' && ch<='z'){
                //小写字母字符
                smallCount ++ ;
            }else if(ch>='A' && ch <='Z'){
                //大写字母字符
                bigCount++ ;
            }else if(ch>='0' && ch <='9'){
                //数字字符
                numberCount ++ ;
            }
        }

        //输出结果
        System.out.println("当前字符串中大写字母字符共有:"+bigCount+"个");
        System.out.println("当前字符串中小写字母字符共有:"+smallCount+"个");
        System.out.println("当前字符串中数字字母字符共有:"+numberCount+"个");
    }
}

16.String类的转换功能(重点)
byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串
注意:
String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法

17.演示:

public class StringDemo {

    //构造方法:
    //构造方法不能使用递归
    /*public StringDemo(){
        StringDemo();
    }*/

    public static void main(String[] args) {
        //定义一个字符串
        String s = "JavaSE" ;

        //byte[] getBytes():将字符串转换字节数组
        byte[] bys = s.getBytes() ;
        //遍历字节数组
        for(int x = 0 ; x < bys.length ; x++){
            System.out.println(bys[x]);
        }
        System.out.println("---------------------");

        //char[] toCharArray():将字符串转换成 字符数组
        char[] chs = s.toCharArray() ;
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }

        System.out.println("---------------------");

        //static String valueOf(char[] chs):将字符数组转换成字符串
        String s2 = String.valueOf(chs) ;
        System.out.println("s2:"+s2);

        //static String valueOf(int i):将一个int类型的数据转换成字符串
        String s3 = String.valueOf(100) ;
        System.out.println("s3:"+s3);

        //String toLowerCase():将字符串全部转成小写
        System.out.println("toLowerCase:"+s.toLowerCase());
        //String toUpperCase():将字符串全部转换成大写
        System.out.println("toUpperCase:"+s.toUpperCase());

        //String concat(String str):字符串拼接方法
        String s4 = "hello" ;
        String s5 = "world" ;
        System.out.println("contact:"+s4.concat(s5));

        String s6 = "java" ;
        s6 += "web" ;
        System.out.println("s6:"+s6);

        /**
         *方法嵌套
         * Math.max(Math.max(a,b),c);
         * 
         *方法递归:方法调用本身的一种现象
         *
         *      三个条件:
         *          1)需要定义个方法
         *          2)方法必须有出口条件
         *          3)必须有某一种规律
         * public void show(int n){
         *      
         *      if(n<0){
         *          System.exit(0) ; //让jvm退出,程序结束
         *      }
         * 
         *      System.out.println(n) ;
         *      show(--n) ;
         * }
         * */
        System.out.println("--------------------");
        //需求:求5的阶乘
        //5! = 5 * 4 * 3 * 2 * 1 ;
        //5! = 5 * 4! ;
        int jc = 1 ;
        //循环思想
        for(int x = 2 ; x <=5 ; x ++){
            jc *= x;
        }
        System.out.println("5的阶乘是:"+jc);
        System.out.println("-------------------------");
        //使用递归的思想:
        //需要定义个方法
        System.out.println("5的阶乘是:"+jieCheng(5));
    }
    /**
     * 明确返回值类型:
     *  int类型
     * 参数类型:int类型的值
     * 
     * 2)出口条件:
     * if(n==1){
     *  return 1 ;
     * }
     * 
     * 3)要有规律
     *  if(n!=1){
     *      return n* 方法名(n-1); 
     * }
     * */
    public static int jieCheng(int n){

        if(n==1){
            return 1 ;
        }else{
            return n* jieCheng(n-1) ; //5 * 4 * 3 * 1 *１　
        }
    }
}

18.String类中的其他功能:
1)替换功能:
public String replace(char oldChar,char newChar):将字符串中某一 个字符用新的字符替换
public String replace(String oldStr,String newStr):将字符串中某一 个子字符串用新 的字符串去替代
2)去除字符串两端空格:
public String trim()
3)两个字符串进行比较:
public int compareTo(String anotherString) 是Comparable接口 中的方法(该接口可以实现一个自然排序)
4)Comparator接口可以比较器排序

19.演示:

public class StringDemo {

    public static void main(String[] args) {

        //定义字符串
        String s1 = "helloworld" ;

        //替换功能
//      public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
//      String s2 = s1.replace('l', 'k') ;
//      System.out.println("s:"+s2);
        //public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
        String s3 = s1.replaceAll("owo", "ak47") ;
        System.out.println("s3:"+s3);

        System.out.println("------------------");

        String s4 = " hello world " ;
        System.out.println("s4:"+"----"+s4+"----");
        //public String trim()
        String s5 = s4.trim() ;
        System.out.println("s5:"+"----"+s5+"----");

        //public int compareTo(String anotherString)
        String s6 = "hello" ;
        String s7 = "hello" ;
        String s8 = "abc" ;
        System.out.println("compareTo():"+s6.compareTo(s7));
        System.out.println("compareTo():"+s6.compareTo(s8));
    }
}

import java.util.Scanner;

/**
 * 需求:键盘录入一个字符串,将该字符串的第一个字母转换成小写,其余的字母字符转换成大写(不考虑其他的字母字符)
 * 
 * 举例:  "Helloworld"
 *  
 *      H--->h
 *      elloworld--->ELLOWORLD
 *  
 * 分析:
 *      A:创建键盘录入对象,录入一个字符串
 *      B:截取:substring(int begin,int end)
 *      C:将上面获取的字符串转换小写
 *      D:在截取刚才录入的这个字符串,substring(int begin):从指定位置截取到末尾,返回一个新的字符串
 *      E:将的得到新的字符串---->转换大写
 *      F:将C和E,使用concat()拼接:字符串拼接方法
 * */
public class StringTest {

        public static void main(String[] args) {
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in) ;

            //录入并接收数据
            System.out.println("请您输入一个字符串:");
            String line = sc.nextLine() ;

            //将接收到的字符串截取
            String s1 = line.substring(0, 1) ;

            //将得到s1字符串转换成小写
            String s2 = s1.toLowerCase() ;

            //在将line字符串的其余字母字符截取出来
            String s3 = line.substring(1) ;
            //转换成大写
            String s4 = s3.toUpperCase() ;

            //s2和s4作品接
            String result = s2.concat(s4) ;
            System.out.println("result:"+result);
            System.out.println("------------------------------");

            //链式编程
            String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
            System.out.println("result2:"+result);
        }
}

20.遇到:看源码:comparTo()的源码

public class StringTest2 {

    public static void main(String[] args) {

        //定义两个字符串
        String s1 = "hello" ;
        String s2 = "hel" ;

        System.out.println("compareTo():"+s1.compareTo(s2));



    }

}

//在底层代码中,一个字符串会自动会转换成字符数组
private final char value[];

//s1= “helloworld” ;
//s2= “hel” ;

//将s1和s2的字符串自动转换成了字符数组
//s1:’h’,’e’,’l’,’l’,’0’
//s2:’h’,’e’,’l’

public int compareTo(String anotherString) {anotherString==>s2=”hel”

    int len1 = value.length; //s1.length= 5
    int len2 = anotherString.value.length;// s2.length: = 3
    int lim = Math.min(len1, len2);// Math.min(5,3) ;=====>int lim = 3 ;
    char v1[] = value;//'h','e','l','l','0'
    char v2[] = anotherString.value;//"hel"


    int k = 0;
    while (k < lim) {k< lim=3
        char c1 = v1[k];// char c1 = 'h','e','l','l','0' = v1[k] = 'h'
        char c2 = v2[k];//char c2 = 'h','e','l' = v2[k] = 'h'
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2; // len1 - len2 = s1.length() - s2.lenth() = 5 -3 = 2 
}

21.演示:

import java.util.Scanner;

/**
 * 需求:键盘录入一个字符串,将字符串进行反转
 * 
 * 举例:
 *      "abc"--->"cba"
 * 
 * 分析:
 *      1)创建键盘录入对象,录入并接收一个字符串
 *      2)定义空字符串
 *      3)可以将字符串转换成字符数组:toCharArray();
 *      4)遍历字符数组,倒着遍历
 *      5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接
 *      6)输出即可!
 * @author Apple
 */
public class StringTest3 {

    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入数据并接收数据
        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;

    /*  //定义一个空字符串
        String result = "" ;

        //将字符串转换成字符数组
        char[] chs = line.toCharArray() ;

        //遍历字符数组,倒着遍历
        for(int x = chs.length-1; x >=0 ; x --){
            //获取到每一个字符
            result+= chs[x] ;
        }*/

        String result = myReverse(line) ;

        //输出
        System.out.println("result:"+result);
    }

    //写一个功能实现
    public static String myReverse(String s){
        //定义空字符串
        String result = "" ;

        //将字符串字符数组
        char[] chs = s.toCharArray() ;

        //遍历字符数组
        for(int x = chs.length -1 ; x >=0; x --){
            //拼接每一个字符
            result+= chs[x];
        }

        return result ;
    }
}

StringBuffer

1.线程
1)线程安全—->同步—->执行效率低!
举例:
银行的网站,医院的平台
2)线程不安全—>不同步—>执行效率高
举例:
一些论坛网站,相亲网站..
3)在实际开发中,线程不安全可能会造成死锁的现象!
线程安全和执行效率是相对的,并且也是困扰开发者的因素!

4)StringBuffer:线程安全的可变字符序列

1. 面试题:
   StringBuffer和String 的区别?
   StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
   StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
   String:普通的一个字符串,从内存角度考虑,耗费空间!

2. StringBuffer的构造方法:
   public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
   public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
   public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

4.常用的功能:
public int length():获取字符串长度数
public int capacity():获取当前字符串缓冲区的容量

5.演示:

public class StringBufferDemo {

    public static void main(String[] args) {
//      StringBuffer sb = "hello" ;
//      String s = "hello" ;
//      StringBuffer sb = s ;

//      public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
        //创建一个字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;
        System.out.println("sb.length:"+sb.length());
        System.out.println("sb.capacity:"+sb.capacity());//16

        System.out.println("----------------------------");

        //  public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
        StringBuffer sb2 = new StringBuffer(50) ;
        System.out.println("sb2.length:"+sb2.length());
        System.out.println("sb2.capacity:"+sb2.capacity());//50

        System.out.println("----------------------------");

        StringBuffer sb3 = new StringBuffer("hello") ;
        System.out.println("sb3.length:"+sb3.length());
        System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度

    }
}

6.StringBuffer中的和添加有关的方法
1)public StringBuffer append(int/String/char/boolean/double/float….):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
2)public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

7.演示:

public class StringBufferDemo2 {

    public static void main(String[] args) {

        //创建一个字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //追加数据
    /*  sb.append("hello") ;
        sb.append(true) ;
        sb.append(13.45) ;
        sb.append('A') ;
        sb.append(12.56F);*/

        //链式编程
        sb.append("hello").append(true).append(13.45).append('A').append(12.56F);

        //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

        sb.insert(5, "world") ;
        //输出
        System.out.println("sb:"+sb);
    }
}

8.StringBuffer的删除功能:
public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

9.演示:

public class StringBufferDemo3 {

    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //给缓冲区追加数据
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java") ;

        ////public StringBuffer deleteCharAt(int index)
        //需求:要删除当前缓冲区中'e'这个字符
//      sb.deleteCharAt(1) ;
        //需求:要删除当前缓冲区中第一个'l'这个字符
//      sb.deleteCharAt(1) ;

//      public StringBuffer delete(int start,int end)
//      sb.delete(5, 9) ;
        //从0索引开始,当前缓冲的字符串全部删除掉
        sb.delete(0, sb.length()) ;

        //输出
        System.out.println("sb:"+sb);
    }
}

10.StringBuffer的反转功能:
public StringBuffer reverse():将此字符串中的字符序列直接反转

11.演示:

import java.util.Scanner;
public class StringBufferDemo4 {

    public static void main(String[] args) {

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入并接收数据
        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;

        //可以创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer(line) ;
        //public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
        //反转功能
         String result = sb.reverse().toString() ;
         System.out.println("result:"+result);


    }
}

12.StringBuffer的替换功能:
public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代

13.演示:

public static void main(String[] args) {

        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //给缓冲添加数据
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java") ;

        //public StringBuffer replace(int start, int end,String str)
        sb.replace(5, 10, "节日快乐") ;

        System.out.println("sb:"+sb);
    }
}

14.StringBuffer的截取功能:
public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

15.演示:

public class StringBufferDemo6 {

    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //添加
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java") ;




        //public String substring(int start)
//      String s1 = sb.substring(5) ;
//      System.out.println("s1:"+s1);

        //public String substring(int start,int end)
        String s2 = sb.substring(5,10) ;
        System.out.println("s2:"+s2);
        System.out.println("sb:"+sb);
    }
}

16.面试题:
String,StringBuffer,StringBuilder的区别?
String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快
String和StringBuffer作为形式参数:
String类型作为形式参数和基本数据类型作为形式参数的效果一样

17.演示:

public static void main(String[] args) {

        //定义两个字符串
        String s1 = "hello" ;
        String s2 = "world" ;
        System.out.println(s1+"---"+s2);
        change(s1,s2) ;
        System.out.println(s1+"---"+s2);

        //定义两个字符串缓冲区对象
        StringBuffer sb1 = new StringBuffer("hello") ;
        StringBuffer sb2 = new StringBuffer("world") ;
        System.out.println(sb1+"---"+sb2);//hello---world
        change(sb1,sb2);
        System.out.println(sb1+"---"+sb2);//hello---worldworld
        //缓冲区是不变
    }

    public static void change(StringBuffer sb1 ,StringBuffer sb2){
        sb1 = sb2 ;  //缓冲区不变"world"
        sb2.append(sb1) ;//worldworld
    }

    public static void change(String s1,String s2){
        s1 = s2 ;
        s2 = s1 + s2 ;
    }
}

18.类与类之间的转换
A类型—>B类型
这里面可能最终使用B类型里面的功能
B类型—>A类型
有时候需要的不是B类型,所以又要将B类型–>A类型
StringBuffer—>String之间的相互转换

19.面试题:
StringBuffer和数组的区别?
两个共同特点:都属于容器类型的变量
数组:只能存储同一种数据类型的元素,数组的长度是固定的
int[] arr = {10,20,40,50,”hello”} 错误的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

20.演示:

public class StringBufferTest {

    public static void main(String[] args) {
        //String--->StringBuffer
        //定义一个字符串
        String s = "hello" ;

        /*StringBuffer sb = "hello" ;
        StringBuffer sb = s ;*/
        //方式1)使用StringBuffer的构造方式:StringBuffer(String str)
        //创建一个字符串缓冲区并指向这个字符串
        StringBuffer sb = new StringBuffer(s) ;
        System.out.println("sb:"+sb);

        //方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
        StringBuffer sb2 = new StringBuffer() ;
        sb2.append(s) ;
        System.out.println("sb2:"+sb2);

        System.out.println("--------------------");

        //StringBuffer--->String
        //有一个字符串缓冲区对象
        StringBuffer buffer = new StringBuffer("world") ;
        //1)方式1String的另一种构造方法:String(StringBuffer buffer)
        String s2 = new String(buffer) ;
        System.out.println("s2:"+s2);
        //2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
        String s3 = buffer.toString() ;
        System.out.println("s3:"+s3);
    }
}

/**
 * 将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法)
 * 
 *      int[] arr = {11,55,33 ,44 ,22} ;
 *      形成这样一个字符串:[11, 55, 33, 44, 22] 
 * 分析:
 *      1)存在一个数组,静态初始化
 *      2)分别使用String和StringBuffer类型去完成
 *  
 * @author Apple
 */
public class StringBufferTest2 {

    public static void main(String[] args) {
        //定义一个数组,静态初始化!
        int[] arr = {11,55,33,44,22} ;

        //方式1)使用String类型实现
        String result = arrayToString(arr) ;
        System.out.println("result:"+result);

        System.out.println("------------------------");
        //方式2:使用StringBuffer的append功能
        String result2 = arrayToString2(arr) ;
        System.out.println("result2: " + result2);
    }

    public static String arrayToString2(int[] arr){
        //1)创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;
        //sb对象追加左中括号
        sb.append("[") ;
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断是否是最大索引
            if(x==arr.length-1){
                //append追加
                sb.append(arr[x]);
            }else{
                sb.append(arr[x]).append(", ") ;
            }
        }

        sb.append("]") ;

        return sb.toString() ; //将StringBuffer--->String
    }

    /**
     * 明确返回值类型:String
     * 明确参数类型:int[] arr
     */
    public static String arrayToString(int[] arr){

        //定义一个空字符串
        String result = "" ;

        //拼接左中括号
        result +="[" ;

        //遍历int数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断是否最大索引
            if(x==arr.length-1){
                //拼接元素以及"]"
                result += arr[x] ;
                result += "]" ;
            }else{
                result += arr[x] ;
                result += ", " ;
            }
        }
        return result ;
    }
}

import java.util.Scanner;

/**
 * 分别使用String和StringBuffer实现字符串的反转
 * @author Apple
 */
public class StringBufferTest3 {

    public static void main(String[] args) {

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入并接收
        System.out.println("请您输入一个字符串:");
        String str = sc.nextLine() ;

        //方式1:使用String类型进行拼接
        String result = myReverse(str) ;
        System.out.println("result:"+result);
        //方式2:使用StringBuffer的reverse()功能

        String result2 = myReverse2(str) ;
        System.out.println("result2:"+result2);
    }

    //StringBuffer的rever()方法实现
    public static String myReverse2(String s){
        //创建字符串缓冲区对象h
        /*StringBuffer sb = new StringBuffer(s) ;
        //开始调用反转功能
        sb.reverse() ;
        //返回
        return sb.toString() ;*/

        //一步完成:
        return new StringBuffer(s).reverse().toString() ;
    }


    //String类型的方式进行反转
    public static String myReverse(String s){
        //定义空串
        String result = "" ;

        //可以字符组其转成字符数组
        char[] chs = s.toCharArray() ;

        //倒着遍历
        for(int x = chs.length-1 ; x >=0 ; x --){
            //空串进行拼接
            result += chs[x] ;
        }

        return result ;
    }
}

import java.util.Scanner;

/**
 * 1判断一个字符串是否是对称字符串

   例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
    使用(String和StringBuffer实现这个功能)

    分析:
            用第一个字符和倒数第一个字符相比较
            用二个字符和倒数第二个字符进行比较
            ...
 * @author Apple
 */
public class StringBufferTest4 {

    public static void main(String[] args) {

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入并接收数据
        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;

        //方式1:String类型的转换功能
        boolean flag = isSame(line) ;
        System.out.println("flag:"+flag);

        //方式2:间接的使用StringBuffer的reverse()功能
        boolean flag2 = isSame2(line) ;
        System.out.println("flag2:"+flag2);
    }

    public static boolean isSame2(String s){
        //直接一步
        //new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
        return new StringBuffer(s).reverse().toString().equals(s) ;
    }

    /**
     * 两个明确:
     *      返回值类型:boolean
     *      参数类型:String s
     */
    /*public static boolean isSame(String s){

        //将字符串转换成字符数组
        char[] chs = s.toCharArray() ;

        for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){
            //判断
            if(chs[start] != chs[end]){
                return false ;
            }

        }
        return true ;
    }*/

    public static boolean isSame(String s){
        //定义一个标记:假设返回值是true
        boolean flag = true ;

        //需要字符串转换成字符数组
        char[] chs = s.toCharArray();
        //遍历字符数组,获取前面索引对应的字符和后面索引的字符
        for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
            //判断
            if(chs[start]!= chs[end]){
                //修改标记
                flag = false ;
                break ;
            }
        }
        return flag ;
    }
}