初识JAVA12:lambda表达式、异常、String类

lambda表达式

Lambda 表达式 -> jdk8新增

​ 作用:就是为了简化匿名内部类结构

​ 前提:函数式接口

​ 函数式接口:只存在一个必须被重写的抽象方法的接口

​ 检查一个接口是否为函数式接口:@FunctionalInterface

​ 结构:

​ ()->{}

​ () :重写的抽象方法的参数列表

​ {}:重写的抽象方法的方法体

​ ->:lambda符合,箭头符号,具有上下文推导的作用

异常

程序出现了问题

程序一旦遇到异常,后面代码无法正常执行,并且同时控制台中展示异常的详细信息|细节问题,便于程序猿的调试

异常体系:
Throwable
/
Error Exception

Error : 一般指由虚拟机生成并脱出的,无需程序猿解决处理

Exception : 异常 异常如果不处理,程序无法正常执行,需要程序猿在代码层面上处理异常

​ RuntimeException 运行时异常 : 运行期间才会发生的异常

​ CheckedException 编译时异常|检查时异常 : 编译期间发生的异常,不处理程序无法运行

重点学习关注异常处理方案:

​ 所有的异常都可以通过标准异常处理方案来处理

​ 运行时异常一般通过增强程序健壮性的代码就可以解决 -> if判断

​ 编译时异常只能通过异常处理方案来处理

