常见实用类：内部类，object类，包装类，String类

我学学学学

已于 2023-08-15 17:26:27 修改

阅读量105

点赞数 1

文章标签： java 开发语言

于 2023-07-15 23:39:41 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_58841149/article/details/131689766

版权

内部类

什么是内部类

什么是内部类：内部类是指在一个类的里面定义的完整的类

class outer{
	class inter{
	}
}

在以上的代码示例中，inter类就是一个内部类，定义在outer这个类中的内部类

内部类的特点：
1. 编译之后会生成单独的字节码文件-.class。
2. 内部类能够直接调用外部类中私有化的属性且不会破坏外部类的封装。

成员内部类

内部类的定义：

package com.oop.Demo07;
//该包用于解释常见实用类的使用
//该类用于解释内部类
public class outer {
    //将name在outer类中私有化
    private String name="你好";

    public class inner{
        public void Header(){
            System.out.println(name);//可以直接调用外部类中的私有化属性。
        }
    }
}

对于成员内部类定义方法的调用

package com.oop;

import com.oop.Demo07.outer;

//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
        /**
         * 测试类或其他类调用成员内部类的方法
         * 方法一：
         *      1.创建成员外部类的对象
         *      2.根据成员外部类创建内部类对象
         *      3.调用
         */
        outer outer = new outer();
        outer.inner inner = outer.new inner();
        inner.Header();

        /**
         * 方法二：一步到位
         *      new 外部对象.new 内部对象
         */
        outer.inner inner2 = new outer().new inner();
        inner2.Header();

    }
}

成员内部类的定义是和外部类的属性、方法属于同级别的
当外部类和内部类存在重名属性时，会优先访问内部类属性
在外部类和内部类有相同属性时访问外部类的属性：外部类名.this.属性名

package com.oop.Demo07;
//该包用于解释常见实用类的使用
//该类用于解释内部类
public class outer {
    //将name在outer类中私有化
    private String name="你好";

    public class inner{
        private String name="在吗";
        public void Header(){
            //在外部类和内部类有相同属性时访问外部类的属性
            System.out.println(outer.this.name);
            System.out.println(name);//可以直接调用外部类中的私有化属性。
        }
    }
}

成员内部类不能包含静态属性：private static String wrong{}这这样写是错误的
但是成员内部类可以包含静态常量：private static final String wrong{}

静态内部类

静态内部类和外部类同级，不依赖外部类对象，可直接声明或创建对象调用，可以声明静态成员

静态内部类的创建和调用

StaticOuter.java:

package com.oop.Demo07;
//用于学习静态内部类的创建和对于属性的调用
public class StaticOuter {
    private String name="静态外部类";


    //创建静态内部类就是使用static标志符
    //静态内部类的层级和外部类的层级相同，大于外部类的属性的层级。
    public static class inner{
        //在静态内部类中创建属性
        private String student="静态内部类";

        //创建静态成员属性
        private static String jing="静态内部类静态成员变量";
        //创建一个test方法调用外部类和内部类的属性
        public void test(){

            //调用外部类的属性值,需要对外部类进行实例化
            StaticOuter staticOuter = new StaticOuter();
            System.out.println(staticOuter.name);


            //调用静态内部类的属性值
            System.out.println(this.student);

            //调用静态内部类的静态成员属性
            //静态变量的调用通过类名进行调用
            System.out.println(inner.jing);
        }
    }
}

Application.java:

package com.oop;

import com.oop.Demo07.StaticOuter;
import com.oop.Demo07.outer;

//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
       /*调用静态内部类，由于静态内部类和外部类同等级所
         *  以不需要对外部类进行实例化
         */
        StaticOuter.inner inner = new StaticOuter.inner();
        inner.test();
    }
}

局部内部类

什么是局部内部类：局部内部类是存在于外部类方法中的类，局部内部类的层级与外部类中的方法内的属性的层级相等。
局部内部类的作用范围和创建对象范围仅限于当前方法。
局部内部类不能定义静态变量，如static String name；但是可以定义静态常量，如final static String name；
局部内部类访问当前方法的局部变量时，只会访问变量的常量jdk 1.7要求定义局部变量时使用final，jdk 1.8之后不定义会默认定义。

