Scanner类、String类和StringBuffer类的相关使用

一、Scanner: 主要用于键盘录入的

构造方法：

Scanner(InputStream source) 构造一个新的 Scanner ，产生从指定输入流扫描的值。

1、next()和nextLine()区别：

String line = sc.next(); // 不会接收特殊字符，比如空格回车这样的符号

String line = sc.nextLine(); // 能够接收特殊字符，比如空格回车这样的符号

int number = sc.nextInt(); // 要保证输入的内容能够转成对应的类型，否则报错 InputMismatchException

2、hasNextXxx()的使用，避免报错

// hasNextXxx() 判断下一次输入的内容是否符合对应类型

参考使用如下：

java 复制代码

 if(sc.hasNextInt()){
            int num = sc.nextInt();
            System.out.println("输入的数字为：" + num);
        }else {
            System.out.println("您输入的内容无法转成int类型");
        }

二、 String: 字符串

解释：

白话文描述：使用一个串将一个一个字符串起来的串儿叫字符串。

专业术语：使用双引号将若干个字符括起来的字符序列

String: 字符串

官网概述：

String类代表字符串。

Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的对象。

字符串不变; 它们的值在创建后不能被更改。

字符串缓冲区支持可变字符串。

因为String对象是不可变的，它们可以被共享。

概述：

1、字符串可以看成是字符数组

2、字符串是由多个字符组成的一串数据(字符序列)

3、字符串一旦被创建，就不能被改变：指字符串一旦被创建就不能被修改了，指的是常量池中的字符串值本身不能被修改。参考示例如下：

java 复制代码

      String s = "abc";
       System.out.println(s);
       s = "qwer";
       System.out.println(s);

结果是qwer

原因是创建的s对象中的abc值并不会改变，后面重新给s赋值，也并没有覆盖原来的abc,而是不再用它了，但它依然存在方法区中的常量池。

更清楚的解释可参考以下图片：

2.1 String构造方法：

public String() 创建一个没有字符的字符串

public String(byte[] bytes) 将一个字节数组转成一个字符串

public String(byte[] bytes,int offset,int length) 将字节数组的一部分转成字符串

public String(char[] value) 将一个字符数组转成一个字符串

public String(char[] value,int offset,int count) 将字符数组的一部分转成字符串

public String(String original) 将字符串转字符串

具体使用代码如下：

java 复制代码

 */
public class StringDemo1 {
    public static void main(String[] args) {
//        String s = "abc";
//        System.out.println(s);
//        s = "qwer";
//        System.out.println(s);

        //  public String()
        String s1 = new String(); // 创建一个没有字符的字符串
        System.out.println("s1: " + s1); // String类中重写的toString()方法

        // public String(byte[] bytes) 将一个字节数组转成一个字符串
        byte[] bytes = {97, 98, 99, 100, 101};将对应数值的ASCII码转换成字符，超出字节数范围127就报错，在这之内如果没有定义的相关字符，就给字符默认值
        String s2 = new String(bytes);
        System.out.println("s2: " + s2);

        // public String(byte[] bytes, int index, int length) 将字节数组的一部分转成字符串
        String s3 = new String(bytes, 1, 3);
        System.out.println("s3: " + s3);

        // public String(char[] value) 将一个字符数组转成一个字符串
        char[] chars = {'我', '爱', '中', '国'};
        String s4 = new String(chars);
        System.out.println("s4: " + s4);

        // public String(char[] value,int offset,int count) 将字符数组的一部分转成字符串
        String s5 = new String(chars, 2, 2); // 长度不能超
        System.out.println("s5: " + s5);

        // public String(String original) 将字符串转字符串
        String s6 = new String("hello");
        System.out.println("s6: " + s6);

        String s7 = "hello";


    }
}

2.2 String类中的判断功能： 首先注意：String类中的equals是重写父类Object中的equals方法，

boolean equals(Object obj) 比较的是内容

boolean equalsIgnoreCase(String str) 忽略大小写比较字符串内容

boolean contains(String str) 判断大字符串中是否有小字符串

boolean startsWith(String str) 判断字符串是否以指定字符串开头

boolean endsWith(String str) 判断字符串是否以指定字符串结尾

boolean isEmpty() 判断字符串是否为空字符串

具体使用代码如下：

