Java教程

Java常用类

本文主要是介绍Java常用类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java常用类

Object类

  • clone()克隆

  • notify()唤醒等待线程

  • wait()等待notify()唤醒

File类

Object类

  • 超类、基类,所有类的直接或间接父类,位于继承树的最顶层

  • 任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承

  • Object类中所定义的方法,是所有对象都具备的方法

  • Object类型可以存储任何对象

    • 作为参数,可接受任何对象

    • 作为返回值,可返回任何对象

getClass()方法

  • public final Class<?> getClass(){}

  • 返回引用中存储的实际对象类型

  • 应用:通常用于判断两个引用中实际存储对象类型是否一致

  • package com.tang.object;
    
    public class TestStudent {
        public static void main(String[] args) {
            Student s1 = new Student("aaa", 20);
            Student s2 = new Student("bbb", 20);
            //1.getClass方法
            System.out.println("--------------getClass方法--------------");
            //判断s1和s2是不是同一个类型
            Class c1 = s1.getClass();
            Class c2 = s2.getClass();
            if (c1.equals(c2)){
                System.out.println("s1和s2是同一个类型");
            }else {
                System.out.println("s1和s2不是同一个类型");
            }
        }
    }
    

hashcode()方法

  • public int hashCode(){}

  • 返回该对象的哈希码值

  • 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

  • 一般情况下相同对象返回相同哈希码

  • package com.tang.object;
    
    public class TestStudent {
        public static void main(String[] args) {
            Student s1 = new Student("aaa", 20);
            Student s2 = new Student("bbb", 20);
        	//2.hashCode方法
            System.out.println("--------------hashCode方法--------------");
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
        }
    }
    

toString()方法

  • public String toString(){}

  • 返回该对象的字符串表示(表现形式)

  • 可以根据程序需求覆盖该方法,如:展示对象各个属性值

  • @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    ---------------------------------------
    package com.tang.object;
    
    public class TestStudent {
        public static void main(String[] args) {
    		Student s1 = new Student("aaa", 20);
            Student s2 = new Student("bbb", 20);
            //3.toString方法
            System.out.println("--------------toString方法--------------");
            System.out.println(s1.toString());
            System.out.println(s2);
        }
    }
    

equals()方法

  • public boolean equals(Object obj){}

  • 默认实现为(this == obj),比较两个对象地址是否相等

  • 可进行覆盖,比较两个对象的内容是否相同

  • package com.tang.object;
    
    public class TestStudent {
        public static void main(String[] args) {
            Student s1 = new Student("aaa", 20);
            Student s2 = new Student("bbb", 20);
            //4.equals方法,判断两个对象是否相等
            System.out.println("--------------equals方法--------------");
            System.out.println(s1.equals(s2));
            Student s3 = new Student("hhh", 19);
            Student s4 = new Student("hhh", 19);
            System.out.println(s3.equals(s4));
        }
    }
    

equals()方法覆盖步骤

  • 比较两个引用是否指向同一个对象

  • 判断obj是否为null

  • 判断两个引用指向的实际对象类型是否一致

  • 强制类型转换

  • 依次比较各个属性值是否相同

  • @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    

finalize()方法

  • 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列

  • 垃圾对象:没有有效引用指向此对象时,为垃圾对象

  • 垃圾回收:由GC销毁垃圾对象,释放数据存储空间

  • 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象

  • 手动回收机制:使用System.gc();通知JVM执行垃圾回收

  • package com.tang.object;
    
    import java.util.Objects;
    
    /**
     * 学生类
     */
    public 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 +
                    '}';
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
        @Override
        protected void finalize() throws Throwable {
            System.out.println(this.name+"对象被回收了");
        }
    }
    --------------------------------------
    package com.tang.object;
    
    public class TestStudent {
            //5.finalize方法
            new Student("hc", 18);
            new Student("ic", 18);
            new Student("gc", 18);
            //回收垃圾
            System.gc();
            System.out.println("回收垃圾");
        }
    }
    

Math类

java.lang

  • random():生成[0,1)之间的随机数

  • max(a,b)/min(a,b):比较两个数的大小

  • pow(a,b):获取a的b次方

  • sqrt(a):求a的平方根

  • ceil(a)/floor(a):向上/下取整,返回double

  • round(a):四舍五入取整

  • abs(a):获取绝对值(int、long、float、double)

  • package com.tang.math;
    
    public class MathTest {
        public static void main(String[] args) {
            //ceil 天花板,向上取整
            System.out.println(Math.ceil(3.57));//4
            System.out.println(Math.ceil(-3.57));//-3
            //floor 地板,向下取整
            System.out.println(Math.floor(3.57));//3
            System.out.println(Math.floor(-3.57));//-4
            //round 四舍五入 取整返回一个long
            System.out.println(Math.round(4.49));//4
            System.out.println(Math.round(-4.49));//-4
            System.out.println(Math.round(4.51));//5
            //abs 绝对值
            System.out.println(Math.abs(-3.45));
            //求 x 的 y 次幂,返回一个double
            System.out.println(Math.pow(3, 5));
            //求 x 的 平方根
            System.out.println(Math.pow(10, 0.5));
            System.out.println(Math.sqrt(10));
            //随机数 生成[0,1)之间的随机数
            System.out.println(Math.random());
            //生成指定区间的随机整数
            // Math.random() * (max - main) + min
            double rd = (Math.random() * 15 + 5);
            long r = (long) rd;
            System.out.println(rd);
            System.out.println(r);
            //sin30° 代表不是度数,参数代表的是弧度
            //弧度 = PI / 180 * 度数
            System.out.println(Math.sin(Math.PI / 180 * 30));
        }
    }
    

Random类

