Java常用类

一、内部类

• 什么是内部类

  概念：在一个类得内部再定义一个完整的类

• 特点：

  • 编译后可生成独立的字节码文件（都有对应的class文件）

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

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

1、1成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。

• 外部类的一个实例部分，在创建内部类对象时，必须依赖外部类的对象。

  //1、创建外部类对象
  Outer outer = new Outer();
  //创建内部类对象
  Outer.Inner inner = outer.new Inner();
  

• 当外部类和成员内部类存在属性重名的时候，会优先访问内部类的属性。访问外部类的属性使用 ：外部类对象.this.属性名

  System.out.println(Outer.this.sex);
  

• 成员内部类不能定义静态成员，但是可以定义静态常量。

  private static final String country = "中国";
  

1、2静态内部类

• 不依赖外部类对象，可直接创建对象或通过类名访问内部静态类的成员，可声名静态成员。相当于一个外部类。
• 注意只有内部类才能用static关键字修饰，普通类不可以是静态类。
• 只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）。

package com.commenclass.Demo02;

public class Outer {
    private String name = "张三";
    private int age = 20;
    private static int a = 0;

    //静态内部类的级别和外部类相同
    static class Inner{
        private String address = "北京";
        private String phone = "123456";
        private static String sex = "男";
        public void show(){
            //如何来调用外部类的属性
            //1、先创建外部类对象
            Outer outer = new Outer();
            //2、通过外部类对象来调用外部类属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）
            System.out.println(a);
            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性,通过类名来访问
            System.out.println(Inner.sex);
        }

    }
    public static void main(String[] args) {
        //无需先创建外部类对象，直接创建内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }

}

1、3局部内部类

• 定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保证变量的生命周期于自身相同，变量必须修饰为final.
• 局部内部类的使用范围仅限于当前方法。
• 如果外部类的当前方法是静态方法，局部内部类访问外部类的成员需要实例化对象访问。
• 定义局部变量,局部变量前面不能加任何的权限访问修饰符jdk1.8，局部变量之前自动加final。
• 局部内部类不能存在静态成员，但是加上final变成静态常量就可以了。

package com.commenclass.Demo03;

public class Outer {
    private String name = "张山";
    private int age = 18;

    public void show(){     //如果方法是静态方法，局部内部类访问外部类的成员需要实例化对象访问
        //定义局部变量,局部变量前面不能加任何的权限访问修饰符
        //jdk1.8，局部变量之前自动加final，相当于final String address
        final String address = "北京";
        //由于是局部变量，当show方法执行后或被回收，而inner对象和Inner类还在，
        // show2方法不能访问一个已经消失的变量，所以外部类的局部变量必须是常量

        //局部内部类，注意前面不能加任何权限访问修饰符
        class Inner{
            private String phone = "110";
            private String email = "zhangsan@qq.com";

            //局部内部类不能存在静态成员，但是加上final变成静态常量就可以了
            private final static String sex = "男";

            public void show2(){
                //访问外部类的属性
                //局部内部类和局部变量的级别相同的，所以可以直接访问
                System.out.println(Outer.this.name);//name =>相当于省略了Outer.this.name
                System.out.println(age);//Outer.this.age
                //访问内部类的成员
                System.out.println(this.phone);//phone =>相当于省略了this.phone
                System.out.println(email);//this.email
                //访问外部类局部变量,jdk1.7要求变量必须是常量，jdk1.8会自动添加final
                System.out.println(address);
            }

        }
        //创建局部内部类对象,调用show2()
        Inner inner = new Inner();
        inner.show2();

    }
}

1、4匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只创建一个该类的对象。
• 优点：减少代码量。
• 缺点：可读性比较差。

package com.commenclass.Demo04;

public interface Usb {
    void service();

}

package com.commenclass.Demo04;

public class Mouse implements Usb {
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作！");
    }
}

package com.commenclass.Demo04;

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

        //局部内部类
       /* 
       class Fan implements Usb{
            @Override
            public void service() {
                System.out.println("连接电脑成分，风扇开始工作了");
            }
        }
        //使用局部内部类来创建对象
        Usb usb = new Fan();
        usb.service();
        
        */

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

