day14-15 常用类

Libra_97

已于 2022-09-20 22:09:27 修改

阅读量175

点赞数

分类专栏： javase 文章标签： java

于 2022-09-19 21:53:39 首次发布

本文链接：https://blog.csdn.net/Libra_97/article/details/126942971

版权

javase 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

常用类

1. 枚举

枚举是由一组固定的静态常量组成的类型枚举类不能new对象

package com.atguigu.test1;

public enum Week {
    MON, TUE, WED, THUR, FRI, SAT, SUN
}

package com.atguigu.test1;

public class PrintWeek {
    public static void main(String[] args) {
        Week day = Week.FRI;

        switch (day){
            case MON:
                System.out.println("周一");
                break;
            case TUE:
                System.out.println("周二");
                break;
            case WED:
                System.out.println("周三");
                break;
            case THUR:
                System.out.println("周四");
                break;
            case FRI:
                System.out.println("周五");  // 周五
                break;
            case SAT:
                System.out.println("周六");
                break;
            case SUN:
                System.out.println("周日");
                break;
            default:
                System.out.println("一周只有七天");
                break;
        }

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

        printWeek(Week.SAT);  // 周六

    }

    public static void printWeek(Week day){
        switch (day){
            case MON:
                System.out.println("周一");
                break;
            case TUE:
                System.out.println("周二");
                break;
            case WED:
                System.out.println("周三");
                break;
            case THUR:
                System.out.println("周四");
                break;
            case FRI:
                System.out.println("周五");
                break;
            case SAT:
                System.out.println("周六");
                break;
            case SUN:
                System.out.println("周日");
                break;
            default:
                System.out.println("一周只有七天");
                break;
        }

        System.out.println("printWeek方法执行完毕");  // printWeek方法执行完毕
    }
}

2. 包装类

基本数据类型和包装类

每个基本数据类型在lang包中都有与之对应的一个包装类类型包装类相当于基本数据类型 ‘穿了一个马甲’

内部依然保存的是基本数据类型的值

byte short int long float double boolean char

Byte Short Integer Long Float Double Boolean Character(科瑞科特儿)

2.1 构造方法

构造方法：每个包装类都支持传入一个与之对应的基本数据类型的参数来构造当前实例

除了Character之外其他的包装类还支持传入一个String类型的参数构造当前实例

在使用字符串构造数值类型的包装类对象的时候，字符串不能为null，必须可以解析为正确的数值才可以，否则将报

NumberFormatException

使用字符串构造Boolean类型实例
字符串内容不缺分大小写如果内容为true 则表示为true 其他都表示为false

package com.atguigu.test2;
/**
 * 基本数据类型和包装类
 * 每个基本数据类型在long包中都有与之对应的一个包装类型 包装类相当于基本数据类型 '穿了一个马甲'
 * 内部依然保存的是基本数据类型的值
 *
 * byte     short       int      long   float   double  boolean     char
 * Byte     Short       Integer  Long   Float   Double  Boolean     Character(科瑞科特儿)
 *
 * 构造方法：每个包装类都支持传入一个与之对应的基本数据类型的参数来构造当前实例
 * 除了Character之外 其他的包装类还支持传入一个String类型的参数构造当前实例
 * */
public class Test1 {

    public static void main(String[] args) {
        Byte b1 = new Byte((byte)28);
        Byte b2 = new Byte("123");

        System.out.println(b1);  // 28
        System.out.println(b2);  // 123

        System.out.println(b1.toString());  // 28
        System.out.println(b2.toString());  // 123

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

        Short s1 = new Short((short)231);
        Short s2 = new Short("324");

        System.out.println(s1);  // 231
        System.out.println(s2);  // 324

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

        Integer i1 = new Integer(456);
        Integer i2 = new Integer("2341");

        System.out.println(i1);  // 456
        System.out.println(i2);  // 2341

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

        Long l1 = new Long(12423);
        Long l2 = new Long("122341");

        System.out.println(l1);  // 12423
        System.out.println(l2);  // 122341

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

        Float f1 = new Float(3.234f);
        Float f2 = new Float("12313");

        System.out.println(f1);  // 3.234
        System.out.println(f2);  // 12313.0

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

        Boolean bl1 = new Boolean(true);
        Boolean bl2 = new Boolean("tRue");
        // 使用字符串构造Boolean类型实例
        // 字符串内容不区分大小写 如果内容为true 则表示为true 其他都表示为false
        Boolean bl3 = new Boolean("asd");

        System.out.println(bl1);  // true
        System.out.println(bl2);  // true
        System.out.println(bl3);  // false

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

        Character ch1 = new Character('A');
        System.out.println(ch1);  // A
    }
}

2.2 包装类转基本数据类型

xxxValue():每个包装类中都提供有这样的方法用于将包装类对象转换为基本数据类型

package com.atguigu.test3;
/**
 * xxxValue(): 每个包装类中都提供有这样的方法 用于将包装类对象转换为基本数据类型
 * */
public class Test1 {
    public static void main(String[] args) {
        // Byte转换为byte基本数据类型
        Byte b1 = new Byte("123");
        byte b2 = b1.byteValue();

        System.out.println(b2);  // 123

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


        // Short转换为short基本数据类型
        Short s1 = new Short("556");

        // 在有返回值的方法名之后直接.var 表示自动生成一个对应的变量来接收方法的返回值
        // 自动生成的变量直接处于选中状态 我们直接改变变量名即可
        short s2 = s1.shortValue();
        System.out.println(s2);  // 556

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


        // Integer转换为int基本数据类型
        Integer i1 = new Integer(2323);
        int i2 = i1.intValue();
        System.out.println(i2);  // 2323

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


        // Long转换为long基本数据类型
        Long l1 = new Long(234123);
        long l2 = l1.longValue();
        System.out.println(l2);  // 234123

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


        // Float转换为float基本数据类型
        Float f1 = new Float(23.132f);
        float f2 = f1.floatValue();
        System.out.println(f2);  // 23.132

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


        // Double转换为double基本数据类型
        Double d1 = new Double(123498234.123);
        double d2 = d1.doubleValue();
        System.out.println(d2);  // 1.23498234123E8

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

        // Boolean转换为boolean基本数据类型
        Boolean bl1 = new Boolean(false);
        boolean bl2 = bl1.booleanValue();
        System.out.println(bl2);  // false

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


        // Character转换为char基本数据类型
        Character ch1 = new Character('A');
        char ch2 = ch1.charValue();
        System.out.println(ch2);  // A


    }
}