伪随机数

  • nextInt():随机产生一个整数

  • nextInt(n):随机产生一个[0,n)之间的浮点数

  • nextFloat/nextDouble():随机生成[0,1)的浮点数

  • nextBytes(byte[] b):生成随机数组,元素范围: byte范围

  • package com.tang.random;
    
    import java.util.Arrays;
    import java.util.Random;
    
    /**
     * 伪随机数
     */
    public class RandomTest {
        public static void main(String[] args) {
            //所有的int整数
            int r1 = new Random().nextInt();
            //[0,10)的整数
            int r2 = new Random().nextInt(10);
            //[0,1)的浮点数
            double r3 = new Random().nextDouble();
            //[0,5)的浮点数
            double r4 = new Random().nextDouble(5);
            //生成随机数组,元素范围: byte范围
            byte[] b = new byte[5];
            new Random().nextBytes(b);
            System.out.println(Arrays.toString(b));
            System.out.println(r2);
        }
    }
    

SecureRandom安全随机数

  • SecureRandom安全随机数,密码学中安全的随机数非常重要

    • getInstanceStrong()创建高强度安全随机数

    • new SecureRandom()创建普通安全随机数

    • package com.tang.random;
      
      import java.security.NoSuchAlgorithmException;
      import java.security.SecureRandom;
      
      public class SecureRandomTest {
          public static void main(String[] args) throws NoSuchAlgorithmException {
              //普通的安全随机数
              SecureRandom random = new SecureRandom();
              SecureRandom rad = SecureRandom.getInstanceStrong();
              System.out.println(random.nextInt(10));
          }
      }
      

包装类

  • 基本数据类型所对应的引用数据类型

  • Object可统一所有数据,包装类的默认值是null

  • 基本类型与包装类对应关系

  • 包装类

  • package com.tang.wrap;
    
    public class WrapTest {
        public static void main(String[] args) {
            Integer a = new Integer(333);
            System.out.println(Integer.MAX_VALUE);//int类型的最大值
            System.out.println(Integer.MIN_VALUE);//int类型的最小值
            Integer b = new Integer(333);
            //比较引用数据类型,代表比较地址是否相等
            System.out.println(a == b);
            // a 和 b 内容是否相等
            System.out.println(a.equals(b));
            //int比较
            System.out.println(Integer.compare(a, b));
            //比较Integer对象的值
            System.out.println(a.compareTo(b));
            //两个数的最大值
            System.out.println(Integer.max(a, b));
            //两个数的和
            System.out.println(Integer.sum(a, b));
            //基本类型-转-包装类型
            System.out.println(Integer.valueOf("333"));
            //包装类型-转-基本类型
            System.out.println(a.floatValue());
            //将数字以不同的进制形式 转成 字符串
            //转-二进制
            System.out.println(Integer.toBinaryString(a));
            //转-八进制
            System.out.println(Integer.toOctalString(a));
            //转-十六进制
            System.out.println(Integer.toHexString(a));
            //将数字(其他进制)格式的字符串 转成对应的 十进制数字
            System.out.println(Integer.valueOf("100", 8));
            System.out.println(Integer.valueOf("100", 5));
            //各个进制书写方式
            System.out.println(0b1111);//二进制
            System.out.println(017);//八进制
            System.out.println(15);//十进制
            System.out.println(0xf);//十六进制
        }
    }
    

类型转换与装箱、拆箱

  • 8种包装类提供不同类型间的转换方式:

    • Number父类(整数与浮点数的包装类的父类)中提供的6个共性方法

    • 装箱:Integer.valueOf(num);

    • 拆箱:integer.intValue();

      • 拆箱,会产生NullPointerException错误

      • int n = 0; //0可以装箱
        Integer i = null; //null无法拆箱
        int sum = i + 4; //产生NullPointerException错误
        System.out.println(sum);
        
    • package com.tang.wrap;
      
      /**
       * JDK1.5之后,提供自动装箱和拆箱
       */
      public class WrapDemo1 {
          public static void main(String[] args) {
              //1.类型转换:装箱,基本类型转换成引用类型的过程:Integer.valueOf(num);
              int num1 = 18;
              Integer integer1 = new Integer(num1);//过时
              Integer integer2 = Integer.valueOf(num1);
              //自动装箱
              Integer integer3 = num1;
              //2.类型转换:拆箱,引用类型转换成基本类型的过程:integer.intValue();
              Integer integer4 = Integer.valueOf(18);
              int num2 = integer4.intValue();
              //自动拆箱
              int num3 = integer4;
          }
      }
      
    • parseXXX()静态方法

      • 引用类型-->基本类型:int n = Integer.parseInt("234");
    • valueOf()静态方法

      • 基本类型-->引用类型:String s = String.valueOf(20);
    • 注意:需要保证类型兼容,否则抛出NumberFormatException异常

    • package com.tang.wrap;
      
      /**
       * JDK1.5之后,提供自动装箱和拆箱
       */
      public class WrapDemo1 {
          public static void main(String[] args) {
              //基本类型与字符串之间相互转换
              //1 基本类型-->字符串
              int n1 = 255;
              //1.1使用+号
              String s1 = n1+"";
              //1.2使用Integer中的toString()方法
              String s2 = Integer.toString(n1,16);//ff
              String s3 = String.valueOf(n1);
              System.out.println(s1);
              System.out.println(s2);
              System.out.println(s3);
              //2 字符串-->基本类型
              String str="150";
              //使用Integer.parseXXX();
              int n2 = Integer.parseInt(str);
              System.out.println(n2);
      
              //字符串转成boolean基本类型
              String str2 = "true";
              boolean b1 = Boolean.parseBoolean(str2);
              System.out.println(b1);//true
          }
      }
      

整数缓冲区

  • Java预先创建了256个常用的整数包装类型对象

  • 在实际应用当中,对已创建的对象进行复用

  • package com.tang.wrap;
    
    public class WrapDemo2 {
        public static void main(String[] args) {
            //面试题
            Integer integer1 = new Integer(100);//过时
            Integer integer2 = new Integer(100);
            System.out.println(integer1 == integer2);//false
            Integer integer3 = 127;//自动装箱
            Integer integer4 = Integer.valueOf(127);
            System.out.println(integer3 == integer4);//true
            Integer integer5 = 128;//自动装箱
            Integer integer6 = 128;//自动装箱
            System.out.println(integer5 == integer6);//false
        }
    }
    

