Java常用类

1. 内部类

1. 内部类分类

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

2. 内部类概念：在一个类的内部再定影一个完整的类

   class Outer{
   	class Inner{
   	}
   }
   

3. 特点：

   • 编译后可生成独立的字节码文件（.class文件）
   • 内部类可直接访问外部类的私有成员，而不破坏封装
   • 内部类可为外部类提供必要的内部功能组件

1.1 成员内部类

• 成员内部类：在类的内部定义，与实例变量、实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

//创建内部类对象方法1
Outer outer =new Outer();
Outer.Inner inner=outer.new Inner();//创建内部类对象时，必须依赖外部类对象
//创建内部类对象方法2
Outer.Inner inner=new Outer().new Inner();

• 当外部类、内部类存在重名属性时，会优先访问内部类属性；若要访问外部类属性，使用 外部类名.this.属性 访问
• 内部类不能定义静态成员

public class Demo {
    public static void main(String[] args) {
//        //1创建外部类对象
//        Outer outer =new Outer();
//        //2创建内部类
//        Outer.Inner inner=outer.new Inner();//创建内部类对象时，必须依赖外部类对象
        //一步创建内部类
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //内部类
    class Inner{
        private String address="上海";
        private String phone="110";
        private String name="李四";
        //private static String country="中国";//内部类不能定义静态成员
        public void show(){
            //当内部类和外部类属性的名字相同时，使用 外部类名.this 指定访问外部类
            //若不指定外部类，会默认调用内部类属性
            System.out.println(Outer.this.name );
            System.out.println(Outer.this.age);
            System.out.println(this.name);
            System.out.println(this.address);
        }
    }
}

1.2 静态内部类

• 静态内部类不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 静态内部类调用外部类属性和方法，需要在静态内部类里面new一个外部类对象
• 只有静态内部类可以使用static修饰，普通类不能使用static修饰

public class Demo {
    public static void main(String[] args) {
        //直接创建静态内部类
        Outer.Inner inner=new Outer.Inner();
        inner.show();
    }
}


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //静态内部类
    static class Inner{
        private String address="上海";
        private String name="李四";
        private static String country="中国";//静态内部类可以定义静态成员
        public void show(){
            //1.静态内部类调用外部类属性
            //（1）先创建外部类对象
            Outer outer=new Outer();
            //（2）调用外部类属性
            System.out.println(outer.name );
            System.out.println(outer.age);
            //2.调用内部类属性
            System.out.println(this.name);
            System.out.println(this.address);
            //3.调用静态内部类的静态属性
            System.out.println(Inner.country);//静态属性可直接通过类名访问
        }
    }
}

1.3 局部内部类

• 局部内部类：定义在外部类的方法之中，作用范围和创建对象范围仅限于当前方法
• 在定义局部内部类时不能添加任何访问修饰符，如private、static
• 局部内部类访问属性
  • 访问外部类属性：可直接访问，为了区分一般使用 外部类名.this.属性名
  • 访问内部类属性：可直接访问，为了区分一般使用 this.属性名
  • 访问方法中的局部变量：
    • jdk1.7之前要求局部变量加修饰符final变为常量才能访问，jdk1.8中会自动添加final
    • 原因内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
• 局部内部类不能包含static修饰的静态属性，可以使用static +final修饰
• 局部内部类使用范围有限：使用局部内部类只能在外部类当前方法中实例化一个内部类对象

public class Demo {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show();
    }
}


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //方法
    public void show(){
        //定义局部变量
        String address="上海";//访问方法中的局部变量：
        // jdk1.7之前要求局部变量加修饰符final变为常量才能访问，jdk1.8中会自动添加final

        //局部内部类
        //在定义局部内部类时不能添加任何访问修饰符，如private、static
        class Inner{
            //局部内部类属性
            private String phone="11938982";
            private String email="zhangsan.@162.com";
            static final private String ID="110";//局部内部类不能包含static修饰的静态属性，可以使用static +final修饰

            public void show(){

                //局部内部类访问外部类属性
                System.out.println(Outer.this.name);//访问外部类属性：可直接访问，为了区分一般使用Outer.this.
                System.out.println(Outer.this.age);
                //局部内部类访问内部类属性
                System.out.println(this.phone);//访问内部类属性：可直接访问，为了区分一般使用this.
                System.out.println(this.email);
                //局部内部类访问局部变量
                System.out.println(address);
            }
        }
        //在方法内部实例化内部类对象
        Inner inner=new Inner();
        inner.show();
    }
}

1.4 匿名内部类

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