2.3 基本数据类型转包装类

valueOf():每个包装类都提供有 valueOf方法用于将基本数据类型转换为与之对应的包装类

package com.atguigu.test3;

import java.util.Date;

/**
 * valueOf():每个包装类都提供由valueOf方法 用于将基本数据类型转换为与之对应的包装类
 * */
public class Test2 {
    public static void main(String[] args) {
        // 将byte基本数据类型转换为Byte包装类
        Byte b1 = Byte.valueOf((byte)123);
        System.out.println(b1);  // 123

        Byte b2 = Byte.valueOf("113");
        System.out.println(b2);  // 113

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

        // 将short基本数据类型转换为Short包装类
        Short s1 = Short.valueOf((short) 2341);
        System.out.println(s1);  // 2341

        Short s2 = Short.valueOf("3241");
        System.out.println(s2);  // 3241

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


        // 将int基本数据类型转换为Integer包装类
        Integer i1 = Integer.valueOf(98273412);
        System.out.println(i1);  // 98273412

        Integer i2 = Integer.valueOf("12314");
        System.out.println(i2);  // 12314

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


        // 将long基本数据类型转换为Long包装类
        Long l1 = Long.valueOf(12398123);
        System.out.println(l1);

        Long l2 = Long.valueOf("12314234");
        System.out.println(l2);

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


        // 将float基本数据类型转换为Float包装类
        Float f1 = Float.valueOf(123.12f);
        System.out.println(f1);  // 123.12

        Float f2 = Float.valueOf("2341.1f");
        System.out.println(f2);  // 2341.1

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

        // 将double基本数据类型转换为Double包装类
        Double d1 = Double.valueOf(12312.123);
        System.out.println(d1);  // 12312.123

        Double d2 = Double.valueOf("123.123");
        System.out.println(d2);  // 123.123

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


        // 将boolean基本数据类型转换为Boolean包装类
        Boolean bl1 = new Boolean(false);
        System.out.println(b1);  // false

        Boolean bl2 = new Boolean("as");
        System.out.println(bl2);  // false

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


        // 将char基本数据类型转换为Character包装类
        Character ch1 = Character.valueOf('A');
        Character ch2 = Character.valueOf('2');

        System.out.println(ch1);  // A
        System.out.println(ch2);  // 2
    }
}

2.4 基本数据类型转字符串

toString() : 每个包装类都提供有toString(带参数)方法用于将基本数据类型转换为字符串

package com.atguigu.test4;
/**
 * toString(): 每个包装类都提供由toString(带参数)方法 用于将基本数据类型转换为字符串
 * */
public class Test1 {
    public static void main(String[] args) {
        // 将Byte包装类转换为字符串类型
        String b1 = Byte.toString((byte)20);

        System.out.println(b1);  // 20
        System.out.println("----------------------");


        // 将Short包装类转换为字符串类型
        String s1 = Short.toString((short) 1234);
        System.out.println(s1);  // 1234

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


        // 将Integer包装类转换为字符串类型
        String i1 = Integer.toString(111);
        System.out.println(i1);  // 111

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


        // 将Long包装类转换为字符串类型
        String l1 = Long.toString(324241L);
        System.out.println(l1);  // 324241

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


        // 将Float包装类转换为字符串类型
        String f1 = Float.toString(132.12f);
        System.out.println(f1);  // 132.12

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


        // 将Double包装类转换为字符串类型
        String d1 = Double.toString(124234.1);
        System.out.println(d1);  // 124234.1

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


        // 将Boolean包装类转换为字符串类型
        String bl1 = Boolean.toString(false);
        System.out.println(bl1);  // false

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


        // 将Character包装类转换为字符串类型
        String ch1 = Character.toString('w');
        System.out.println(ch1);  // w


    }
}

2.5 字符串转基本数据类型

parseXXX() : 除了Character类之外每个包装类都提供有这个方法用于将字符串转为基本数据类型

package com.atguigu.test4;
/**
 * parseXxx(): 除了Character类之外 每个包装类都有提供这个方法 用于将字符串转换为基本数据类型
 * */
public class Test2 {

    public static void main(String[] args) {
        // 字符串类型转换为byte基本数据类型
        byte b1 = Byte.parseByte("123");
        System.out.println(b1);  // 123

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


        // 字符串类型转换为short基本数据类型
        short s1 = Short.parseShort("12334");
        System.out.println(s1);  // 12334

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


        // 字符串类型转换为int基本数据类型
        int i1 = Integer.parseInt("23413123");
        System.out.println(i1);  // 23413123

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


        // 字符串类型转换为long基本数据类型
        long l1 = Long.parseLong("241232");
        System.out.println(l1);  // 241232

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


        // 字符串类型转换为float基本数据类型
        float f1 = Float.parseFloat("123123");
        System.out.println(f1);  // 123123.0

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


        // 字符串类型转换为double基本数据类型
        double d1 = Double.parseDouble("1234");
        System.out.println(d1);  // 1234.0

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


        // 字符串类型转换为boolean基本数据类型
        boolean bl1 = Boolean.parseBoolean("qweoi");
        System.out.println(bl1);  // false

    }
}

3. 自动装箱和拆箱

自动装箱和拆箱：JDK1.5开始允许包装类对象和基本数据类型混合运算使用这种现象就是装箱或者拆箱

装箱：将基本数据类型直接赋值给包装类类型

拆箱：将包装类类型直接赋值给基本数据类型

package com.atguigu.test5;
/**
 * 自动装箱和拆箱：JDK1.5开始 允许包装类对象和基本数据类型混合运算使用 这种现象就是装箱或者拆箱
 *
 * 装箱：将基本数据类型直接赋值给包装类类型
 * 拆箱：将包装类类型直接赋值给基本数据类型
 * */
