5.0 Java API

API（Application Programming Interface）指的是应用程序编程接口，API可以让编程变得更加方便简单。Java也提供了大量API供程序开发者使用，即Java API。Java API指的就是JDK提供的各种功能的Java类库，如之前所讲的Arrays、Collection类等，都是Java提供给开发者的类库。Java API非常多，无法针对所有的API都进行逐一讲解，本章将详细讲解实际开发中的常用API。

1. 字符串类

1.1. String类

（1）String类对象

String类对象进行初始化

String 变量名 = 字符串;

使用上述语法格式初始化String对象,示例代码如下所示。

String str1 = null;   //将字符串str1设置为空
String str2 = "";     //将字符串str2设置为空字符串
String str3 = "abc"; //将字符串str3设置为abc

String类是专门用于处理字符串的类。字符串一旦被创建，其内容就不能再改变。例如下面的代码。

String str = "hello";
str = "helloworld";

如下图所示，str在初始化时，其内存地址指向的是字符串常量池的"hello"字符串的地址0x001。当为str重新赋值时为"helloworld"时，程序会在常量池分配一块内存空间存储"helloworld"字符串，然后将str指向"helloworld"字符串。由此可知，str的值发生了变化，是指str的指向发生了变化，但字符串"hello"被创建之后，存储在常量池中，它的值不能被改变。

调用String类的构造方法初始化字符串对象

String 变量名 = new String(字符串);

String类的常见构造方法如下表所示。

方法声明	功能描述
String()	创建一个内容为空的字符串
String(String value)	String(String value)
String(char[] value)	根据指定的字符数组value创建对象
String(byte[] bytes)	根据指定的字节数组bytes创建对象

（2）String类的常用方法

String类的常用方法包括获取字符串长度以及访问字符串中的字符、字符串的转换操作、字符串的替换和去除空格操作、字符串判断、字符串的截取和分割操作。

方法声明	功能描述
int length()	返回当前字符串的长度，即字符串中字符的个数。
int indexOf(int ch)	返回指定字符ch在字符串中第一次出现位置的索引。
int lastIndexOf(int ch)	返回指定字符ch在字符串中最后一次出现位置的索引。
int indexOf(String str)	返回指定子字符串str在字符串第一次出现位置的索引。
int lastIndexOf(String str)	返回指定子字符串str在此字符串中最后一次出现位置的索引。
char charAt(int index)	返回字符串中index位置上的字符，其中index的取值范围是0~(字符串长度-1)。
boolean endsWith(String suffix)	判断此字符串是否以指定的字符串结尾。
boolean equals(Object obj)	比较obj与当前字符串对象的内容是否相同。
boolean equalsIgnoreCase(String str)	以忽略大小写的方式比较str与当前字符串对象的内容是否相同。
int compareTo(String str)	按对应字符的Unicode编码比较str与当前字符串对象的大小。若当前字符串对象比str大，返回正整数；若比str小，返回负整数；若相等则返回0。
int compareToIgnoreCase(String str)	按对应字符的Unicode编码以忽略大小写的方式比较str与当前字符串对象的大小。若当前字符串对象比str大，返回正整数；若比str小，返回负整数；若相等则返回0。
boolean isEmpty()	判断字符串长度是否为0，如果为0则返回true，反之则返回flase。
boolean startsWith(String prefix)	判断此字符串是否以指定的字符串prefix开始。
boolean contains(CharSequence cs)	判断此字符串中是否包含指定的字符序列cs。
String toLowerCase()	使用默认语言环境的规则将String中的所有字符都转换为小写。
String toUpperCase()	使用默认语言环境的规则将String中的所有字符都转换为大写。
static String valueOf(int i)	将int变量i转换成字符串。
char[] toCharArray()	将此字符串转换为一个字符数组。
String replace(CharSequence oldstr, CharSequence newstr)	使用newstr替换原字符串中的oldstr，返回一个新的字符串。
String concat(String str)	将str连接到当前字符串对象之后。
String[] split(String regex)	根据参数regex将原来的字符串分割为若干个子字符串。
String substring(int beginIndex)	返回一个新字符串，它包含从指定的beginIndex处开始，直到此字符串末尾的所有字符。
String substring(int beginIndex, int endIndex)	返回一个新字符串，它包含从指定的beginIndex处开始，直到索引endIndex-1处的所有字符。
String trim()	去除了原字符串首尾的空格。