局部内部类的实例

局部内部类：
part .java:

package com.oop.Demo07;
//对于局部内部类的创建、调用
public class part {
    //创建外部类属性
    private String name="外部类的属性";

    //定义方法
    public void show(){
        //创建外部类局部变量
        String outer="外部类局部变量";

        //创建局部内部类，局部内部类的创建不能携带任何的访问修饰符，如private等
        class  inner{
            //创建局部内部类属性
            private String age="局部内部类属性";

            //创建局部内部类方法
            public void show1(){
                //调用外部类属性    直接调用
                System.out.println(part.this.name);
                //调用外部类局部变量  直接调用   这里只能访问外部内局部变量的常量相当于传递过来的值不是
                //outer="外部类局部变量";而是外部类局部变量
                System.out.println(outer);
                //调用局部内部类属性
                System.out.println(this.age);
            }
        }
        //想要调用局部内部类，对于局部内部类的对象的创建只能在方法中进行
        inner inner = new inner();
        inner.show1();

    }
}

注：想要调用局部内部类，对于局部内部类的对象的创建只能在方法中进行

Application.java:

import com.oop.Demo07.part;

//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
        part part = new part();
        part.show();
    }
}

匿名内部类

什么是匿名内部类：匿名内部类实际就是没有类名的局部内部类
匿名内部类必须继承一个父类或实现一个接口
匿名内部类实际是一个定义类，创建类，实现类的合并，只能创建一个该类的对象
匿名内部类能减少代码量，但是可读性较差。

匿名内部类的实例

*匿名内部类接口：

package com.oop.Demo07;
//匿名内部类的接口
public interface AnonymityFather {
    void work();
}

实现类：

package com.oop.Demo07;
//匿名内部类的实现类
public class anonymity implements AnonymityFather{
    //重写接口方法
    @Override
    public void work() {
        System.out.println("测试接口成功！");
    }
}

测试方法：

package com.oop.Demo07;

public class Test {
    public static void main(String[] args) {
        //对接口进行实例化
        AnonymityFather anonymityFather = new anonymity();
        anonymityFather.work();

        //使用局部内部类去对接口进行实现
        class anonymity1 implements AnonymityFather{
            @Override
            public void work() {
                System.out.println("内部类实现接口");
            }
        }
        //使用局部内部类创建对象
        AnonymityFather anonymityFather1 = new anonymity1();
        anonymityFather1.work();

        //创建匿名内部类对接口进行实现
        AnonymityFather anonymityFather2 = new AnonymityFather(){

            @Override
            public void work() {
                System.out.println("匿名内部类实现接口");
            }
        };
        anonymityFather2.work();
    }
}

object类

object类是所有类直接或者间接的父类，位于继承树的最顶端
object类在任何类没有写extend对某个类进行继承时，任何类都默认继承object类，否则就是间接继承
object类作为参数可以接受任何对象
object类作为返回值可以返回任何类型的值

getClass（）方法

getClass（）方法用于返回一个值的对应类型。可通过if函数判断两个对象的类型是否相等。

getClass（）方法使用示例

getClass类：

package com.oop.Demo08;

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

    public getClass() {
    }

    public getClass(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;
    }
}

测试类：
GetClassTest：

package com.oop.Demo08;

public class GetClassTest {
    public static void main(String[] args){
        getClass ge1= new getClass("和",23);
        getClass ge2= new getClass("睦",112);
        //使用getClass函数会返回值的类型
        Class ge1Class = ge1.getClass();
        Class ge2Class = ge2.getClass();
        if (ge1Class==ge2Class){
            System.out.println("ge1和ge2是同一个类型");
        }
        else {
            System.out.println("ge1和ge2不是同一个类型");
        }
    }
}

hashCode（）方法