public class TestUsb {
    public static void main(String[] args) {
        //2.1 使用局部内部类实现接口
//        class Fan implements Usb{
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作...");
//            }
//        }
//        Usb usb = new Fan();
//        usb.service();

        //2.2 使用匿名内部类实现接口
        Usb usb=new Usb(){//匿名类实现了Usb接口
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作...");
            }
        };//注意这里有个分号
        usb.service();
    }
}


//使用匿名内部类首先要继承一个父类或者实现一个接口
//1.定义一个接口
public interface Usb {
    //服务
    void service();
}

2. Object类

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

2.1getClass()方法

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

2.2 hashCode()方法

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

2.3 toString() 方法

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

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

2.4 equals ()方法

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

    @Override
//重写equals()方法，改为比较属性值是否相同
    public boolean equals(Object obj) {
        //1. 比较两个引用是否指向同一个对象
        if (this==obj){
            return true;
        }
        //2. 判断obj是否为null
        if (obj==null){
            return false;
        }
        //3. 判断两个引用指向的实际对象是否一致
        //3.1使用this.getClass判断
//        if(this.getClass()==obj.getClass()){
//
//        }
        //3.2使用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;

    }

2.5 finalize ()方法

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

第2节实现代码

public class Demo {
    public static void main(String[] args) {
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        //1.使用getClass()判断两个引用中实际储存对象类型是否一致
        System.out.println("=======getClass()=======");
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if(class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
        //2.hashCode()方法获得对象的哈希值
        System.out.println("=======hashCode()=======");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        //3.toString()方法该对象的字符串表示，一般为了查看属性都会重写该方法
        System.out.println("=======toString()=======");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        //4.equals()比较对象，默认比较对象地址是否相同，可重写为比较内容是否相同
        System.out.println("=======equals()=======");
        //System.out.println(s1.equals(s2));
        //System.out.println(s1.equals(s3));//不重写之前是比较对象地址是否相同
        Student s4=new Student("张三",18);
        System.out.println(s1.equals(s4));
        //5.finalize()方法回收垃圾
        System.out.println("=======finalize()=======");
        new Student("zhangsan",19);
        new Student("lisi",29);
        //回收垃圾
        System.gc();//手动调用通知系统垃圾回收
        System.out.println("回收垃圾");
    }
}


//定义Student类
public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return 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 false;
        }
        //3. 判断两个引用指向的实际对象是否一致
        //3.1使用this.getClass判断
//        if(this.getClass()==obj.getClass()){
//
//        }
        //3.2使用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;
    }

    //重写finalize()，便于判断该方法是否执行过
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}

3. 包装类

3.1包装类概述

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

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

3.2 类型转换：装箱、拆箱

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

public class Demo {
    public static void main(String[] args) {
        //1. 数据类型转换：装箱与拆箱
        //（1）装箱，基本类型转成引用类型的过程
        //方法1，使用构造函数转换
        int num1=18;
        Integer integer1=new Integer(num1);
        //方法2，使用Integer.valueof()方法转换
        Integer integer2=Integer.valueOf(num1);
        //（2）拆箱，引用类型转换为基本类型
        int num2=integer1.intValue();

        //（3）JDK1.5后，提供自动装箱和拆箱，编译器自动完成装箱拆箱操作
        int age=30;
        Integer integer4=age;//装箱
        int age2=integer4;//拆箱

        //2. 基本类型和字符串之间的转换
        //(1)基本类型转成字符串
        int num=255;
        //方法1 使用“+”号
        String s1=num+"";
        System.out.println(s1);
        //方法2 使用Integer.toString()方法
        String s2=Integer.toString(num,16);//radix可以指定基数，16即为十六进制数，默认为十进制数
        System.out.println(s2);
        //（2) 字符串转换为基本类型
        String str="150";
        //使用Integer.parseXXX()；
        int num3=Integer.parseInt(str);
        System.out.println(num3);
        //(3) boolean字符串形式转换为基本类型 只有"true"->true，其余字符串都会转为false
        String str1="true";
        boolean b1=Boolean.parseBoolean(str1);
        System.out.println(b1);

        String str2="aaa";
        boolean b2=Boolean.parseBoolean(str2);
        System.out.println(b2);
    }
}

3.3 Integer整数缓冲区

• Java预先创建了256个常用的整数包装类型对象（使用Integer.valueOf()或自动装箱时）
• 在实际应用当中，对已经创建的对象进行复用

