I love Java

• 前言
• 一、API
• • 1.1 API概述
  • 1.2 帮助文档
  • 1.3 API使用练习（以Scanner为例）
• 二、String
• • 2.1 String概述
  • • 2.11 字符串的特点
  • 2.2 String构造函数
  • • 2.21 String类的运用
  • 2.3 String 对象的特点
  • 2.4 String类 代码的运行内存分布
  • • 2.41 常量池存放的历史
  • 2.5 字符串的比较
  • 案例：用户登录
  • 案例：遍历字符串
  • 案例：统计字符次数
  • 案例：拼接字符串
  • 案例：字符串反转
• 三、StringBuilder
• • 3.1 StringBuilder概述
  • 3.2 StringBuilder的构造方法
  • 3.3 StringBuilder的添加和反转方法
  • 3.4 StringBuilder和String相互转换
  • • 3.41 StringBuilder转换为String
    • 3.42 String转换为StringBuilder

前言

大家好！我是小笙！我以后想走的方向是Java后端开发的工程师，我最近想要进一步深入学习Java,主要是想巩固基础，所以想和大家一起来谈谈Java.同时我再次申明以下内容是我通过学习黑马程序猿等视频的总结，但是都是纯手打和加入个人的总结！这次我探讨的是字符串有关的知识点

一、API

1.1 API概述

我知道很多初学者对API这个概念还是很不理解！所以今天我来说一说
API（Application Programming Interface，应用程序接口）
指的是JDK中提供的各种功能功能java类，这些类将底层的实现封装了起来，我们不关心怎么实现的，我们的更加关心如何去使用！

1.2 帮助文档

Java 11在线中文文档
你可以下载jdk的官方文档去下载！我觉得是非常有用的！建议！

1.3 API使用练习（以Scanner为例）

学会看API文档对程序员来说很重要！很重要！很重要！！

很多方法，你都可以尝试，我举一例：

package javase_Scanner_use;

import java.util.Scanner;

/**
 * @author Al_tair
 * @date 2021/6/29-21:33
 */
/**
 * Scanner : 用于获取键盘录入数据（ primitive types and strings）
 * public String nextLine(); 获取键盘录入的字符串数据
 * Advances this scanner past the current line and returns the input that was skipped.
 * This method returns the rest of the current line, excluding any line separator at the end.
 * The position is set to the beginning of the next line.
 * 
 * 注意：
 * 调用方法的时候，如果方法有明确的返回值，我们用变量接受可以手动完成
 * 也可以使用快捷键（Ctrl+Alt+V）
 */
public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        // 接受数据
        System.out.print("输入一段字符串:");
        String string = sc.nextLine();
        
        // 输出结果
        System.out.println("输入的字符串:"+string);

    }
}

二、String

2.1 String概述

    /**
     * String 概述
     * The String class represents character strings.
     * All string literals in Java programs,such as "abc",
     * are implemented as instances of this class.
     * 意思是:String类代表字符串 ，所有"..."都是String类的实现对象
     */

2.11 字符串的特点

1. 字符串是不可变，他们的值在创建后不能被更改
2. 虽然String的值是不可以变的，但是他们是可以被共享的
3. 字符串的效果上相当于字符数组(char[]),但是底层实现上是字节数组(byte[])
   

2.2 String构造函数

2.21 String类的运用