BigInteger类

java.math

  • 继承java.lang.Number

  • package com.tang.wrap;
    
    import java.math.BigInteger;
    
    public class TestBigInteger {
        public static void main(String[] args) {
            //构建一个BigInteger对象
    
            BigInteger bd = new BigInteger("5");
            //加法
            BigInteger r1 = bd.add(new BigInteger("3"));
            System.out.println(r1);
            //减法
            BigInteger r2 = bd.subtract(new BigInteger("4"));
            System.out.println(r2);
            //乘法
            BigInteger r3 = bd.multiply(new BigInteger("6"));
            System.out.println(r3);
            //除法
            BigInteger r4 = bd.divide(new BigInteger("3"));
            System.out.println(r4);
            //求余
            BigInteger r5 = bd.mod(new BigInteger("3"));
            System.out.println(r5);
            //将 基本数据类型 转换成 BigInteger
            BigInteger bi = BigInteger.valueOf(3);
            //将 BigInteger 转换成 基本数据类型
            int i = bi.intValue();
            System.out.println(i);
        }
    }
    

BigDecimal类

java.math

  • 继承java.lang.Number

  • 思考:以下程序输出结果是多少

  • public class TestBigDecimal {
        public static void main(String[] args) {
            double d1 = 1.0;
            double d2 = 0.9;
            System.out.println(d1-d2);
            //0.09999999999999998
        }
    }
    
  • 很多实际应用中需要精确运算,而double是近似值存储,不符合要求,需要借助BigDecimal。

  • 位置:java.math包中

  • 作用:精确计算浮点数

  • 创建方式:BigDecimal bd = new BigDecimal("1.0");

  • 方法:

    • public BigDecimal add(BigDecimal bd) 加

    • public BigDecimal subtract(BigDecimal bd) 减

    • public BigDecimal multiply(BigDecimal bd) 乘

    • public BigDecimal divide(BigDecimal bd, int scal, RoundingMode mode) 除

    • scale():获取小数个数

    • precision():获取有效数字个数

    • setScale(n, RoundingMode):保留小数个数,进制规则

      • 第二个参数不设置,默认是ROUND_UNNECESSARY,保留n位小数,n位之后必须都为0,否则报错

      • RoundingMode.UP:绝对值向上取整

      • RoundingMode.DOWN(常用):直接截断

      • RoundingMode.HALF_UP(常用):四舍五入,相当于Math.round的用法

      • RoundingMode.CEILING:向上取整,相当于Math.ceil的用法

      • RoundingMode.FLOOR:向下取整,相当于Math.floor的用法

      • RoundingMode.HALF_DOWN:如果大于0.5,则舍入,否则舍弃

    • stripTrailingZeros():截取小数点尾部的0

    • package com.tang.wrap;
      
      import java.math.BigDecimal;
      import java.math.RoundingMode;
      
      public class TestBigDecimal {
          public static void main(String[] args) {
              double d1 = 1.0;
              double d2 = 0.9;
              System.out.println(d1-d2);
              //面试题
              double result = (1.4-0.5)/0.9;
              System.out.println(result);
              //BigDecimal,大的浮点数精确计算
              BigDecimal bd1 = new BigDecimal("1.0");
              BigDecimal bd2 = new BigDecimal("0.9");
              //减法
              BigDecimal r1 = bd1.subtract(bd2);
              System.out.println(r1);
              //加法
              BigDecimal r2 = bd1.add(bd2);
              System.out.println(r2);
              //乘法
              BigDecimal r3 = bd1.multiply(bd2);
              System.out.println(r3);
              //除法
              BigDecimal r4 = bd1.divide(bd2,3, RoundingMode.HALF_UP);
              System.out.println(r4);
              //-------------------------------------
              BigDecimal decimal = new BigDecimal("1.122133313213244434232");
              decimal = decimal.multiply(new BigDecimal("1.234324545445653532"));
              System.out.println(decimal);
              //获取小数位数
              System.out.println(decimal.scale());
              //获取有效数字个数
              System.out.println(decimal.precision());
              //获取转换为字符串后的长度
              System.out.println(decimal.toString().length());
              System.out.println("-----------------------保留小数设置------------------------");
              //保留小数个数
              System.out.println(new BigDecimal("20.38000").setScale(2));
              //RoundingMode.UP:绝对值向上取整
              System.out.println(new BigDecimal("12.32243").setScale(2, RoundingMode.UP));
              System.out.println(new BigDecimal("-12.32243").setScale(2, RoundingMode.UP));
              //RoundingMode.DOWN(常用):直接截断
              System.out.println(new BigDecimal("12.32243").setScale(2, RoundingMode.DOWN));
              System.out.println(new BigDecimal("-12.32243").setScale(2, RoundingMode.DOWN));
              //RoundingMode.HALF_UP(常用):四舍五入
              System.out.println(new BigDecimal("12.35243").setScale(2, RoundingMode.HALF_UP));
              System.out.println(new BigDecimal("-12.34243").setScale(2, RoundingMode.HALF_UP));
              //RoundingMode.CEILING:向上取整
              System.out.println(new BigDecimal("12.31").setScale(1, RoundingMode.CEILING));
              System.out.println(new BigDecimal("-12.31").setScale(1, RoundingMode.CEILING));
              //RoundingMode.FLOOR:向下取整
              System.out.println(new BigDecimal("12.31").setScale(1, RoundingMode.FLOOR));
              System.out.println(new BigDecimal("-12.31").setScale(1, RoundingMode.FLOOR));
              //RoundingMode.HALF_DOWN:如果大于0.5,则舍入,否则舍弃
              System.out.println(new BigDecimal("12.3500").setScale(1, RoundingMode.HALF_DOWN));
              System.out.println(new BigDecimal("-12.3501").setScale(1, RoundingMode.HALF_DOWN));
              //stripTrailingZeros:截取小数点尾部的0
              BigDecimal i = new BigDecimal("3000000000000000000000.00000").stripTrailingZeros();
              BigInteger j = new BigDecimal("3000000000000000000000.00000").stripTrailingZeros().toBigInteger();
              BigDecimal k = new BigDecimal("3000000100000000000000.13000").stripTrailingZeros();
              System.out.println(i);
              System.out.println(j);
              System.out.println(k);
          }
      }
      
    • 除法:divide(BigDecimal bd, int scal, RoundingMode mode)

    • 参数scal:指定精确到小数点后几位

    • 参数mode:

      • 指定小数部分的取舍模式,通常采用四舍五入的模式

      • 取值为RoundingMode.HALF_UP