java 复制代码

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HelLO";

        //boolean equals(Object obj)
        boolean b1 = s1.equals(s2); // String类中的equals是重写父类Object中的equals方法，比较的是内容
        System.out.println(b1);


        //boolean equalsIgnoreCase(String str)
        boolean b2 = s1.equalsIgnoreCase(s2); // 忽略大小写比较字符串内容
        System.out.println(b2);

        //boolean contains(String str) // 判断大字符串中是否有小字符串
        String s3 = "wohaoshuai帅";
        String s4 = "wohao";
        boolean b3 = s3.contains(s4);
        System.out.println(b3);

        //boolean startsWith(String str) // 判断字符串是否以指定字符串开头
        boolean b4 = s3.startsWith("wo");
        System.out.println(b4);

        //boolean endsWith(String str) // 判断字符串是否以指定字符串结尾
        boolean b5 = s3.endsWith("帅");
        System.out.println(b5);

        // boolean isEmpty() 判断字符串是否为空字符串
        boolean b6 = s3.isEmpty();
        System.out.println(b6);
        s3 = "";
        System.out.println(s3.isEmpty());
//        s3 = null;
//        System.out.println(s3.isEmpty()); // NullPointerException，表明空不等于null


    }
}

2.3String类的获取功能

int length() 获取字符串中的字符个数

char charAt(int index) 根据索引获取对应的字符

int indexOf(int ch) 传入字符对应的ascii码值，返回字符从左向右第一次找到的对应的位置索引

int indexOf(String str) 传入小字符串，在大字符串中找这个小字符串，若找到，返回小字符串中第一个字符所在的索引位置

int indexOf(int ch,int fromIndex) 从fromIndex索引开始找该字符，若找到了该字符，返回该字符在整个字符串中的位置索引

int indexOf(String str,int fromIndex) 从fromIndex索引开始找该字符串，若找到了该字符串，返回该字符串的第一个字符在整个大字符串中的位置索引

String substring(int start) 从指定索引位置开始截取字符串，返回截取后的字符串

String substring(int start,int end) 截取从start开始到end结束之间的字符串，返回截取后的字符串，范围是 [start, end)

参考使用如下：

java 复制代码

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "hello world！";

        //int length() 获取字符串中的字符个数
        int length = s1.length();//定义一个int类型的length变量接收
        System.out.println(length);

        //一个字符串可以被看成一个字符数组,索引是从0开始的
        //char charAt(int index) 根据索引获取对应的字符
        System.out.println(s1.charAt(6));
        //一般情况下，在java中和索引有关的操作，若提供不存在的索引，一般都会直接报错
//        System.out.println(s1.charAt(20)); // StringIndexOutOfBoundsException


        //int indexOf(int ch) 传入字符对应的ascii码值，返回字符从左向右第一次找到的对应的位置索引
        System.out.println(s1.indexOf(119));
//        System.out.println(s1.indexOf(126)); // -1  若找不到就返回-1

        //int indexOf(String str) 传入小字符串，在大字符串中找这个小字符串，若找到，返回小字符串中第一个字符所在的索引位置
        System.out.println(s1.indexOf("o wo"));
        System.out.println(s1.indexOf("shu")); // -1

        //int indexOf(int ch, int fromIndex) 从fromIndex索引开始找该字符，若找到了该字符，返回该字符在整个字符串中的位置索引
        String s2 = "hello wojavarld nijavahao java";
        System.out.println(s2.indexOf(111, 12));

        //int indexOf(String str,int fromIndex) 从fromIndex索引开始找该字符串，若找到了该字符串，返回该字符串的第一个字符在整个大字符串中的位置索引
        System.out.println(s2.indexOf("java",22)); // 26


        //String substring(int start) 从指定索引位置开始截取字符串，返回截取后的字符串
        String s3 = "今天是疯狂星期四，v我50可好？";
        String s4 = s3.substring(9);
        System.out.println(s4);

        //String substring(int start,int end) 截取从start开始到end结束之间的字符串，返回截取后的字符串 [start, end)
        String s5 = s3.substring(5, 8);
        System.out.println(s5);


    }
}

2.4 String类的转换功能：

byte[] getBytes() 将字符串转成一个字节数组

char[] toCharArray() 将字符串转成一个字符数组

static String valueOf(char[] chs) 直接使用String类名的方式进行调用，将字符数组转成字符串