获取字符串长度以及访问字符串中的字符案例

在Java程序中，有时需要获取字符串的一些信息，如获取字符串长度、获取指定索引位置的字符等。针对每一个操作，String类都提供了对应的方法。

public class TestDemo {
    @Test
    public void test(){
        String s = "ababcdedcba";
        System.out.println("字符串的长度为：" + s.length());
        System.out.println("字符串中第一个字符:" + s.charAt(0));
        System.out.println("字符c第一次出现的位置:" + s.indexOf('c'));
        System.out.println("字符c最后一次出现的位置:" + s.lastIndexOf('c'));
        System.out.println("子字符串ab第一次出现的位置：" + s.indexOf("ab"));
        System.out.println("子字符串ab字符串最后一次出现的位置：" + s.lastIndexOf("ab"));
    }
}

字符串的转换操作案例

程序开发中，经常需要对字符串进行转换操作。例如，将字符串转换成数组的形式，将字符串中的字符进行大小写转换等。

public class TestDemo {
    @Test
    public void test() {
        String str = "abcd";
        System.out.print("将字符串转为字符数组后的结果:");
        char[] charArray = str.toCharArray(); // 字符串转换为字符数组
        for (int i = 0; i < charArray.length; i++) {
            if (i != charArray.length - 1) {
                // 如果不是数组的最后一个元素,在元素后面加逗号
                System.out.print(charArray[i] + ",");
            } else {
                //如果不是数组的最后一个元素,则在元素后不加逗号
                System.out.println(charArray[i]);
            }
        }
        System.out.println("将int值转换为String类型之后的结果:" + String.valueOf(12));
        System.out.println("将字符串转换成大写之后的结果:" + str.toUpperCase());
        System.out.println("将字符串转换成小写之后的结果:" + str.toLowerCase());
    }
}

字符串的替换和去除空格操作案例

程序开发中，用户输入数据时经常会不小心输入错误的数据和空格，这时可以调用String类的replace()和trim()方法，进行字符串的替换和去除空格操作。trim()方法用于去除字符串两端的空格，不能去除中间的空格。若想去除字符串中间的空格，需要调用String类的replace()方法。

public class TestDemo {
    @Test
    public void test() {
        String s = "wfit";
        // 字符串替换操作
        System.out.println("将wf替换成wflg的结果:" + s.replace("wf", "wflg"));
        // 字符串去除空格操作
        String s1 = "  wf  it  ";
        System.out.println("去除字符串两端空格后的结果:" + s1.trim());
        System.out.println("去除字符串中所有空格后的结果:" + s1.replace(" ", ""));
    }
}

字符串判断案例

操作字符串时，经常需要对字符串进行一些判断，例如判断字符串是否以指定的字符串开始、结束，判断字符串是否包含指定的字符串，字符串是否为空等。

public class TestDemo {
    @Test
    public void test() {
        String s1 = "String"; // 定义一个字符串
        String s2 = "string";
        System.out.println("判断s1字符串对象是否以Str开头:" + s1.startsWith("Str"));
        System.out.println("判断是否以字符串ng结尾:" + s1.endsWith("ng"));
        System.out.println("判断是否包含字符串tri:" + s1.contains("tri"));
        System.out.println("判断字符串是否为空:" + s1.isEmpty());
        System.out.println("判断s1和s2内容是否相同:" + s1.equals(s2));
        System.out.println("忽略大小写的情况下判断s1和s2内容是否相同:" + s1.equalsIgnoreCase(s2));
        System.out.println("按对应字符的Unicode比较s1和s2的大小:" + s1.compareTo(s2));
    }
}

字符串的截取和分割操作案例

在操作字符串时，截取和分割也是经常要执行的操作，例如，截取一个文本某一段内容，使用特殊的符号将字符串分割为若干段。String类提供了substring()方法和split()方法实现字符串的截取和分割操作，substring()方法用于截取字符串的一部分，split()方法用于将字符串按照某个字符进行分割。

