Java 常用类

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存放任何对象。
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

getClass()方法

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

 package com.standardClass.demo05;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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;
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}
//运行结果：s1和s2属于同一个类型

hashCode()方法

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码

 package com.standardClass.demo05;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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;
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        //hashCode方法
        System.out.println(s1.hashCode());
 
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
    }
//    运行结果：
//    s1和s2属于同一个类型
//    460141958
//    1163157884
//    460141958
}

toString()方法

public String toString(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值

 package com.standardClass.demo05;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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;
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println("----------------------getClass------------------");
        //getClass方法
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("----------------------hashCode------------------");
        //hashCode方法
        System.out.println(s1.hashCode());
 
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
 
        System.out.println("----------------------toString------------------");
        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
//    运行结果：
//----------------------getClass------------------
//    s1和s2属于同一个类型
//----------------------hashCode------------------
//            460141958
//            1163157884
//            460141958
//----------------------toString------------------
//    com.standardClass.demo05.Student@1b6d3586
//    com.standardClass.demo05.Student@4554617c
}

 package com.standardClass.demo05;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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 +
                '}';
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println("----------------------getClass------------------");
        //getClass方法
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("----------------------hashCode------------------");
        //hashCode方法
        System.out.println(s1.hashCode());
 
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
 
        System.out.println("----------------------toString------------------");
        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
//    运行结果：
//----------------------getClass------------------
//    s1和s2属于同一个类型
//----------------------hashCode------------------
//            460141958
//            1163157884
//            460141958
//----------------------toString------------------
//    Student{name='aaa', age=20}
//    Student{name='bbb', age=20}
}

equals()方法

public boolean equals(Object obj){}
默认实现为(this == obj)，比较两个对象地址是否相同（this表示当前调用equals()方法的对象，obj表示你传递进去进行比较的对象）
可进行覆盖，比较两个对象的内容是否相同

 package com.standardClass.demo05;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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 +
                '}';
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println("----------------------getClass------------------");
        //1.getClass方法
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("----------------------hashCode------------------");
        //2.hashCode方法
        System.out.println(s1.hashCode());
 
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
 
        System.out.println("----------------------toString------------------");
        //3.toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
 
        System.out.println("----------------------equals------------------");
        //4.equals方法
        System.out.println(s1.equals(s2));
 
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5));
    }
//    运行结果：
//----------------------getClass------------------
//    s1和s2属于同一个类型
//----------------------hashCode------------------
//            460141958
//            1163157884
//            460141958
//----------------------toString------------------
//    Student{name='aaa', age=20}
//    Student{name='bbb', age=20}
//----------------------equals------------------
//            false
//            false
}

equals()方法覆盖步骤

比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用指向的实际对象类型是否一致
强制类型转换
依次比较各个属性值是否相同

 package com.standardClass.demo05;
 
import java.util.Objects;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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 obj) {
        //1.判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //2.判断obj是否null
        if (obj==null){
            return true;
        }
        //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;
    }
}

 package com.standardClass.demo05;
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println("----------------------getClass------------------");
        //1.getClass方法
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("----------------------hashCode------------------");
        //2.hashCode方法
        System.out.println(s1.hashCode());
 
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
 
        System.out.println("----------------------toString------------------");
        //3.toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
 
        System.out.println("----------------------equals------------------");
        //4.equals方法
        System.out.println(s1.equals(s2));
 
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5));
    }
//    运行结果：
//----------------------getClass------------------
//    s1和s2属于同一个类型
//----------------------hashCode------------------
//            460141958
//            1163157884
//            460141958
//----------------------toString------------------
//    Student{name='aaa', age=20}
//    Student{name='bbb', age=20}
//----------------------equals------------------
//            false
//            true
}

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc();通知JVM执行垃圾回收

 package com.standardClass.demo05;
 
import java.util.Objects;
 