public class Demo {
    public static void main(String[] args) {
        //Inter整数缓冲区
        //比较对象是否为同一个对象
        //（1）使用new Integer()对比
        Integer integer = new Integer(100);
        Integer integer1 = new Integer(100);
        System.out.println(integer==integer1);//false,使用对象创建，指向堆中位置不同

        //（2）自动装箱或使用Integer.valueOf()
        //Integer.valueOf()会使用静态方法提前在堆中生成缓冲区Integer数组
        //当数字在-128~127之间时，integer是调用缓冲区数组
        //当数字不在这个范围内时，才会重新new Integer()对象
        //作用是-128~127使用频繁，降低内存消耗。Integer.valueOf()内部调用的也是new Integer()，只不过会提前生成缓冲区
        Integer integer2=100;
        Integer integer3=100;
        System.out.println(integer2==integer3);//true

        //
        Integer integer4=200;
        Integer integer5=200;
        System.out.println(integer4==integer5);//false
    }
}

4. String类

4.1 字符串概述

• 字符串是常量，创建之后不可改变
• 字符串字面值存储在方法区的字符串池中，可以共享
• 创建字符串
  • String s="Hello"；产生一个对象，字符串池中存储
  • String s=new String("Hello"); 产生两个对象，堆和池中各存储一个，堆中数据仍然是指向字符串池中

4.2 字符串常用方法

• 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 String toLowerCase() 将大写转成小写
• public boolean endWith(String str) 判断字符串是否以str结尾；public boolean startWith(String str) 判断字符串是否以str开始
• public String replace(char oldChar, char newChar) 将旧字符串替换成新字符串
• public String[] split(String str) 根据str做拆分
• public String equals() 判断字符串是否相等；public String equalsIgnoreCase() 忽略大小写
• public String compareTo() 比较字符串大小，按编码表进行比较
• 代码

import java.util.Arrays;
import java.util.Locale;

public class Demo {
    public static void main(String[] args) {
        //1. public int length() 返回字符串的长度
        //2. public char charAt(int index) 根据下标获取字符
        //3. public boolean contains(String str) 判断当前字符串中是否包含str
        String content="Java是世界上最好的语言,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"));
        //public char[] toCharArray() 将字符串转换为数组
        //public int indexOf(String str) 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
        //public int lastIndexOf(String str) 查找字符串在当前字符串中最后一次出现的下标索引
        System.out.println(Arrays.toString(content.toCharArray()));//按字符转换为数组
        System.out.println(content.indexOf("Java",2));//fromIndex指定第几次出现，默认为第一次
        System.out.println(content.lastIndexOf("Java"));
        //public String trim() 却掉字符串前后的空格
        //public String toUpperCase() 将小写转成大写；public String toLowerCase() 将大写转成小写
        //public boolean endWith(String str) 判断字符串是否以str结尾；public boolean startWith(String str) 判断字符串是否以str开始
        String content2="  hello World  ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase(Locale.ROOT));
        System.out.println(content2.toLowerCase(Locale.ROOT));
        String filename="hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
        //public String replace(char oldChar, char newChar) 将旧字符串替换成新字符串
        //public String[] split(String str) 根据str做拆分
        System.out.println(content.replace("Java","Php"));
        String say="java is  the best programing language,,java xiang";
        //say.split("[ ,]+")参数，[ ,]+表示使用空格和","分割，"+"表示可以空格和","可以出现一次或多次
        String [] arr= say.split("[ ,]+");
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }
        //public String equals() 判断字符串是否相等
        //public String compareTo() 比较字符串大小，按编码表进行比较
        String s1="Hello";
        String s2="hello";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写
        String s3=new String("hello");
        String s4=new String("hello");
        System.out.println(s3.equals(s4));//String类内部已经重写了equals()

        String s5="abc";//97
        String s6="xyza";//120
        System.out.println(s5.compareTo(s6));//-23 按编码表比较，返回首次出现差别字符的int类型的差值,此处即a-x=-23

        String s7="abcdef";
        System.out.println(s5.compareTo(s7));//-3 当出现"abcdef"完全包含"abc"时，返回的是字符个数的差值
    }
}

• 案例演示
  • 需求：已知String str="this is a text"
    • 将str中的单词单独获取出来
    • 将str中的text替换为practice
    • 在text前面插入一个easy
    • 将每个单词的首字母改为大写

/**
 * 将str中的单词单独获取出来
 * 将str中的text替换为practice
 * 在text前面插入一个easy
 * 将每个单词的首字母改为大写
 */

