Java常用类

内部类

成员内部类
静态内部类
局部内部类
匿名内部类

什么是内部类

在一类的内部再定义一个完整的类

特点

编译之后可生成独立的字节码文件
内部类可直接访问外部类的私有成员，而不破坏封装

//身体
public class body {
    private String name = "空白";

    //头部
    class head{
        public void show(){
            System.out.println(name);
        }
    }

    public static void main(String[] args) {
        body body = new body();
        body.head head = body.new head(); //通过外部类来实例内部类
        head.show();

    }
}

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

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
- Outer outer = new Outer();
- Outer.Inner inner = outer.new Inner();

Outer类：

package com.oop.demo12;
//外部类
public class Outer {
    //实例变量
    private String name = "kongbai";
    private int age = 20;

    
    public class Inner{
        private String address = "北京";
        private String phone = "120";

        //方法
        public void show(){
            //打印外部类
            System.out.println(name);
            System.out.println(age);
            //打印内部类
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

Application对象：

import com.oop.demo12.Outer;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
//        //1.创建外部类对象
//        Outer outer = new Outer();
//        //2.创建内部类对象
//        Outer.Inner inner = outer.new Inner();
//        inner.show();

        //用一段代码也可以完成
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

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

比如还是上面的代码，在内部类也有一个name属性，定义为“张三”；那么程序执行就会显示张三；那这时如何才能访问外部类的name呢？

//外部类
public class Outer {
    //实例变量
    private String name = "kongbai";
    private int age = 20;

    class Inner{
        private String address = "北京";
        private String phone = "120";

        private String name = "张三";

        //方法
        public void show(){
            //打印外部类
            //内部类属性和外部类属性名字相同时加<外部类>.this
            System.out.println(Outer.this.name);
            System.out.println(age);
            //打印内部类
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

成员内部类不能定义静态成员，但是可以定义静态常量
```
class Inner{  
    private static final String country = "中国";
}
```

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员（只有静态内部类可以使用static修饰，普通类不行）

//外部类
public class Outer {
    private String name  = "空白";
    private int age = 18;

    //静态内部类，它的级别和外部类相同
    static class Inner{
        private String address = "安徽";
        private String phone = "110";

        //静态成员
        private static int country = 999;

        public void show(){
            //调用外部类的属性
            //1.创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);

            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);

            //调用静态内部类的静态属性
            System.out.println(Inner.country);
        }
    }
}

测试对象

public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
- Outer.Inner inner = new Outer.Inner();
- inner.show();

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法（静态方法里不能直接访问非静态属性）
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
限制类的使用范围
局部内部类不能定义静态属性，但可以定义静态常量

//外部类
public class Outer {
    private String name = "kongbai";
    private int age = 35;

    public void show(){
        //定义局部变量
        String address = "宿州";

        //局部内部类，不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "117790";
            private String email = "117790@163.com";

            public void show2() {
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部变量,在jdk1.7要求变量必须是常量final；jdk1.8自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

public class TestOuter {
    public static void main(String[] args) {
        //直接运行不会有任何结果，因为Inner只做了声明，需要在Outer里创建局部内部类对象
        Outer outer = new Outer();
        outer.show();
    }
}

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口

Usb接口：

//接口
public interface Usb {
    //服务方法
    void service();
}

测试对象：

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
//        Usb usb = new Mouse();
//        usb.service();

        //局部内部类
//        class keyboard implements Usb{
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，键盘开始工作");
//            }
//        }
//        //使用局部内部类创建对象
//        Usb usb = new keyboard();
//        usb.service();

        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("连接电脑成功，键盘开始工作");
            }
        };
        usb.service();
    }
}

定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量
缺点：可读性较差

Object类

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

getClass()方法

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

Student类：

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;
    }
}

TestStudent测试对象：

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 222);
        //判断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()方法

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

Student类：

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;
    }
}

TestStudent测试对象：

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 222);
        //判断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方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        System.out.println("================================");
        
        Student s3 = s1; //s1值给了s3，所以hashCode是一样的
        System.out.println(s3.hashCode());
    }
}