public class TestDemo {
    @Test
    public void test() {
        String str = "石家庄-武汉-哈尔滨";
        // 下面是字符串截取操作
        System.out.println("从第5个字符截取到末尾的结果：" + str.substring(4));
        System.out.println("从第5个字符截取到第6个字符的结果：" + str.substring(4, 6));
        // 下面是字符串分割操作
        System.out.print("分割后的字符串数组中的元素依次为:");
        String[] strArray = str.split("-"); // 将字符串转换为字符串数组
        for (int i = 0; i < strArray.length; i++) {
            if (i != strArray.length - 1) {
                // 如果不是数组的最后一个元素,在元素后面加逗号
                System.out.print(strArray[i] + ",");
            } else {
                System.out.println(strArray[i]);// 数组的最后一个元素后面不加逗号
            }
        }
    }
}

1.2. StringBuilder与StringBuffer

（1）StringBuffer

在Java中，因为String类是final类型的，所以使用String定义的字符串是一个常量，也就是说使用String定义的字符串一旦创建，其内容和长度是不可改变的。为了便于对字符串进行修改，Java提供了StringBuffer类（也称字符串缓冲区）来操作字符串。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的StringBuffer对象。

（2）StringBuffer类的常用方法

方法声明	功能描述
StringBuffer()	创建初始容量为16，不含任何内容的字符串缓冲区
StringBuffer(int capacity)	创建初始容量为capacity，不含任何内容的字符串缓冲区
StringBuffer(String s)	创建初始容量为s.length()+16，内容为s的字符串缓冲区
int length()	获取缓冲区中字符串内容的长度
StringBuffer append(char c)	添加参数到StringBuffer对象中
StringBuffer insert(int offset,String str)	在字符串的offset位置插入字符串str
StringBuffer deleteCharAt(int index)	移除此序列指定位置的字符
StringBuffer delete(int start,int end)	删除StringBuffer对象中指定范围的字符或字符串序列
StringBuffer replace(int start,int end,String s)	在StringBuffer对象中替换指定的字符或字符串序列
void setCharAt(int index, char ch)	修改指定位置index处的字符序列
StringBuffer reverse()	反转字符串
String substring(int start)	获取缓冲区中字符串从索引start（含）至末尾的子串
String substring(int start,int end)	获取缓冲区中字符串从索引start（含）至索引end（不含）的子串
String toString()	获取缓冲区中的字符串

（3）StringBuilder

除了StringBuffer类，还可以使用StringBuilder类修改字符串，StringBuffer类和StringBuilder类的对象都可以被多次修改，且不产生新的未使用对象。StringBuilder类与StringBuffer类的功能相似，且两个类中所提供的方法也基本相同。二者之间最大不同在于StringBuffer的方法是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑使用StringBuilder类。

（4）StringBuilder案例

public class TestString {
    @Test
    public void test(){
        StringBuilder str = new StringBuilder();
        // 拼接字符串
        str.append("我的姓名是张三");
        str.append("年龄20岁");
        System.out.println(str.toString());
        // 反转
        str.reverse();
        System.out.println(str.toString());
        // 长度
        System.out.println(str.length());
    }
}

2. System类

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，因此，可以使用System类直接引用类中的属性和方法。System类的常用方法如下所示。

方法名称	功能描述
static void exit(int status)	该方法用于终止当前正在运行的Java虚拟机，其中参数status表示状态码，若状态码非0 ，则表示异常终止
static void gc()	运行垃圾回收器，并对内存中的垃圾进行回收

在Java中，一个对象如果不再被任何栈内存所引用，该对象就称为垃圾对象。垃圾对象会占用内存空间，时间一长，垃圾对象越来越多，就会导致内存空间不足。针对这种情况，Java引入了垃圾回收机制。除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用System.gc()方法通知Java虚拟机立即进行垃圾回收。

3. Math类

Math类是一个工具类，类中包含许多用于进行科学计算的方法，如计算一个数的平方根、绝对值或获取一个随机数等。因为Math类构造方法的访问权限是private，所以无法创建Math类的对象。Math类中所有方法都是静态方法，可以直接通过类名调用Math类中的方法。除静态方法外，Math类中还定义了两个静态常量PI和E，分别代表数学中的π和e。