练习3

比较器

  • * 实现了 Comparable 接口,该类就可以比较大小
    * 比较规则由 compareTo 方法来制定
    * sort 可以直接对 基本数据类型 进行排序
    * sort 如果要对 引用数据类型 进行排序,
    	那么 该引用类型必须要 实现Comparable接口
        或者 在调用 sort 的时候,传入 自定义的排序规则
            自定义排序规则由 Comparator 接口提供
    * sort 默认按照 自然顺序 排列
    * 实现了 Iterable 接口,该类就可以进行迭代
    

Integer数组排序

  • 定义一个Integer[]数组,存放多个无序的数字

    1. 要求使用Array.sort完成升序排列

    2. 要求使用Array.sort完成降序排列

    3. 要求使用Array.sort完成随机排列

    4. Comparator接口

      package com.tang.wrap;
      
      import java.util.Arrays;
      import java.util.Comparator;
      
      /**
       * 定义一个Integer[]数组,存放多个无序的数字
       *      1. 要求使用Array.sort完成升序排列
       *      2. 要求使用Array.sort完成降序排列
       *      3. 要求使用Array.sort完成随机排列
       */
      public class Demo {
          public static void main(String[] args) {
              Integer[] array = {23,54,65,78,35};
              //使用Array.sort完成降序排列
              Arrays.sort(array, Comparator.reverseOrder());//降序
              System.out.println(Arrays.toString(array));
              //下面的Lambda表达式---就是重写了Comparator接口中的compare方法
              Arrays.sort(array, (a,b)->{
                  return b.compareTo(a);
              });//降序
              System.out.println(Arrays.toString(array));
              //使用Array.sort完成随机排列
              Arrays.sort(array, (a,b)->{
                  return Math.random()<0.5 ? -1 : 1;
              });
              System.out.println(Arrays.toString(array));
          }
      }
      

枚举类

package com.tang.wrap;

/**
 * 枚举类
 *      枚举类 用关键字 enum 进行定义
 *      所有的枚举类都继承 Enum 类
 * 枚举类 拥有 name , ordinal 属性
 *      name 用来获取 枚举值 对应的 字符串表示形式, 例如 M 是SexType的值,他的字符串标识形式为"M"
 *      ordinal 用来获取 定义枚举值的 索引顺序, 默认从0开始,不推荐使用
 *
 * 枚举类 中 可以定义属性, 但属性推荐用 final 修饰
 */
public enum EnumGender {
    M("男"),
    F("女"),
    S("保密");
    public final String value;

    private EnumGender(String value) {
        this.value = value;
    }
}
class Test{
    public static void main(String[] args) {
        EnumGender sex = EnumGender.M;
        System.out.println(sex.name());
        System.out.println(sex.value);
    }
}

String类

  • 字符串是常量,创建之后不可改变

  • 字符串字面值存储在字符串(常量)池中,可以共享

  • 字符串创建

  • package com.tang.String;
    
    public class Demo1 {
        public static void main(String[] args) {
            String name = "hello";//存储在常量池
            name = "zhangsan";//重新开辟空间
            String name2 = "zhangsan";
            System.out.println(name==name2);//true
            System.out.println(name.equals(name2));//true
    
            //字符串的另一种创建方式
            String str = new String("aaa");
            String str2 = new String("aaa");
            System.out.println(str==str2);//false
            System.out.println(str.equals(str2));//false
        }
    }
    

常用方法

  • public int length():返回字符串的长度

  • public char charAt(int index):根据下标获取字符

  • public boolean contains(String str):判断当前字符串中是否包含str

  • public char toCharArray():将字符串转换成数组

  • public int indexOf(String s):查找s首次出现的下标,存在,则返回该下标;不存在,则返回-1。

  • public int lastIndexOf(String s):查找字符串s在当前字符串中最后一次出现的索引

  • public String trim():去掉字符串前后的空格

  • public String toUpperCase():将小写转成大写

  • public boolean endWith(String s):判断字符串是否以s结尾

  • public String replace(char oldChar,char newChar):将旧字符串替换成新字符串

  • public String[] split(String s):根据s做拆分

  • String.join()方法:字符串拼接,与String.split()方法刚好相反

  • System.out.println(String.join(",", "e", "a", "h"));//e,a,h
    
  • 补充:

    • equalsIgnoreCase(s):忽略大小写比较

    • compareTo():比较大小

  • package com.tang.String;
    
    import java.util.Arrays;
    
    public class Demo2 {
        public static void main(String[] args) {
            //字符串方法的使用
            String str = "TangGuoTang糖果思雨淑敏";
            //1.length():返回字符串的长度
            System.out.println(str.length());
            //2.charAt(int index):根据下标获取字符
            System.out.println(str.charAt(8));
            //3.contains(String str):判断当前字符串中是否包含str
            System.out.println(str.contains("Tang"));
            //4.toCharArray():将字符串转换成数组
            System.out.println(Arrays.toString(str.toCharArray()));
            //5.indexOf(String s):查找s首次出现的下标
            System.out.println(str.indexOf("Tang"));
            System.out.println(str.indexOf("Tang",2));
            //6.lastIndexOf(String s):查找s最后一次出现的下标索引
            System.out.println(str.lastIndexOf("Tang"));
            //7.trim():去掉字符串前后的空格
            String str2 = "    Hello World  ";
            System.out.println(str2.trim());
            //8.toUpperCase():将小写转成大写; toLowerCase():大转小
            System.out.println(str2.toUpperCase());
            System.out.println(str2.toUpperCase().toLowerCase());
            //9.endWith(String s):判断字符串是否以s结尾
            String str3 = "Hello World";
            System.out.println(str3.endsWith("World"));
            System.out.println(str3.startsWith("Hello"));
            //10.replace(char oldChar,char newChar):将旧字符串替换成新字符串
            System.out.println(str3.replace("World", "tangGuo"));
            //11.split(String s):根据s做拆分
            String s = "糖果 , 思雨,  淑敏 ,甜甜";
            String[] as = s.split("[ ,]+");
            for (String a : as) {
                System.out.println(a);
            }
            
            //补充两个方法equals compareTo();比较大小
            System.out.println("----------补充----------");
            String s1 = "hello";
            String s2 = "Hello";
            System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写比较
            String s3 = "abc";//97
            String s4 = "xyz";//120
            System.out.println(s3.compareTo(s4));//-23
            String s5 = "abc";
            String s6 = "abcxyz";
            System.out.println(s5.compareTo(s6));//-3
        }
    }
    