二、Object类

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

三、Object类常用方法

3、1 getClass()方法

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

package com.commenclass.Demo05;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.commenclass.Demo05;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",19);

        //判断s1和s2这两个对象是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        System.out.println(class1==class2);

    }
}

3、2 hashCode()方法

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

3、3 toString()方法

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

3、4 equals()方法

• public boolean equals(Object obj) {}
• 默认实现为（this == obj） ，比较两个对象地址是否相同。
• 可进行覆盖（override），比较两个对象的内容是否相同。具体步骤如下：
  1. 比较两个引用是否指向同一个对象。
  2. 判断obj是否为null。
  3. 判断两个引用指向的实际对象类型是否一致。
  4. 强制类型转换。
  5. 依次比较各个属性值是否相等。

  /* @Override
    public boolean equals(Object obj) {
        //1、判断对象是否是同一个引用
        if (this == obj) return true;
        //2、判断obj是否为null和是否为同一类型
        if (obj == null || this.getClass() != obj.getClass()) return false;
        //3、强制类型转换
        Student student = (Student) obj;
        return age == student.age && Objects.equals(name, student.name);
    }*/

@Override
   public boolean equals(Object obj) {
       //1、判断对象是否是同一个引用
       if (this == obj) return true;
       //2、判断obj是否为null和是否为同一类型
       if(obj == null||this.getClass()!= obj.getClass()) return false;
       //3、强制类型转换
       Student student = (Student) obj;
       return this.age == student.getAge() && Objects.equals(this.name, student.getName());
   }

3、5 finalize() 方法

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

四、包装类

什么是包装类

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

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

4、1类型转换与装箱、拆箱

装箱：把基本类型转化为引用类型

拆箱：把引用类型转换为基本类型

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

  • Number父类中提供的6个共性方法。
  • pareseXXX()静态方法（基本类型和字符串类型转换）。
  • valueof()静态方法（基本类型和引用类型转换）。、

  注意：需要保证类型兼容，否者会抛出NumberFormatException异常。

package com.commenclass.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 基本数据类型和字符串之间的转换
        //1.1 基本类型转子字符串
        int n1 = 15;
        String s1 = n1+"";
        //1.2 Integer中的toString()方法
        String s2 = Integer.toString(n1,16);//f
        System.out.println(s1);
        System.out.println(s2);

        //2 字符串转换为基本类型
        String str = "150";//注意子字符串内只能是数字
        //使用Integer.parseInt(str)
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        //boolean类型转换为字符串，"true"---->true 非"true"---->false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
        
    }
}

4、2 整数缓冲区

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

package com.commenclass.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 = Integer.valueOf(100);
        System.out.println(integer3==integer4);//true

        Integer integer5 = Integer.valueOf(200);
        Integer integer6 = Integer.valueOf(200);
        System.out.println(integer5==integer6);//false 超出Integer缓冲区了 integer[-128，127]
    }
}

五、String类

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

package com.commenclass.Demo06;

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

        //1、字符串的第一种创建方式
        String name = "hello";//"hello"存储在字符串池中
        name = "张三";
        //并没有修改字符串的值，而是重新开辟一块空间存“张三”，然后name指向"张三";
        // name存的是字符串池中字符串的地址
        String name2 = "张三";

        //2、字符串的第二种创建方式,使用的是new创建的
        String str =new String("java");
        String str2 =new String("java");
        System.out.println(str==str2);//false如果没有使用new赋值的话是true，但是new地址不同
        System.out.println(str.equals(str2));//String类重写了equals方法，比较的是值而不是地址
        
    }
}

5、1 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():将小写转换为大写；
• public boolean endWith(String str):判断字符串是不是以str结尾；
• public String replace(char oldChar,char newChar):将旧字符串替换为新字符串；
• public String[] split(String str):根据str做拆分。

package com.commenclass.Demo06;