（1）Math类的常用方法

方法声明	功能描述
abs(double a)	用于计算a的绝对值
sqrt(double a)	用于计算a的方根
ceil(double a)	用于计算大于a的最小整数，并将该整数转化为double型数据。例如Math.ceil(15.2)的值是16.0
floor(double a)	用于计算小于a的最大整数，并将该整数转化为double型数据。例如Math.ceil(-15.2)的值是-16.0
round(double a)	用于计算小数a进行四舍五入后的值
max(double a,double b)	用于返回a和b的较大值
min(double a,double b)	用于返回a和b的较小值
random()	用于生成一个大于0.0小于1.0的随机值（包括0不包括1）
sin(double a)	返回a的正弦值
asin(double a)	返回a的反正弦值
pow(double a,double b)	用于计算a的b次幂，即ab的值

（2）Math类的案例

public class TestDemo {
    @Test
    public void test() {
        System.out.println("计算-10的绝对值: " + Math.abs(-10));
        System.out.println("求大于5.6的最小整数: " + Math.ceil(5.6));
        System.out.println("求小于-4.2的最大整数: " + Math.floor(-4.2));
        System.out.println("对-4.6进行四舍五入: " + Math.round(-4.6));
        System.out.println("求2.1和-2.1中的较大值: " + Math.max(2.1, -2.1));
        System.out.println("求2.1和-2.1中的较小值: " + Math.min(2.1, -2.1));
        System.out.println("生成一个大于等于0.0小于1.0随机值: " +Math.random());
        System.out.println("计算1.57的正弦结果: "+Math.sin(1.57));
        System.out.println("计算4的开平方的结果: "+Math.sqrt(4));
    }
}

4. Ramdom类

Random类可以产生指定取值范围的随机数字。

（1）Random类构造方法

Random类提供了两个构造方法，如下表所示。

方法声明	功能描述
Random()	使用当前机器时间创建一个Random对象
Random(long seed)	使用参数seed指定的种子创建一个Random对象

使用无参构造方法来产生随机数

public class TestDemo {
    @Test
    public void test() {
        Random random = new Random(); 
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.println(random.nextInt(100));
        }
    }
}

使用有参构造方法产生随机数

当创建Random类对象时，如果指定了相同的种子，则每个对象产生的随机数序列相同。

public class TestDemo {
    @Test
    public void test() {
        Random r = new Random(1);   // 创建对象时传入种子
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.println(r.nextInt(100));
        }
    }
}

（2）Random类常用方法

Random类提供了更多的方法来生成随机数，不仅可以生成整数类型的随机数，还可以生成浮点类型的随机数。Random类的常用方法，如下表所示。

方法声明	功能描述
boolean nextBoolean()	随机生成boolean类型的随机数
double nextDouble()	随机生成double类型的随机数
float nextFloat()	随机生成float类型的随机数
long nextLong()	随机生成long类型的随机数
int nextInt()	随机生成int类型的随机数
int nextInt(int n)	随机生成[0~n)之间int类型的随机数

（3）Random案例

public class TestDemo {
    @Test
    public void test() {
        Random r = new Random(); // 创建Random实例对象
        System.out.println("生成boolean类型的随机数: " + r.nextBoolean());
        System.out.println("生成float类型的随机数: " + r.nextFloat());
        System.out.println("生成double类型的随机数:" + r.nextDouble());
        System.out.println("生成int类型的随机数:" + r.nextInt());
        System.out.println("生成0~100之间int类型的随机数:" +r.nextInt(100));
        System.out.println("生成long类型的随机数:" + r.nextLong());
    }
}

5. 日期和时间类

5.1. LocalDate

LocalDate类表示不带时区的日期，它所表示的日期包括年份和月份两部分。LocalDate类不能代表时间线上的即时信息，只是描述日期。LocalDate类提供了两个获取日期对象的方法now()和of(int year, int month, int dayOfMonth)，具体如下所示。

//按指定日期创建LocalDate对象
LocalDate date = LocalDate.of(2020, 12, 12);
//从默认时区的系统时钟获取当前日期
LocalDate now1 = LocalDate.now();

当前日期案例