toString()方法

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

依旧是上面的代码

TestStudent对象：

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        System.out.println("================getClass================");
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 222);
        //判断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());

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

        Student s3 = s1; //s1值给了s3，所以hashCode是一样的
        System.out.println(s3.hashCode());

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

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

前面就是一些信息，后面的数字就是hashCode，因为这里显示的是16进制，所以跟上面的hashCode不一样，可以自己转换为10进制看一下

这样的结果往往没有什么意思，怎样通过toString把s1和s2的值显示出来？只需在Student类中重写toString方法

快捷键alt+insert，选择toString()

点击ok，即可自动生成重写

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qDTz6T9R-1640575912753)(C:Users15357AppDataRoamingTyporatypora-user-imagesimage-20211223150853916.png)]

这样就是一个有用的数据了，当然手动重写也一样，无非就是return后不同

equals()方法

public boolean equals(Object obj) {}
默认实现（this == obj），比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        System.out.println("================getClass================");
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 222);
        //判断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());

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

        Student s3 = s1; //s1值给了s3，所以hashCode是一样的
        System.out.println(s3.hashCode());

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

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());

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

        //equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小明", 17);
        Student s5 = new Student("小明", 17);
        System.out.println(s4.equals(s5));
    }
}

equals()方法覆盖步骤

上面的代码可以看见s4和s5也不相同，Student s4 = new Student(“小明”, 17);重新new了对象，在堆内存中开辟了新的空间，所以地址值不想等，而equals方法比较两个字符串的内容是否相等

怎么改变equlas的输出结果？只要值相同就为true，可以重写equlas方法

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

在Student类中重写：

@Override
public boolean equals(Object obj) {
    //1.判断两个对象是否是同一个引用
    if (this == obj) {
        return true;
    }
    //2.判断obj是否为null
    if (obj == null) {
        return false;
    }
    //3.判断是否是同一个类型
    if (obj instanceof Student) {
        //4.强制类型转换
        Student s = (Student) obj;
        //5.比较属性值
        if (this.name.equals(s.getName()) && this.age == s.getAge()) {
            return true;
        }
    }
    return false;
}

再运行一遍，此时s4和s5相等

finalize()方法

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

在finalize源码中这个方法是空的

protected void finalize() throws Throwable { }

我们需要在Student中重写一下，方便显示效果

@Override
protected void finalize() throws Throwable {
    System.out.println(this.name + "对象已回收");
}

TestStudent2类：

public class TestStudent2 {
    public static void main(String[] args) {
        //没有任何调用为垃圾对象
        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("回收垃圾");
    }
}

包装类什么是包装类

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

包装类对应

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

类型转换与装箱、拆箱

基本类型转换为引用类型为装箱，反之为拆箱

8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法

举个例子

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换为引用类型
        int num1 = 10;
        //使用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);


        //上面为1.5之前，jdk1.5之后提供自动装箱和拆箱
        int age = 20;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

可以查看一下class文件做个对比

整数缓冲区

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

public class Demo02 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);

        //自动装箱
        Integer integer3 = 100;
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);

        //自动装箱
        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5 == integer6);
    }
}

第一个为false是因为内存地址不同；第二个和第三个为何输出结果不同？

其实自动装箱写完整是这样的

//自动装箱
Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4);

//自动装箱
Integer integer5 = Integer.valueOf(200);
Integer integer6 = Integer.valueOf(200);
System.out.println(integer5 == integer6);

查看一下valueOf的源码

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

从源码可以看出这是有一个范围的，点进low或high看一下

IntegerCache，缓冲区，不难看出它定义的范围为-128~127，100在这个范围内，所以对比为true；而200超过这个范围，它就会执行if后面的语句：return new Integer(i);直接在堆中开辟一个空间，这样对比内存地址不同，所以为false

String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享

public class Dmoe01 {
    public static void main(String[] args) {
        String name = "hello"; //常量，存储在字符串池中（常量池）
        name = "kongbai"; //并没有修改值，而是重新开辟一个空间
        String name2 = "kongbai";
    }
}