案例演示

  • 需求:

    • 已知String str = "this is a text";

      1. 将str中的单词单独获取出来

      2. 将str中的text替换为practice

      3. 在text前面插入easy

      4. 将每个单词的首字母改为大写

      package com.tang.String;
      
      import java.nio.charset.Charset;
      
      public class Demo {
          public static void main(String[] args) {
              String str = "this is a text";
              // 1.将str中的单词单独获取出来
              String[] arr = str.split(" ");
              for (String s : arr) {
                  System.out.println(s);
              }
              // 2.将str中的text替换为practice
              System.out.println(str.replace("text", "practice"));
              // 3.在text前面插入easy
              System.out.println(str.replace("text", "easy text"));
              // 4.将每个单词的首字母改为大写
              str = "";
              for (String s : arr) {
                  char first = s.charAt(0);
                  //把第一个字符转成大写
                  char upperFirst = Character.toUpperCase(first);
                  String s1 = upperFirst + s.substring(1);
                  str = str + " " + s1;
              }
              System.out.println(str.trim());
          }
      }
      

Buffer与Builder、Joiner

  • StringBuffer用法与StringBuilder一样

  • StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全

  • StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全,在多线程环境下,使用的时候,需要注意安全

StringBuffer

  • package com.tang.StringBufferBuilder;
    
    /**
     * StringBuffer和StringBuilder的使用
     * (1)比String效率高
     * (2)比String节省内存
     */
    public class Demo1 {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            //1.append()追加
            sb.append("tangGuo ");
            System.out.println(sb);
            sb.append("siYu ");
            System.out.println(sb);
            sb.append("shuMin");
            System.out.println(sb);
            //2.insert()添加
            sb.insert(0,"friend: ");
            System.out.println(sb);
            //3.replace()
            sb.replace(0,sb.length(),"very good");
            System.out.println(sb);
            //4.delete()删除
            sb.delete(0,3);
            System.out.println(sb);
            //清空
            sb.delete(0,sb.length());
            System.out.println(sb.length());
        }
    }
    
  • package com.tang.StringBufferBuilder;
    
    /**
     * 验证StringBuilder效率高于String
     */
    public class Demo2 {
        public static void main(String[] args) {
            //String用时
            long start = System.currentTimeMillis();
            String string = "";
            for (int i = 0; i < 10000; i++) {
                string+=i;
            }
            System.out.println(string);
            long end = System.currentTimeMillis();
            System.out.println("String用时"+(end-start));
            //StringBuilder用时
            start = System.currentTimeMillis();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 10000; i++) {
                sb.append(i);
            }
            System.out.println(sb);
            end = System.currentTimeMillis();
            System.out.println("StringBuilder用时"+(end-start));
        }
    }
    

StringBuilder

  • StringBuffer用法与StringBuilder一样

  • package com.tang.StringBuilder;
    
    /**
     * StringBuilder
     *      字符串构造器,可以创建长度可变的字符串
     */
    public class Demo1 {
        public static void main(String[] args) {
            //创建对象,共3种方式
            StringBuilder sb = new StringBuilder(10);//值为空字符串,不是null
            //sb = new StringBuilder("abc");
            //StringBuilder sb2 = new StringBuilder(sb);
            sb.append("helloWorld");
            sb.append("helloWorld");
            //删除字符[2,4)
            sb.delete(2,4);
            //删除一个字符
            sb.deleteCharAt(0);
            System.out.println(sb);
            //查找索引
            //查找第一次出现的索引
            System.out.println(sb.indexOf("l"));
            //查找第二次出现的索引
            System.out.println(sb.indexOf("l", sb.indexOf("l") + 1));
            //反转字符串
            System.out.println(sb.reverse());
            System.out.println(sb);
            System.out.println(sb.length());
            //字符串转StringBuilder
            String s = "abc";
            StringBuilder sb2 = new StringBuilder(s);
            //StringBuilder转字符串
            String s1 = sb2.toString();
            System.out.println(String.join(",", "e", "a", "gh", "h"));
        }
    }
    

StringJoiner

  • 按照相同的分隔符,拼接字符。与String.split()方法相反

  • package com.tang.StringJoiner;
    
    import java.util.StringJoiner;
    
    public class Demo {
        public static void main(String[] args) {
            //创建StringJoiner对象,?为分隔符
            StringJoiner joiner = new StringJoiner("?");
            //参数: 分隔符,前缀,后缀
            StringJoiner joiner2 = new StringJoiner(",","H--","--W");
            //如果字符串为空: 将设置成XXX
            System.out.println("默认字符: "+joiner.setEmptyValue("XXX"));
            //拼接元素
            joiner.add("a");
            joiner.add("b");
            System.out.println(joiner);//a?b
            joiner2.add("c");
            joiner2.add("d");
            System.out.println(joiner2);//H--c,d--W
            //将两个Joiner合并成一个Joiner
            joiner.merge(joiner2);
            System.out.println(joiner);//a?b?c,d
            joiner2.merge(joiner);
            System.out.println(joiner2);//H--c,d,a?b?c,d--W
        }
    }
    

