一、API概述

API就是应用程序接口，已经写好的程序或功能，程序要需要时可以直接调用，无需再次编写。

1、API分类

• 编程语言API：内置的API
• 方法库或框架API：第三方方法库或框架提供的API
• 操作系统API：由操作系统提供的应用程序和操作系统之间的接口
• 远程API：允许开发人员操作远程资源
• Web API：使用HTTP从客户设备访问Web服务器的服务

2、为什么需要API？

减少重复写代码，提高开发速度

3、常用API包结构

二、Object

1、什么是Object类？

是java中所有类的父类，如果编写的类不主动继承任何类，默认继承Object类。

2、Object类中的方法

• toString：用于返回对象的字符串表示，常用于调试中
• equals：用于判断两个对象的逻辑相等，默认判断的是对象的内存地址
• finalize：用于释放资源
• hashCode：为对象生成一个hash值，用于哈希查找
• wait和notify相关：线程中使用
• getClass：反射中使用
• clone：克隆对象的方法

toString

返回一个可以代表该对象的字符串，该字符串中一般包含的是对象的具体信息，如果不重写toString方法，返回值类型为：类型@散列码

/**
 * @document: toString
 * @Author:SmallG
 * @CreateTime:2023/7/31+10:36
 */

public class Demo01 {
    public static void main(String[] args) {
        Student student = new Student("Tom", 20);
        //默认情况下，调用toString方法 结果是：类型@hashcode值
        System.out.println(student.toString()); //day01.Student@3b07d329
        //java中很多地方默认调用toString方法 比如System.out.println();

        //获取对象的详细信息
        System.out.println("姓名：" + student.getName() + ",年龄：" + student.getAge());
    }
}

