Java中常用的Object java中常用的api

常用API

• 1 API概述
• 2 Scanner类
• 3 Random类
• 4 String类

• 4.1 String类概述
• 4.2 String类的构造方法
• 4.3 创建字符串对象的区别（常见面试题）
• 4.4 String类的常用方法

• 5 StringBuilder类

• 5.1 StringBuilder类概述
• 5.2 StringBuilder类的构造方法
• 5.3 StringBuilder的常用方法

• 6 Optional类

• 6.1 获取对象
• 6.2 常用方法
• 6.3 处理空指针的方法

1 API概述

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

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

API的使用步骤：

1. 导包

import 包名.类名;

注意：

• 只有 java.lang 包下的内容不需要导包，其他的包都需要 import 语句

2. 创建对象

使用该类的构造方法，创建一个该类的对象。 格式：

数据类型 变量名 = new 数据类型(参数列表);

3. 调用方法

调用该类的成员方法，完成指定功能。 格式：

变量名.方法名();

2 Scanner类

Scanner类是一个可以解析基本类型和字符串的简单文本扫描器。

public static void main(String[] args) {
        // 创建Scanner对象
        Scanner sc  = new Scanner(System.in);

        // 调用方法
        System.out.println("请输入字符串1：");
        String s1 = sc.nextLine();
        System.out.println(s1);

        System.out.println("请输入字符串2：");
        String s2 = sc.next();
        System.out.println(s2);

        System.out.println("请输入整数：");
        int i = sc.nextInt();
        System.out.println(i);
    }

注意：

• System.in系统输入指的是通过键盘录入数据。
• 获取键盘输入的一个int数字：int num = sc.nextInt();
• 获取键盘输入的一个字符串：

• String str = sc.next();，遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键
• String str = sc.nextLine();，可以将数据完整的接收过来 , 结束标记: 回车换行符

• nextInt和nextLine方法都是以回车为结束符，二者配合使用的时候, nextLine方法就没有键盘录入的机会了。

• 建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接收字符串，或者将 nextLine方法放在前面

3 Random类

此类的实例用于生成伪随机数

Random r = new Random(); 
int i = r.nextInt();

注意：

• 产生1-10之间的随机数：int i = sc.nextInt(10)+1;
• 获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
• 获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)，实际上代表的含义是：[0,3)，也就是0~2

案例：猜数字

需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？当猜错的时候根据不同情况给出相应的提示

• 如果猜的数字比真实数字大，提示你猜的数据大了
• 如果猜的数字比真实数字小，提示你猜的数据小了
• 如果猜的数字与真实数字相等，提示恭喜你猜中了

import java.util.Scanner;
import java.util.Random;

public class Test {
	public static void main(String[] args){
		// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
		Random r = new Random();
		Scanner sc = new Scanner(System.in);
		// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
		int randomNum = r.nextInt(100) + 1;
		
		// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
		while(true){
			// 3. 键盘录入用户猜的的数据
			System.out.println("请输入您猜的数据:");
			int num = sc.nextInt();
			// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
			if(num > randomNum){
				System.out.println("猜大了");
			}else if(num < randomNum){
				System.out.println("猜小了");
			}else{
				// 6. 猜对之后, break结束.
				System.out.println("恭喜,猜中了");
				break; // 加了break，死循环后的语句可能可以执行到
			}
		}
		
		System.out.println("感谢您的使用"); // 死循环中，不加break该语句会报错
	}
}

4 String类

4.1 String类概述

java.lang.String类代表字符串。

API当中说：Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）

字符串的特点：

• Java程序当中所有的双引号字符串，都是String类的对象
• 字符串是常量，它们的值在创建后不可以被更改
• 正是因为字符串不可改变，所以字符串是可以 共享 使用的（字符串常量池）
• 字符串效果上相当于是char[]字符数组，但是底层原理是被final 修饰的 byte[]字节数组

对于“ 字符串是常量，它们的值在创建后不可以被更改”的疑问？

• String对象是不可改变的，修改字符串的值实际上是在重新创建实例并赋值。