public class Test1 {

    public static void main(String[] args) {
        Integer i1 = new Integer(20);
        Integer i2 = Integer.valueOf(20);

        Integer i3 = 20;  // 自动装箱 底层依然调用 valueOf()方法

        int num = i3;  // 自动拆箱 底层调用intValue()来实现

    }
}

4. 包装类面试题

回顾之前讲过的 ==和equals的区别这个面试题

包装类面试题：

1.当整数数值(Short Integer Long)的包装类以及char类型的包装类(Character) 直接使用等号赋值

如果取值范围在byte以内取值相同的两个对象==比较为true

如果取值范围超过byte 取值相同的两个对象比较为false

2.为什么会有这样的效果？

因为Integer类中帮我们维护了一个Integer类型的数组此数组中保存 byte范围以内的数值

如果直接=号赋值在此范围以内将从数组中取出对应的对象所以比较为true

如果超出这个范围将直接new一个对象所以比较为false

3.为什么要这样设计？

这样的设计的目的用于节省内存空间不是每次都开辟新的空间创建新的对象

package com.atguigu.test5;
/**
 * 回顾之前讲过的==和equals的区别这个面试题
 *
 * 包装类面试题：
 *  1.当整数数值(Short Integer Long)的包装类以及char类型的包装类(Character)直接使用等号赋值
 *      如果取值范围在byte以内 取值相同的两个对象==比较为true
 *      如果取值范围超过byte 取值相同的两个对象比较为false
 *
 * 2.为什么会有这样的效果呢？
 *      因为Integer类中帮我们维护了一个Integer类型的数组 此数组中保存 byte范围以内的数值
 *      如果直接=号赋值在此范围以内 将从数组中去除对应的对象 所以比较为true
 *      如果超出这个范围 将直接new一个对象 所以比较为false
 *
 * 3.为什么要这样设计？
 *      这样的设计的目的用于节省内存空间 不是每次都开辟新的空间 创建新的对象
 * */
public class Test2 {
    public static void main(String[] args) {
        Integer i1 = -128;
        Integer i2 = -128;

        System.out.println(i1.equals(i2));  // true
        System.out.println(i1 == i2);  // true

        Integer i3 = -129;
        Integer i4 = -129;

        System.out.println(i3.equals(i4));  // true
        System.out.println(i3 == i4);  // false

        Integer a = new Integer(1);
        Integer b = new Integer(1);

        System.out.println(a == b);  // false

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


        Short s1 = 127;
        Short s2 = 127;
        System.out.println(s1 == s2);

        Short s3 = 128;
        Short s4 = 128;

        System.out.println(s3 == s4);  // false

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


        // char是无符号数 0 ~ 65535
//        Character ch1 = -100;  // 不能为负数
        Character ch1 = 127;
        Character ch2 = 127;
        System.out.println(ch1 == ch2);  // true

        Character ch3 = 128;
        Character ch4 = 128;
        System.out.println(ch3 == ch4);  // false
    }
}

5.包装类属性

包装类提供了一些属性用于获取当前包装类相关的信息比如最大值最小值等

package com.atguigu.test5;
/**
 * 包装类中的属性 比如 获取当前包装类 最大值 最小值
 * */
public class Test3 {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);  // 2147483647
        System.out.println(Integer.MIN_VALUE);  // -2147483648

        System.out.println(Byte.MAX_VALUE);  // 127
        System.out.println(Byte.MIN_VALUE);  // -128

        System.out.println(Long.MAX_VALUE);  // 9223372036854775807
        System.out.println(Long.MIN_VALUE);  // -9223372036854775808
    }
}

6. Math类

Math类中提供的有常用的数学运算的方法以及两个静态常量 E PI

课后小练习：随机生成一个100以内的整数提示用户猜这个数猜大或者猜小进行提示直到猜对统计猜了几次

package com.atguigu.test6;
/**
 * Math类中提供的有常用的数学运算的方法 以及 两个静态常量 E PI
 * 课后小练习：随机生成一个100以内的整数 提示用户才这个数 猜大或者猜小 进行提示 直到猜对 统计猜了几次
 * */
public class TestMath {

    public static void main(String[] args) {
        System.out.println("自然对数的底数：" + Math.E);  // 自然对数的底数：2.718281828459045

        System.out.println("圆周率：" + Math.PI);  // 圆周率：3.141592653589793

        System.out.println("绝对值：" + Math.abs(-33));  // 绝对值：33

        System.out.println("3.3向上取整：" + Math.ceil(3.3));  // 3.3向上取整：4.0

        System.out.println("3.6向下取整：" + Math.floor(3.6));  // 3.6向下取整：3.0

        System.out.println("3.5四舍五入：" + Math.round(3.5));  // 3.5四舍五入：4

        System.out.println("大于0.0 小于1.0随机double类型的小数：" + Math.random());  // 大于0.0 小于1.0随机double类型的小数：0.7837207369982422

        System.out.println("100以内的随机整数：" + (int)(Math.random() * 100));

        System.out.println("15以内的随机整数：" + (int)(Math.random() * 15));

    }
}

7. Random类

Random类可以生成更多类型的随机数

nextBoolean()

nextDouble()

nextFloat()

nextInt()

nextInt(int bound)

package com.atguigu.test6;

import java.util.Random;

/**
 * Random类可以生成更多类型的随机数
 *      nextBoolean()
 *      nextDouble()
 *      nextFloat()
 *      nextInt()
 *      nextInt(int bound)
 * */
public class TestRandom {

    public static void main(String[] args) {

        Random rand1 = new Random();

        // 随机生成double类型的小数
        System.out.println(rand1.nextDouble());  // 0.8066395068217753
        // 随机生成float类型的小数
        System.out.println(rand1.nextFloat());  // 0.40055525
        // 随机生成int类型的整数
        System.out.println(rand1.nextInt());  // 1421085858
        // 随机生成指定范围内的int类型的整数
        System.out.println(rand1.nextInt(100));  // 64
        // 随机生成long类型的整数
        System.out.println(rand1.nextLong());  // 1202525455539240436
        // 随机生成boolean类型的数
        System.out.println(rand1.nextBoolean());  // false
    }

}