class Student {
    //成员属性默认全私有的，除非有特殊说明
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

equals方法

在java中，equals()方法用于比较两个对象是否相等，

**经典面试题：equals和==区别

简洁版回答：

• "=="操作符用于比较引用是否相等，比较的是对象在内存中的地址
• "equals"方法用于比较对象的内容是否相等，通常需要重写以满足自定义的相等性标准
• 在比较对象时，通常应该使用个"equals"方法来比较内容相等性，而不是使用"=="操作符来比较引用相等性
• 但对于基本数据类型，可以使用"=="操作符来比较他们的值

三、String

1、**String特点：

• 不可变性：String对象一旦创建，其值无法修改。
• 常量池：Java通过字符串常量池来重用相同值的String对象，以节省内存和提高性能。
• 丰富的方法：String类提供了许多方法来操作和处理字符串，如连接、截取、比较、搜索、替换、格式化等。

2、创建字符串

/**
 * @document: String对象创建
 * @Author:SmallG
 * @CreateTime:2023/7/31+14:03
 */

public class Demo03 {
    public static void main(String[] args) {
        //创建字符串的基本方式
        String str1 = "Hello World";
        System.out.println(str1);
        //第二种创建方式
        String str2 = new String("Hello World");
        System.out.println(str2);
        System.out.println(str1.equals(str2)); //true

        String str3 = "Hello " +
                "World";
        System.out.println(str3); //Hello World

        //字符串字面量，通过使用三个"""来创建字符串字面量
        String str4 = """
                Hello
                World
                """;
        //Hello
        //World
        System.out.println(str4);
    }
}

3、字符串常量池和字符串字面量

• 字符串常量池的目的是重用具有相同值的字符串对象，以节省内存和提高性能
• 当使用双引号创建字符串时，Java会首先检查字符串常量池中是否已经存在相同的值的字符串对象，如果存在，则直接返回常量池中的实例，而不会创建新的对象。

/**
 * @document: 字符串常量池
 * @Author:SmallG
 * @CreateTime:2023/7/31+14:26
 */

public class Demo04 {
    public static void main(String[] args) {
        String str1 = "Hello World";
        String str2 = "Hello World";
        //内容相等，地址相同，指向的是同一块内存
        System.out.println(str1 == str2); //true
    }
}

当new创建新的字符串对象时，在常量池中没有相应的常量时，会在堆区中创建一个字符串的地址，在常量池中创建一个常量，堆区中的地址指向常量池中的常量。

4、String对象的不变性

string对象的不变性指的是一旦创建了String对象，其值无法修改

String对象的不变性带来了许多好处：线程安全性、便于缓存

String对象的不可变性原理

• String对象是通过final关键字修饰的，即不可被继承，避免了子类对其进行修改
• 在创建String对象时，它的值被保存在内部的字符数组（char[]）中（Java11以后更换为byte[]），并且该数组被声明为final和private，无法被外部修改
• String提供的方法，如拼接、替换等，并不修改原始的String对象，而是创建一个新的String对象并返回。

5、String常用方法

• length（）：返回字符串的长度（字符个数）。
• charAt（int index）：返回指定索引位置的字符。
• substring（int beginIndex）：返回从指定索引开始到字符串末尾的子字符串。
• substring（int beginIndex，int endIndex）：返回指定索引范围内的子字符串。范围[半闭，半开区间)
• concat（String str）：将指定字符串来连接到原始字符串的末尾。
• equals（Object ojb）：比较字符串是否与指定对象相等。
• equalsIgnoreCase（String str）：比较字符串是否与指定字符串相等，忽略大小写。
• compareTo(String str)：按字典顺序比较字符串。
• indexOf（String str）：返回指定字符串在原始字符串中第一次出现的索引位置。

charAt和length方法示例：

/**
 * @document: String的常用方法  charAt（int index）和length（）方法示例
 * @Author:SmallG
 * @CreateTime:2023/8/1+9:30
 */

public class Demo05 {
    public static void main(String[] args) {
        //length()方法返回字符串的长度
        String str1 = "Hello World";
        System.out.println("str1字符串长度为：" + str1.length()); //11

        //charAt（int index）方法放回字符串指定位置的字符
        char firstChar = str1.charAt(0); //字符串的首字符
        char lastChar = str1.charAt(str1.length() - 1);
        System.out.println("首字符是：" + firstChar);
        System.out.println("最后一个字符是：" + lastChar);

        //配合使用，遍历字符串
        for (int i = 0; i < str1.length(); i++) {
                System.out.println(str1.charAt(i));
        }
    }
}

indexOf（）和lastIndexOf（）方法：

indexOf（）返回指定字符或子字符串在原字符串中首次出现的位置的索引值。

lastIndexOf（）用于查找字符串中指定字符或子字符串最后一次出现的位置的索引值。

replace方法示例：

/**
 * @document: replace方法示例 字符串的替换
 * @Author:SmallG
 * @CreateTime:2023/8/1+10:19
 */

public class Demo07 {
    public static void main(String[] args) {
        String str = "SmallG 大帅锅";
        //replace（）方法
        String str1 = str.replace("G", "Y"); //string具有不可变性，replace后生成一个新的字符串
        System.out.println(str1);
        System.out.println(str);

        String str2 = str1.replaceFirst("S","s");
        System.out.println(str2);

    }
}

startsWith和endsWith方法示例：

startsWith()判断一个字符串是不是以固定的字符串开头 返回布尔类型结果

endsWith（）判断一个字符串是不是以固定的字符结尾

/**
 * @document: startsWith和endsWith方法示例
 * @Author:SmallG
 * @CreateTime:2023/8/1+10:29
 */

public class Demo08 {
    public static void main(String[] args) {
        String str = "SmallG";
        //startsWith()判断一个字符串是不是以固定的字符串开头 返回布尔类型结果
        boolean flag1 = str.startsWith("a"); //false
        System.out.println(flag1);
        boolean flag2 = str.startsWith("S"); //true
        System.out.println(flag2);

        //endsWith（）判断一个字符串是不是以固定的字符结尾
        boolean flag3 = str.endsWith("G"); //true
        boolean flag4 = str.endsWith("3"); //false
        System.out.println(flag3);
        System.out.println(flag4);
    }
}

split和join方法的使用：

split用于分割字符串，返回类型是字符串数组，需要用数组接收。

join用于拼接字符串，返回类型为一个字符串

/**
 * @document: split和join方法的使用
 * @Author:SmallG
 * @CreateTime:2023/8/1+10:37
 */

public class Demo09 {
    public static void main(String[] args) {
        String str1 = "SmallG 好帅";
        //split返回类型是字符串数组
        String[] strs = str1.split(" ");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        //如果字符串中不存在分割的字符，那么数组长度为1，数组中存储的是原来的字符串
        String[] str2 = str1.split(",");
        System.out.println(str2[0]);

        //join()方法 用于字符串的拼接
        String[] words = {"Hello", "World"};
        //join是个静态方法 可以通过类直接访问方法
        String str4 = String.join(" ", words);
        System.out.println(str4); //Hello World
    }
}

substring和trim方法的使用：

substring用于截取字符串中的一部分内容

trim用于去掉字符串两端的空格

/**
 * @document: 字符串的截取与修剪
 * @Author:SmallG
 * @CreateTime:2023/8/1+10:52
 */

public class Demo10 {
    public static void main(String[] args) {
        //substring方法
        String name = "SmallG";
        String charAt = name.substring(1); //截取字符串中第一个字符和以后的所有内容
        String charAT1 = name.substring(1, 3); //截取下标1到3的字符串
        System.out.println(charAt);  //mallG
        System.out.println(charAT1); //ma

        String CardId = "1301232023416066014";
        String birthday = CardId.substring(6, 14);
        System.out.println(birthday);

        //trim（）方法去掉字符串两端的空格
        String username = "      Tom ";
        String trimName = username.trim();
        System.out.println(username);
        System.out.println(trimName);
    }
}

valueOf方法的使用：

主要是做字符串的转换，将其他类型转换为字符串

/**
 * @document: valueOf（）方法
 * @Author:SmallG
 * @CreateTime:2023/8/1+11:19
 */

public class Demo11 {
    public static void main(String[] args) {
        //valueOf（）方法 把基本的数据类型转换为字符串
        int a = 123;
        String s1 = String.valueOf(a); //int类型的变量转换为字符串数据，赋给了s1
        System.out.println(s1);
        System.out.println(s1 instanceof String);

        double b = 123.456;
        String s2 = String.valueOf(b);
        System.out.println(s2);

        String s3 = b + ""; //将任意类型的数据和字符串相加，结果都是字符串 但效率低下
        System.out.println(s3);
        
    }
}

字符串的比较：

/**
 * @document: 字符串的比较
 * @Author:SmallG
 * @CreateTime:2023/8/1+11:36
 */

public class Demo12 {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        System.out.println(str1.equals(str2)); //false