异常处理方案:
1.异常抛出 throws
把异常抛出到上一层,谁调用谁处理
2.异常捕获
异常对象当前抓住捕获,直接处理

     try {
        可能会出现异常的代码;
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (NullPointerException e) {
        e.printStackTrace();
    } catch (Exception e) {  --> 接盘侠
        System.out.println("出现了异常, 捕获异常...");
        e.printStackTrace();
    } finally{
         System.out.println("无论如何都会执行的语句,即使try中代码存在return语句,finally中的语句也会执行");
     }

​ 注意:
​ 1.异常一旦处理,不影响程序的继续执行

​ 2.try中代码可能出现异常,可能不会出现异常,

​ 如果没有出现异常,try{}中的代码执行完毕,try…catch结束

​ try中代码一旦异常,try后面的代码不会执行,直接执行catch的判断

​ 从上到下一次判断,判断当前的catch是否能够捕获出现的异常对象,如果能,执行后面的{}中的代码,

​ 如果不能匹配,继续向下判断,如果所有的都不鞥匹配,当前的异常对象没有处理,中止程序的执行

​ 3.一个try后面可以跟1~n个catch

​ 4.如果一个异常已经通过catch处理不影响后面代码的执行

​ 5.接收范围较大的异常的catch,需要定义在后面

​ 6.finally 最终的

​ 无论try中是否会出现异常,finally中的代码肯定最后会执行

​ 一般会定义一些资源的关闭等代码

自定义异常

​ 异常类也是类

​ 需要直接或者间接的继承自Exception

​ 如果是运行时期异常必须直接或者间接的继承RuntimeException

​ 制造异常: throw

package com.xxx.learn.exceptionlearn;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class ExceptionLearn {
    public static void main(String[] args) {
        User1 user1 = new User1();
        try{
            user.setAge(1);
        }catch (AgeException e){
            e.printStackTrace();
        }finally {
            System.out.println("我是finally");
        }

        try {
            user.setId(0);
        } catch (IdException e) {
            e.printStackTrace();
        }
        System.out.println(user);
        System.out.println("main方法执行完毕");

    }
}


class User{
    private int age;
    private int id;

    public User1() {
    }

    public int getAge() {
        return age;
    }
    //设置年龄需要满足18-60岁,不在范围内的赋值的话,需要抛出异常
    public void setAge(int age) throws AgeException{
        if(age>=18 && age<=60){
            this.age = age;
        }else{
            this.age = 18;
            throw new AgeException(age+"->年龄赋值不合法!将设置为默认值18岁");
        }

    }

    public int getId() {
        return id;
    }

    public void setId(int id) throws IdException{
        if(id<1){
            this.id = 1;
            throw new IdException(id+"->id的值小于1不合法!将设置为默认值1");
        }else{
            this.id = id;
        }
    }

    @Override
    public String toString() {
        return "User1{" +
                "age=" + age +
                ", id=" + id +
                '}';
    }
}

//自定义运行时异常处理
class AgeException extends RuntimeException{
    public AgeException(){}

    public AgeException(String message){
        super(message);
    }
}

//自定义编译时异常处理
class IdException extends Exception{
    public IdException(){}

    public IdException(String message){
        super(message);
    }
}

常用类

常用类 : 经常使用的类

字符串String

​ 不可变长字符序列

​ String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。

​ “abc” 字符串常量 --> 字符串常量池中-> 方法区 new String() --> 堆中

学习API类型:

​ 了解类的作用与特点

​ 学习构造器

​ 学习方法

​ 成员

​ 非静态

​ 静态的

​ 底层分析:

​ jdk11 ->使用字节数组存储字符串数据 private final byte[ ] value;

​ jdk8 -> 使用字符数组存储字符串数据 private final char[ ] value;

public class Demo {
    public static void main(String[] args) {
        //str引用
        String str = "abc";  //有1个对象  "abc"->字符串常量池中
        String str2 = new String("haha");  //有2个 new->堆中  "haha"->常量池中
        String str3 = new String("abc");  //有1个  new->堆中  "abc"
		//在java中当多个字符串进行拼接的时候,内部会先构建StringBuilder对象,做追加,最终返回一个String对象
        String str4 = "a"+"b"+"c"+"d";  //"abcd" -> 常量池中,此过程中只会创建一个对象
        int i = 3*4+5;
        System.out.println(i);
        System.out.println(str4);
    }
}

String类常用方法

package com.xxx.demo;


import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //不同的String类型变量引用同一个字面常量时,可以使用==比较是否相等
        String str1 = "字面常量1";
        String str2 = "字面常量1";
        System.out.println(str1 == str2);//true

        //不同的String类型变量引用new的对象时,==比较的时对象的地址,比较内容需要使用equalS方法
        //String类中重写了equals方法
        //构造器
        String str3 = new String("字面常量2");
        String str4 = new String("字面常量2");
        System.out.println(str3 == str4);//false
        //String() 初始化新创建的 String对象，使其表示空字符序列。
        String str5 = new String();
        System.out.println(str5.equals(""));//true

        //String(char[] value),将字符数组通过构造方法转换为字符串
        char[] ch = {'c','y','d','z','m'};
        String str6 = new String(ch);
        System.out.println(str6);

        //String(char[] value, int offset, int count),将字符数组指定个数的内容通过构造方法转换字符串
        //int offset起始位置,int count包含起始位置后n个
        String str7 = new String(ch,1,3);
        System.out.println(str7);//ydz

        //String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组构造新的 String 
        //utf-8->一个汉字使用三个字节表示
        byte[] arr1 = "中国".getBytes();
        System.out.println(arr1.length);
        System.out.println(Arrays.toString(arr1));
        //gbk->一个汉字使用两个字节表示
        //指定格式需要try{}cash{}解决异常或者throws抛出异常
        byte[] arr2 = "中国".getBytes("GBK");
        System.out.println(arr2.length);
        System.out.println(Arrays.toString(arr2));
        //转换的过程保证字符编码格式一致统一就不会出现乱码
        //String(byte[] bytes, String charsetName)
        String str8 = new String(arr1);
        System.out.println(str8);
        String str9 = new String(arr2,"GBK");
        System.out.println(str9);
        //格式不对会乱码,arr1是以utf-8标准转换的来的
        String str10 = new String(arr1,"GBK");
        System.out.println(str10);

        //String(byte[] bytes, int offset, int length)
        String str11 = new String(arr1,3,3);
        System.out.println(str11);

        //String(byte[] bytes, int offset, int length, String charsetName)
        //把字节数组arr中从索引为2的位置开始,拿2个字节数据转为字符串,使用执行"GBK"字符编码格式
        String str12 = new String(arr2,2,2,"GBK");
        System.out.println(str12);

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

        String str13 = "abcdefghijklmnopqrstuvwxyz";
        String str14 = "aBcdefghijklmnopqrstuvwxyZ";

        //char charAt(int index) 返回指定索引处的char值。
        System.out.println(str13.charAt(25));//返回字符串中第26个字符
        //int codePointAt(int index) 返回指定索引处的字符（Unicode代码点）
        System.out.println(str13.codePointAt(25));//返回字符串中第26个字符的ASCII

        //int compareTo(String anotherString) 按字典顺序比较两个字符串。
        System.out.println(str13.compareTo(str14));//返回str13和str14两个字符串中第一个不相同的字符相差的ASCII码,如果相等返回0,str13大于str14返回正数
        System.out.println(str13.compareTo(str13));//0

        //int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写差异。
        System.out.println(str13.compareToIgnoreCase(str14));//忽略大小写,所以相等,返回0

        //String concat(String str) 将指定的字符串连接到此字符串的末尾。
        System.out.println(str13.concat(str14));//abcdefghijklmnopqrstuvwxyzaBcdefghijklmnopqrstuvwxyZ

        //boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列(字符串)时，才返回true
        System.out.println(str13.contains("abc"));//true

        //boolean equals(Object anObject) 将此字符串与指定的对象进行比较。
        System.out.println(str13.equals(str14));//false

        //boolean equalsIgnoreCase(String anotherString) 将此 String与另一个 String比较，忽略了大小写
        System.out.println(str13.equalsIgnoreCase(str14));//true

        //boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。
        System.out.println(str13.endsWith("xyz"));

        //static String copyValueOf(char[] data) 相当于 valueOf(char[])返回字符串
        char[] ch2 = new char[]{'a','b','c','d'};
        System.out.println(String.copyValueOf(ch2));
        //从指定索引位置开始copy,copy n个
        System.out.println(String.copyValueOf(ch2,2,2));

        //void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将此字符串中的字符复制到目标字符数组中
        //srcBegin:对字符串copy开始位置,srcEnd对字符串copy结束的位置(不包含结束位置),dst:存储copy内容的字符串,dstBegin:从指定索引位置开始存储
        char[] ch3 = new char[10];
        str13.getChars(2,5,ch3,2);
        System.out.println(Arrays.toString(ch3));

        //int indexOf(String str) 返回指定子字符串第一次出现的字符串中的索引,找不到返回-1
        System.out.println(str13.indexOf("efg"));

        //int indexOf(String str, int fromIndex) 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引,找不到返回-1
        System.out.println(str13.indexOf("efg",10));

        //int lastIndexOf(int ch) 返回指定字符最后一次出现的字符串中的索引
        System.out.println(str13.concat(str14).lastIndexOf('a'));//26
        //int lastIndexOf(int ch, int fromIndex) 返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索
        System.out.println(str13.concat(str14).lastIndexOf('a',20));//0
        System.out.println(str13.lastIndexOf("efg"));

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

        String str15 = new String("abcdefghijklmnopqrstuvwxyz");
        //String intern() 返回字符串对象的规范表示。

        System.out.println(str13.intern() == str15.intern());//true


        //boolean isBlank() 如果字符串为空或仅包含 white space代码点，则返回 true ，否则 false 
        System.out.println(str1.isBlank());//false
        System.out.println("".isBlank());//true
        System.out.println(" ".isBlank());//true
        System.out.println("    ".isBlank());//true

        //boolean isEmpty() length == 0时返回true
        System.out.println(str1.isEmpty());//false
        System.out.println("".isEmpty());//true
        System.out.println(" ".isEmpty());//false
        System.out.println("    ".isEmpty());//false

        //int length() 返回此字符串的长度。
        String str = null;
        //空引用会报错
        //System.out.println(str.length());
        System.out.println(str1.length());

        //String repeat(int count) 返回一个字符串，其值为此字符串的串联重复count次
        System.out.println(str1.repeat(3));//字面常量1字面常量1字面常量1

        //String replace(char oldChar, char newChar) 返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 
        System.out.println(str1.replace('1','0'));
        //String replace(CharSequence target, CharSequence replacement) 将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。
        System.out.println(str1.replace("字面常量","ziMianChangLiang"));

        //String[] split(String regex) 将此字符串拆分为给定 regular expression的匹配 项   ***
        String s = "name=zhangsan&age=18";
        //拆分包含多个分割符的字符串,返回分割后结果的String序列
        String[] arr = s.split("&");
        System.out.println(Arrays.toString(arr));
        for(String string:arr){
            String[] arr3 = string.split("=");
            System.out.println(Arrays.toString(arr3));
        }

        //boolean startsWith(String prefix)

        //String trim() 返回一个字符串，其值为此字符串，删除了所有前导和尾随空格 --> 只去除半角空格
        System.out.println(" abc　".trim());//abc后为全角空格,无法删除
        //String strip() 返回一个字符串，其值为此字符串，并删除了所有前导和尾随 white space --> 可以去除全角以及半角空格
        System.out.println(" abc　".strip());
        //String stripLeading() 返回一个字符串，其值为此字符串，并删除了所有前导 white space --> 可以去除全角以及半角空格
        System.out.println(" abc　".stripLeading());
        //String stripTrailing() 返回一个字符串，其值为此字符串，并删除所有尾随 white space --> 可以去除全角以及半角空格
        System.out.println(" abc　".stripTrailing());

        //String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。   ***
        System.out.println("abcdefghijk".substring(3));
        //String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。结束索引不包含
        System.out.println("abcdefghijk".substring(3,5));

        //char[] toCharArray() 将此字符串转换为新的字符数组。   ***
        System.out.println(Arrays.toString(str1.toCharArray()));

        //String toLowerCase() 使用默认语言环境的规则将此 String所有字符转换为小写。  ***
        //String toUpperCase() 使用默认语言环境的规则将此 String所有字符转换为大写。
        System.out.println(str13.toUpperCase());

        //static String valueOf(boolean b) 返回 boolean参数的字符串表示形式。
        System.out.println(String.valueOf(false));//返回false为字符串类型
        System.out.println(Arrays.toString(String.valueOf(false).toCharArray()));
    }
}