• java基础之常用类1

    以下为本人的学习笔记

     

    1、内部类

    • 分类：

      1.内部类：成员内部类，静态内部类， 局部内部类（定义在方法内部），匿名内部类

    • 概念：在一个类的内部再定义一个完整的类（类中类）

    • 特点：

    1. 编译之后可生成独立的字节码文件；

    2. 内部类可直接访问外部类的私有成员，而不破坏封装

    3. 可为外部类提供必要的内部功能组件

    public class Body{
    private String name;
    //内部类
    class Header{
        public void show(){
            //访问外部类私有成员
        System.out.println(name)
        }
    }
}

     

    1.1成员内部类

      1.在类的内部定义，与实例变量、示例方法同级别的类；

      2.外部类的一个实例部分，创建内部类对象时，必须先创建外部类对象：

    • Outer out = new Outer();
    • out.Inner in = out.new Inner();

      3.当外部类、内部类存在重名属性时，会优先访问内部类属性；

      4.成员内部类不能定义静态成员，但是能定义静态常量。

    示例：

    public class Outer{
    private String name="张三";
    private int age = 20;
    
    //内部类 
    class Inner{
        private String address = "北京";
        private String phone="110";
        private String name = "李四";
        
        //方法
        public void show(){
            //打印外部类的属性，内部类属性和外部类的属性名字相同(重名时)：Outer.this
            System.out.println(Outer.this.name);
            System.out.println(age);
            
            //打印内部类中的属性
            System.out.println(this.address);
            System.out.println(phone);
        }
    
    }
}
​
public class TestOuter{
    public static void main(String [] agrs){
        //1创建外部类对象
  //      Outer outer = new Outer();
        //2创建内部类对象，要加外部类对象前缀
  //      outer.Inner inner = outer.new Inner()
            
          //1,2合并为一句
        Inner inner = new Outer().new Inner();
        inner.show();
    }
}

     

    1.2静态内部类

    (静态内部类，在内部类基础上加static,级别相当于外部类，给外部类使用)

      1.不依赖（先创建）外部类对象，可直接创建或通过类名访问

      2.可声明静态成员

      3.只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

    • Outer.Inner inner = new Outer.Inner();
    • Outer.Inner.show();

    示例：

    public class Outer {
​
    private String name ="小米";
    private int age = 19;
​
    //静态内部类
    static class Inner{
        private String name = "计缘";
        private int age =11;
        static private String address = "广东";
        public void show(){
            //1.调用外部类的属性，先创建外部类对象，因为静态内部类与外部类属于同一级别
            Outer outer = new Outer();
            //2.调用外部类的属性
            System.out.println(outer.name);
            //3.调用静态内部类的属性
            System.out.println(name);
            //4.调用静态内部类的静态属性，类名.属性名
            System.out.println(Inner.address);
        }
​
​
    }
}
//测试
public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}
​

     

    1.3局部内部类

    1. 定义在外部类方法中，作用范围和创建对象仅限于当前方法；

      • 局部内部类前缀不能加任何访问修饰符（如，public，protect...),作用范围在方法里

      • 局部内部类和局部变量属于同一级别

      • 静态方法不能访问非静态的成员，因为静态属性是类的属性，不是单个成员的属性

      • 局部内部类不能定义静态变量，但可以定义静态常量

    2. 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final；

    3. 限制类的使用范围。

    局部内部类访问局部变量：

    • 访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final；

    • 因为局部变量在方法完成后会消失，但是局部内部类不会消失，可是局部内部类会使用到一个将要消失的局部变量？所以要让局部变量为常量。

    public class Outer {
​
    private String name = "计缘";
    private int age = 42;
​
    public void show(){
        String address = "广东";
        class Inner{
            private String name = "尹兆先";
            private int age = 43;
​
            public void show2(){
                //访问外部类的属性，Outer.this可省略
                System.out.println(Outer.this.name);
                System.out.println(age);
​
                //访问内部类的属性
                System.out.println(name);
                //访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final
                System.out.println(address);
            }
        }
        //不能在main方法里创建局部内部类对象，
        // 在main方法里调用外部类的show方法是不能调用局部内部类的，因为
        // 上面只做了声明，没有调用。
        // 要调用局部内部类的方法要在上一级方法（跟局部内部类同一级上）创建局部内部类对象并调用方法
        Inner inner = new Inner();
        inner.show2();
    }
}
​
​
//测试
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
​

     

    1.4匿名内部类

    1. 没有类名的局部内部类（一切特征都与局部内部类相同）；

    2. 必须继承一个父类或者实现一个接口；

    3. 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象；

    • 优点：减少代码量；

    • 缺点：可读性较差。

    示例：

    public interface Usb {
    public void service();
}
​
​
public class Mouse implements Usb{
​
    public void service(){
        System.out.println("鼠标正在工作中...");
    }
}
​
​
public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量,多态
//        Usb usb = new Mouse();
//        usb.service();
​
        //局部内部类，main方法也是方法里
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作...");
//            }
//        }
//
//        //使用局部内部类创建对象
//         Usb usb = new Fan();
//          usb.service();
//
​
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb(){//第二个Usb位置可以是接口，抽象类，父类，在方法体里可以重写方法
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作...");
            }
        };
        usb.service();
    }
}
​

     

    2、Object类

    1. 超类、基类，所有类的直接或间接父类，位于继承树的最顶层；
    2. 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承；
    3. Object类中所调用的方法，是所有对象都基本的方法；
    4. Object类型可以存储任何对象
    • 作为参数，可接收任何对象。
    • 作为返回值，可返回任何对象。

    3、Object类常用方法

    3.1getClass()方法

    public final Class getClass(){}
    返回引用中存储的实际对象类型；
    应用：通常用于判断两个引用中实际存储对象类型是否一致。
    示例：

    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;
    }
}
​
​
​
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
​
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
​
    }
}
​ 
    3.2hashCode()方法

    public int hashCode(){}
    返回该对象的哈希码值；
    哈希值根据对象的地址或字符串或数字使用hash算法（系统底层提供）计算出来的int类型的数值；
    一般情况下相同对象返回相同哈希码。
    示例：

      Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());//s1.hashCode()!=s2.hashCode()
        Student s3 = s1;
        System.out.println(s3.hashCode());//s1.hashCode()=s3.hashCode()

     

    3.3 toString()方法

    public String toStrin(){};
    返回该对象的字符串表示；
    可以根据程序需求覆盖该方法，如：展示对象各个属性的值。

         System.out.println(s1.toString());
     System.out.println(s2.toString());//输出：默认名字+返回哈希值的十六进制

    重写toString：

     @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

 
    3.4equals()方法

    public boolean equals （Object obj）{}
    默认(源码)实现为（this == obj）[比较两个对象是否相同]，比较两个对象地址是否相同；
    可进行覆盖（重写后），比较两个对象的内容是否相同
    equals是Object类的方法，默认为比较地址，跟'=='一样，String类中重写equals方法，比较的是值。

      //判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        Student s6 = new Student("小米", 12);
        Student s7 = new Student("小米", 12);
        System.out.println(s6.equals(s7));//false

     
    String类里，覆盖（重写）equals()方法的步骤：

    1. 比较两个引用是否指向同一个对象；
    2. 判断obj是否为null；
    3. 判断两个引用指向的实际对象类型是否一致；
    4. 强制类型转换；
    5. 依次比较各个属性值是否相同。
    //Student类里  