String s = “hello”;产生一个对象，字符串池中存储
String s = new String(“hello”);产生两个对象，堆、池各存储一个

//new创建字符串
String str = new String("java");

这里的“Java”在实际运行的时候只有一个对象，存放在方法区，画图只是可以这样理解

比如这里又new了一个str2

String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2);
System.out.println(str.equals(str2));

因此字符串的比较要用equals而不是"=="，equals比较的值，"=="比较地址

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

String常用方法

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

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {


        System.out.println("============字符串方法使用1============");
        
        String count = "javaNB,java真香,java";
        System.out.println(count.length()); //length()
        System.out.println(count.charAt(0)); //charAt()
        //减一是因为字符长度为13，而下标是从0开始的，0位是"j"，结束下标为12；
        System.out.println(count.charAt(count.length()-1)); //length()和charAt()
        System.out.println(count.contains("java")); //contains()
        System.out.println(count.contains("php"));

        System.out.println("============字符串方法使用2============");
        
        System.out.println(Arrays.toString(count.toCharArray())); //toCharArray()
        System.out.println(count.indexOf("java")); //indexOf()
        System.out.println(count.indexOf("java", 4)); //从第4位开始找
        System.out.println(count.lastIndexOf("java")); //lastIndexOf()

        System.out.println("============字符串方法使用3============");
        
        String count2 = " Hello World ";
        System.out.println(count2.trim()); //trim()
        System.out.println(count2.toUpperCase()); //toUpperCase()
        System.out.println(count2.toLowerCase()); //toLowerCase()
        String count3 = "hello.java";
        System.out.println(count3.endsWith("java")); //endWith()
        System.out.println(count3.startsWith("java")); //startWith()

        System.out.println("============字符串方法使用4============");
        
        String conut4 = "javaNB,java真香,java";
        System.out.println(conut4.replace("java", "php")); //replace()
        System.out.println(count2.replace(" ", "")); //将count2的空格替换掉
        String count5 = "java is the best programing language";
        String[] array = count5.split(" "); //split(),这里以空格作为拆分单位
        System.out.println(count5.length());
        for (String string : array) { //增强型for循环；意思是把array中的每个元素依次赋值给string
            System.out.println(string);
        }

        System.out.println("-----split()使用技巧1-----");
        //关于split有一个技巧，比如count6，如果我们想分别用空格和“，”号来进行拆分，怎么做
        String count6 = "java is the best programing language,java";
        String[] array1 = count6.split("[ ,]"); //小括号里面输入空格和逗号
        System.out.println(count6.length());
        for (String string1 : array1) {
            System.out.println(string1);
        }

        System.out.println("-----split()使用技巧2-----");
        
        String count7 = "java is the  best programing language,java";
        String[] array2 = count7.split("[ ,]+"); //后面再添加一个+符号，表示前面的空格或逗号可以连续出现多个也可以拆分
        System.out.println(count7.length());
        for (String string2 : array2) {
            System.out.println(string2);
        }

        System.out.println("-----补充-----");
        //补充两个方法equals()、compareTo()比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2)); //忽略大小写比较

        //compareTo()比较的是编码表的位置，只要第一位对比出结果就行；
        //如果第一位都一样，那就比第二位，以此类推
        String s3 = "abc"; //a=97
        String s4 = "xyz"; //x=120
        System.out.println(s3.compareTo(s4)); //s3-s4的结果

        //这种情况的比较就不是比大小，而是比位数
        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));
    }
}

============字符串方法使用1============
18
j
a
true
false
============字符串方法使用2============
[j, a, v, a, N, B, ,, j, a, v, a, 真, 香, ,, j, a, v, a]
0
7
14
============字符串方法使用3============
Hello World
 HELLO WORLD 
 hello world 
true
false
============字符串方法使用4============
phpNB,php真香,php
HelloWorld
36
java
is
the
best
programing
language
-----split()使用技巧1-----
41
java
is
the
best
programing
language
java
-----split()使用技巧2-----
42
java
is
the
best
programing
language
java
-----补充-----
false
true
-23
-3