static String valueOf(int i) 将整数转成字符串

String toLowerCase() 将字符串中的字母全部转小写

String toUpperCase() 将字符串中的字母全部转大写

String concat(String str) 字符串的拼接

参考使用如下：

java 复制代码

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "hello WoRlD";

        //byte[] getBytes() 将字符串转成一个字节数组
//        byte[] bytes = s1.getBytes();
//        for(int i=0;i<bytes.length;i++){
//            System.out.println(bytes[i]);
//        }

        //char[] toCharArray() 将字符串转成一个字符数组
//        char[] chars = s1.toCharArray();
//        for (int i = 0; i < chars.length; i++) {
//            System.out.println(chars[i]);
//        }

        //static String valueOf(char[] chs) 直接使用String类名的方式进行调用，将字符数组转成字符串
        char[] chars = {'我', '爱', '美', '丽', '的', '中', '国'};
        String s2 = String.valueOf(chars);
        System.out.println(s2);

        //static String valueOf(int i)
        String s3 = String.valueOf(100); //将整数100转成字符串100
        System.out.println(s3); // 100 --> "100"

        //String toLowerCase() 将字符串中的字母全部转小写
        String s4 = s1.toLowerCase();
        System.out.println(s4);

        //String toUpperCase() 将字符串中的字母全部转大写
        String s5 = s1.toUpperCase();
        System.out.println(s5);

        //String concat(String str) 字符串的拼接
        String s6 = "hello";
        String s7 = "world";
        String s8 = s6.concat(s7);
        System.out.println(s8);
    }
}

2.5 String类的其他功能：

替换功能

String replace(char old,char new) 将字符串中所有的旧字符使用新字符进行替换，返回新的字符串

String replace(String old,String new) 将字符串中所有的旧字符串使用新字符串进行替换，返回新的字符串

去除字符串两空格

String trim() 去除字符串两边的空白字符

按字典顺序比较两个字符串

int compareTo(String str)

int compareToIgnoreCase(String str) 忽略大小写，比较两个字符串

小注意：使用 int compareTo(String str)比较，如果两个字符串完全相同，返回值为0，如果两个字符串存在包含关系，但是第一个字符要相同，比如s1=Javahaha,s2=Jav,返回值为s1的长度减s2的长度，返回值为5，如果两个字符串从第一个字母就不同，则用返回值为两个字符的ASCII码之差。 这和String类中compareTo方法的源码算法有关！

参考使用如下：

java 复制代码

public class StringDemo7 {
    public static void main(String[] args) {
        String s1 = "今天ajava的天气是java非炎热，每走一java步都出java汗！";

        //String replace(char old,char new) 将字符串中所有的旧字符使用新字符进行替换，返回新的字符串
        String res1 = s1.replace('a', '_');
        System.out.println("s1: "+s1);
        System.out.println("res1: "+res1);

        System.out.println("----------------------------------------------");
        //String replace(String old,String new) 将字符串中所有的旧字符串使用新字符串进行替换，返回新的字符串
        String res2 = s1.replace("java", "hadoop");
        System.out.println("s1: "+s1);
        System.out.println("res2: "+res2);

        System.out.println("----------------------------------------------");
        //String trim() 去除字符串两边的空白字符
        String s2 = "    hello   world         ";
        String res3 = s2.trim();
        System.out.println("s2: "+s2);
        System.out.println("res3: "+res3);
//        String res4 = s2.replace(" ", "");
//        System.out.println("res4: "+res4);

        System.out.println("----------------------------------------------");
        //int compareTo(String str) 比较两个字符串中的内容是否相同,当结果是0的时候，说明比较的两个内容相同
        String s3 = "hello";
        String s4 = "world";
        System.out.println(s3.compareTo(s4)); // -15

        String s5 = "hel";
        System.out.println(s3.compareTo(s5)); // 2

        String s6 = "hello";
        System.out.println(s3.compareTo(s6)); // 0

    }
}

小练习：只用String如何将字符串abc反转为cba.

分析;分析：

1、String没有直接的反转功能，所以先将字符串转字符数组

2、然后将数组逆序，得到逆序后的字符数组

3、再将逆序后的字符数组转字符串

代码如下：

java 复制代码