8. String类

String类

length() 获取字符串长度

equals() 比较字符串内容是否相同

equalsIgnoreCase() 忽略大小写比较字符串内容是否相同

toLowerCase() 将字符串内容转换为小写

toUpperCase() 将字符串内容转换为大写

concat() 拼接字符串

indexOf() 查找某个字符串第一次出现的位置如未找到返回-1

lastIndexOf() 查找某个字符串最后一次出现的位置如未找到返回-1

substring(int index) :从指定位置截取字符串到末尾

substring(int beginIndex,int endIndex) :从指定位置截取字符串到指定结束位置包前不包后

trim() 去除空格只能去除首尾的空格不能去除中间的空间

split() 拆分字符串

charAt(int index) :根据指定下标获取当对应的字符

endsWith(String str) :判断字符串是否以某一个字符串结尾

startsWith(String str):判断字符串是否以某一个字符串开头

contains(String str):判断字符串中是否包含某个字符串

replace(String oldStr,String newStr):替换字符串

toCharArray() ：将字符串转换为char数组

package com.atguigu.test7;
/**
 * String类
 * length() 获取字符串长度
 * equals() 比较字符串内容是否相同
 * equalsIgnoreCase() 忽略大小写比较字符串内容是否相同
 * toLowerCase() 将字符串内容转化为小写
 * toUpperCase() 将字符串内容转换为大写
 * concat() 拼接字符串
 * */
public class TestString1 {
    public static void main(String[] args) {
        String str1 = "abcdef";

        System.out.println("数组的长度：" + str1.length());  // 数组的长度：6

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

        String str2 = "abcdef";
        System.out.println(str1.equals(str2));  // true

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


        String str3 = "helloWorLD";
        String str4 = "HeLLOwORLd";

        // equals() 比较字符串内容是否相同
        System.out.println(str3.equals(str4));  // false
        // equalsIgnoreCase() 忽略大小写比较字符串内容是否相同
        System.out.println(str3.equalsIgnoreCase(str4));  // true
        System.out.println("-----------------------");

        // toUpperCase() 将字符串内容转换为大写
        String str5 = "abc";  // ABC
        System.out.println(str5.toUpperCase());

        // toLowerCase() 将字符串内容转化为小写
        String str6 = "ABC";  // abc
        System.out.println(str6.toLowerCase());

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

        String str7 = "abc";
        String str8 = "666";

        System.out.println(str7 + str8);  // abc666
        // concat() 拼接字符串
        System.out.println(str7.concat(str8));  // abc666

    }
}

package com.atguigu.test7;
/**
 * indexOf() 查找某个字符串第一次出现的位置 如未找到 返回-1
 * lastIndexOf() 查找某个字符串最后一次出现的位置 如未找到 返回-1
 *
 * substring(int index): 从指定位置截取字符串到末尾
 * substring(int beginIndex, int endIndex): 从指定位置截取字符串到指定结束位置 包前不包后
 *
 * trim() 去除空格 只能取出首尾的空格 不能去除中间的空间
 * */
public class TestString2 {
    public static void main(String[] args) {
        String str1 = "A中bcHelloAbc中";

        // 查找某个字符串第一次出现的位置 如未找到 返回-1
        System.out.println(str1.indexOf("A"));  // 0 第一个索引
        System.out.println(str1.indexOf("B"));  // -1 未找到
        System.out.println(str1.indexOf(65));  // // 0 第一个索引
        System.out.println(str1.indexOf(20013));  // 1 第二个索引

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

        System.out.println(str1.indexOf("S"));  // -1
        // lastIndexOf() 查找某个字符串最后一次出现的位置 如未找到 返回-1
        System.out.println(str1.lastIndexOf("S"));  // -1

        System.out.println(str1.lastIndexOf("A"));  // 9
        System.out.println(str1.indexOf("A"));  // 0

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


        String str2 = "abcHello666";
        // substring(int index): 从指定位置截取字符串到末尾
        System.out.println(str2.substring(2));  // cHello666
        System.out.println(str2.substring(5, 8));  // llo

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

        // trim() 去除空格 只能取出首尾的空格 不能去除中间的空间
        String str3 = "     a b c   ";
        System.out.println(str3.trim());  // a b c

    }
}

package com.atguigu.test7;
/**
 * split() 拆分字符串
 * */
public class TestString3 {
    public static void main(String[] args) {
        String str = "长亭外 古道边 芳草碧连天 晚风拂柳 笛声残 夕阳山外山";

        String[] strs = str.split(" ");

        for (int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
}

package com.atguigu.test7;

import java.util.Scanner;

/**
 * 使用split方法实现查找字符在字符串中出现的次数
 * */
public class TestString4 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("请输入一段文字：");

        String str = scan.next();

        System.out.print("请输入要查找的文字：");

        String findStr = scan.next();

        // 第一种方式
//        String[] split = str.split("");
//
//        int count = 0;
//        for (int i = 0;i < split.length;i++){
//            if (findStr.equals(split[i])){
//                count++;
//            }
//        }
//        System.out.println(str + "字符串中出现了" + count + "次:" + findStr);

        // 第二种方式
        String[] res = str.split(findStr);
        System.out.println(str + "字符串中出现了" + (res.length - 1) + "次:" + findStr);
    }
}

package com.atguigu.test1;
/**
 * charAt(int index):根据指定下标获取对应的字符
 * endsWith(String str):判断字符串是否以某一个字符串结尾
 * startsWith(String str):判断字符串是否以某一个字符串开头
 * contains(String str):判断字符串是否包含某个字符串
 * replace(String oldStr, String newStr):转换字符串
 * toCharArray(): 将字符串转化为char数组
 * */