hashCode（）方法会根据对象的地址，字符串或者数数字去计算相应的int类型的数值
hashCode会返回对象的哈希值，相同的对象返回的哈希值是相同的。
示例：

//hashCode()方法
        System.out.println(ge1.hashCode());
        System.out.println(ge2.hashCode());
        getClass ge3=ge1;
        System.out.println(ge3.hashCode());

输出结果：

toString（）方法

toString方法会返回一个对象的类型和十六进制的哈希值
若返回类型不满足要求可以对toString方法进行重写
重写要求：修饰符，返回值，方法名相同且返回值类型不能比原函数更严格。
代码示例1：
- 未被重写的toString函数使用：

//toString（）方法
        System.out.println("=========toString()方法=========");
        System.out.println(ge1.toString());
        System.out.println(ge2.toString());

运行结果：
代码示例2 ：
- 重写的toString函数使用：
  1. toString的重写：

public String toString(){
        return name+age;
    }

		2.重写后toString函数的应用：

//toString（）方法
        System.out.println("=========toString()方法=========");
        System.out.println(ge1.toString());
        System.out.println(ge2.toString());

运行结果：

equals（）方法

equals方法用于判断两个对象是否相等。
equals方法返回值的类型Boolean。
代码示例：

System.out.println("=========equals()方法=========");
        //equals方法：判断两个对象是否相等，返回值是boolean。
        System.out.println(ge1.equals(ge2));

运行结果：
对equals（）方法进行重写后的使用，单纯用于判断两个对象的值0是否相等，不判断两个对象是否完全相等。

对equals方法进行重写：


    //对equals方法重写，使得判断两个对象的值是否相等不判断是否完全相等。
    @Override
    public boolean equals(Object obj) {
        //1.判断对象object是否为空
        if (obj==null){
            return  false;
        }
        //2.判断this引用的对象和obj是否完全相等
        if (this==obj){
            return true;
        }
        //3.判断是否属于同一个类型
        if (obj instanceof getClass){
            //4.强制类型转换
            getClass g=(getClass) obj;
            //5.判断属性是否相同
            if (this.name.equals(g.getName())&&this.age==g.getAge()){
                return true;
            }
        }
        return false;
    }

对重写后的方法进行调用：

 System.out.println("=========重写equals()方法=========");
        //equals方法：判断两个对象是否相等，返回值是boolean。
        getClass a=new getClass("小明",12);
        getClass b=new getClass("小明",12);
        System.out.println(a.equals(b));

运行结果：

finalize（）方法

当对象被判定为垃圾对象时，JVM会自动执行finalize（）方法，标记垃圾对象，进入回收队列。
垃圾对象值没有明确指向的对象，如new getClass();
自动回收机制：JVM内存耗尽，一次性回收所有垃圾对象
手动回收机制：通过System.gc()，提醒JVM执行回收操作。
代码示例：
1. 垃圾对象：

package com.oop.Demo08;

public class FinalizeTest {
    public static void main(String[] args) {
        //finalize()方法会回收没有有效指向的对象
        //有效指向 对象名=new对象类型
        //getClass getClass = new getClass();
        
        System.out.println("====finalize方法的使用====");

        new getClass("111",12);
        new getClass("222",12);
        new getClass("333",12);
        new getClass("444",12);
        // 提示垃圾收集器执行回收操作
        System.gc();
    }
}

finalize（）方法的重写：

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

包装类

什么是包装类

包装类是基本数据类型对应的引用数据类型。
基本数据类型保存在栈中，引用数据类型保存在堆里。

基本类型转换，装箱和拆箱

装箱

什么是装箱：装箱就是将一个基本类型的数据转换为一个引用类型的数据，基本类型数据中数据直接存储在栈中。引用类型数据存储在堆中；栈中存放的只是一个指向。

拆箱

什么是拆箱：拆箱就是一个将引用类型的数据转换为基本类型的数据的过程。

代码实例

ReferenceType.java:

package com.oop.TypeCast;
//该类用于展现基本数据类型和引用数据类型之间的相互转换
public class ReferenceType {
    public static void main(String[] args) {
        //创建一个基本数据类型
        int num1=10;
        /**
         * 在jdk1.5之前没有自动装箱和自动拆箱的功能
         * 非自动装箱和拆箱需要用到对应的装箱和拆箱函数
         */
        System.out.println("======非自动装箱======");
        //基本数据类型装换：非自动装箱
        //1.使用Integer构造方法进行类型装换。
        Integer integer1 = new Integer(num1);
        //2.使用Integer.valueOf()方法进行类型转换
        Integer integer2=Integer.valueOf(num1);
        System.out.println("构造方法进行的数据类型转换");
        System.out.println(integer1);
        System.out.println("Integer.valueOf()方法进行类型转换");
        System.out.println(integer2);

        System.out.println("======非自动拆箱=====");
        //引用类型转换：非自动拆箱
        //使用  引用类型.intValue()方法进行拆箱
        Integer integer3 = new Integer(100);
        int num2=integer3.intValue();
        System.out.println("使用integer3.intValue()进行拆箱");
        System.out.println(num2);

        System.out.println("=====自动装箱和拆箱======");

        //自动装箱
        Integer integer4=num1;
        System.out.println("自动装箱"+integer4);

        //自动拆箱
        int num3=integer3;
        System.out.println("自动拆箱"+num3);

    }
}

基本数据类型和字符串数据类型的转换

基本数据类型转字符串数据类型

代码实例：

 //基本数据类型转字符串
        System.out.println("========基本数据类型转字符串=========");
        int num4=10;
        //1.使用+号转换
        String str1=num4+" ";
        //2.使用Integer中的ToString方法
        //ToString中的重写方法toString(num4，进制)，可以根据不同的进制进行转换
        String str2 = Integer.toString(num4);
        System.out.println(str1);
        System.out.println(str2);

字符串数据类型转基本数据类型

代码实例：

        //字符串转基本数据类型
        System.out.println("========字符串转基本数据类型=========");
        String str3="123";
        int num5=Integer.parseInt(str3);
        System.out.println(num5);

字符串数据类型转Boolean数据类型

代码实例：

        //字符串转Boolean数据类型
        System.out.println("========字符串转Boolean数据类型=========");
        //字符串转Boolean数据类型的过程中字符串我true时，返回值为true，其他的非“true“的值都返回false。
        String str4="true";
        Boolean bo1=Boolean.parseBoolean(str3);
        Boolean bo2=Boolean.parseBoolean(str4);
        System.out.println(bo1);
        System.out.println(bo2);

integer缓冲区：integer会在堆中创建一个-127到128的缓冲区，当引用数据类型在这个缓冲区内时，会直接将引用类型的地址指向缓冲区中创建好的地址块，若没有在引用类型没有在缓冲区内，则会根据引用类型的大小重新创建存储块。

String字符串类

字符串的空间存储

字符串是一个常量，创建后不可修改
字符串存储在字符串池中，可以共享

字符串的创建方法

String str1="hello";=>该创建方法是在JVM中在栈中创建一个str1，在常量池中的字符串池中创建一个空间用于存储：“hello”；str1在栈中存放的数据就是指向存放：“hello”的空间的地址。
图例解释：
String str2=new String("hello");=>该创建方法是在栈空间中创建一个空间用于存放指向堆空间中对应存储位置的地址，堆空间和字符串常量池中都会存在一个空间用于存放：“hello”。
图例演示：

字符串创建后的不可修改性

字符串在创建后对字符串进行修改不会在原本存储字符串的字符串常量池的原存储位置对数据进行修改，而是在字符串常量池中额外的开辟一片空间去存放修改的数据，同时修改栈中对应的地址使得指向新的数据。
示例代码：

String str1=“hello”;
str1="word";

图例解释：

字符串创建后的可共享性

在字符串创建后，创建的字符串会存储在字符串常量池中，正在创建其他的字符串时会优先遍历字符串常量池，假如创建的字符串在常量池中存在，则不新开辟空间去存储新创建的字符串，直接在栈中将地址指向该存储位置，实现共享。
代码示例：