public class Demo {
    public static void main(String[] args) {
        String str="this is a text";
        //1. 将str中的单词单独或取出来
        String [] arr=str.split(" ");
        System.out.println("-----将str中的单词单独取出来-----");
        for (String s : arr) {
            System.out.println(s);
        }
        //2. 将str中的text替换为practice
        System.out.println("-----将str中的text替换为practice-----");
        String str2=str.replace("text","practice");
        System.out.println(str2);
        //3. 在text前面插入easy
        System.out.println("-----在text前面插入easy------");
        String str3=str.replace("text","easy text");
        System.out.println(str3);
        //4. 将每个单词的首字母改为大写
        for (int i=0;i<arr.length;i++){
            //4.1 将每个单词第一个字母变为大写
            char first=arr[i].charAt(0);
            char upperFirst=Character.toUpperCase(first);//使用了字符的封装类
            //4.2 将第一个单词与后面内容拼装
            String news=upperFirst+arr[i].substring(1);//arr[i].substring(1)为截取字符串的字串，参数有起始位置和终止位置
            System.out.println(news);
        }

    }
}

4.3 可变字符串

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

• StringBuilder: 可变长字符串，JDK5.0提供，运行效率块、线程不安全

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

• 常用方法

//1 append(); 追加
//2 insert(); 添加
//3 replace(); 替换
//4 delete(); 删除
//5 reverse();倒置

public class Demo {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        //1 append(); 追加
        sb.append("Java真好");
        sb.append("Java真香");
        System.out.println(sb.toString());
        //2 insert(); 添加,offset为插入位置
        sb.insert(0,"最前面");
        System.out.println(sb.toString());
        //3 replace(); 替换,start开始位置，end结束位置
        sb.replace(0,3,"hello");
        System.out.println(sb.toString());
        //4 delete(); 删除,位置从0到4的字符
        sb.delete(0,5);
        System.out.println(sb.toString());
        //5 reverse();倒置
//        sb.reverse();
//        System.out.println(sb.toString());
    }
}

• 验证StringBuilding效率高于String

/**
 * 验证StringBuilding效率高于String
 */

public class Demo {
    public static void main(String[] args) {
//        long startTime1=System.currentTimeMillis();
//        String string="";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
//        long endTime1=System.currentTimeMillis();
//        System.out.println("String用时："+(endTime1-startTime1));

        long startTime2=System.currentTimeMillis();
        StringBuilder sb=new StringBuilder();
        for (int i=0;i<99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long endTime2=System.currentTimeMillis();
        System.out.println("StringBuild用时："+(endTime2-startTime2));
    }
}

5. BigDecimal使用

• 位置：java.math包中
• 作用：精确计算浮点数
• 创建方式：BigDecimal bd=new BigDecimal("1.0")
• 常用方法
  • 加 BigDecimal add(BigDecimal bd)
  • 减 BigDecimal subtract(BigDecimal bd)
  • 乘 BigDecimal multiply(BigDecimal bd)
  • 除 BigDecimal divide(BigDecimal bd)
    • 除法时涉及除不尽小数时，需要指定精确参数
    • divide(BigDicimal bd, int scal, RoundingMode mode)
    • 参数scal: 指定精确到小数点后几位
    • 参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式，BigDecimal.ROUND_HALF_UP

import java.math.BigDecimal;

public class Demo {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //加法1.0+0.9
        BigDecimal r1= bd1.add(bd2);
        System.out.println(r1);
        //减法1.0-0.9
        BigDecimal r2=bd1.subtract(bd2);
        System.out.println(r2);
        //乘法1.0*0.9
        BigDecimal r3=bd1.multiply(bd2);
        System.out.println(r3);
        //除法(1.4-0.5)/0.9
        BigDecimal r4=new BigDecimal("1.4").subtract(new BigDecimal("0.5"))
                .divide((new BigDecimal(("0.9"))));
        System.out.println(r4);
        //除法除不尽时需要指定舍入模式和保留小数位数20/3=6.67
        //scale:2表示保留2位小数
        //BigDecimal.ROUND_HALF_UP 表示四舍五入
        BigDecimal r5=new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

6. 与时间有关的类

6.1 Data类

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

import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //1. 创建Date对象
        //public Date() 返回当前时刻时间
        Date date1=new Date();
        System.out.println(date1.toString());//date1.toString()使用默认时间格式转换时间为字符串
        System.out.println(date1.toLocaleString());//已过时 date1.toLocaleString()使用当地时间格式转换时间为字符串
        //public Date(long date) 可以输入一个long类型数值，按毫秒计算与1970/1/1 0:0:0的差值
        //创建昨天时间date2
        Date date2=new Date(date1.getTime()-60*60*24*1000);//date1.getTime()获取当前时间，以毫秒计  60*60*24*1000一天总共毫秒
        System.out.println(date2.toLocaleString());
        //2. before()和after() 判断两个时间的先后，返回boolean值
        boolean b1=date1.before(date2);
        System.out.println(b1);
        boolean b2=date1.after(date2);
        System.out.println(b2);
        //3. compareTo()比较两个时间大小，以毫秒比较，大返回1，小返回-1，相等为0
        int d=date1.compareTo(date2);
        System.out.println(d);
        //4. equals() 判断两个时间是否相等，返回Boolean值
        boolean b3=date1.equals(date2);
        System.out.println(b3);
    }
}