public class TestString1 {
    public static void main(String[] args) {
        String str = "abcHello";

        // charAt(int index):根据指定下标获取对应的字符
        System.out.println(str.charAt(0));  // a

        // endsWith(String str):判断字符串是否以某一个字符串结尾
        System.out.println(str.endsWith("abc"));  // false

        // startsWith(String str):判断字符串是否以某一个字符串开头
        System.out.println(str.startsWith("abc"));  // true

        // contains(String str):判断字符串是否包含某个字符串
        System.out.println(str.contains("el"));  // true

        // replace(String oldStr, String newStr):转换字符串
        System.out.println(str.replace("abc", "666"));  // 666Hello

        // toCharArray(): 将字符串转化为char数组
        char[] chars = str.toCharArray();

        for (int i = 0;i < chars.length;i++){
            System.out.println(chars[i]);
        }
    }
}

9. String 类面试题

在这里插入图片描述

String类相关面试题：

String对象被设计为不可变对象，

任何对字符串内容的改变都将产生一个新的字符串对象

为什么String对象是不可变对象？

1.String类不能被继承因为此类使用final修饰

2.每一个String对象底层都是使用final修饰的char数组维护的

3.这个final修饰的char数组是private

有没有其他的方法可以改变字符串对象？

有，使用反射

final修饰的变量称之为常量

final修饰基本数据类型其值不能被改变

final修饰引用数据类型引用不能改变但是引用中的内容可以改变

面试题：代码阅读

String str1 = “abc”;

String str2 = “abc”;

String str3 = new String(“abc”);

System.out.println(str1 == str2);

System.out.println(str1 == str3);

System.out.println(str2 == str3);

package com.atguigu.test1;
/**
 * String类相关面试题：
 *      String对象被设计为不可变对象
 *      任何对字符串内容的改变都将产生一个新的字符串对象
 *
 * 为什么String对象是不可变对象？
 *      1.String类不能被继承 因为此类使用final修饰
 *      2.每一个String对象底层都是使用final修饰的char数组维护的
 *      3.这个final修饰的char数组是private
 *
 *
 * final修饰的变量称之为常量
 * final修饰基本数据类型 其值不能被改变
 * final修饰引用数据类型 引用不能改变 但是引用中的内容可以改变
 *
 * 面试题：代码阅读
 * String str1 = "abc";
 * String str2 = "abc";
 * String str3 = new String("abc");
 *
 * System.out.println(str1 == str2);
 * System.out.println(str1 == str3);
 * System.out.println(str2 == str3);
 * */
public class TestString2 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        String str3 = new String("abc");
        String str4 = new String("abc");

        System.out.println(str1 == str2);  // true
        System.out.println(str1 == str3);  // false
        System.out.println(str2 == str3);  // false
        System.out.println(str3 == str4);  // false
    }
}

package com.atguigu.test1;
/**
 * final修饰的变量称之为常量
 * final修饰的基本数据类型 其值不能被改变
 * final修饰引用数据类型 引用不能改变 但是引用中的内容可以改变
 * */
public class TestString3 {

    final char[] chs = {'a', 'b', 'c'};
    final char ch1 = 'A';

    public static void main(String[] args) {
        TestString3 ts3 = new TestString3();

//        ts3.ch1 = 'B';  // 报错 final修饰的变量无法被修改

//        ts3.chs = new char[3];  // 报错 final修饰的引用数据类型 无法修改

        ts3.chs[0] = '中';
        ts3.chs[1] = '国';
        ts3.chs[2] = '人';

        System.out.println(ts3.chs[0]);  // 中
        System.out.println(ts3.chs[1]);  // 国
        System.out.println(ts3.chs[2]);  // 人
    }
}

9. StringBuffer&StringBuilder

String类是一个不可变对象任何对字符串内容的改变都会产生新的字符串对象

所以如果我们在开发中需要频繁的对某个字符串内容改变不推荐使用String类型

推荐使用StringBuffer或者StringBuilder

举例：比如我们通过电商平台搜索商品

String、StringBuffer和StringBuilder的区别？

String是不可变对象 StringBuffer和StringBuilder是可变对象

StringBuffer线程安全 JDK1.0

StringBuilder线程不安全 JDK1.5

package com.atguigu.test2;
/**
 * String类是一个不可变对象 任何对字符串内容的改变 都会产生新的字符串对象
 * 所以 如果我们在开发中 需要频繁的对某个字符串内容改变 不推荐使用String类型
 * 推荐使用StringBuffer或者StringBuilder
 *
 * 举例：比如我们通过电商平台搜索商品
 *
 * String、StringBuffer和StringBuilder的区别？
 *      String是不可变对象 StringBuffer和StringBuilder是可变对象
 *      StringBuffer线程安全    JDK1.0
 *      StringBuilder线程不安全  JDK1.5
 *
 * */
public class StringBufferAndStringBuilder {
    public static void main(String[] args) {

        String condition = "电脑";

        condition += "笔记本";

        condition += "联想";

        condition += "拯救者";

        condition += "12代i7";

        condition += "3060 135W";


        System.out.println(condition);  // 电脑笔记本联想拯救者12代i73060 135W

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

        StringBuilder sb = new StringBuilder();

        // append() 把参数当作字符串追加
        sb.append(23);

        sb.append(3.5);

        sb.append(false);

        sb.append("abc");

        System.out.println(sb);  // 233.5falseabc

        // delete(int start, int end) 删除指定范围内的字符 包前不包后
        System.out.println(sb.delete(3, 7));  // 233lseabc

        // insert(int offset, String str) 在指定索引前插入数据
        System.out.println(sb.insert(0, "hello666"));  // hello666233lseabc

        // 反转
        System.out.println(sb.reverse());  // cbaesl332666olleh
    }
}

10. System类

java.lang.System 此类位于lang包使用不必导包此类不能new对象

package com.atguigu.test3;
/**
 * java.lang.System 此类位于lang包 使用不必导包 此类不能new对象
 * */
public class TestSystem {