public static void main(String[] args) {
        String str = "微微"; //“微微”这是一个字符串对象
        System.out.println(str);
		
		// 这一步是让str这个字符串类型的变量，记录了一个新的对象
        str = "啦啦啦"; // “啦啦啦”这又是一个新的字符串对象
        System.out.println(str);
    }

4.2 String类的构造方法

创建字符串的对象（创建对象的过程就是调用构造方法）

public static void main(String[] args) {
    // 使用空参构造
    String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
    System.out.println("第1个字符串：" + str1);

    // 根据字符数组创建字符串
    char[] charArray = { 'A', 'B', 'C' };
    String str2 = new String(charArray);
    System.out.println("第2个字符串：" + str2);

    // 根据字节数组创建字符串
    byte[] byteArray = { 97, 98, 99 };
    String str3 = new String(byteArray);
    System.out.println("第3个字符串：" + str3);

    // 直接创建
    String str4 = "Hello";
    System.out.println("第4个字符串：" + str4);
}

注意：

• String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址，而是该对象所记录的真实内容

4.3 创建字符串对象的区别（常见面试题）

问题：构造方法可以创建对象，双引号也可以创建字符串对象，二者有什么区别？

注意：== 号作比较

• 对于基本类型来说，== 是进行【数值】的比较。
• 对于引用类型来说，== 是进行【地址值】的比较。

1. 双引号创建字符串对象

以""方式直接给出字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会创建一个String对象并在 字符串常量池 中维护，字符串常量池从JDK7开始，从方法区挪到了堆内存中。

当使用双引号创建字符串对象的时候，系统会检查该字符串是否在字符串常量池中存在：

• 不存在：创建
• 存在：不会重新创建，而是直接复用

public static void main(String[] args) {
        String s1 = "abc"; // 字符串常量池里面没有，创建
        String s2 = "abc"; // 字符串常量池里面存在，直接复用
        // s1和s2指向了同一块内存地址
        System.out.println(s1 == s2); // true
}

2. 通过构造方法创建字符串对象，在 堆内存 中存储，每一次 new 都会申请新的内存空间，虽然内容相同，但是地址不同

public static void main(String[] args) {
        char[] charArray = {'a', 'b', 'c'};
        String s1 = new String(charArray);
		String s2 = new String(charArray);
		System.out.println(s1 == s2); // false
}

结论：

• 双引号创建的字符串对象，在字符串常量池中存储，而通过构造方法创建的字符串对象，在堆内存中存储。

3. 其他情况

（1）

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 == s2); // false
    }

s1 的内存地址在常量池中，s2 的内存地址在堆内存中，二者地址指向不一样。

注意：

• String s2 = new String("abc");，实际上是创建了两个对象（一个是new创建的，一个是双引号创建的），比较浪费内存

（2）

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ab";
        String s3 = s2+"c"; // 一个变量与字符串拼接
        System.out.println(s1==s3); // false
    }

当字符串之间使用 + 号拼接时，系统底层会在堆内存自动创建一个StringBuilder 对象，然后再调用其 append方法完成拼接，最后再调用 toString 方法转为 String 类型。

（3）

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "a"+"b"+"c"; // 字符串常量拼接 
        System.out.println(s1 == s2); // true
    }

Java存在常量优化机制，在编译的时候，就会将 “a”+“b”+“c” 拼接为 “abc”

4.4 String类的常用方法

1. 判断功能的方法

== 是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

• public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
• public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABC";
        String s3 = "abc";

        // equals : 比较字符串内容, 区分大小写
        System.out.println(s1.equals(s2)); // false
        System.out.println(s1.equals(s3)); // true

        // equalsIgnoreCase : 比较字符串内容, 忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); // true
    }

注意：

• equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
• 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

• 推荐："abc".equals(str)
• 不推荐：str.equals("abc")

案例：用户登录

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示。