public class TestDate {
    @Test
    public void test(){
        LocalDate now = LocalDate.now();
        String str = now.getYear() + "年" + now.getMonth().getValue() + "月" + now.getDayOfMonth() + "日";
        System.out.println(str);
    }
}

固定日期案例

public class TestDate {
    @Test
    public void test(){
        LocalDate now = LocalDate.of(2022,5,10);
        String str = now.getYear() + "年" + now.getMonth().getValue() + "月" + now.getDayOfMonth() + "日";
        System.out.println(str);
    }
}

字符串日期案例

public class TestDate {
    @Test
    public void test(){
        String dateStr = "2021-05-10";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate date = LocalDate.parse(dateStr,formatter);
        System.out.println(date);
    }
}

5.2. LocalTime

LocalTime类用来表示时间，通常表示的是小时分钟秒。

当前时间案例

public class TestTime {
    @Test
    public void test(){
        LocalTime now = LocalTime.now();
        String str = "当前时间:" + now.getHour() + ":" + now.getMinute() + ":" + now.getSecond();
        System.out.println(str);
    }
}

固定时间案例

public class TestTime {
    @Test
    public void test(){
        LocalTime now = LocalTime.of(12,20,59);
        String str = "当前时间:" + now.getHour() + ":" + now.getMinute() + ":" + now.getSecond();
        System.out.println(str);
    }
}

字符串时间案例

public class TestTime {
    @Test
    public void test(){
        String timeStr = "13:20:59";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        LocalTime time = LocalTime.parse(timeStr,formatter);
        System.out.println(time);
    }
}

5.3. LocalDateTime

LocalDateTime类是LocalDate类与LocalTime类的综合，它既包含日期也包含时间。

当前日期时间案例

public class TestDateTime {
    @Test
    public void test(){
        LocalDateTime dateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(dateTime.format(formatter));
    }
}

字符串日期时间案例

public class TestTime {
    @Test
    public void test(){
        String timeStr = "2022-05-01 13:20:59";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse(timeStr,formatter);
        System.out.println(dateTime.format(formatter));
    }
}

6. 基本类型包装类

Java程序设计提倡一种思想，即万物皆对象。这样就出现一个矛盾，因为Java中的数据类型分为基本数据类型和引用数据类型，很多类的方法都需要接收引用类型的对象，此时就无法将一个基本数据类型的值传入。为了解决这样的问题，就需要将基本数据类型值进行包装，即将基本数据类型值包装为引用数据类型的对象。能够将基本数据类型值包装为引用数据类型对象的类，称为包装类。JDK提供了一系列包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。

Java提供8个基本数据类型包装类（wrapper class），通过这些类，可以将基本类型的数据包装成对象。

基本类型	对应的包装类	基本类型	对应的包装类
boolean	Boolean	int	Integer
char	Character	long	Long
byte	Byte	float	Float
short	Short	double	Double

（1）自动装箱

自动装箱（autoboxing）是指基本类型的数据可以自动转换为包装类的实例。

（2）自动拆箱

自动拆箱（unboxing）是指包装类的实例自动转换为基本类型的数据。

（3）自动拆装箱案例

public class TestDemo {
    @Test
    public void test() {
        Integer num = Integer.valueOf(10);     //手动装箱
        int sum = num.intValue() + 10;           //手动拆箱
        System.out.println(num);
        System.out.println(sum);
    }
}

7. Lambda表达式

Lambda表达式是JDK 8之后新增的一个新特性，Lambda可以取代大部分的匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

（1）Lambda格式

Lambda表达式由参数列表、箭头符号 -> 和方法体组成。方法体既可以是一个表达式，也可以是一个语句块，一般格式如下。

(参数1, 参数2, ...) -> 表达式
(参数1, 参数2, ...) -> { /* 代码块 */ }

（2）Lambda表达式案例

public class TestDemo {

    @Test
    public void test(){
        List<String> list = new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        //for循环遍历
        for(int i=0;i<list.size();i++){
            String course = list.get(i);
            System.out.println(course);
        }
        //增强的for循环
        for (String course: list) {
            System.out.println(course);
        }
        //lambda表达式
        list.forEach(course -> System.out.println(course));
    }

}