public class Student {
    private String name;
    private int age;
    public Student(){
        //TODO Auto-generated constructor stub
    }
 
    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
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}

 package com.standardClass.demo05;
 
public class TestStudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("aaa", 20);
//        Student s2 = new Student("bbb", 20);
//        Student s3 = new Student("ccc", 20);
//        Student s4 = new Student("ddd", 20);
//        Student s5 = new Student("eee", 20);
        new Student("aaa", 20);
        new Student("bbb", 20);
        new Student("ccc", 20);
        new Student("ddd", 20);
        new Student("eee", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}
//运行结果：
//回收垃圾
//eee对象被回收了
//ddd对象被回收了
//ccc对象被回收了
//bbb对象被回收了
//aaa对象被回收了

包装类

什么是包装类？

基本数据类型所对应的引用数据类型
Object可统一所有数据，包装类的默认值是null

包装类对应

基本数据类型---------包装类型
byte---------------------Byte
short--------------------Short
int------------------------Integer
long----------------------Long
float----------------------Float
double------------------Double
boolean-----------------Boolean
char-----------------------Character

类型转换与装箱、拆箱

装箱:把基本类型转换为引用类型的过程

拆箱:把引用类型转换为基本类型的过程

8种包装类提供不同类型间的转换方式：
- Number父类中提供6个共性方法。
- parseXXX()静态方法
- valueOf()静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常

 package com.standardClass.demo06;
 
public class Demo01 {
    public static void main(String[] args) {
 
        //JDK1.5之前的装箱和拆箱
 
        //类型转换：装箱，基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);
 
        //类型转换：拆箱，引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);
 
 
        //JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
 
        System.out.println("------------基本类型和字符串之间转换----------");
        //基本类型和字符串之间转换
        //1.基本类型转成字符串
        int n1 = 255;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
//        String s2 = Integer.toString(n1);//255
        String s2 = Integer.toString(n1,16);//ff
        System.out.println(s1);
        System.out.println(s2);
 
 
        //2.字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);
 
        //boolean字符串形式转成基本类型."true"--->true   非"true"--->false
        String str2 = "truerr";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);//false
 
 
    }
}

整数缓冲区（Integer缓冲区）

Java预先创建了256个常用的整数包装类型对象
在实际应用当中，对已创建的对象进行复用

 package com.standardClass.demo06;
 
public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//false
 
        Integer integer3 =Integer.valueOf(100);//自动装箱
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//true
 
        Integer integer5 = 200;//自动装箱
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
    }
}

 //看Integer.valueOf源码
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

String类

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String s = "Hello";//产生一个对象，字符串池中存储。
String s = new String("Hello");//产生两个对象，堆，池各存储一个。

 package com.standardClass.demo06;
 
public class Demo03 {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中
        name = "zhangsan";//"zhangsan"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2 = "zhangsan";
 
        //演示字符串的另一种创建方式，new String();//创建了两个对象分别在堆和字符串池里
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true
    }
}

常用方法

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

         System.out.println("------------------字符串方法的使用1--------------------");
        //字符串方法的使用
        //1、length();返回字符串的长度
        //2、charAt(int index);返回某个位置的字符
        //3、contains(String str);判断是否包含某个子字符串
 
        String content = "java是世界上最好的java编程语言,java真香";
        System.out.println(content.length());//15
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("java"));//true
        System.out.println(content.contains("php"));//false
 
        System.out.println("------------------字符串方法的使用2--------------------");
        //字符串方法的使用
        //4、toCharArray();返回字符串对应的数组
        //5、indexOf();返回子字符串首次出现的位置
        //6、lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 世, 界, 上, 最, 好, 的, j, a, v, a, 编, 程, 语, 言, ,, j, a, v, a, 真, 香]
        System.out.println(content.indexOf("java"));//0
        System.out.println(content.indexOf("java",4));//11
        System.out.println(content.lastIndexOf("java"));//20
 
        System.out.println("------------------字符串方法的使用3--------------------");
        //字符串方法的使用
        //7、trim();去掉字符串前后的空格
        //8、toUpperCase();把小写转成大写，toLowerCase();把大写转成小写
        //9、endsWith(str);判断是否以str结尾，startsWith();判断是否以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"));//true
        System.out.println(filename.startsWith("hello"));//true
 
        System.out.println("------------------字符串方法的使用4--------------------");
 
        //10、replace(char old,char new); 用新的字符或字符串替换旧的字符或字符串
        //11、split();对字符串进行拆分
 
        System.out.println(content.replace("java","php"));
 
        String say = "java is the best    programing language,java xiang";
        String[] arr = say.split("[ ,]+");
        System.out.println(arr.length);
        for (String String : arr){
            System.out.println(String);
        }
        //运行结果