public class Test1 {
    /*
        思路：
        1. 已知用户名和密码，定义两个字符串表示即可
        2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            字符串的内容比较，用equals() 方法实现
        4. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环

     */
    public static void main(String[] args) {
        // 1. 已知用户名和密码，定义两个字符串表示即可
        String username = "admin";
        String password = "123456";
        // 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        // 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
        for(int i = 1; i <= 3; i++){
            System.out.println("请输入用户名:");
            String scUsername = sc.nextLine();
            System.out.println("请输入密码:");
            String scPassword = sc.nextLine();
            // 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            if(username.equals(scUsername) && password.equals(scPassword)){
                System.out.println("登录成功");
                break;
            }else{
                if(i == 3){
                    System.out.println("您的登录次数已达到今日上限, 请明天再来");
                }else{
                    System.out.println("登录失败,您还剩余" + (3-i) +"次机会");
                }

            }
        }

    }
}

2. 转换功能的方法

• public char[] toCharArray () ：将此字符串转换为新的字符数组。
• public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
• public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。（CharSequence意思就是说可以接受字符串类型）

public class Demo {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        System.out.println("==============");

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==============");

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
        System.out.println("==============");
    }
}

案例一：统计字符个数

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numCount = 0;
        // 3. 遍历字符串，得到每一个字符
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            // 4. 判断该字符属于哪种类型，然后对应类型的统计变量+1
            if (c >= 'A' && c <= 'Z') {
                bigCount++;
            } else if (c >= 'a' && c <= 'z') {
                smallCount++;
            } else if (c >= '0' && c <= '9') {
                numCount++;
            }
        }

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

案例二：字符串替换

键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 替换敏感词
        String result = s.replace("TMD","***");
        // 3. 输出结果
        System.out.println(result);
    }

3. 获取功能的方法

• public int length () ：返回此字符串的长度。
• public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
• public char charAt (int index) ：返回指定索引处的 char值。
• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
• public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
• public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。截取完成后要找一个新的遍历接收，因为字符串不可变。

注意：

• 数组的长度：数组名.length
• 字符串的长度：字符串对象.length()

（1）案例一：遍历字符串

第一种方法

public static void main(String[] args) {
    //  1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入:");
    String s = sc.nextLine();
    // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
    for(int i = 0; i < s.length(); i++){
        // i : 字符串的每一个索引
        char c = s.charAt(i);
        System.out.println(c);
    }
}

第二种方法

public static void main(String[] args) {
    //  1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入:");
    String s = sc.nextLine();
    // 2. 将字符串拆分成字符数组
    char[] chars = s.toCharArray()
    for(int i = 0; i < chars.length; i++){
        // 3. 遍历字符数组
        System.out.println(chars[i]);
    }
}

（2）案例二：字符串截取

以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽，最终效果为：156****1234

public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String telString = sc.nextLine();
        // 2. 截取字符串前三位
        String start = telString.substring(0,3);
        // 3. 截取字符串后四位
        String end = telString.substring(7);
        // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
        System.out.println(start + "****" + end);
    }

4. 分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

注意： split 方法的参数其实是一个正则表达式，如果按照英文句点 “.” 进行切分，必须写"\\."（两个反斜杠）

案例：切割字符串

以字符串的形式从键盘录入学生信息，例如：“张三 , 23”，从该字符串中切割出有效数据，封装为Student学生对象

Student类

public class Student {
    private String name;
    private String age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

TestStudent类

import java.util.Scanner;

public class TestStudent {
    public static void main(String[] args) {
        // 2. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息:");
        String stuInfo = sc.nextLine();
        // stuInfo = "张三,23";
        // 3. 根据逗号切割字符串，得到（张三）（23）
        String[] sArr = stuInfo.split(",");

        // System.out.println(sArr[0]);
        // System.out.println(sArr[1]);

        // 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        Student stu = new Student(sArr[0],sArr[1]);

        // 5. 调用对象getXxx方法，取出数据并打印。
        System.out.println(stu.getName() + "..." + stu.getAge());
    }
}

5 StringBuilder类

5.1 StringBuilder类概述

StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

作用：提高字符串的操作效率

例子：分别使用StringBuilder和String将1到100000的数字进行拼接

public class demo1 {