public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this == obj) {
            return true;
        }
        //2.判断obj是否null
        if (obj == null) {
            return false;
        }
        //3.判断是否是同一个类型
//        if (this.getClass() == obj.getClass()) {
//
//        }
        //instanceof 判断对象是否是某种类型
        if (obj instanceof Student) {
            //4.强制类型转换
            Student s = (Student) obj;
            //5.比较属性
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        return false;
    }

    tips： instanceof比较的是前面的实际类型是不是后面对象实际类型的子类或同类，是的话返回true，否则返回false，所以true的情况下要强制转换为同类

     
    3.5finalize（）方法

    finalize：译：最终确定，把(计划、旅行、项目等)最后定下来;定案

    1. 当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列；
    2. 垃圾对象：没有 有效引用（没有被赋予变量等） 指向此对象时，为垃圾对象；
    3. 垃圾回收：由GC销毁垃圾对象，释放数据存储空间；
    4. 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象；
    5. 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。（说是手动，其实还是JVM自动回收，只不过是被人为的告诉JVM一声）。
    //Student类里
 protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了...");
    }
    
//TestStudent类里
     new Student("aaa",32);
        new Student("bbb",32);
        new Student("ccc",32);
        new Student("ddd",32);
        new Student("eee",32);
        System.gc();
        System.out.println("回收垃圾");

    4.包装类

    1. 基本数据类型所对应的引用数据类型；
    2. Object可统一所有数据，包装类的默认值是null；
    3. 包装类对应：
    基本数据类型 包装类型
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    boolean Boolean
    char Character

    如：Byte类将基本类型byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为byte的字段。即把原来放栈里的byte数据放到堆里。

    • 基本类型数据存储在栈空间，且栈里面存对象的引用地址
    • 引用类型数据存储在堆空间，堆里面存对象

    效果图：

     

    4.1、类型转换与装箱、拆箱

    装箱：把基本数据类型转换成引用数据类型的过程，即把栈里面的值放到堆里面。
    拆箱：把引用数据类型转换成基本数据类型的过程，即把堆里面的对象放到栈里面。

    //JDK1.5之前的办法：
