08_Java中的字符串

Java中的字符串

一、APl（注：Java的默认包是java.lang使用时不需要导包）

1、APl概述：

APl(Application Programming Interface)：应用程序编程接口

Java APl：指的就是JDK中提供各种功能的Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些APL如何使用

2、如何使用帮助文档：

右键打开->在索引框中输入Random->查看这个类在那个包下->看类的描述->看构造方法->看成员方法（主要关注：返回值 方法名 参数）

3、APl使用练习

需求：按照帮助文档的使用步骤学习Scanner类的使用，并实现键盘录入一个字符串，最后输出在控制台

package com.itheima_01;
/*
    Scanner:
        用于获取键盘录入数据。（基本数据类型，字符串数据）
 
    public String nextLine();
        获取键盘录入字符串数据
 */
//导包
import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
 
        //接收数据
        System.out.println("请输入一个字符串数据：");
        //快捷生成接收变量 Ctrl + Alt + v
        String line = sc.nextLine();
 
        //输出结果
        System.out.println("你从键盘输入的数据是：" + line);
    }
}
 

注意：调用方法时，如果方法有明确的返回值，我们用变量接收，可以手动完成，也可以使用快捷键的方式完成（Ctrl + Alt + V）

二、String

1、string概述：

String类在java.lang包下，所以使用时候不需要导包

String类代表字符串，Java程序中的所有字符串文字（例如“abc”）都被实现为此类的实例

也就是说，Java程序中所有双引号字符串，都是String类的对象

字符串的特点：

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

虽然String的值是不可变的，但是它们可以被共享

字符串相当于字符数组（char[] ），但是底层原理是字节数组（byt[] ）

2、String构造方法：

方法名	说明
public String()	创建一个空白字符串对象，不含任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串数组对象
pbulic String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = "abc";	直接赋值的方式创建字符串对象，内容就是"abc"

package com.itheima_02;
/*
测试String的几种构造方法
     推荐使用直接赋值的方式
 */