    public static void main(String[] args) {

        stringBuilderMethod();
        stringMethod();
    }

    private static void stringBuilderMethod() {
        long start = System.currentTimeMillis();

        StringBuilder sb = new StringBuilder();
        for(int i = 1; i <= 100000; i++){
            sb.append(i);
        }
//        System.out.println(sb);

        long end = System.currentTimeMillis();
        System.out.println("StringBuilder耗时："+(end - start));
    }

    private static void stringMethod() {
        // 获取1970年1月1日 0时0分0秒 到当前时间所经历过的毫秒值
        long start = System.currentTimeMillis();

        String s = "";
        for(int i = 1; i <= 100000; i++){
            s += i;
        }
//        System.out.println(s);

        long end = System.currentTimeMillis();
        System.out.println("String耗时："+(end - start));
    }
}

结果输出：

StringBuilder耗时：11
String耗时：15453

由此可见，StringBuilder的效率比String高出很多

StringBuilder提高效率原理图

String的拼接

对于String来说，有1个“+”，堆内存中就会有2个对象（StringBuilder对象和String对象）

StringBuilder的拼接

无论进行多少次拼接，堆内存中始终只有一个StringBuilder对象

5.2 StringBuilder类的构造方法

• public StringBuilder() ：构造一个空的StringBuilder容器。
• public StringBuilder(String str) ：构造一个StringBuilder容器，并将字符串添加进去。

public class Demo {
    public static void main(String[] args) {
        //空参数构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println(bu1);// 

        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println(bu2);// abc
    }
}

注意：

• 同String类一样，StringBuilder类打印对象名时不是内存地址，而是具体的内容

5.3 StringBuilder的常用方法

1. public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        // 方法一

//        sb.append("红色");
//        System.out.println(sb); // 红色
//        sb.append("蓝色");
//        System.out.println(sb); // 红色蓝色
//        sb.append("绿色");
//        System.out.println(sb); // 红色蓝色绿色

         // 方法二

//        StringBuilder sb2 = sb.append("红色");
//        StringBuilder sb3 = sb2.append("蓝色");
//        sb3.append("绿色");
//        System.out.println(sb3); // 红色蓝色绿色
//
//        System.out.println(sb==sb2); // true
//        System.out.println(sb2==sb2); // true

        // 方法三
        // 链式编程: 如果一个方法返回的是对象类型, 对象就可以继续向下调用方法.
        sb.append("红色").append("蓝色").append("绿色");
        System.out.println(sb); // 红色蓝色绿色
    }

案例：字符串拼接

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回调用该方法，并在控制台输出结果。

例如，数组为int[] arr = {1,2,3};，执行方法后的输出结果为：[1, 2, 3]

public class Test {
    public static void main(String[] args) {
        // 1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};
        // 4. 调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        // 5. 输出结果
        System.out.println(s); // [1,2,3]
    }

    // 2. 定义一个方法，返回值类型 String，参数列表 int[] arr
    public static String arrayToString(int[] arr){
        // 3. 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder("[");

        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length -1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(", ");
            }
        }
        return sb.toString();
    }
}

2. public StringBuilder reverse()：返回相反的字符序列

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("我是微微啊");
        System.out.println("反转前："+sb); // 反转前：我是微微啊
        sb.reverse();
        System.out.println("反转后："+sb); // 反转后：啊微微是我
    }

3. public String length()：返回长度（字符个数）

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("我是微微啊");
        System.out.println("sb中字符的个数"+sb.length()); // sb中字符的个数5
    }

4. public String toString() ：将当前StringBuilder对象转换为String对象。

StringBuilder和String可以相互转换:

• String —> StringBuilder:可以使用StringBuilder的构造方法

• StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

• StringBuilder —> String:可以使用StringBuilder中的toString方法

• public String toString()：将当前StringBuilder对象转换为String对象。

public static void main(String[] args) {
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);// str:hello
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);// str:helloworld

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);// s:helloworld
    }