    public static void main(String[] args) {

        System.out.println("正常输出语句");
        System.err.println("错误打印语句");


        // 获取从1970年1月1日 0点0时0秒到目前的毫秒数
        // 因为linux操作系统认为1970年是计算机诞生的元年
        System.out.println("当前系统时间毫秒数：" + System.currentTimeMillis());  // 当前系统时间毫秒数：1663646223932

        String str1 = "abc";

        // 调用此方法并不能保证立即回收垃圾对象
        // gc Garbage Collection
        System.gc();

        System.out.println(str1);  // abc 依然可以访问str1


        // System类提供有获取当前系统相关信息的方法
        // 比如 系统版本号 JDK版本 JVM编码格式等
        // 这些信息都以键值对的形式存在 比如 身份证号(键 key) ------> 名字(值 value)
        System.out.println(System.getProperty("user.name"));
        System.out.println(System.getProperty("file.encoding"));  // UTF-8
        System.out.println(System.getProperty("java.version"));  // 1.8.0_131

        // 显示所有
        System.getProperties().list(System.out);


        // 参数为int类型状态码 目前传入任何int类型的整数都可以退出JVM虚拟机
        // 0表示正常退出
        // 非0表示非正常退出
        System.exit(100);  // Process finished with exit code 100
    }
}

11.Runtime类

Runtime类不能new对象类中提供了一个方法getRuntime()用于获取此类对象

此类被设计为单例(程序执行过程中只有一个其只能有一个此类的实例)模式

Runtime类中提供了用于获取程序运行期间信息的方法

package com.atguigu.test3;

import java.io.IOException;

/**
 * Runtime类 不能new对象 类中提供了一个方法getRuntime()用于获取此类对象
 * 此类被设计为单例(程序执行过程中只有一个且只能由一个此类的实例)模式
 *
 * Runtime类中提供了用于获取程序允许期间信息的方法
 * */
public class TestRuntime {
    public static void main(String[] args) throws IOException {

        Runtime runtime = Runtime.getRuntime();

//        runtime.exec("D:\\阿里云盘\\aDrive\\aDrive.exe");

        runtime.gc();  // 与System中的gc()方法属于同一个方法

        // 默认以字节为单位   / 1024 / 1024 以兆为单位显示
        System.out.println("空间内存：" + runtime.freeMemory() / 1024 / 1024);  // 空间内存：232
        System.out.println("最大内存：" + runtime.maxMemory() / 1024 / 1024);  // 最大内存：3499
        System.out.println("总内存：" + runtime.totalMemory() / 1024 / 1024);  // 总内存：236

        runtime.exit(1);  // 退出JVM虚拟机 System类中的exit() 也使用这个方法
    }
}

12. 日期API

12.1 java.util.Date

java.util.Date : 次类中提供的有用于获取时间设置时间的各种方法

大部分已弃用依然可以使用但是不推荐使用

package com.atguigu.test4;

import java.util.Date;

/**
 * java.util.Date: 此类中提供的用于获取时间 设置时间的各种方法
 *
 * 大部分已弃用 依然可以使用 但不推荐使用
 * */
public class TestDate {
    public static void main(String[] args) {

        Date date1 = new Date();
        // 获取当前年份 需+1900
        System.out.println("年份：" + (date1.getYear() + 1900));  // 年份：2022
        // 获取当前月份 从0开始算的 所以需要加1
        System.out.println("月份：" + (date1.getMonth() + 1));  // 月份：9
        // 获取本月的第几天
        System.out.println("一月中的第几天：" + date1.getDate());  // 一月中的第几天：20
        // 获取本周的第几天
        System.out.println("一周中的第几天：" + date1.getDay());  // 一周中的第几天：2

        System.out.println("小时：" + date1.getHours());  // 小时：14
        System.out.println("分钟：" + date1.getMinutes());  // 分钟：41
        System.out.println("秒钟：" + date1.getSeconds());  // 秒钟：17

        System.out.println(date1);  // Tue Sep 20 14:43:04 CST 2022

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

        System.out.println("当前系统时间的毫秒数：" + System.currentTimeMillis());  // 当前系统时间的毫秒数：1663656237026

        Date date2 = new Date(System.currentTimeMillis());

        System.out.println(date2);  // Tue Sep 20 14:43:57 CST 2022

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

        Date date3 = new Date(12, 10, 1, 10, 10, 10);
        System.out.println(date3);  // Fri Nov 01 10:10:10 CST 1912


        m1();

    }

    // 注解 表示当前方法已弃用
    @Deprecated
    public static void m1(){
        System.out.println("version 1.0 m1 method");
    }
}

12.2 SimpleDateFormat

java.text.SimpleDateFormat ：此类专门用于对日期进行格式化处理

String format(java.util.Date date) :将日期对象转换为字符串

java.util.Date parse(String source):将字符串对象转换为日期对象

package com.atguigu.test4;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * java.text.SimpleDateFormat: 此类专门用于对日期进行格式化处理
 *
 * String format(java.util.Date date): 将日期对象转换为字符串
 * java.util.Date parse(String source): 将字符串对象转换为日期对象
 *
 * */
public class TestSimpleDateFormat {
    public static void main(String[] args) throws ParseException {

        Date date1 = new Date();

        // 自定义格式化
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");

        String dateStr = sdf1.format(date1);
        System.out.println(dateStr);  // 2022/09/20 14-49-17

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

        // 默认格式
        SimpleDateFormat sdf2 = new SimpleDateFormat();

        String dateStr2 = sdf2.format(date1);
        System.out.println(dateStr2);  // 22-9-20 下午3:49

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


        String dateStr3 = "22-9-20 下午3:49";

        SimpleDateFormat sdf3 = new SimpleDateFormat();
        // 字符串格式转成Date类型
        Date parseDate1 = sdf3.parse(dateStr3);

        System.out.println(parseDate1);  // Tue Sep 20 15:49:00 CST 2022
        System.out.println("----------------------------");


        // 自定义字符串格式转成Date类型，两者格式需一致
        String dataStr4 = "2022/12/12 11:11:11";

        SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date parseDate2 = sdf4.parse(dataStr4);

        System.out.println(parseDate2);  // Mon Dec 12 11:11:11 CST 2022
    }
}

12.3 Calendar

java.util.Calendar 日历类：用于取代java.util.Date类中的大部分方法功能

此类不能直接new对象

package com.atguigu.test4;