日期时间类

Date日期

  • Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代

  • 时间单位

    • 1秒=1000毫秒

    • 1毫秒=1000微秒

    • 1微秒=1000纳秒

    • package com.tang.date;
      
      import java.time.Instant;
      import java.util.Date;
      
      public class DateDemo1 {
          public static void main(String[] args) {
              //1.创建一个当前系统时间的日期对象
              Date date1 = new Date();
              System.out.println(date1);
              Date date = new Date(0);
              //东八区,和格林尼治时间,相差8个小时
              System.out.println(date);
              //2.方法after before
              System.out.println(date1.after(date));
              System.out.println(date.before(date1));
              //比较compareTo()
              System.out.println(date1.compareTo(date));//结果-1,0,1
              //比较是否相等equals()
              System.out.println(date1.equals(date));
              //3.时间戳
              System.out.println(date1.getTime());
              //昨天
              long ms = date1.getTime() - 1000 * 60 * 60 * 24;
              //重置时间
              date.setTime(ms);
              //新建时间
              System.out.println(new Date(ms));
              System.out.println(date);
              //jdk8新特性
              Instant instant = date.toInstant();
              System.out.println(instant);//格林尼治时间
              Date d = Date.from(instant);
              System.out.println(d);
          }
      }
      

Calendar日历(建议使用)

  • Calendar提供了获取或设置各种日历字段的方法

  • 月份:0-11代表1-12月

  • 星期:1-7代表周日-周六

  • 构造方法

    • protected Calendar():由于修饰符protected,所以无法直接创建该对象

    • 其他方法

    • Calendar方法

    • package com.tang.date;
      
      import java.util.Calendar;
      
      public class CalendarDemo1 {
          public static void main(String[] args) {
              //1.创建Calendar对象
              Calendar calendar = Calendar.getInstance();
              System.out.println(calendar.getTime().toInstant());
              System.out.println(calendar.getTimeInMillis());//获取毫秒值
              //2.获取时间信息
              //年
              int year = calendar.get(Calendar.YEAR);
              System.out.println(year);
              //月
              int month = calendar.get(Calendar.MONTH);
              System.out.println(month);
              //日
              int day = calendar.get(Calendar.DATE);
              System.out.println(day);
              System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
              //星期 ,  1 代表周日 ,  7 代表周六
              System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
              //小时
              int hour = calendar.get(Calendar.HOUR_OF_DAY);
              //System.out.println(calendar.get(Calendar.HOUR));//12小时
              System.out.println(hour);//24小时
              //分钟
              int minute = calendar.get(Calendar.MINUTE);
              System.out.println(minute);
              //秒
              int second = calendar.get(Calendar.SECOND);
              System.out.println(second);
              System.out.println(year+"年"+(month+1)+"月"+day+"日 "+hour+"时"+minute+"分"+second+"秒");
              //3.修改时间
              Calendar calendar2 = Calendar.getInstance();//新建日期
              calendar2.set(2021,3,5);//修改字段
              //通过常量 设置 日历
              calendar2.set(Calendar.DAY_OF_MONTH,22);//修改日期字段
              calendar2.set(Calendar.MONTH,1);//修改日期字段
              System.out.println(calendar2.getTime().toInstant());
              //4.add方法修改时间
              calendar2.add(Calendar.HOUR_OF_DAY,20);
              System.out.println(calendar2.getTime().toInstant());
              //5.补充方法:获取 月/日等的 最大/小值
              int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
              int max1 = calendar2.getActualMaximum(Calendar.DATE);//同上面结果相同
              int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
              System.out.println(max);
              System.out.println(max1);
              System.out.println(min);
          }
      }
      

练习

  • 根据月份生成该月日历

  • package com.tang.date;
    
    import java.util.Calendar;
    
    public class DemoCalendar {
        public static void main(String[] args) {
            //5 代表5月份
            showCalendar(2022,5);
        }
    
        public static void showCalendar(int year, int month){
            System.out.println(year+"年"+month+"月");
            //月份减一
            --month;
            // 第一行
            String[] weeks = {"一","二","三","四","五","六","日"};
            for (String week : weeks) {
                System.out.print(week + "\t");
            }
            System.out.println();
            //构建一个日历对象
            Calendar date = Calendar.getInstance();
            //调用日历到 当月
            date.set(year,month,1);
            //获取当前 月最大的天数
            int max = date.getActualMaximum(Calendar.DAY_OF_MONTH);
            //获取当月的一号是星期几, 1-7 : 对应 : 周日 - 周六
            int week = date.get(Calendar.WEEK_OF_MONTH);
            //设置 1-7 : 对应 : 周一 - 周日
            week = week==1?7:week-1;
            /* System.out.println(year+"年"+(month+1)+"月"+"1"+"日, 是周"+week); */
            //调用日历到 上月
            date.set(Calendar.MONTH,month-1);
            //获取上月 最大的天数
            int d = date.getActualMaximum(Calendar.DAY_OF_MONTH);
            dayOfMonth(max,week);/*显示当月的日历*/
            // 第二行
            //获取上月显示的日期
            for (int i = 1; i < week; i++) {
                System.out.print((d-(week-1-i))+"\t");
            }
            int start = 1;//记录日历,从1号开始
            //本月 开始行 显示的日期
            for (int j = week; j <= 7; j++) {
                System.out.print(start+"\t");
                start = start == max ? 0 : start;
                start++;
            }
            System.out.println();
            // 第3-7行 显示的日期
            for (int i = 0; i < 5; i++) {
                for (int j = 1; j <= 7; j++) {
                    System.out.print(start+"\t");
                    start = start == max ? 0 : start;
                    start++;
                }
                System.out.println();
            }
        }
    
        /**
         * 显示当月的日历,结合上面的方法,可以作为显示日历的方法来用
         * @param maxDay 当月最大天数
         * @param week 当月1号是星期几
         */
        public static void dayOfMonth(int maxDay, int week){
            for (int i = 1; i < week; i++) {
                System.out.print("\t");
            }
            for (int i = 1; i <= maxDay; i++) {
                System.out.print(i+"\t");
                if (8 - week == i % 7) {
                    System.out.println();
                }
            }
            System.out.println("\n");
        }
    }
    