import java.util.Arrays;

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

        //1、字符串的第一种创建方式
        String name = "hello";//"hello"存储在字符串池中
        name = "张三";
        //并没有修改字符串的值，而是重新开辟一块空间存“张三”，然后name指向"张三";
        // name存的是字符串池中字符串的地址
        String name2 = "张三";

        //2、字符串的第二种创建方式,使用的是new创建的
        String str =new String("java");
        String str2 =new String("java");
        System.out.println(str==str2);//false如果没有使用new赋值的话是true，但是new地址不同
        System.out.println(str.equals(str2));//String类重写了equals方法，比较的是值而不是地址

        System.out.println("----------字符串常用方法1------------");
        //字符串方法的使用
        //1、length（）返回字符串的长度
        //2、charAt(int index) 返回某个位置的字符
        //3、contains(String str) 判断是否包含某个字符串

        String content = "别特么学java了,学个鸡毛学的java";
        System.out.println(content.length());
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));

        System.out.println("----------字符串常用方法2------------");
        //字符串方法的使用
        //4、toCharArray() 将字符串转换为数组
        //5、indexOf() 返回字符串首次出现的位置
        //6、lastIndexOf() 返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",5));
        System.out.println(content.lastIndexOf("java"));

        System.out.println("----------字符串常用方法3------------");
        //7、trim() 去掉字符串前后的空格
        //8、toUpperCase() 把小写转换为大写  toLowerCase() 将大写转换为小写
        //9、endWith(str) 判断字符串是否以str结尾, startWith(str) 判断字符换是否以str开头

        String content2 = " hello world ! ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));

        System.out.println("----------字符串常用方法4------------");
        //10、replace (char oldChar,char newChar) 用新的字符或者字符串替换旧的字符或字符串
        //11、split (str) 根据str做拆分

        System.out.println( content.replace("java","php"));
        String say = "java is the worst  programming language!C is the best!";
        String[] arr = say.split("[ ,]+");
        System.out.println(arr.length);
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }

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

        String s3 = "abcsd";// a-->97
        String s4 = "xyzhsf";// x-->120
        System.out.println(s3.compareTo(s4));

        String s5 = "abc";
        String s6 = "abcsfsf";
        System.out.println(s5.compareTo(s6));//特殊，s5长度-s6长度=-4
        
    }
}

5、2 String案例演示

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

package com.commenclass.Demo06;

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

        //1、将str按单吃输出
        String[] arr = str.split(" ");
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("------------");

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

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

        //4、将每个单词的首字母大写
        System.out.println("------------");
        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);
        }

    }
}

5、3 StringBuffer和StringBuilder

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
• StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
• StringBuffer和StringBuilder的方法是一样的。
• 常用方法：
  1. append()方法：追加
  2. insert()方法：添加
  3. replace()：替换，可以指定位置
  4. delete()：删除

package com.commenclass.Demo06;
/*
* StringBuffer 和StringBuilder的使用
* 和String的去区别：
* 1、效率更高
* 2、更节省内存
* */
public class Demo05{
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1、append()方法：追加
        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,4,"hello");//  4的位置是不会换的
        System.out.println(sb.toString());
        //4、delete()：删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        sb.reverse();//反转
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());

    }
}

六、BigDecimal类

• 位置：java.math包中；

• 作用：精确计算浮点数；

• 创建方式：BigDecimal bd = new BigDecimal(“1.0”);

• 方法:

  1. BigDecimal add(BigDecimal bd) ----- 加发
  2. BigDecimal qubtract(BigDecimal bd)----- 减法
  3. BigDecimal multiply(BigDecimal bd)----- 乘法
  4. BigDecimal divide(BigDecimal bd，int scale，RoundingModule mode)---- 除法

  • 参数：scale---->保留几位小数

  • 参数mode:

    • 指定小数部分的取舍模式，通常采用四舍五入的模式
    • 取值为BigDecimal.ROUND_HALF_UP。

package com.commenclass.Demo06;

import java.math.BigDecimal;

public class Demo07 {
    public static void main(String[] args) {
        //double 是近似值存储 容易出现精度丢失
        double a = 1.0;
        double b = 0.9;
        System.out.println(a-b);
        double result = (1.4-0.5)/0.9;
        System.out.println(result);//精度丢失

        //BigDecimal,打的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("0.9");
        BigDecimal bd2 = new BigDecimal("1.0");
        //减法
        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,2,BigDecimal.ROUND_HALF_UP);
        //如果除不尽会报异常,scale：保留几位小数，四舍五入
        System.out.println(r4);

    }
}