//基本类型
int num1 = 18;
//装箱
//法一：使用Integer类创建对象
Integer integer1 = new Integer(num1);
//法二：使用valueof（）方法创建对象
Integer integer2 = Integer.valueOf(num1);
​
//拆箱
Integer integer3 = new Integer(100);
//使用Number里的intValue（）方法。
int num2 = integer3.intValue();
​
//JDK1.5之后，提供自动装箱和拆箱
int age = 30;
//自动装箱    直接给Integer引用类型变量赋予int类型值，背后编译器自动将age转换为Integer.valueOf(age);
Integer integer4 = age;
//自动拆箱  背后编译器自动将integer4转换为Integer4.intValue();
int age2 = integer4

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

    • Number父类中提供的6个共性方法
    • 包装类名.parseXXX()静态方法
    • valueOf()静态方法

    注意：需保证类型兼容，否则抛出NumberFormatException异常

    //基本类型和字符串之间转换
​
//1基本类型转换成字符串
int n1 = 100；
//1.1使用+号
String s1 = n1+"";//s1=100 ,100后有空格字符
//1.2使用Integer的toString（）方法
String s2 = Integer.toString(n1)//s2 = 100
//toString重载方法
//String s2 = Integer.2toString(n1,16);//第二个参数数字表示多少进制
​
//2字符串转成基本类型
String str = "150";
//使用Integer.parseXX();
int n2 = Integer.parseInt(str);//str不能包含除数字的其他字符
​
//boolean字符串形式转成基本类型
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);//输出结果："true"---->true 非"true"---->false
     
    4.2整数缓冲区
    • Java预先创建了256个常用的整数包装类型对象；
    • 在实际应用中，对创建的对象进行复用
    Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(s1 == s2 );//false
​
Integer integer3 = 100;//自动装箱使用Integer.valueOf(100),而Integer.valueOf里规定了一个缓存区，-128到127的缓存数组（256个对象），要赋值时先在这个数组里找已存在的对象
Integer integer4 = 100;//integer4指向的对象是缓存区已有的100对象,即integer3指向的那个对象。
System.out.println(s3 == s4 );//true   
​
Integer integer5 = 200;//自动装箱使用Integer.valueOf(100),200>127,所以不能使用缓存数组。直接在堆new Integer（200）
Integer integer6 = 200;
System.out.println(s5 == s6 );//false

    注意：

     Integer a = new Integer(10);
 Integer b = new Integer(10);
 Integer c = new Integer(11);
 Integer d = 11;
 Integer e = 11;
 int f =10;
 System.out.println(a==b);//false，因为==比较的是内存地址，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）
 System.out.println(c==d);//false，非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，
                           // 而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）
 System.out.println(d==e);//true对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false
 System.out.println(b==f);//true因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较

    5.String类

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

    字符串字面值存储在字符串池（或叫常量池）中，可以共享（重用）

    String s = "Hello";产生一个对象，字符串池中存储；

    String s = new String ();产生两个对象，堆，池各存储一个。


    注：方法区在JDK1.8之后叫元空间，JDK1.8之前叫永久代

    //面试题