Process finished with exit code 0

String案例演示

需求
- 已知String str = “this is a text”;
- 1.将str中的单词单独获取出来
- 2.将str中的text替换为practice
- 3.在text前面插入一个easy
- 4.将每个单词的首字母改为大写

public class Demo01 {
    public static void main(String[] args) {
        String str = "this is a text";

        System.out.println("========1========");
        //1.将str中的单词单独获取出来
        String[] array = str.split(" ");
        for (String s : array) {
            System.out.println(s);
        }

        System.out.println("========2========");
        //2.将str中的text替换为practice
        String str2 = str.replace("text", "practice");
        System.out.println(str2);

        System.out.println("========3========");
        //3.在text前面插入一个easy
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);

        System.out.println("========3========");
        //4.将每个单词的首字母改为大写
        for (int i = 0; i  
 
可变字符串 
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全 
以下是StringBuffer和StringBuilder的一些使用方法 
//StringBuffer和StringBuilder
//比String效率高，比String节省内存
public class Demo01 {
    public static void main(String[] args) {
        
        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();

        //1.append();追加
        sb.append("妙啊");
        System.out.println(sb.toString());
        sb.append("javaNB");
        System.out.println(sb.toString());

        //2.insert();添加  这个0表示在哪添加
        sb.insert(0, "我第一");
        System.out.println(sb.toString());

        //3.replace();替换 与前面replace()方法类似，但这个可以指定替换位置
        sb.replace(0, 3, "hello"); //左闭右开原则
        System.out.println(sb.toString());

        //4.delete();删除
        sb.delete(0, 3); //左闭右开原则
        System.out.println(sb.toString());
        //清空
        sb.delete(0, sb.length());
        System.out.println(sb.length()); //查看长度
    }
}
 
 
下面来验证一下StringBuffer或StringBuilder的效率比String高 
先来看看String，输出1~99999要花多久，注意这个数值别弄太大，小心电脑卡死或长时间无结果 
//StringBuilder和StringBuffer效率都高于String
//验证StringBuilder效率高于String
public class Demo02 {
    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);
        long end = System.currentTimeMillis(); //结束时间
        System.out.println("用时：" + (end - start));
    }
}
 
上面是结果，下面是耗时，大约18秒 
 
18接下用StringBuilder试一下 
long start = System.currentTimeMillis(); //开始时间
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 99999; i++) {
    sb.append(i);
}
System.out.println(sb.toString());
long end = System.currentTimeMillis(); //结束时间
System.out.println("用时：" + (end - start));
 
可以看到非常快；0.023秒 
 
BigDecimal 
 思考：一下程序输出结果是多少
 public class Test {
    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);
    }
}
  
 
为什么会这样 
Java中的简单浮点数类型float和double不能够进行运算，因为大多数情况下是正常的，但是偶尔会出现如上所示的问题。这个问题其实不是JAVA的bug，因为计算机本身是二进制的，而浮点数实际上只是个近似值，所以从二进制转化为十进制浮点数时，精度容易丢失，导致精度下降 
要保证精度就要使用BigDecimal类，而且不能直接从double直接转BigDecimal，要将double转string再转BigDecimal。也就是不能使用BigDecimal(double val) 方法，你会发现没有效果。要使用BigDecimal(String val) 方法 
位置：java.math包中
作用：精确计算浮点数
创建方式：BigDecimal bd = new BigDecimal(“1.0”);
方法： 
  BigDecimal add(BigDecimal bd)–加
BigDecimal subtract(BigDecimal bd)–减
BigDecimal multiply(BigDecimal bd)–乘
BigDecimal divide(BigDecimal bd)–除
  
import java.math.BigDecimal;

public class Test {
    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);

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

        //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);
        //除法运算，这里1.0 / 0.9除不尽，所以换个数；这里使用链式编程，就是定义和运算写在一块
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);

        //除法可能会出现除不尽的情况，divide方法有一个四舍五入方法：BigDecimal.ROUND_HALF_UP
        BigDecimal r5 = new BigDecimal("10")
                .divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP); //保留2位
        System.out.println(r5);
    }
}
 
 
除法：divide(BigDecimal bd, int scal, RoundingMode mode) 
  参数scal：指定精确到小数点后几位