import java.util.Calendar;

/**
 * java.utils.Calendar 日历类：用于取代java.util.Date类中的大部分方法 功能
 * 此类不能直接new对象
 * */
public class TestCalendar {

    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();

        System.out.println("年份：" + instance.get(Calendar.YEAR));  // 年份：2022
        System.out.println("月份：" + (instance.get(Calendar.MONTH) + 1));  // 月份：9  从0开始算 需加1
        System.out.println("一周中的第几天：" + instance.get(Calendar.DAY_OF_WEEK));  // 一周中的第几天：3  从0开始算
        System.out.println("一月中的第几天：" + instance.get(Calendar.DAY_OF_MONTH));  // 一月中的第几天：20

        System.out.println("时：" + instance.get(Calendar.HOUR));  // 时：4
        System.out.println("分：" + instance.get(Calendar.MINUTE));  // 分：39
        System.out.println("秒：" + instance.get(Calendar.SECOND));  // 秒：6

    }
}

12.4 LocalDate

JDK8新增的日期API

LocalDate : 只包含年月日

package com.atguigu.test5;

import java.time.LocalDate;

/**
 * JDK8新增的日期API
 * LocalDate：只包含年月日
 * */
public class TestLocalDate {
    public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();

        System.out.println("年：" + localDate.getYear());  // 年：2022

        System.out.println("月：" + localDate.getMonth());  // 月：SEPTEMBER

        System.out.println("一周中第几天：" + localDate.getDayOfWeek());  // 一周中第几天：TUESDAY
        System.out.println("一月中第几天：" + localDate.getDayOfMonth());  // 一月中第几天：20
        System.out.println("一年中第几天：" + localDate.getDayOfYear());  // 一年中第几天：263

        System.out.println(localDate);  // 2022-09-20

        // 指定年月日转换成LocalDate类型
        LocalDate localDate1 = LocalDate.of(2019, 12, 11);
        System.out.println(localDate1);  // 2019-12-11
    }
}

12.5 LocalTime

JDK8新增的日期API

LocalTime : 只包含时分秒

package com.atguigu.test5;

import java.time.LocalTime;

/**
 * 只包含时分秒
 * */
public class TestLocalTime {
    public static void main(String[] args) {

        LocalTime localTime = LocalTime.now();

        System.out.println("小时：" + localTime.getHour());  // 小时：18

        System.out.println("分钟：" + localTime.getMinute());  // 分钟：15

        System.out.println("秒钟：" + localTime.getSecond());  // 秒钟：19

        // 1秒等于10亿纳秒
        System.out.println("纳秒：" + localTime.getNano());  // 纳秒：572000000

        System.out.println(localTime);  // 18:15:19.572

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

        // 指定时分秒转换成LocalTime类型
        LocalTime localTime1 = LocalTime.of(10, 10, 10);
        System.out.println(localTime1);  // 10:10:10
    }
}

12.6 LocalDateTime

JDK8新增的日期API

LocalDateTime：包含年月日时分秒

package com.atguigu.test5;

import java.time.LocalDateTime;

/**
 * LocalDateTime：包含年月日 时分秒
 * */
public class TestLocalDateTime {

    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();

        System.out.println("年：" + now.getYear());  // 年：2022
        System.out.println("月：" + now.getMonth());  // 月：SEPTEMBER

        System.out.println("一周中第几天：" + now.getDayOfWeek());  // 一周中第几天：TUESDAY
        System.out.println("一月中第几天：" + now.getDayOfMonth());  // 一月中第几天：20
        System.out.println("一年中第几天：" + now.getDayOfYear());  // 一年中第几天：263

        System.out.println("小时：" + now.getHour());  // 小时：18
        System.out.println("分钟：" + now.getMinute());  // 分钟：31
        System.out.println("秒钟：" + now.getSecond());  // 秒钟：24

        // 1秒等于10亿纳秒
        System.out.println("纳秒：" + now.getNano());  // 纳秒：269000000

        // 指定年月日时分秒转换成LocalDateTime类型
        LocalDateTime localDateTime = LocalDateTime.of(2011, 10, 12, 11, 11, 11);
        System.out.println(localDateTime);


    }
}

13.BigInteger & BigDecimal

BigInteger : 可以保存任意大的整数

package com.atguigu.test6;

import javax.jws.soap.SOAPBinding;
import java.math.BigInteger;

/**
 * BigInteger：可以保存任意大的整数
 * */
public class TestBigInteger {
    public static void main(String[] args) {

        BigInteger b1 = new BigInteger("1232846182746381237468235467812541123");
        System.out.println(b1);

        BigInteger b2 = new BigInteger("123234123143");

        // add() 相加 参数必须是BigInteger类型
        System.out.println(b1.add(b2));  // 1232846182746381237468235591046664266

        // subtract() 相减 参数必须是BigInteger类型
        System.out.println(b1.subtract(b2));  // 1232846182746381237468235344578417980

        // multiply() 相乘 参数必须是BigInteger类型
        System.out.println(b1.multiply(b2));  // 151928718300945027355785255191330905591533509589

        // divide() 相除 参数必须是BigInteger类型
        System.out.println(b1.divide(b2));  // 10004097495916738057625012
    }
}

BigDecimal:可以保存任意大任意精度的小数

package com.atguigu.test6;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * BigDecimal:可以保存任意大 任意精度的小数
 * */
public class TestBigDecimal {
    public static void main(String[] args) {

        BigDecimal b1 = new BigDecimal("12398264816487164131.2342397529835672834");
        System.out.println(b1);  // 12398264816487164131.2342397529835672834

        BigDecimal b2 = new BigDecimal("128361287.2354234");

        // add() 相加 参数必须是BigDecimal类型
        System.out.println(b1.add(b2));  // 12398264816615525418.4696631529835672834

        // subtract() 相减 参数必须是BigDecimal类型
        System.out.println(b1.subtract(b2));  // 12398264816358802843.9988163529835672834

        // multiply() 相乘 参数必须是BigDecimal类型
        System.out.println(b1.multiply(b2));  // 1591457231329952864063248149.29274370541086928978679156

        // divide() 相除 参数必须是BigDecimal类型
        // 第一个参数 除数
        // 第二个参数 保留几位小数
        // 第三个参数 小数位保留策略 四舍五入
        System.out.println(b1.divide(b2, 5, RoundingMode.HALF_UP));
    }
}