6.2 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设置此日历的时间。Calendar-Date
  • void add(int field, int amount)：按照日历的规则，给指定字段添加或减少时间量
  • long getTimeInMillies()：毫秒为单位返回该日历的时间值

import java.util.Calendar;
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //1. 创建calendar对象
        // Calendar.getInstance()依据当前时区创建默认的Calendar对象
        Calendar calendar=Calendar.getInstance();//不能使用new创建对象
        System.out.println(calendar.getTime().toLocaleString());//calendar.getTime()依据Calendar类创建一个Data类
        System.out.println(calendar.getTimeInMillis());//calendar.getTimeInMillis()返回毫秒计的calendar时间
        //2. 获取时间信息
        int year=calendar.get(Calendar.YEAR);//年
        int month=calendar.get(Calendar.MONTH);//月 注意该方法返回的月份为0~11月
        int day=calendar.get(Calendar.DATE);//日 Calendar.DAY_OF_MONTH或alendar.DATE
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//时 Calendar.HOUR_OF_DAY 24小时值; Calendar.HOUR 12小时值
        int minute=calendar.get(Calendar.MINUTE);//分
        int second=calendar.get(Calendar.SECOND);//秒
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //3. 修改时间 calendar2.set()
        Calendar calendar2=Calendar.getInstance();
        //修改月份
        calendar2.set(Calendar.MONTH,4);//注意此处月份仍是从0开始
        //修改日期
        calendar2.set(Calendar.DAY_OF_MONTH,10);
        System.out.println(calendar2.getTime().toLocaleString());
        //4. add方法修改时间
        calendar2.add(Calendar.HOUR,-1);//-1表示值减1，正数表示值增加
        System.out.println(calendar2.getTime().toLocaleString());
        //5. 获得时间的最大值和最小值
        int max=calendar.getActualMaximum(Calendar.DAY_OF_MONTH);//月份天数最大值
        int min=calendar.getActualMinimum(Calendar.DAY_OF_MONTH);//月份最小值
        System.out.println("当月最多有"+max+"天，"+"最少有"+min+"天");
    }
}

6.3 SimpleDateFormat类

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

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

public class Demo {
    public static void main(String[] args) throws ParseException {
        //1. 创建SimpleDateFormat对象 指定时间的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        //2. 创建Date
        Date date = new Date();

        //3. 格式化date(将date对象转换为sdf指定格式的字符串)
        String str=sdf.format(date);
        System.out.println(str);

        //4. 解析(把字符串转成data对象的日期)
        Date date1=sdf.parse("1996/03/20 08-45-55");
        System.out.println(date1.toLocaleString());

    }
}

7. System类

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

public class Demo {
    public static void main(String[] args){
        //1. 数组复制System.arraycopy(src,srcPos,dest,destPos,length)
        //Arrays.copyOf()内部调用的也是System.arraycopy()
        //src--源数组,srcPos--从哪个位置开始复制,dest--目标数组,destPos--目标数组的位置,length--复制的长度
        int[] arr={20,14,34,23,17,17};
        int[] dest=new int[arr.length];
        System.arraycopy(arr,2,dest,2,4);
        for (int i : dest) {
            System.out.print(i+" ");
        }
        //2. System.currentTimeMillis()获取当前系统时间，单位毫秒
        long start=System.currentTimeMillis();
        for(int i=-999999;i<9999999;i++){
            for(int j=-999999;j<9999999;j++){
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println();
        System.out.println("用时："+(end-start));
        //3.System.gc() 告诉垃圾回收
        //4. System.exit 退出jvm
        System.exit(0);//0 正常退出; 非0 异常退出
        System.out.println("程序结束了");
    }
}

8. 总结

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

__EOF__

本文作者：Ray963
本文链接：https://www.cnblogs.com/ray93/p/16293909.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！