//        php是世界上最好的php编程语言,php真香
//        6
//        java
//        is
//        the
//        best
//        programing
//        language
//        java
//        xiang
        System.out.println("------------------补充--------------------");
        //补充两个方法equals、compare();比较大小（在编码表的位置）
        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.standardClass.demo06;
 
/**
 * - 已知String str = "this is a text";
 * - 1、将str中的单词单独获取出来
 * - 2、将str中的text替换为practice
 * - 3、在text前面插入一个easy
 * - 4、将每个单词的首字母改为大写
 */
public class Demo04 {
    public static void main(String[] args) {
        String str = "this is a text";
        System.out.println("-------------1、将str中的单词单独获取出来-----------------");
        // 1、将str中的单词单独获取出来
        String[] arr = str.split(" ");
        for (String s : arr){
            System.out.println(s);
        }
 
        System.out.println("-------------2、将str中的text替换为practice-----------------");
        // 2、将str中的text替换为practice
        String str2 = str.replace("text","practice");
        System.out.println(str2);
 
        System.out.println("-------------3、在text前面插入一个easy-----------------");
        // 3、在text前面插入一个easy
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
 
        System.out.println("-------------4、将每个单词的首字母改为大写-----------------");
        // 4、将每个单词的首字母改为大写
        for (int i=0;i< arr.length;i++){
            char first = arr[i].charAt(0);
            //把第一个字符转成大写
            char upperfirst =  Character.toUpperCase(first);
 
            String news = upperfirst + arr[i].substring(1);
            System.out.println(news);
        }
 
    }
}

可变字符串（String的进阶）

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。

 package com.standardClass.demo06;
 
/**
 *- StringBuffer和StringBuilder的使用(一样)
 * 和String区别(1)效率比String高(2)比String节省内存
 */
public class Demo05 {
    public static void main(String[] args) {
        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1 append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());
        sb.append("java不错");
        System.out.println(sb.toString());
        //2 insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());
        //3 replace();指定位置替换
        sb.replace(0,5,"hello");
        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());
        System.out.println(sb.length());
    }
}

 package com.standardClass.demo06;
 
/**
 * 验证StringBuilder效率高于String
 */
public class Demo06 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//        String string = "";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);//用时：52415
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());//用时：28
 
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
    }
}

BigDecimal类

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

 public class Demo07 {
    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");
方法：
- BigDecimal add(BigDecimal bd) 加
- BigDecimal subtract(BigDecimal bd) 减
- BigDecimal multipiy(BigDecimal bd) 乘
- BigDecimal divide(BigDecimal bd) 除
利用BigDecimal可以进行数值计算
除法：divide(BigDecimal bd,int scale,RoundingMode mode)
参数scale：指定精确到小数点后几位。
参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式，
- 取值为BigDecimal.ROUND_HALF_UP。

 package com.standardClass.demo06;
 
import java.math.BigDecimal;
import java.math.RoundingMode;
 
public class Demo07 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998
 
        //面试题
        double result = (1.4-0.5)/0.9;
        System.out.println(result);//0.9999999999999999
 
        //BigDecimal,大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);//0.1
 
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);//1.9
 
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);//0.90
 
        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);//1
 
        BigDecimal r5 = new BigDecimal("20")
                .divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);//6.67
    }
}

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calender类中的方法所取代。
时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒

 package com.standardClass.demo07;
 