2.3 String 对象的特点

        /**
         * String 对象的特点
         */
        /**
         *  1.通过new创建的对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值是不相同的，因为是两个对象
         *    System.identityHashCode(S1) 只能确定引用的不同，不能用于查询内存地址，只是对象的唯一标识符号
         */
        char[]ch = {'A','l','_','t','a','i','r'};
        String S1 = new String(ch);
        String S2 = new String(ch);
        System.out.println(System.identityHashCode(S1));
        System.out.println(System.identityHashCode(S2));

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

        /**
         * 2.直接赋值方式的字符串，只要字符内容相同，无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池进行维护
         *   2.0 解释一下字符串池的概念 位置是在方法区的常量池中
         *   2.1在JVM层面为字符串提供字符串常量池，可以理解为是一个缓存区；
         *   2.2创建字符串常量时，JVM会检查字符串常量池中是否存在这个字符串；
         *   2.3若字符串常量池中存在该字符串，则直接返回引用实例；若不存在，先实例化该字符串，
         *      并且，将该字符串放入字符串常量池中，以便于下次使用时，直接取用，达到缓存快速使用的效果。
         */
         String S3 = "AL_tair";
         String S4 = "AL_tair";
         System.out.println(System.identityHashCode(S3));
         System.out.println(System.identityHashCode(S4));

2.4 String类 代码的运行内存分布

2.41 常量池存放的历史

2.5 字符串的比较

1.做==比较

• 基本类型：比较的是数据值是否相同
• 引用类型：比较的是地址值是否相同

2.比较字符串的值是否相同，是用一个方法实现的：equals()

代码的实现

package javase_String_use;

import java.sql.SQLOutput;

/**
 * @author Al_tair
 * @date 2021/6/30-16:11
 */
public class StringCompare {
    /**
     * 字符串的地址和数据的比较实现
     */
    public static void main(String[] args) {
        // 构造方法获得对象
        char[]c = {'A','l','_','t','a','i','r'};
        String S1 = new String(c);
        String S2 = new String(c);
        // 直接赋值的方式获得对象
        String S3 = "Al_tair";
        String S4 = "Al_tair";

        // 比较字符串地址是否相同
        System.out.println(S1==S2);
        System.out.println(S1==S3);
        System.out.println(S3==S4);

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

        // 比较字符串数据是否相同
        System.out.println(S1.equals(S2));
        System.out.println(S1.equals(S3));
        System.out.println(S3.equals(S4));
    }
}

案例：用户登录

需求：已知用户名和密码，请用程序实现模拟用户登入，总共给三次机会，登入之后，给出相应的提示信息
思路：
1.已知用户名和密码，定义两个字符串即可
2.键盘录入要登入的用户名和密码，Scanner实现
3.拿键盘录入的用户名，密码与已知的用户名和密码进行比较，给出相应的提示。比较用方法.equals()实现
用循环实现多次机会，使用break结束循环

package javase_String_Test;

import java.util.Scanner;

/**
 * @author Al_tair
 * @date 2021/7/2-20:04
 */
public class StrgingTest {
    /**
     *  案例：用户登录
     *
     * 需求：已知用户名和密码，请用程序实现模拟用户登入，总共给三次机会，登入之后，给出相应的提示信息
     * 思路：
     * 1.已知用户名和密码，定义两个字符串即可
     * 2.键盘录入要登入的用户名和密码，Scanner实现
     * 3.拿键盘录入的用户名，密码与已知的用户名和密码进行比较，给出相应的提示。比较用方法.equals()实现
     * 4.用循环实现多次机会，使用break结束循环
     */
    public static void main(String[] args) {
        // 1.已知用户名和密码，定义两个字符串就可以了
        String Username = "Al_tair";
        String Password = "I love Java";

        // 2.键盘录入要登入的用户名和密码，Scanner实现
        for (int i = 0; i < 3; i++) {
            System.out.println("***********************************************");
            System.out.print("请输入用户名:");
            Scanner sc = new Scanner(System.in);
            String username = sc.nextLine();
            System.out.print("请输入密码:");
            String password = sc.nextLine();

        // 3.拿键盘录入的用户名，密码与已知的用户名和密码进行比较
            if(Username.equals(username) && Password.equals(password)) {
                System.out.println("登入成功");
                break;
            }else if(i == 3){
                System.out.println("登入失败，没有尝试机会了!!");
            }else {
                System.out.println("登入失败，你还有"+(2-i)+"次机会");
            }
            System.out.println("***********************************************");
        }
    }
}