案例：判断对称字符串

public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对称字符串:");
        String s = sc.nextLine();
        // 2. 将键盘录入的字符串反转
        // 将字符串封装为StringBuilder对象, 目的是为了掉用其反转的方法
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String reverseStr = sb.toString();
        // s : String
        // sb : StringBuilder
        // 3. 使用反转后的字符串，和原字符串进行比对
        if(s.equals(reverseStr)){
            System.out.println("是对称字符串");
        }else{
            System.out.println("不是对称字符串");
        }
    }

6 Optional类

可能包含或不包含非 null 值的容器对象

6.1 获取对象

已存在 Student 类

import java.util.Optional;

public class demo {
    public static void main(String[] args) {
        method1();
        method2();

    }

    private static void method2() {
        //public static <T> Optional<T> ofNullable(T value)
        //获取一个Optional对象，Optional封装的值对象可以是null也可以不是null
        //Student s = new Student("zhangsan",23);
        Student s = null;
        //ofNullable方法，封装的对象可以是null，也可以不是null。
        Optional<Student> optional = Optional.ofNullable(s);

        System.out.println(optional);//Optional.empty
    }

    private static void method1() {
        //static <T> Optional<T> of(T value)    获取一个Optional对象，封装的是非null值的对象

        Student s = new Student("zhangsan",23);
//        Student s = null;
        //Optional可以看做是一个容器，里面装了一个引用数据类型的对象。
        //返回值就是Optional的对象
        //如果使用of方法，封装的对象如果为空，那么还是会抛出空指针异常
        Optional<Student> optional1 = Optional.of(s);
        System.out.println(optional1);//Optional[Student{name='zhangsan', age=23}]
    }
}

6.2 常用方法

import java.util.Optional;

public class demo {
    public static void main(String[] args) {
        //get() 如果存在值，返回值，否则抛出NoSuchElementException
        //public boolean isPresent()    判断Optional所封装的对象是否不为空，如果不为空返回true , 否则返回false

        Student s = new Student("zhangsan",23);
//        Student s = null;
        Optional<Student> optional = Optional.ofNullable(s);
        //如果封装的是一个null，那么通过get方法再次获取会抛出NoSuchElementException。
        if(optional.isPresent()){
            Student student = optional.get();
            System.out.println(student);//Student{name='zhangsan', age=23}
        }else{
            System.out.println("Optional封装的对象为空");
        }
    }
}

6.3 处理空指针的方法

import java.util.Optional;

public class demo {
    public static void main(String[] args) {
        method1();
        method2();
        method3();
        method4();

    }

    private static void method4() {
//        Student s = new Student("zhangsan",23);
        Student s = null;
        Optional<Student> optional = Optional.ofNullable(s);
        //public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)、
        //如果不为空，则使用该值执行给定的操作，否则执行给定的基于空的操作。
        optional.ifPresentOrElse(student -> System.out.println(student),
                ()->System.out.println("为空了"));
    }

    private static void method3() {
        //Student s = new Student("zhangsan",23);
        Student s = null;
        Optional<Student> optional = Optional.ofNullable(s);
        //ifPresent (Consumer<? super T> action)
        //如果不为空，则使用该值执行给定的操作，否则不执行任何操作
        optional.ifPresent(student -> System.out.println(student));
    }

    private static void method2() {
//        Student s = new Student("zhangsan",23);
        Student s = null;
        Optional<Student> optional = Optional.ofNullable(s);
        //orElseGet(Supplier<? extends T> supplier)
        //如果不为空，则返回具体的值，否则返回由括号中函数产生的结果

        Student student = optional.orElseGet(()-> new Student("lisi" , 24));
        System.out.println(student);
    }

    private static void method1() {
//        Student s = new Student("zhangsan",23);
        Student s = null;
        Optional<Student> optional = Optional.ofNullable(s);
        //orElse(T other) 如果不为空，则返回具体的值，否则返回参数中的值
        Student student = optional.orElse(new Student("lisi", 24));
        System.out.println(student);
    }
}