import java.util.Date;
 
public class Demo01 {
    public static void main(String[] args) {
        //1、创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2、方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date1.before(date2);
        System.out.println(b2);
 
        //比较compareTo();
        int d1 = date1.compareTo(date2);
        int d2 = date2.compareTo(date1);
        int d3 = date1.compareTo(date1);
        System.out.println(d1);
        System.out.println(d2);
        System.out.println(d3);
        //比较是否相等equals();
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

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()	毫秒为单位返回该日历的时间值

 package com.standardClass.demo07;
 
import java.util.Calendar;
 
public class Demo02 {
    public static void main(String[] args) {
        //1、创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.toString());//一般不用这个
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2、获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //月 从0-11
        int month = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//也可以用Date
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR12小时 HOUR_OF_DAY24小时
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //3、修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,25);
        System.out.println(calendar2.getTime().toLocaleString());
 
        //4、add方法修改时间
        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());
 
        //5、补充方法
        calendar2.add(Calendar.MONTH,1);
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
常用的时间模式字母

字母日期或时间示例

y 年 2022

M 年中月份 03

d 月中天数 10

H 1天中小时数(0-23) 22

m 分钟 16

s 秒 59

S 毫秒 367

字母	日期或时间	示例
y	年	2022
M	年中月份	03
d	月中天数	10
H	1天中小时数(0-23)	22
m	分钟	16
s	秒	59
S	毫秒	367

 package com.standardClass.demo07;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1、创建SimpleDateFormat对象 y 年 M 月
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2、创建Date
        Date date = new Date();
        //格式化date(把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //解析(把字符转成日期)
        Date date2=sdf.parse("1990/05/01");//注意格式要和上面保持一致
        System.out.println(date2);
    }
}

System类

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

方法名	说明
static void arraycopy(...)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);	退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm

 package com.standardClass.demo07;
 
public class Student {
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
 
    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
    protected void finalize() throws Throwable {
        System.out.println("回收了"+name+""+"   "+age);
    }
}

 package com.standardClass.demo07;
 
import java.util.Arrays;
 
public class Demo04 {
    public static void main(String[] args) {
        //1、arraycopy：数组的复制
        //src：源数组
        //srcPos：从哪个位置开始复制0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr = {20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        System.arraycopy(arr,4,dest,4,4);
 
        for (int i=0;i< dest.length;i++){
            System.out.println(dest[i]);
        }
        //Arrays.copyOf(original,newLength)该方法里用的就是System.arraycopy
 
        //2、获取毫秒数
        System.out.println(System.currentTimeMillis());
 
        long start=System.currentTimeMillis();
        for (int i=-999999999;i<99999999;i++){
            for (int j=-999999999;j<999999999;j++) {
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));//用时：8
 
        //3、回收垃圾
        Student s1 = new Student("aaa",19);
        new Student("bbb",19);
        new Student("ccc",19);
 
        System.gc();//告诉垃圾回收器回收
        //运行结果：
        //回收了ccc   19
        //回收了bbb   19
 
        //4、退出jvm
        System.exit(0);
 
        System.out.println("程序结束了。。。");//该程序没有执行
        
    }
}

总结

内部类：
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类、局部内部类、匿名内部类。
Object类：
- 所有类的直接或间接父类，可存储任何对象。
包装类：
- 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
BigDecimal类：
- 可精确计算浮点数。
Date类：
- 特定时间
Calendar类：
- 日历
SimpleDateFormat类：
- 格式化时间
System类：
- 系统类

笔记出处

posted @ 2022-03-26 21:23 时间染指阅读(22) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Collection体系集合

· Java 内部类

· Java进阶_常用类

· 2-Java常用类

· java_day11

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称：时间染指
园龄： 3年4个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六