String str1="hello";
String str2="hello";

图例解释：

字符串的常见方法的使用

计算字符串长度：字符串.length
*

String s="hello";
System.out.println(s.length());//返回字符串长度

返回字符串某个位置的字符：字符串.charAt（int index）=>int index就是想要返回的字符的位置，从0开始。
*

String s="hello";
System.out.println(s.charAt(0));//返回字符串中第一个字符
System.out.println(s.charAt(s.length()-1);//返回字符串中最后一个字符

判断字符串中是否存在某个子字符串：s.contains(String str)=>String str是指所要查询的是否存在的字符串
*

String s="hello";
System.out.println(s.contains("he"));//存在就返回true，不存在就返回false

将字符串转换为数组：s.toCharArray()
*

String s="hello";
System.out.println(s.toCharArray());//字符串转换为数组
//字符串转化为数组后，将数组用字符串的形式输出
System.out.println(Arrays.toString(s.toCharArray()));

返回字符串第一次出现的位置：indexOf（）
indexOf(“查询的字符串”，查询开始的位置)查询开始的位置不写默认0
*

String s="java hello，java"
System.out.println(s.indexOf("java",5));

返回字符串最后一次出现的位置：lastIndexOf（）
*

String s="java hello，java"
System.out.println(s.lastIndexOf("java"));

去掉字符串前后的空格,trim只能去除字符串两端的不能去除存在于字符串里的：trim（）

String s=" java hello，java "
System.out.println(s.trim());

将小写改成大写：toUpperCase（），将大写转为小写：toLowerCase（）
*

        //将小写改成大写
        String s2;
        s2=s.toUpperCase(Locale.ROOT);
        System.out.println(s2);
        //将大写改成小写
        String s3;
        s3=s2.toLowerCase(Locale.ROOT);
        System.out.println(s3);

判断字符串是否以某个字符结尾： endsWith（str），判断字符串是否以某个字符串开始：startsWith（str）
*

		//判断字符串是否以某个字符结尾
        System.out.println(s.endsWith(" "));
        //判断字符串是否以某个字符串开始
        System.out.println(s.startsWith(" "));

对字符串中的字符使用新的字符对其进行替换：replace（“需要替换的字符”，“用于替换的字符”）
*

//对字符串中的字符使用新的字符对其进行替换
		String s=" java是最好的 java ，java真香 ";
        System.out.println(s.replace("java","php"));

通过split（）使用某个字符对字符串进行拆分
1. 单纯的只通过空格对字符串进行拆分，拆分后使用数组保存并且循环输出

		String s4="你 好 世 界，我 来 了";
        String [] str=s4.split(" ");
        for (String string:str) {
            System.out.println(string);
        }

2. 使用空格或逗号对数组进行拆分：

中括号[]中表示使用“ ”或“，”对字符串进行拆分

		String s4="你 好 世 界，我 来 了";
		 String [] str1=s4.split("[ ，]");//中括号中表示使用“ ”或“，”对字符串进行拆分
        for (String string:str1) {
            System.out.println(string);
        }

3. 存在多个空格或者其他符号时，对字符串进行分隔

String s5="你 好 世     界，，，，，我 来 了";
        String [] str2=s5.split("[ ，]+");//[]+表示使用多个“ ”或“，”对字符串进行拆分
        for (String string:str2) {
            System.out.println(string);
        }

对字符串进行比较不区分大小写：equalsIgnoreCase（）

        String s6="hello";
        String s7="HELLO";
        System.out.println(s6.equalsIgnoreCase(s7));

比较字符串的大小：compareTo（）

//   1. 当字符串长度一致时，从第一个字符开始比较，比且只比较第一个不想提字符的大小
        String s8="abc";
        String s9="xcs";
        System.out.println(s8.compareTo(s9));//返回值是ascll表中的值相减=> s8-s9
        //   2. 当字符串长度不一致时，直接比较字符串长度，返回值是长度只差
        String s10="afcs";
        System.out.println(s8.compareTo(s10));
        //   3. 当字符串一样时，返回值=0
        System.out.println(s8.compareTo(s8));

String的常用方法的小案例：

package com.oop.MethodsString;

/**
 * 字符串常见使用方法的案例
 * 需求：
 *      已知 String str="this is a text";
 *      1.将str中的单词单独的提取出来
 *      2.将str中的text替换成practice
 *      3.在text前插入一个easy
 *      4.将每个单词的首字母改成大写
 */
public class CaseShow {
    public static void main(String[] args) {
        String str="this is a text";
        //1.将str中的单词单独的提取出来
        String[] s=str.split(" ");
        for (String string:s) {
            System.out.println(string);
        }

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

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

        System.out.println("========将每个单词的首字母改成大写========");
        //将每个单词的首字母改成大写
        //1.对通过String[] s=str.split(" ");将每个单词提取出来后的数组s进行循环
        for (int i=0;i<s.length;i++) {
            //创建一个字符串常量去存储每个单词的第一个字符
            char first=s[i].charAt(0);
            //输出每个单词的第一个字母
            // System.out.println(first);
            //将每个单词的第一个字母转为大写
            char firstUP = Character.toUpperCase(first);
//            System.out.println(firstUP);
            //将首字母和后面的字母拼接成原来的单词
            //substring(n)从字符串的第n位开始截取字符串
            String str2=firstUP+s[i].substring(1);
            System.out.println(str2);
        }
    }
}

字符串中的可变字符串：StringBuffer和StringBuilder。

StringBuffer：可变长字符串，运行效率：StringBuilder > StringBuffer > string 。线程安全
StringBuilder：可变长字符串，线程不安全
StringBuffer和StringBuilder功能一样但是StringBuffer更加安全
StringBuffer的基本四种方法的使用：拼接：append；指定位置添加：insert；替换指定的字符串：replace；删除指定字段：delete；
代码实例：

package com.oop.MethodsString;
//StringBuffer和StringBuilder的使用方法一样所以在这只讲述StringBuffer的用法
public class StringBufferUser {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.使用append进行拼接
        sb.append("我是第一段");
        System.out.println(sb.toString());
        sb.append("我是第二段");
        System.out.println(sb.toString());
        //使用insert对指定位置进行添加字符串
        sb.insert(0,"我从0位置添加");
        System.out.println(sb.toString());
        //使用replace替换指定位置范围内的字符串
        sb.replace(0,7,"我被换掉了");
        System.out.println(sb.toString());
        //使用delete删除指定的字符串
        sb.delete(0,7);
        System.out.println(sb.toString());
    }
}