参数mode： 
    指定小数部分的取舍模式，通常采用四舍五入的模式ROUND_HALF_UP
取值为BigDecimal.ROUND_HALF_UP
 
  
Date类 
Date表示特定的瞬间，精确到毫秒；Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位 
  1秒 = 1000毫秒
1毫秒 = 1000微秒
1微秒 = 1000纳秒
  
过时的方法会用删除线表示出来 
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 d = date1.compareTo(date2);
        System.out.println(d);
        int d1 = date2.compareTo(date1);
        System.out.println(d1);

        //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 getTimeMillies() 毫秒为单位返回该日历的时间值
import java.util.Calendar;

public class Demo02 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis()); //毫秒值，从1970年开始

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR); //这里面可以直接写1，但这样代码可读性会降低
        System.out.println(year);
        //获取月，需要注意月的范围是0-11，所以输出结果需要+1
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH); //也可以用DATE
        System.out.println(day);
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY); //24小时制；也可以用HOUR，12小时制
        System.out.println(hour);
        //分钟
        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 calendar1 = Calendar.getInstance();
        
        calendar1.set(Calendar.MONTH, 10); //月份修改为11
        System.out.println(calendar1.getTime().toLocaleString());

        //4.add方法修改时间
        calendar1.add(Calendar.HOUR, 1); //小时增加1，减少就用负数，如-1
        System.out.println(calendar1.getTime().toLocaleString());

        //5.补充方法；获取当前时间的最大值或最小值
        calendar1.add(Calendar.MONTH, 1); //月份+1
        System.out.println(calendar1.getTime().toLocaleString());
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH); //本月最大的一天
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH); //本月最小的一天
        System.out.println(max);
        System.out.println(min);
    }
}
 
 
SimpleDateFormat类 
 SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
 
 进行格式化（日期->文本）、解析（文本->日期）
 
 常用的时间模式字母 
  字母 日期或时间 示例
y 年 2019
M 月 08
d 日 10
H 一天中小时数（0-23） 22
m 分钟 16
s 秒 59
S 毫秒 367
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); //输出的格式

        //2.创建Date
        Date date = new Date();
        //格式化date  把日期转为字符串
        String str = sdf.format(date);
        System.out.println(str);

        //解析  把字符转转为日期
        Date date1 = sdf.parse("2020年10月11日"); //必须与上面的格式相对应
        System.out.println(date1.toLocaleString());

    }
}
  
 
System类 
 System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的 
  方法名 说明
static void arraycopy() 复制数组
static long currentTimeMillis() 获取当前系统时间，返回的是毫秒值
static void gc() 建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status) 退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm 
看一下arraycopy和exit即可，另外两个前面已学习 
public class Demo01 {
    public static void main(String[] args) {
        //1.arraycope(src, srcPos, dest, desPos, length):数组复制
        
        int[] array = {1, 5, 8, 20, 55, 7, 90, 6};
        int[] dest = new int[8];
        System.arraycopy(array, 2, dest, 4, 3);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        //2.退出jvm
        System.exit(0); //非0为异常退出
        System.out.println("jvm退出了"); //上面已经退出，所以这里不会执行了
    }
}
 
 
总结 
内部类 
  在一个类的内部再定义的一个完整的类
成员内部类、静态内部类、局部内部类、匿名内部类
 
Object类 
  所有类的直接或间接父类，可存储任何对象
 
包装类 
  基本数据类型所对应的引用数据类型，可以使Object统一所有数据
 
String类 
  字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
 
BigDecimal类 
  可精确计算浮点数
 
Date类 
  特定时间
 
Calendar类–对Date类的改善 
  日历
 
SimpleDateFormat类 
  格式化时间
 
System类 
  系统类

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

字母	日期或时间	示例
y	年	2019
M	月	08
d	日	10
H	一天中小时数（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	367

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

Java常用类

Java相关栏目本月热门文章