时区

TimeZone

  • TimeZone.getAvailableIDs():获取系统支持的所有时区

  • TimeZone.getTimeZone("Asia/Shanghai"):获取中国时区

  • toZoneId():TimeZone时区转ZoneId时区

  • package com.tang.date;
    
    import java.time.ZoneId;
    import java.util.Arrays;
    import java.util.Calendar;
    import java.util.TimeZone;
    
    public class TimeZoneDemo {
        public static void main(String[] args) {
            //获取系统支持的所有时区
            String[] availableIDs = TimeZone.getAvailableIDs();
            System.out.println(Arrays.toString(availableIDs));
            //获取时区
            TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");
            System.out.println(timeZone);
            //日历设置时区
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeZone(timeZone);
            //JDK1.8新特性 转成新的ZoneId时区
            ZoneId zoneId = timeZone.toZoneId();
            System.out.println(zoneId);
        }
    }
    

JDK1.8新特性(建议用)

java.time

ZoneId时区
  • ZoneId.systemDefault():获取系统默认时区

  • ZoneId.of("Asia/Shanghai"):构建时区

  • ZoneId.getAvailableZoneIds():获取可用的所有时区集合

  • package com.tang.date;
    
    import java.time.ZoneId;
    import java.util.Set;
    
    public class ZoneIdDemo {
        public static void main(String[] args) {
            //1.ZoneId.systemDefault() 获取系统默认时区
            ZoneId zoneId = ZoneId.systemDefault();
            System.out.println(zoneId);
            //2.ZoneId.of("Asia/Shanghai") 构建时区
            ZoneId of = ZoneId.of("Asia/Shanghai");
            System.out.println(of);
            //3.ZoneId.getAvailableZoneIds() 获取可用的所有时区集合
            Set<String> sets = ZoneId.getAvailableZoneIds();
            System.out.println(sets.size());
        }
    }
    
本地日期和时间
  • LocalDateTime/LocalDate/LocalTime:获取本地的日期、时间

    • 静态方法

      • now():获取当前系统时间

      • of(year,month,...):设置时间

      • from(TemporalAccessor):从一个LocalDateTime/LocalDate/LocalTime获取时间

      • parse(text,DateTimeFormatter):字符串解析成时间

      • package com.tang.date;
        
        import java.time.LocalDate;
        import java.time.LocalDateTime;
        import java.time.LocalTime;
        import java.time.format.DateTimeFormatter;
        
        public class LocalDateTimeDemo1 {
            public static void main(String[] args) {
                //获取当前系统日期时间
                System.out.println(LocalDateTime.now());
                System.out.println(LocalDate.now());
                System.out.println(LocalTime.now());
                //设置时间
                System.out.println(LocalDate.of(2010, 6, 28));
                System.out.println(LocalTime.ofNanoOfDay(23L*60*60*1000*1000*1000));//纳秒
                //从LocalDateTime/LocalDate/LocalTime获取时间
                System.out.println(LocalDate.from(LocalDateTime.now()));
                System.out.println(LocalTime.from(LocalDateTime.now()));
                //设置日期时间格式
                DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
                //格式化时间
                System.out.println(dtf.format(LocalDateTime.now()));
                //字符串解析成日期, 要求严格按照格式, 不能少一个字符, 0也要写上, 否则编译不通过
                LocalDateTime parse = LocalDateTime.parse("1997-03-05 08:44:32.545",dtf);
                System.out.println(parse);
                //不能用下面方法 将字符串解析成日期
                //LocalDateTime parse2 = (LocalDateTime) dtf.parse("1997-03-05 08:44:32.545");
            }
        }
        
    • 成员方法

      • format(DateTimeFormatter)

      • 加法计算时间

        • plus(duration)

        • plusYears(years)

        • plusDays(days)

        • .....

      • 减法计算时间

        • minus(duration)

        • minusMonths(months)

        • minusHours(hours)

        • .....

      • 获取对应的日期属性值

        • getDayOfYear()

        • getYear()

        • getHour()

        • .....

      • 重新设置对应的日期信息

        • withDayOfYear(day)

        • withHour(year)

      • package com.tang.date;
        
        import java.time.Duration;
        import java.time.LocalDateTime;
        import java.time.format.DateTimeFormatter;
        import java.time.temporal.ChronoUnit;
        
        public class LocalDateTimeDemo2 {
            public static void main(String[] args) {
                //获取当前系统时间
                LocalDateTime date = LocalDateTime.now();
                //格式化时间
                DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
                System.out.println(date.format(dtf));
                //加法 计算时间
                //日期加3天
                System.out.println(date.plusDays(3));
                System.out.println(date.plus(3, ChronoUnit.DAYS));
                System.out.println(date.plus(Duration.ofDays(3)));
                //日期加3毫秒
                System.out.println(date.plus(3, ChronoUnit.MILLIS));
                //获取对应的日期属性值
                System.out.println(date.getDayOfMonth());
                //重新设置对应的日期信息
                System.out.println(date.withDayOfYear(2));
                System.out.println(date.withHour(7));
            }
        }
        
  • DateTimeFormatter.ofPattern(pattern)

    • format

    • parse

  • ZonedDateTime 带时区的日期和时间

  • package com.tang.date;
    
    import java.time.ZoneId;
    import java.time.ZonedDateTime;
    import java.time.temporal.ChronoField;
    
    public class ZoneDateTimeDemo {
        public static void main(String[] args) {
            //创建一个 ZonedDateTime 对象
            ZonedDateTime date = ZonedDateTime.now(ZoneId.of("America/Cuiaba"));
            System.out.println(date);
            //重置时间
            date = date.with(ChronoField.YEAR, 2000)
                    .with(ChronoField.MONTH_OF_YEAR, 12)
                    .with(ChronoField.DAY_OF_MONTH, 22)
                    .withHour(11)
                    .withMinute(35)
                    .withSecond(55)
                    .withNano(123456789);
            System.out.println(date);
            //获取时间 - 年
            System.out.println(date.get(ChronoField.YEAR));
            // - 月
            System.out.println(date.get(ChronoField.MONTH_OF_YEAR));
            // - 日
            System.out.println(date.getDayOfMonth());
            // - 时
            System.out.println(date.get(ChronoField.HOUR_OF_DAY));
            // - 分
            System.out.println(date.get(ChronoField.MINUTE_OF_HOUR));
            // - 秒
            System.out.println(date.get(ChronoField.SECOND_OF_MINUTE));
            // - 毫秒
            System.out.println(date.get(ChronoField.MILLI_OF_SECOND));
            // - 微秒
            System.out.println(date.get(ChronoField.MICRO_OF_SECOND));
            // - 纳秒
            System.out.println(date.get(ChronoField.NANO_OF_SECOND));
            //获取时区
            System.out.println(date.getZone());
        }
    }
    
  • Instant高精度时间戳

    • Instant instant = Instant.now()//创建高精度时间戳对象

    • instant.getEpochSecond()//获取秒

    • instant.toEpochMilli()//获取毫秒

    • package com.tang.date;
      
      import java.time.Instant;
      import java.time.temporal.ChronoField;
      
      public class InstantDemo {
          public static void main(String[] args) {
              //创建 Instant 高精度时间戳对象
              Instant instant = Instant.now();
              System.out.println(instant);
              //获取秒
              System.out.println(instant.getEpochSecond());
              //获取毫秒
              System.out.println(instant.toEpochMilli());
              //重置秒(从1970年1月1日算起), 毫秒\微秒\纳秒不会被重置
              instant = instant.with(ChronoField.INSTANT_SECONDS, 1);
              System.out.println(instant);
              //重置毫秒\微秒\纳秒,只要重置一个, 另外两个将清零
              System.out.println(instant.with(ChronoField.MILLI_OF_SECOND, 1));
              System.out.println(instant.with(ChronoField.MICRO_OF_SECOND, 1));
              System.out.println(instant.with(ChronoField.NANO_OF_SECOND, 1));
          }
      }
      
  • Duration时间间隔

  • package com.tang.date;
    
    import java.time.Duration;
    import java.time.LocalDateTime;
    
    public class DurationDemo {
        public static void main(String[] args) {
            /*
            * Duration.ofXXX ... 构建一个 间隔对象
            * Duration.toXXX ... 获取间隔的 天\秒等... 返回一个数字
            *  */
            //创建时间对象
            LocalDateTime d1 = LocalDateTime.of(2000,5,12,12,34,3);
            LocalDateTime d2 = LocalDateTime.now();
            //创建时间间隔对象, 计算间隔,  d1 d2 必须有 时\分\秒
            Duration duration = Duration.between(d1, d2);
            System.out.println(duration);//输出结果: d2-d1
            //获取间隔天数
            System.out.println(duration.toDays());
            //构建一个 三天的 时间间隔对象
            Duration threeDays = Duration.ofDays(3);
            //三天前的时间
            d2 = d2.minus(threeDays);
            System.out.println(d2);
    
        }
    }
    
  • ISO8601规范

    • ISO8601规定的日期和时间分隔符是T

    • 日期:yyyy-MM-dd

    • 时间:HH:mm:ss

    • 带毫秒的时间:HH:mm:ss.SSS

    • 日期和时间:yyyy-MM-dd'T'HH:mm:ss

    • 带毫秒的日期和时间:yyyy-MM-dd'T'HH:mm:ss.SSS