14. 内部类

内部类：一个类中又书写了另外一个或者多个类写在内部的类就称之为内部类

内部类生成的class文件名格式为：外部类$内部类.class

什么情况下会使用内部类呢？

当我们需要使用一个类来描述某个信息而这个类没有必要对外界开放访问那么就可以使用内部类

内部类分类：

1.普通内部类(了解)

2.静态内部类(了解)

3.局部内部类(了解)

4.匿名内部类(必须掌握)

内部类介绍

package com.atguigu.test7;
/**
 * 内部类：一个类中又书写了另外一个或者多个类 写在内部的类 被称之为内部类
 * 内部类生成的class文件名格式为：外部类&内部类.class
 *
 * 什么情况下会使用内部类？
 * 当我们需要使用一个类来描述某个线下 而这个类没有必要对外界开放访问 那么久可以使用内部类
 *
 * 内部类分类：
 *      1.普通内部类(了解)
 *      2.静态内部类(了解)
 *      3.局部内部类(了解)
 *      4.匿名内部类(必须掌握)
 * */
public class Test1 {
    public static void main(String[] args) {

        Student stu1 = new Student();
        stu1.age = 20;
        stu1.name = "赵四";
        stu1.address = stu1.new Address();

        // 创建内部类Address对象
        Student.Address addr1 = new Student().new Address();
        // 创建内部类Address对象
        Student.Address addr2 = stu1.new Address();

        addr1.m1();

        addr2.m1();

    }
}

class Student{
    String name;
    int age;
    Address address;


    class Address{
        private String province;
        private String city;
        private String area;
        private String street;

        public void m1(){
            System.out.println(name);
            System.out.println(age);
            System.out.println(address);

            System.out.println("内部类m1方法");
        }
    }
}

class Outer{
    class inner{

    }
}

静态内部类

package com.atguigu.test7;
/**
 * 静态内部类
 * */
public class Test2 {
    public static void main(String[] args) {
        // 创建内部类Inner2对象
        Outer2.Inner2 inner2 = new Outer2.Inner2();
        inner2.m2();  // 内部类m2方法

        // 直接通过类名调用方法
        Outer2.Inner2.m3();  // 内部类m3方法

        System.out.println(inner2.c);  // 0

        System.out.println(inner2.d);  // 0.0

    }
}

class Outer2{
    int a;
    String b;

    public void m1(){
        System.out.println("外部类m1方法");
    }

    static class Inner2{
        int c;
        double d;
        public void m2(){
            System.out.println("内部类m2方法");
        }

        public static void m3(){
            System.out.println("内部类m3方法");
        }
    }
}

局部内部类

package com.atguigu.test7;
/**
 * 局部内部类
 * */
public class Test3 {
    public static void main(String[] args) {
        Outer3 outer3 = new Outer3();
        outer3.m1();
    }
}

class Outer3{
    int a;
    double b;
    public void m1(){
        System.out.println("外部类m1方法");
        class Inner3{
            int d;
            char c;
            public void m2(){
                System.out.println("局部内部类m2方法");
            }
        }
        Inner3 inner3 = new Inner3();
        inner3.m2();
    }
}

匿名内部类

package com.atguigu.test7;
/**
 * 匿名内部类：没有名字的类
 * */
public class Test4 {
    public static void main(String[] args) {
        A a = new A() {
            @Override
            void m1() {
                System.out.println("匿名内部类的方式实现m1方法");
            }
        };
        a.m1();  // 匿名内部类的方式重写m1方法

        B b = new B() {
            @Override
            public void m2() {
                System.out.println("匿名内部类的方式实现m2方法");
            }
        };
        b.m2();

        C c = new C() {
            @Override
            void m1() {
                System.out.println("匿名内部类方式实现m1");
            }

            @Override
            void m2() {
                System.out.println("匿名内部类方式实现m2");
            }

            @Override
            void m3() {
                System.out.println("匿名内部类方式实现m3");
            }
        };

        c.m1();  // 匿名内部类方式实现m1
        c.m2();  // 匿名内部类方式实现m2
        c.m3();  // 匿名内部类方式实现m3

    }
}

abstract class A{
    abstract void m1();
}

interface B{
    void m2();
}

abstract class C{
    abstract void m1();
    abstract void m2();
    abstract void m3();
}

lambda表达式

lambda表达式因为匿名内部类的写法太不美观所以从JDK8开始引入lambda表达式优化匿名内部类

这种啰嗦臃肿的写法

lambda要求：使用lambda表达式只能是接口并且接口中只能有一个抽象方法

@FunctionalInterface:此注解只能用于修饰接口表示此接口属于函数式接口

函数式接口要求接口中只能有一个抽象方法

package com.atguigu.test7;
/**
 * lambda表达式 因为匿名内部类的写法太不美观 所以从JDK8开始 引入lambda表达式优化匿名内部类这种啰嗦 臃肿的写法
 *
 * lambda要求：使用lambda表达式 只能是接口 并且接口中只能有一个抽象方法
 *
 * @FunctionalInterface:此注解只能用于修饰接口 表示此接口属于函数式接口
 *
 * */
public class Test5 {
    public static void main(String[] args) {
        E e1 = new E() {
            @Override
            public void m1() {
                System.out.println("匿名内部类方式重写m1");
            }
        };
        e1.m1();  // 匿名内部类方式重写m1

        // 使用lambda表达式
        E e2 = ()-> System.out.println("lambda表达式重写m1");
        e2.m1();  // lambda表达式重写m1

        E e3 = ()-> {
            System.out.println("lambda表达式重写m1 1");
            System.out.println("lambda表达式重写m1 2");
            System.out.println("lambda表达式重写m1 3");

        };
        e3.m1();
    }
}

@FunctionalInterface
interface E{
    void m1();
}