public class StringDemo01 {
    public static void main(String[] args) {
        //public String(); 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);
 
        //public String(char[] chs); 根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c', '\0'}; //貌似不需要'\0'
        String s2 = new String(chs);
        System.out.println("s2:" + s2);
 
        //public String(byte[] bys); 根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};  //通过对应输入的字节值的 ASCLL码值来生成字母
        String s3 = new String(bys);
        System.out.println("s3:" + s3);
 
        //String s = "abc"; 直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

3、String对象的特点：

1、通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同

char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);

上面代码中，JVM会首先创建一个字符串数组，然后每一次new的时候都会有一个新的地址，只不过s1和s2参考的字符串内容是相同的

2、以 ”“ 方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护

String s3 = "abc";
String s4 = "abc";

在上面的代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；

第二行则让s4直接参考字符串池中的String对象，也就是说它们本质上同一个对象

4、字符串比较：

使用 == 做比较

基本类型：比较的是数据值是否相同

引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals()

public boolean eauals(Objec anObject); 将此字符串与指定对象进行比较由于我们比较的是字符串对像，所以参数直接传递一个字串

5、String案例：

1、模拟用户登录：

package com.itheima_03;
/*
使用String类实现模拟用户登录
 */
//导包
import java.util.Scanner;
 
public class StringTest01 {
    public static void main(String[] args) {
        //创建对像
        Scanner sc = new Scanner(System.in);
        String username = "张三";
        String password = "123456";
 
        //使用for循环实现三次机会
        for(int i = 0; i < 3; i++){
            //接收输入
            System.out.println("请输入用户名：");
            String u = sc.nextLine();    //用户名
            System.out.println("请输入密码：");
            String p= sc.nextLine();    //密码
 
            if(username.equals(u) && password.equals(p)){
                System.out.println("正在登录...");
                break;
            }
            else{
                if(i == 2){
                    System.out.println("你的账户被锁定，请与管理员联系");
                }
                else{
                    //机会：2 1 0
                    //i: 0 1 2
                    System.out.println("你输入的用户名或者密码有误,登录失败！你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

2、遍历字符串：

package com.itheima_03;
/*
利用String中的charAt方法来实现字符串的遍历
    char charAt(int index);     返回指定索引处的char值
    int length();         返回字符串长度
 */
 
//导包
import java.util.Scanner;
 
public class StringTest02 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
 
        //定义一个变量来接收字符串的传入
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine(); //Scanner 对象方法nextLine() 用于接收字符串
 
        //使用for循环来遍历字符串中的字符
        for(int i = 0; i < str.length(); i++){
            //使用charAt方法
            System.out.println(str.charAt(i));
        }
    }
}

3、统计字符次数

package com.itheima_03;
/*
统计字符 大小写，数字字符出现的次数
 
 */
//导包
import java.util.Scanner;
 
public class StringTest03 {
    public static void main(String[] args) {
        //定义三个变量统计个数
        int x = 0, y = 0, z = 0;
        //定义一个变量控制语句输出
        boolean flag = true;
 
        Scanner sc = new Scanner(System.in);
 
        System.out.println("请输入一个字符串（只含大小写字母、数字）");
        String str = sc.nextLine();
 
        //除了使用ASCLL码数字形式外 字符形式也行  'a' <= 字符 <= 'z'
        for (int i = 0; i < str.length(); i++) {
            //判断数字
            if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
                x++;
            }//判断小写字母
            else if (str.charAt(i) >= 97 && str.charAt(i) <= 122) {
                y++;
            }//判断大写字母
            else if (str.charAt(i) >= 65 && str.charAt(i) <= 90) {
                z++;
            }
            else{
                System.out.println("输入了非题目要求的字符！");
                flag = false;
                break;
            }
        }
        //输出结果
        if(flag){
            System.out.println("数字个数：" + x + "\n" + "小写字母：" + y + "\n" + "大写字母：" + z);
        }
    }
}

4、拼接字符串：

package com.itheima_03;
/*
拼接字符串
    需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法
    并在控制台输出结果。例如，数组为int[] arr = {1, 2, 3}; ，执行方法后输出结果为：[1, 2, 3]
 */
public class StringTest04 {
    public static void main(String[] args){
        //静态初始化一个整型数组
        int[] arr = {1, 2, 3, 4};
 
        //此方法可以修改数组长度并使用
        String s = myToString(arr);
        System.out.println(s);
    }
 
    //明确 返回值类型 和 参数
    public static String myToString (int[] arr){
        //定义一个字符串变量用于接收数据并返回
        String s = "";
 
        s += "[";
        for(int i = 0; i < arr.length; i++){
            s += arr[i];
            //不是最后一个元素时 拼接,用于隔开数据
            if(i < arr.length - 1){
                s += ",";
            }
        }
        s += "]";
 
        return s;
    }
}

5、字符串反转：

package com.itheima_03;
/*
字符串反转
    定义一个方法，实现字符串反转
    利用String中的提取字符方法：char charAT(int index);
 */
//导包
import java.util.Scanner;
 
public class StringTest05 {
    public static void main(String[] args){
        //定义一个变量接受从键盘录入的字符串变量
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串字符：");
        String str = sc.nextLine();
 
        //方法调用
        System.out.println("逆序后为：");
        inversionString(str);
    }
 
    public static void inversionString(String str){//无返回值的 若是需要返回就定义一个字符串变量依次拼接字符
        //利用for逆序遍历字符串 注意格式
        for(int i = str.length() - 1; i >= 0; i--){
            if(i > 0){
                System.out.print(str.charAt(i));
            }
            else{
                System.out.println(str.charAt(i));
            }
        }
    }
}

6、通过帮助文档查看String中的方法：

方法名	说明
public boolean equals(Object anObject)	比较字符串的内容，严格区分大小写（用户名和密码）
public char charAt(int index)	返回指定索引处的 char 值
public int length()	返回此字符串的长度（String是类length时方法 与数组区分）

7、StringBuilder:

由于字符串String追加是会在堆区添加多个字符常量，产生了空间浪费，所以产生StringBuilder来处理这个问题

1、StringBuilder概述：

是一个可变的字符串类，我们可以把它看作是一个容器

这里的可变指的StringBuilder对象中的内容是可以变的

String 和 StringBuilder的区别：

String：内容是不可变的

StringBuilder：内容是可变的

2、StringBuilder构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

package com.itheima_01;
/*
测试StringBuilder构造方法：    在java.lang包内无需导包
    public StringBuilder();
    public StringBuilder(String str);
 */
public class StringBuilderDemo01 {
    public static void main(String[] args){
        //使用StringBuilder(); 构造方法创建一个空白的可变字符串对象，不含任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());
 
        //使用StringBuilder(String str); 构造方法创建String字符串内容的可变字符串对象，不含任何内容
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

3、Stringbuilder的添加和反转方法：

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列

package com.itheima_02;
/*
    StringBuilder的添加和反转方法：
    public StringBuilder append(任意类型);  添加数据，并返回对象本身
    public StringBuilder reverse();        返回相反的字符序列
 */
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();
 
//        //1、使用append()方法添加数据并返回给对象本身
//        StringBuilder sb2 = sb.append("hello");
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//
//        //测试sb == sb2   比较的是地址值 String中的equals()比较的字符串
//        System.out.println(sb == sb2);  //由于添加后的返回值是对象本身 所以 == 对应的地址值相同
 
//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);
 
        //因为返回的对象使其本身 即可以使用链式编程思想(调用函数后还是对象 仍然可以继续调用对象的方法)
        sb.append("hello").append("world").append("java").append(100);
 
        System.out.println("sb:" + sb);
 
        //2、使用reverse()方法返回相反的字符串序列
        sb.reverse();
        System.out.println("sb:" + sb );
    }
}

4、StingBuilder 和 String 相互转换：

4.1、StringBuilder转换为String

​ public String toString(); 通过toString就可以实现把StringBuilder转换为String

4.2、String转换为StringBuilder

​ public StringBuilder(String s); 通过构造方法就可以实现把String转换为StringBuilder

package com.itheima_02;
/*
实现String和StringBuilder之间的相互转换
 */
public class StringBuilderDemo02 {
    public static void main(String[] args){
        //1、StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
 
        //错误示范：
        //String str1 = sb;
 
        //正确示范：使用StringBuilder 中的toString方法
        String str = sb.toString();
        System.out.println(str);
 
        //1、String 转换为 StringBuilder
        String str2 = "hello";
        //错误的方法
        //StringBuilder sb2 = str2;
 
        //正确示范：使用StringBuilder的一个构造方法
        StringBuilder sb3 = new StringBuilder(str2);
        System.out.println(sb3);
    }
}

5、StringBuilder案例

1、拼接字符串：

package com.itheima_03;
/*
使用StringBuilder来实现案例 拼接字符串
 */
 
public class StringBuilderTest01 {
    public static void main(String[] args){
        //使用静态方式定义一个数组
        int[] arr = {1, 2, 3, 4};
 
        //调用方法
        String str = arrayToString(arr);
        System.out.println(str);
    }
 
    public static String arrayToString(int[] arr){
        String str = "";
        //定义一个空的StringBuilder类
        StringBuilder sb = new StringBuilder();
 
        sb.append("[");
        for(int i = 0; i < arr.length; i++){
            if(i != arr.length - 1){
                sb.append(arr[i]);
                sb.append(",");
            }
            else{
                sb.append(arr[i]);
            }
        }
        sb.append("]");
 
        //使用StringBuilder的成员方法 来实现 StringBuilder到String的转换
        str = sb.toString();
 
        return str;
    }
 
}

2、字符串反转：

此处提到了匿名对象：new StringBuilder(str) 使用构造方法构建了匿名对象

//匿名对象 是在:
类名 对象名 = new 构造方法名（即类名）([参数]);	//java
的基础上 去掉了等号与其左值：
new 构造方法名（即类名）([参数]);	//此时系统会自动创建一个临时对象来接收 并在当前语句执行后自动回收掉匿名对象

你可以将这一个理解为一个对象  所以它能够调用reverse() 方法

又因为reverse方法的返回值是对象本身 所以又可以理解为一个变量 又调用了toString方法（链式编程）

package com.itheima_03;
/*
使用StringBuilder来实现字符串反转案例
 */
//导包
import java.util.Scanner;
 
public class StringBuilderTest02 {
    public static void main(String[] args) {
        //从键盘录入一串字符串
        System.out.println("请输入一串字符串：");
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
 
        //调用方法
        String str = myReverse(line);
 
        //输出结果
        System.out.println("反转后字符串的结果为：");
        System.out.println(str);
    }
 
    public static String myReverse(String str){
//        //使用StringBuilder(String str) 构造方法来将String转换为StringBuilder格式
//        StringBuilder sb = new StringBuilder(str);
//
//        //使用reverse()方法来反转可变字符串
//        sb.reverse();
//
//        String line = sb.toString();
//        return line;
 
        //这里使用了 匿名对象 的方式 与上面的实现等价
        return new StringBuilder(str).reverse().toString();
    }
}

8、通过帮助文档查看StringBuilder中的方法：

方法名	说明
public StirngBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列
public String toString()	通过toString()就可以实现把StringBuilder转换为String