SimpleDateFormat

  • SimpleDateFormat是一个(与语言环境有关的方式)格式化和解析日期的具体类

  • 进行格式化(日期 → 文本)、解析(文本 → 日期)

  • 常用的时间模式字母

  • 常用日期格式化字母

  • package com.tang.date;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class FormatDemo1 {
        public static void main(String[] args) {
            //1.创建SimpleDateFormat对象
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2022-05-30 16:28:30
            SimpleDateFormat sdf1 = new SimpleDateFormat("y-M-d H:m:s S");//2022-5-30 16:28:30 493
            //2.创建Date
            Date date = new Date();
            //格式化date
            String fDate = sdf.format(date);
            System.out.println(fDate);
            System.out.println(sdf1.format(date));
            //字符串解析成日期
            Date date2 = sdf.parse("1990-4-3 9:34:52");
            System.out.println(sdf.format(date2));
            //重新设置日期格式
            sdf.applyPattern("yyyy-MM-dd");
            date2 = sdf.parse("1990-4-3");
            System.out.println(sdf.format(date2));
        }
    }
    

System类

  • System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的

  • System类的方法

  • package com.tang.System;
    
    import java.util.Arrays;
    
    public class Demo1 {
        public static void main(String[] args) {
            //1.arraycopy数组复制
            //原数组,开始索引,目标数组,开始索引,复制长度
            int[] arr = {9,3,54,6,7,56,34,8,4};
            int[] arrCopy = new int[4];
            System.arraycopy(arr,3,arrCopy,0,4);
            System.out.println(Arrays.toString(arrCopy));
            //2.获取当前系统时间(时间戳)
            System.out.println(System.currentTimeMillis());
            long start = System.currentTimeMillis();
            for (int i = 0; i < 2000000000; i++) {
                for (int j = 0; j < 2000000000; j++) {
                    int result = i+j;
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("用时: "+(end-start));
            //3.System.gc();告诉垃圾回收器回收垃圾
            Teacher teacher1 = new Teacher("aaa",25);//不回收
            new Teacher("bbb",26);//不一定回收
            new Teacher("ccc",27);//不一定回收
            System.gc();
            //4.退出JVM
            System.exit(0);//退出JVM,程序结束
            System.out.println("程序结束了....");//不执行
        }
    }
    

IDEA快捷键

  • Ctrl+N:搜索
  • Ctrl+H:搜索子类
这篇关于Java常用类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!