        //equalsIgnoreCase()方法忽略大小写，比较字符串是否相等
        System.out.println(str1.equalsIgnoreCase(str2));

        //== 比较的是字符串的内存地址 equals比较的是对象的内容是否一致
    }
}

6、可变长度字符串

(1)StringBuilder

• 用于高效地进行字符串操作，它属于可变字符串类，用于处理频繁的字符串拼接、插入和修改操作，StringBuilder允许对字符串进行原地修改，避免了频繁创建新的字符串对象，从而提升了性能。
• StringBuilder：可变性，StringBuilder对象的值可以被修改。高效的字符串拼接，通过append（）方法可以将字符串片段追加到StringBuilde对象的末尾，提高了性能

/**
 * @document: 普通String类型字符串耗时 string的字符串拼接耗费时间
 * @Author:SmallG
 * @CreateTime:2023/8/1+14:04
 */

public class Demo13 {
    public static void main(String[] args) {
        int n = 10000;
        //获取当前的时间戳 1970年1月1日0时0分0秒到现在的毫秒数
        long startTime = System.currentTimeMillis();
        String result = "";
        for (int i = 0; i < n; i++) {
            result += "a";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("String执行程序耗费：" + (endTime - startTime) + "毫秒");
       
        //StringBuilder
        long startTime1 = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0;i<n;i++){
            stringBuilder.append("a");
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("StringBuilder执行程序耗费：" + (endTime1 - startTime1) + "毫秒");
    }
}

(2)StringBuilder常用方法

• append（）：在尾部追加内容
• delete（）：删除指定范围内的内容
• replace（）：替换指定范围内的内容
• insert（）：在指定位置插入内容
• reverse（）：反转字符串

/**
 * @document: StringBuilder操作方法
 * @Author:SmallG
 * @CreateTime:2023/8/1+14:26
 */

public class Demo16 {
    public static void main(String[] args) {
        //先定义一个字符串对象
        String str = "好好学习Java";
        //创建StringBuilder对象 赋值str的内容到builder对象中
        StringBuilder builder = new StringBuilder(str);
        //追加内容 append()方法在字符串的末尾添加内容

        builder.append(", 为了找个好工作");
        System.out.println(builder); //好好学习Java,为了找个好工作

        //替换内容 replace（起始位置，终止位置，替换内容）
        builder.replace(10, 17, "就是为了改变世界");
        System.out.println(builder);

        //delete（起始位置，结束位置）删除内容 包含开始但是不包含结尾
        builder.delete(0, 10);
        System.out.println(builder);

        //insert(起始位置，插入内容)插入内容
        builder.insert(0, "活着");
        System.out.println(builder);
        
        //字符串的反转
        builder.reverse();
        System.out.println(builder);
    }
}

四、正则表达式

1、什么是正则表达式？

正则表达式是指定文本搜索模式的字符序列，也就是能够描述字符串的格式，其实就是个文本处理工具。

2、正则表达式的语法

（1）[]：表示一个字符

（2）预定义字符

（3）数量词

（4）分组"()"

• 将括号内的内容看作是一个整体
• 分组时，可以使用"|"表示"或"关系
• 例如：（abc）{3}表示abc整体出现3次。可以匹配abcabcabc，但是不能匹配aaa或abcabc

（5）边界匹配："^"和"$"

• ^表示字符串开始
• $代表字符串结束

3、正则表达式API

• matches：判断当前字符串是否与指定的正则表达式匹配
• replaceFirst/replaceAll：替换当前字符串与正则表达式匹配的内容
• split：基于正则表达式匹配的内容将当前字符串拆分成字符串数组

五、练习

1 获取一个字符串中最后一个"/"后的字符序列

比如现有字符串为“someapp/manager/emplist.action”，截取该字符串最后一个“/”后的所有字符。截取后的结果为字符串“emplist.action”。

运行效果如下所示：

/**
 * @document: 获取一个字符串中最后一个"/"后的字符序列
 * @Author:SmallG
 * @CreateTime:2023/7/31+9:30
 */

public class GetString {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //输入字符串
        System.out.println("请输入字符串：");
        String s1 = scanner.next();
        //采用split函数将数组中的内容分隔开
        String[] ss = s1.split("/");
        //输出结果
        System.out.println("subStr=" + ss[ss.length - 1]);
    }
}