public class StringTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个要反转的字符串: ");
        String info = sc.next();
        System.out.println("反转前：" + info);

        char[] chars = info.toCharArray();

        for (int front = 0, end = chars.length - 1; front < end; front++, end--) {
            char tmp = chars[front];
            chars[front] = chars[end];
            chars[end] = tmp;
        }

        String res = String.valueOf(chars);
        System.out.println("反转后：" + res);
    }
}

三、StringBuffer: 可变字符串，这个容器中只能存放字符

概述：

线程安全，可变的字符序列。

字符串缓冲区就像一个String ，但可以修改。

在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

构造方法：

public StringBuffer()

public StringBuffer(int capacity) 自定义初始容量，类似于动态初始化数组时给定的长度

public StringBuffer(String str) 创建一个StringBuffer，放入一个初始字符串

3.1 StringBuffer的功能：

添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

替换功能

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

反转功能

public StringBuffer reverse()

截取功能

public String substring(int start)

public String substring(int start,int end)

参考代码如下：

java 复制代码

public class StringBufferDemo2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println("sb: " + sb);

        System.out.println("-------------------------------------");
        // public StringBuffer append(String str) 在末尾处添加字符，返回自身
        // 任何数据类型值一旦进入到StringBuffer中就是一个一个的普通字符
        sb.append(100);
        sb.append(12.345);
        sb.append(true);
        sb.append(1000L);
        sb.append("hello");
        System.out.println("sb: " + sb);
        System.out.println("-------------------------------------");
        //public StringBuffer insert(int offset,String str) 指定位置添加字符串，返回自身
        sb.insert(9, "_____");
        System.out.println("sb: " + sb);
        System.out.println("-------------------------------------");
        //10012.345_____true1000hello
        //public StringBuffer deleteCharAt(int index) 根据索引删除某一个字符
//        sb.deleteCharAt(14);
//        System.out.println("sb: " + sb);
        System.out.println("-------------------------------------");
        //public StringBuffer delete(int start,int end) [start, end)
//        sb.delete(9,14);
//        System.out.println("sb: " + sb);

        System.out.println("-------------------------------------");
        //public StringBuffer replace(int start,int end,String str) 使用一个新的字符串将一段字符串进行替换 [start, end)
        sb.replace(9, 14, "aaaaaa");
        System.out.println("sb: " + sb);
        System.out.println("-------------------------------------");
        //public StringBuffer reverse()
        StringBuffer sb2 = new StringBuffer("hello");
        sb2.reverse();
        System.out.println("sb2: " + sb2);


    }
}

四、 String和StringBuffer的相互转换

A -> B

B -> A

参考代码如下：

java 复制代码

public class StringBufferDemo4 {
    public static void main(String[] args) {
        // String -> StringBuffer
        //可以通过构造方法来转换，将String作为参数传递
        String s1 = "hello";
        StringBuffer sb1 = new StringBuffer(s1);

        //StringBuffer -> String
        //1、可以使用String类中的构造方法
        //public String(StringBuffer buffer)
        StringBuffer sb2 = new StringBuffer("world");
        String s2 = new String(sb2);

        //2、调用StringBuffer中toString()方法
        String s3 = sb2.toString();

        //3、使用截取的方式将字符串取出来
        String s4 = sb2.substring(0);

    }
}

☆☆String和StringBuffer作为参数传递☆☆

String和StringBuffer作为参数传递，相同的是都重写了父类Object的toString方法，所以展示出来的不是地址值，而是对象内容

以下是两者的不同：
一、String作为参数传递： 因为没有new，所以内容只在方法区，有相同的字符就会指向常量池中同一个地址值，没有就会创建一个新的，

但是方法调用的时候，只在方法里发生变化，因为方法是在栈里面运行的，所以方法结束，就自动消失，不会对原来的内容发生永久改变，
sb1不变，sb2也不变！ ，所以外面的System.out.pringtln()，不会受到调用方法的影响

二、StringBuffer当作参数 ：因为new，在堆里面开辟一块内存空间，当调用方法时，sb2.append(sb1)改变的内容会被保留下来，

而sb1=sb2,这个赋值方法只是运行在栈里面，将sb2的地址值赋值给sb1，并没有直接改变了sb1所指的地址值内容，所以只有sb2在堆里面的内容发生了永久改变，

（总结：谁调用方法谁改变），所以在该方法fun1()后面的System.out.pringtln(sb1,sb2)中,sb1不变，只有sb2发生改变！