运行结果

BigDecimal类

BigDecimal用于浮点型数据的精确计算，double和float两个都是使用近似值对数据进行存储，而BigDecimal可以使用字符串的形式0对数据进行存储，对数据的计算更加精确。
BigDecimal的加减乘除：

package com.oop.MethodsString;
//浮点数的精准计算
import java.math.*;
public class BigDecimal1 {
    public static void main(String[] args) {
        //double和float都是存储的近似值，在计算时可能会导致出错
        double n=1.0,m=0.9;
        System.out.println(n-m);//结果: 0.09999999999999998
        //在要求精准计算的时候可以使用BigDecimal，存储字符串的方式来计算保证结果的准确性
        //BigDecimal是一个工具类使用时需要实例化对象。同时因为是对象所以不能使用简单的加减乘除运算符
        System.out.println("=========BigDecimal=============");
        //加法
        System.out.println("减法");
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal sub = bd1.subtract(bd2);
        System.out.println(sub);

        System.out.println("加法");
        BigDecimal add = new BigDecimal("1.0").add(new BigDecimal("0.9"));
        System.out.println(add);

        System.out.println("乘法");
        BigDecimal multiply = new BigDecimal("1.0").multiply(new BigDecimal("0.9"));
        System.out.println(multiply);

        System.out.println("除法");
        BigDecimal divide = new BigDecimal("1.0").divide(new BigDecimal("0.5"));
        System.out.println(divide);
    }
}