2 检测一个字符串是否为回文

回文字符串是指正着读和反着读该字符串都是相同拼写，比如“radar”、“level“。

本案例要求编写程序判断用户输入的字符串是否为回文。

运行效果如下所示：

/**
 * @document: 检测一个字符串是否为回文
 * @Author:SmallG
 * @CreateTime:2023/7/31+9:38
 */

public class Palindrome {
    public static void main(String[] args) {
        //输入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s1 = scanner.next();
        boolean isP = true;
        int j = s1.length() - 1;
        //遍历
        for (int i = 0; i <= s1.length() / 2; i++) {
            if (s1.charAt(i)==s1.charAt(j)){
                j--;
            }else{
                isP = false;
                break;
            }
        }
        if (isP){
            System.out.println("是回文");
        }else{
            System.out.println("不是回文");
        }
    }
}

3 生成一个包含所有汉字的字符串

生成一个包含所有汉字的字符串，编写程序输出所有汉字，每生成50个汉字进行换行输出。

提示：在Java中，字符类型事实上是一个16位无符号整数，这个值对应字符的编码。Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如：‘\u4e2d’。所有汉字的Unicode范围是U+4E00～U+9FA5。

部分运行效果如下所示：

/**
 * @document: 生成一个包含所有汉字的字符串
 * @Author:SmallG
 * @CreateTime:2023/7/31+9:46
 */

public class AllString {
    public static void main(String[] args) {
        String s1="";
        //计数器
        for (char c = '\u4e00', i = 1; c <= '\u9fa5'; c++, i++) {
            s1 +=c;
            if (i % 50 == 0) { 
                s1+="\n";
            }
        }
        System.out.println(s1.length());
        System.out.println(s1);
    }
}