七、Date类

Date表示特定的瞬移，精确到毫秒。Date类中的大部分方法都已经被Calender类中的方法所取代。

时间单位：

• 1秒 = 1000毫秒
• 1毫秒 = 1000微秒
• 1微秒 = 1000纳秒

1. 创建Date对象：Date date1 = new Date();
2. after()和before()方法：判断时间是否在之后或者之前
3. compare（）：比较
4. equals（）：判断是否相等

package com.commenclass.Date;


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);// true 今天在昨天之后
        boolean b2 = date1.before(date2);// false 今天不在在昨天之前
        System.out.println(b1);
        System.out.println(b2);

        //比较compareTo()
        int b3 = date1.compareTo(date2);// date1 - date2 = 1
        int b4 = date2.compareTo(date1);// -1
        System.out.println(b3);
        System.out.println(b4);

        //equals() 比较时间是否相等
        boolean b5 = date1.equals(date2);
        System.out.println(b5);// false

    }
}

八、Calender类

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

• 构造方法

  • protected Calendar(）：由于修饰符是protected，所以无法直接创建该对象

• 其他方法

  方法名	说明
  static Calendar getlnstance()	使用默认时区和区域获取日历
  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 getTimelnMillies()	毫秒为单位返回该日历的时间值

package com.commenclass.Date;
import java.util.Calendar;

public class Demo02 {
    public static void main(String[] args) {
        //1、创建Calender对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        //2、获取时间信息
        int year = calendar.get(Calendar.YEAR);
        int month =calendar.get(Calendar.MONTH);//月从0~11
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//二十四小时制
        int minu = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minu+"分"+second+"秒");
        //3、修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar1.getTime().toLocaleString());
        //4、 add 基于当前时间来增加或者减少
        calendar1.add(Calendar.HOUR,1);//增加一个小时 减一小时就设置为-1
        System.out.println(calendar1.getTime().toLocaleString());
        //5、补充方法
        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	年	2022
  M	年中月份	08
  d	月中天数	10
  H	一天中小时数（0-23）	22
  m	分钟	16
  s	秒	59
  S	毫秒	367

package com.commenclass.Date;

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

public class Demo03 {
    public static void main(String[] args) throws Exception {
        //1、创建SimpleDateFormat对象 y--年 M--月 d--日 m--分钟 s--秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2、创建Date
        Date date1 = new Date();
        //3、格式化date(把时间转换为字符串)
        String str = sdf.format(date1);
        System.out.println(str);
        //4、解析(把字符串转换为时间)
        Date date2 =  sdf.parse("1990/5/4");//这里的格式必须和sdf的格式相同
        System.out.println(date2.toLocaleString());


    }
}

十、System类

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

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

package com.commenclass.Demo07;

import java.io.FilterOutputStream;
import java.util.Arrays;

public class Demo01 {

    public static void main(String[] args) {
        //1、arraycopy：数组的赋值
        //src：源数组
        // srcPos:从哪个位置开始复制
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制的长度
        int[] arr = {1,2,3,4,5,6,7,8};
        int[] dest = new int[8];
        System.arraycopy(arr,4,dest,4,4);
        System.out.println(Arrays.toString(dest));

        //2、currentTimeMillis();
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999999; i++) {
            for (int j = -9999999; j < 9999999; j++) {
               int result = i+j;
            }

        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));//计算程序执行时间

        //3、System.gc() 告诉垃圾回收器回收垃圾
        new Student("aaa",18);
        new Student("bbb",19);
        new Student("ccc",20);
        System.gc();//告诉垃圾回收器回收

        //4、exit() 退出JVM
        System.exit(0);
        System.out.println("程序结束了。。。。");//不会被打印，已经退出JVM了

    }
}

十一、总结

• 内部类：

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

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

• Object类:

  • 所有类的直接或间接父类，可存储任何对象。

• 包装类:

  • 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据。

• String类:

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

• BigDecimal:

  • 可精确计算浮点数。

• Date

  • 特定时间

• Calendar

  • 日历

• SimpleDateFormat

  • 格式化时间

• System

  • 系统类