案例：遍历字符串

需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
思路：
1.键盘录入一个字符串用Scanner实现
2.遍历字符串，首先能够获取到字符串中的每一个字符 public char charAt(int index):返回指定索引处的char值,字符串的索引也是从0开始
3.遍历字符串,其次要能够获取到字符串的长度 public int length():返回此字符串的长度 数组的长度：数组名.length 字符串的长度: 字符串对象.length()
4.遍历字符串的通用格式 for(int i=0;i<s.length();i++){
s.charAt(i); //就是指定索引处的字符值 }

package javase_String_traversal;

import java.util.Scanner;

/**
 * @author Al_tair
 * @date 2021/7/15-23:07
 */
public class StringTraversal {
    /**
     * 需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
     * 思路：
     * 1.键盘录入一个字符串用Scanner实现
     * 2.遍历字符串，首先能够获取到字符串中的每一个字符
     *  public char charAt(int index):返回指定索引处的char值,字符串的索引也是从0开始
     * 3.遍历字符串,其次要能够获取到字符串的长度
     *  public int length():返回此字符串的长度
     *  数组的长度：数组名.length
     *  字符串的长度: 字符串对象.length()
     * 4.遍历字符串的通用格式
     *  for(int i=0;i<s.length();i++){
     *      s.charAt(i); //就是指定索引处的字符值
     *  }
     */
    public static void main(String[] args) {
        // 1.键盘录入一个字符串用Scanner实现
        System.out.print("请输入一个字符串:");
        Scanner sc = new Scanner(System.in);
        String string = sc.nextLine();

        // 2.遍历字符串，首先能够获取到字符串中的每一个字符
        // 3.遍历字符串,其次要能够获取到字符串的长度
        for (int i = 0; i < string.length(); i++) {
            System.out.println("第"+(i+1)+"个字符是:"+string.charAt(i));
        }
    }
}

案例：统计字符次数

需求：键盘录入一个字符串，统计字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
思路：
1.键盘录入一个字符串，用Scanner实现
2.要统计三种类型的字符个数，需定义三个统计变量，初始值为0
3.遍历字符串，得到每一个字符
4.判断该字符属于哪种类型，然后对应类型的统计变量+1
5.输出三种类型的字符个数

package javase_String_count;

import java.util.Scanner;

/**
 * @author Al_tair
 * @date 2021/7/19-12:58
 */
public class StringCount {
    /**
     * 需求：键盘录入一个字符串，统计字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
     * 思路：
     * 1.键盘录入一个字符串，用Scanner实现
     * 2.要统计三种类型的字符个数，需定义三个统计变量，初始值为0
     * 3.遍历字符串，得到每一个字符
     * 4.判断该字符属于哪种类型，然后对应类型的统计变量+1
     * 5.输出三种类型的字符个数
     */
    public static void main(String[] args) {
        // 1.键盘录入一个字符串，用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串:");
        String string = sc.nextLine();

        // 2.要统计三种类型的字符个数，需定义三个统计变量，初始值为0
        int CountA = 0,Counta = 0,Count0 = 0;

        // 3.遍历字符串，得到每一个字符
        // 4.判断该字符属于哪种类型，然后对应类型的统计变量+1
        for (int i = 0; i < string.length(); i++) {
            if(string.charAt(i) >= 'A' && string.charAt(i) <= 'Z'){
                CountA++;
            }else if(string.charAt(i) >= 'a' && string.charAt(i) <= 'z'){
                Counta++;
            }else if(string.charAt(i) == (int)string.charAt(i) ){
                Count0++;
            }
        }

        // 5.输出三种类型的字符个数
        System.out.println("大写字母字符个数:"+CountA);
        System.out.println("小写字母字符个数:"+Counta);
        System.out.println("数字字符个数:"+Count0);
    }
}

案例：拼接字符串

需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果
思路:
1.定义一个int了类型的数组，用静态初始化完成数组元素的初始化
2.定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回，返回类型String,参数列表int[] arr
3.在方法中遍历数组，按照要求进行拼接
4.调用方法，用一个变量接收数据
5.输出结果

package javase_String_concat;

/**
 * @author Al_tair
 * @date 2021/7/19-15:32
 */
public class StringConcat {
    /**
     * 需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果
     * 思路:
     * 1.定义一个int了类型的数组，用静态初始化完成数组元素的初始化
     * 2.定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回，返回类型String,参数列表int[] arr
     * 3.在方法中遍历数组，按照要求进行拼接
     * 4.调用方法，用一个变量接收数据
     * 5.输出结果
     */
    public static void main(String[] args) {
        // 1.定义一个int了类型的数组，用静态初始化完成数组元素的初始化
        int []arr = {1,2,3,4,5};
        
        // 4.调用方法，用一个变量接收数据
        // 5.输出结果
        String string = concat(arr);
        System.out.println(string);
    }

    //  2.定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回，返回类型String,参数列表int[] arr
    public static String concat(int []arr) {
        String sum = "[";
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
            if(i != arr.length-1)
                sum += ",";
            else{
                sum += "]";
            }
        }
        return sum;
    }
}