运行结果：

Date类（大多方法已不被使用）

Date类用于返回某一时刻的毫秒值。
代码解释：

package com.oop.MethodsString;

import java.util.Date;

//Date类中的简单方法的使用
public class DateTest {
    public static void main(String[] args) {
        //初始化对象，获取当前时间
        Date date1 = new Date();
        //获取前一天的时间
        Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(date1);
        System.out.println(date2.toLocaleString());
        //after 和before方法用于判断某个时间点在另外一个时间点的前或者后
        System.out.println("after 和before方法用于判断某个时间点在另外一个时间点的前或者后");
        boolean after = date1.after(date2);
        System.out.println(after);
        boolean before = date1.before(date2);
        System.out.println(before);
        //比较两个时间值的大小，小于返回-1，等于返回0，大于返回1
        System.out.println("比较两个时间值的大小，小于返回-1，等于返回0，大于返回1");
        int i = date1.compareTo(date2);
        System.out.println(i);
        //equals比较两个时间点的值是否相等
        System.out.println("equals比较两个时间点的值是否相等");
        boolean equals = date1.equals(date1);
        System.out.println(equals);
    }
}

Calendar类

Calendar提供了获取和设置各种日历字段的方法
直接上代码：

package com.oop.MethodsString;

import java.util.Calendar;

//Calendar类的简单使用
public class CalendarTest {
    public static void main(String[] args) {
        //创建一个Calendar类的对象，因为Calendar是受保护的，所以不能直接使用new进行创建对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getTime().toLocaleString());
        //获取时间信息
        //获取年
        int year= instance.get(Calendar.YEAR);
        //月
        int month = instance.get(Calendar.MONTH);
        //日
        int day = instance.get(Calendar.DAY_OF_MONTH);
        //小时
        int hour = instance.get(Calendar.HOUR);
        //分钟
        int minute = instance.get(Calendar.MINUTE);
        //秒
        int second = instance.get(Calendar.SECOND);
        //输出当前日期
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+" "+hour+":"+minute+":"+second);
        System.out.println("=====修改时间=======");
        //重新获取一个时间
        Calendar instance1 = Calendar.getInstance();
        //用过set修改时间set(修改的时间单元,修改的数据);
        instance1.set(Calendar.DATE,7);
        System.out.println(instance1.getTime().toLocaleString());
        //add方法修改时间:在对应的时间单元上进行数值的加减
        instance1.add(Calendar.HOUR,1);
        System.out.println(instance1.getTime().toLocaleString());
        System.out.println("==========补充方法==============");
        //计算某个时间单元的最大最小值
        int max = instance1.getActualMaximum(Calendar.MONTH);
        int min = instance1.getActualMinimum(Calendar.MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

在这里插入图片描述
*

package com.oop.MethodsString;

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

//SimpleDateFormat将date转化为字符串或者将字符串转为date
public class SimpleDateFormatTest {
    public static void main(String[] args) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //创建Date
        Date date = new Date();
        //date转为字符串
        System.out.println("date转为字符串");
        String date1 = sdf.format(date);
        System.out.println(date1);
        System.out.println("字符串转为date");
        Date parse = sdf.parse("1234/12/23");
        System.out.println(parse);


    }
}

System类

代码来了：

package com.oop.MethodsString;
//System 的使用
public class SystemTest {
    public static void main(String[] args) {
        //数组的复制
        int[] str1={1,21,13,3,301,31,322,3};
        int[] str2=new int[8];
        //System.arraycopy(原数组,复制起始位置,目标数组,复制开始的位置,复制数组的长度);
        System.arraycopy(str1,0,str2,0,str1.length);
        for (int i=0;i<str2.length;i++){
            System.out.println(str2[i]);
        }

        //获取当前程序的时间：毫秒
        System.out.println(System.currentTimeMillis());
        //关闭jvm
        System.exit(0);//正常关闭
        System.out.println("nihao");
    }
}