String name = "hello"; //"hello" 常量存储在字符串池中
name = "zhangsan";//”zhangsan"赋值给name变量，给字符串赋值时，没有修改数据，而是重新开辟一个空间，这就是不可变性
String name2 = "zhangsan";
​
//字符串的另一种创建方式
String str = new String("java");//在堆创建一个对象"java"，在字符串池也会有一个“java”，浪费空间
String str2 = new String("java");
System.out.println(str==str2);//false
System.out.println(str.equals(str2));//true

     

     

    5.1常用方法

    public int length()：返回字符串的长度
    public char charAt(int index):根据下标获取字符
    public boolean contains(String str) 判断当前字符是否包含srt
    public char[] toCharArray() :将字符串转换成数组
    public int indexOf(String str): 查找str首次出现的下标，存在，则返回该下标；不存才，则返回-1
    public int lastIndexOf(String str);查找字符串在当前字符串中最后一次出现的下标索引
    public String trim():去掉字符串前后的空格
    public String toUpperCase():将小写转成大写
    public boolean endsWith(String str):判断字符串是否以str结尾
    public String replace(char oldChar,char newChar);将旧字符串替换成新字符串
    public String[] split(String str);根据str做拆分

    //字符串方法的使用
//length();返回字符串的长度
//2.charAt(int index);返回某个位置的字符
//3.contains(String str);判断是否包含某个子字符串
​
String content = "java是世界上最好的,java真香";
system.out.println(content.length());//输出：11
system.out.println(content.charAt(content.length()-1));//输出‘的’
system.out.println(content.contains("java"));//true
system.out.println(content.contains("php"));//false
​
//字符串方法的使用
//4.toCharArray():返回字符串对应的数组
//5.indexOf();返回字符串首次出现的位置
//6.lastIndexOf();返回字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));//输出：0
System.out.println(content.indexOf("java",4));//从下标4往后找
System.out.println(content.lastIndexOf("java"));//输出：18
​
​
//字符串方法的使用
//7.trim()；去掉字符串前后的空格
//8.toUpperCase();把小写转成大写，toLowerCase();把大写转成小写
//9.endsWith(String str)；判断是否以str结尾，starsWith(String str)；判断是否以str开头
String content2 = "  Hello world  ";
System.out.println(content2.trim());//输出：Hello world
System.out.println(content2.toUpperCase());//输出：HELLO WORLD
System.out.println(content2.toLowerCase());//输出：hello world
​
String fileName = "hello.java";
System.out.println(fileName.endsWith(".java"));
System.out.println(fileName.startsWith("hello"));
​
//字符串方法的使用
//10.replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
//11.split();对字符串进行拆分
System.out.println(content.replace("java","php"));
​
String say = "java is the best programing language";
String[] arr = say.split(" ");
//正则表达式，[],[ ,]→以空格或逗号划分
//String[] arr = say.split("[ ,]+");
System.out.println(arr.length);//6
for(String string : arr ){
    System.out.println(string);
}
​
//补充两个方法equals,compare();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//equalsIgnoreCase()忽略大小写比较
​
String s3 = "abc";//a编号97
String s4 = "xyz";//x编号120
System.out.println(s3.compareTo(s4));//s3编号位置减s4编号位置，输出：-23；当s3,s4长度不等时，compareTo比较的是长度，s3的长度减s4的长度
​
//截取字符串
//字符串.substring(int beginIndex)
//字符串.substring(int beginIndex, int endIndex)
     
    5.2可变字符串

    StringBuffer→（提前开辟缓存区）:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
    StringBuilder→（单线程可用）:可变长字符串，JDK5.0提供，运行效率快、线程不安全。
    两者与String区别：

    • 效率比String高，比String节省内存

    StringBuilder功能同StringBuffer一样：

    StringBuffer sb = new StringBuffer();
//1.append();追加
sb.append("阿珍爱上");
System.out.println(sb.toString());//输出：阿珍爱上
sb.append("阿强！");
System.out.println(sb.toString());//输出：阿珍爱上阿强！
​
//2.insert();添加，可以在指定位置添加
sb.insert(0,"我发现")//第一个参数表示添加位置
System.out.println(sb.toString());//输出：我发现阿珍爱上阿强！
​
​
//3.replace();String的replace()只能新值替换旧值，这里的replace可以指定位置
sb.replace(3,5,"晓晓")//3到5的位置，不含5，即含头不含尾，以0为开始。
System.out.println(sb.toString());//输出：我发现晓晓爱上阿强！
​
​
//4.delete();删除,
sb.delete(0.5)//位置同一含头不含尾
System.out.println(sb.toString())
    