案例：字符串反转

需求：定义一个方法，实现字符串的反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
思路：
1.键盘录入一个字符串，用Scanner实现
2.定义一个方法，实现字符串反转。返回值类型String，参数String s
3.在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
4.调用方法，用一个变量接收结果
5.输出结果

package javase_String_invert;

import java.util.Scanner;

/**
 * @author Al_tair
 * @date 2021/7/19-16:21
 */
public class StringInvert {
    /**
     * 需求：定义一个方法，实现字符串的反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
     * 思路：
     * 1.键盘录入一个字符串，用Scanner实现
     * 2.定义一个方法，实现字符串反转。返回值类型String，参数String s
     * 3.在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
     * 4.调用方法，用一个变量接收结果
     * 5.输出结果
     */

    public static void main(String[] args) {
        // 1.键盘录入一个字符串，用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串:");
        String string = sc.nextLine();

        // 4.调用方法，用一个变量接收结果
        // 5.输出结果
        string = invert(string);
        System.out.println(string);


    }
    // 2.定义一个方法，实现字符串反转。返回值类型String，参数String s
    // 3.在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
    public static String invert(String s){
        String sum = "";
        for (int i = s.length()-1; i >= 0;i--) {
            sum += s.charAt(i);
        }
        return sum;
    }
}

三、StringBuilder

3.1 StringBuilder概述

StringBuilder 是一个可变的字符串类，我们把它看成是一个容器，这里的可变指的是StringBuilder对象的内容是可变的
详情见API文档

3.2 StringBuilder的构造方法

3.3 StringBuilder的添加和反转方法

public StringBuilder append();
// 链式编程
StringBuilder strb = new StringBuilder();
strb.append("hello ").append("world! ").append(Java!);

public StringBuilder reverse();

3.4 StringBuilder和String相互转换

3.41 StringBuilder转换为String

// 通过toString()就实现把StringBuilder转换成String
public String toString();

3.42 String转换为StringBuilder

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

package javase_StringBuilder_String;

/**
 * @author Al_tair
 * @date 2021/7/20-13:26
 */
public class StringBuilderTurn {
    /**
     * 通过toString()就实现把StringBuilder转换成String
     * public String toString();
     * 通过构造方法就可以实现把String转换成StringBuilder
     * public StringBuilder(String s)
     */
    public static void main(String[] args) {
        // StringBuilder 转换成 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello ").append("world!");

        String s = sb.toString();
        System.out.println(s);

        // String 转换成 StringBuilder
        String s1 = new String("I Love Java!");
        StringBuilder sb1 = new StringBuilder(s1);
        sb1.append(" Please Join me!");
        System.out.println(sb1);

    }
}