//清空
sb.delete(0,sb.length());
System.out.println(sb.toString())

    测试：StringBuilder效率比String高

    public class test5 {
    public static void main(String[] args) {
​
       long start = System.currentTimeMillis();
        String sb = " ";
        for (int i = 0; i<99999;i++){
            sb+=i;
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println("String用时："+(end - start));//用时：21557毫秒
​
        long start2 = System.currentTimeMillis();
        StringBuilder sb2 = new StringBuilder(" ");
        for (int i = 0; i<99999;i++){
            sb2.append(i);
        }
        System.out.println(sb2.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder用时:"+(end2-start2));//用时：125毫秒
    }
}

    6.BigDecimal类(精确存储)

    思考：一下程序输出结果是多少？

    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);//0.9999999999999999
}
}

    结果→1？错，结果为0.9999999999999998
    （double和float存的是近似值，比如存1，但实际存的是0.9999999999999999）
    很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助BigDecimal。
    位置：java.math包中
    作用；精确计算浮点数
    创建方式：BigDecimal db = new BigDecimal("1.0");//构造方法的参数一定用字符串，如果是用1.0的话，你传进去就会有精度缺失，就不是1.0了，而可能是0.9999.....
    方法：
    加法: BigDecimal add( BigDecimal bd)
    减法: BigDecimal subtract( BigDecimal bd)
    乘法: BigDecimal divide( BigDecimal bd)
    除法: BigDecimal multiply( BigDecimal bd)
    当除不尽时使用重载方法：
    除法：divide（BigDecimal bd, int scal,RoundingMode mod)
    参数scale：指定精确到小数点后几位
    参数mode：

    • 指定小数部分的取舍模式，通常采用四舍五入的模式，
    • 取值为BigDecimal.ROUND_HALF_UP
    //BigDecimal，大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
​
//减法
BigDecimal r1 = bd1.subtract(db2);
System.out.println(r1);
​
//加法
BigDecimal r2 = bd1.add(db2);
Sysetm.out.println(r2);
​
//乘法
BigDecimal r3 = bd1.multiply(bd2);
Sysetm.out.println(r3);
​
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"))
Sysetm.out.println(r4);
​
//当除法，除不尽时，要加保留小数点后几位
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//ROUND_HALF_UP四舍五入
Sysetm.out.println(r5);

    7.Date类（特定时间）

    • Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经别Calendar类中的方法所取代。
    • 时间单位：1秒=1000毫秒1毫秒=1000微秒1微秒=1000纳秒
    import java.util.Date;
​
public class TestDate {
    public static void main(String[] args) {
        //1.今天的日期，
        Date d1 = new Date();
        System.out.println(d1.toString());//输出为：Tue Sep 27 16:14:34 CST 2022
        System.out.println(d1.toLocaleString());//此方法过时了，输出为：2022-9-27 16:14:34
​
        //昨天的日期， getTime()获取毫秒数
        Date d2 = new Date(d1.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(d2.toLocaleString());
​
        //2.after:比较日期d1是否在d2之后，是就返回true，否则返回false,
        // before：比较日期d1是否在d2之前，是就返回true，否则返回false,
        boolean b1 = d1.after(d2);
        System.out.println(b1);//true
        boolean b2 = d1.before(d2);
        System.out.println(b2);//false
​
        //3.compareTo:比较毫秒数，前后毫秒数相减，正数返回1，负数返回-1，相等就返回0
        System.out.println(d1.compareTo(d2));
​
        //4.比较equals
        System.out.println(d1.equals(d2));//false
    }
}

    8.Calendar类（日历）

    • Calendar提供了获取或设置各种日历字段的方法
    • 构造方法：protected Calendar():由于修饰符是protected,所以无法直接创建该对象
    • 其他方法：
    方法名 说明
    static Calendar getInstance() 使用默认时区和区域获取日历
    void set(int year,int month,int date,int hourofday,int minute,int second) 设置日历的年、月、日、时、分、秒。
    int get(int field) 返回给定日历字段的值。字段比如年、月、日等
    void setTime(Date date) 用给定的Date设置此日历的时间。Date-Calendar
    Date getTime() 返回一个Date表示此日历的时间。Calendar-Date
    void add(int field,int amount) 按照日历的规则，给指定字段添加或减少时间量
    long getTimeInMillies() 毫秒为单位返回该日历的时间值 
    import java.util.Calendar;
​
public class TestCalendar {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月,从0-11，所以要加 1
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //获取小时,HOUR是12小时制，HOUR_OF_DAY是24小时制
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //获取分钟
        int minutes = calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println("现在时间为："+year+"年"+(month+1)+"月"+day+"日"+hour+"小时"+minutes+"分"+second+"秒");
        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.YEAR,1);//将year设置为1月
        System.out.println(calendar2.getTime().toLocaleString());
        //4.add方法修改时间
        calendar2.add(Calendar.MONTH,1);//加一个月，是-1的话，就是减少一个月
        System.out.println(calendar2.getTime().toLocaleString());
        //5.获得最大值，最小值
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

    9.SimpleDateFormate类（格式化时间）

    SimpleDateFormate是一个以语言环境有关的方式来格式化和解析日期的具体类
    进行格式化（日期 —>文本）、解析（文本 —>日期），即特定字符串与日期互相转换
    常用的时间模式字母：

    字母 日期或时间 示例
    y 年 2019
    M 年中月份 08
    d 月中天数 10
    H 1天中小时数（0-23），h表示12进制的 22
    m 分钟 16
    s 秒 59
    S 毫秒 367 
    public class Demo{
    public static void main(String[] args) throws Exception{
        //1.创建SimpleDateFormat对象,y年M月,设置为yyyy年MM月dd日 HH:mm:ss这种格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.创建Date
        Date date = new Date();
        //格式化date(把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str)//输出：2022年9月27日 17:13:21
        //解析(把字符串转成日期)
        Date date2 = sdf.parse("1990年05月01日 11:45:24")//parse()里的格式跟SimpleDateFormat格式不一致的话，会报错
            System.out.println(date2)
}
}

    10.System类（系统类）

    System系统类，主要用于获取系统的属性数据（都是静态的，用System.调用就行）和其他操作，构造方法私有（不需要创建对象）。

    方法名 说明
    static void arraycopy(...) 复制当前数组
    static long currenTimeMillis(); 获取当前系统时间，返回的是毫秒数
    static void gc(); 建议JVM赶快启动垃圾回收器回收垃圾
    static void exit(int status); 退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm 
    //1.复制数组，arraycopy(Object src,int srcPos,Object dest,int destPos，int lengt):数组的复制
//Object src被复制的数组,
//int srcPos从哪个位置开始复制,
//Object dest目标数组,
//int destPos目标数组的位置，
//int length复制的长度
int[] arr = {20.18,15,8,35,26,45,90};
int[] dest = new int[8];
System.arraycopy(arr,0,dest,0,arr.length);
for(int i = 0 ;iout.println(dest[i]);
}
//Arrays.copyOf(original,newLength)效率比System.arraycopy低
​
//2.System.currentTimeMilis()用来计时,获取毫秒数
System.out.println(System.currentTimeMilis());
​
long start System.currentTimeMillis();
for(int i = 0;i<999999;i++){
for()(int j = 0;j<999999;j++){
int result=i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));
​
//3.System.gc()例子见3.5
​
//4.退出JVm
System.exit(0)
System.out.println("程序退出来...")//没有打印这条语句就说明已经退出了

     

    参考资料：

    JDK1.8帮助文档

     

    ■免责申明
    ⒈ 本站是纯粹个人学习网站，与朋友交流共赏，不存在任何商业目的。
    ⒉ 本站利用了部分网络资源，版权归原作者及网站所有，如果您对本站所载文章及作品版权的归属存有异议，请立即通知我们，我们将在第一时间予以删除，同时向你表示歉意！

     

  • 相关阅读:
    AQUATOX模型 水环境与水生态应用
    聊聊druid连接池的监控
    烽火传递——单调队列优化dp问题
    IS-IS
    第一节 Maven核心程序解压与配置
    OS2.3.4:信号量机制
    Fetch 请求不转换BLOB正常显示GBK编码的数据
    是的，决定放弃算法去机器学习了
    DS：八大排序之堆排序、冒泡排序、快速排序
    产品经理视角 | 电商封装商品数据API接口知识小结
  • 原文地址：https://www.cnblogs.com/lyh1024/p/16732224.html