概述

记录点JavaSE的小知识。

Object类

Object类是所有类的父类, 所有的类都直接或者间接继承自Object类。

构造方法

public Object();

所有自定义类的第一行默认都是super();这种无参构造方法，而不是有参构造方法，就是因为所有自定义类都继承自Object类，Object类默认就是无参构造方法（且它只有无参构造方法）。

成员方法

toString()方法

返回对象的字符串表示形式(即: 地址值)，无意义，一般子类需要重写该方法才能获取到子类的实例对象中所有的数据。

public class Student {
    private String name ;
    private int 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;
    }

    public Student() {
    }

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

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

public class Run {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println("student1.toString() = " + student1.toString());
        //不重写ToString方法时会输出student1.toString() = com.ac.ToStringDemo.Student@1b6d3586
        //∵Java中类为引用数据类型，对象存储在堆内存中，ToString方法默认只能输出堆内存地址
        //重写toString方法后输出student1.toString() = Student{name='null', age=0}
    }
}

运行后：

student1.toString() = Student{name='null', age=0}

Process finished with exit code 0

以此为例说明。

重写toString方法时会有提示，可以自动生成。

equals(Object obj)方法

比较两个对象是否相等，默认比较的是地址值，无意义，子类一般都会重写该方法。

import java.util.Objects;

public class A {
    private String string = "aa";

    public A() {
    }

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

    public A(String string) {
        this.string = string;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;//如果指向同一个堆内存地址则true
        if (o == null || getClass() != o.getClass()) return false;//如果传入空对象或本类与传入的类不是同类则false
        A a = (A) o;
        return string.equals(a.string);//如果是同一个类就判断对象的内容（字符串）是否相等
    }
    @Override
    public int hashCode() {
        return Objects.hash(string);
    }
}

public class Run {
    public static void main(String[] args) {
        A a = new A("gg");
        A aa = new A("gg");
        A b = new A("mm");

        System.out.println("a.hashCode() = " + a.hashCode());
        System.out.println("aa.hashCode() = " + aa.hashCode());
        System.out.println("b.hashCode() = " + b.hashCode());
    }
}

运行后：

a.hashCode() = 3327
aa.hashCode() = 3327
b.hashCode() = 3519

Process finished with exit code 0

重写equals时有提示。

都选上。

import java.util.Objects;

public class Student {
    private String name;
    private int 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;
    }

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

    public Student() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

equals和hashCode方法会都自动写好。idea还是很强大的。

//如果要比较对象中的内容是否一样 要重写 equals 方法 代码会自动生成
//一般重写 equals 方法的时候 最好是连hashCode方法也重写了 提高对比的效率
public class Run {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 19);
        Student student2 = new Student("李四", 20);
        boolean bl = student1.equals(student2);
        System.out.println("bl = " + bl);
    }
}

运行后：

bl = false

Process finished with exit code 0

本例中笔者重写hashCode与equals方法，从而判断是否为同一个对象。开发中堆内存指向不同但数据及方法完全相同的应该视为同一个对象。

哈希值不一样 两个对象中的内容肯定不一样。由于hashCode的计算较equals的比较非常快，用于判断对象是否相同时使用hashCode提速明显。

hashCode方法能比较不同，但是hashCode不能比较相同(如果哈希值是一样的 有可能内容不一样 也有可能内容是一样的)。用hashCode能够判断不同，但是 hashCode返回值一旦一样，就没法判断内容是否一致，此时再调用equals方法比较内容。

Arrays排序

Arrays类概述

该类是针对数组进行操作的工具类。提供了把数组转成字符串，对数组排序等功能（默认为升序排列）。

Arrays成员方法

public static String toString(int[] arr)，用于把int类型的数组转成其对应的字符串形式。

public static void sort(int[] arr)，用于对给定的int数组, 按照元素升序的顺序进行排序。

//使用Arrays的sort方法对数组的数据排序
import java.util.Arrays;

public class Run {
    public static void main(String[] args) {
        int[] array1 = {25, 69, 80, 57, 13};
        String string1 = Arrays.toString(array1);
        System.out.println("array1 = " + array1);
        System.out.println("string1 = " + string1);

        Arrays.sort(array1);//使用该方法排序，默认只能从小到达排序
        System.out.println("array1 = " + array1);
        System.out.println("Arrays.toString(array1) = " + Arrays.toString(array1));
    }
}

运行后：

array1 = [I@1b6d3586
string1 = [25, 69, 80, 57, 13]
array1 = [I@1b6d3586
Arrays.toString(array1) = [13, 25, 57, 69, 80]

Process finished with exit code 0

冒泡排序

再看看Java中的冒泡排序怎么写。

import java.util.Arrays;

//从小到大冒泡排序
public class Run {
    public static void main(String[] args) {
        int[] array = {25, 69, 80, 57, 13};
        System.out.println("array = " + array);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1; j++) {//-1的目的是防止数组越界
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

        //可以优化一下
        for (int i = 0; i < array.length-1; i++) {
            //∵排好后排数据后，只留下最后一个数据，一定是最小数据
            //外循环用作循环轮数的限制
            for (int j = 0; j < array.length - 1-i; j++) {
                //-1的目的是防止数组越界
                //-i的目的是尾部数据已排好，无需重排
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

        System.out.println("array = " + array);
        //依旧是array = [I@1b6d3586，表明数组是引用数据类型，指向的堆内存中的数据发生了改变，但指向的地址不变
        System.out.println("Arrays.toString(array) = " + Arrays.toString(array));

    }
}

运行后：

array = [I@1b6d3586
array = [I@1b6d3586
Arrays.toString(array) = [13, 25, 57, 69, 80]

Process finished with exit code 0

包装类

为了对基本类型进行更多更方便的操作，Java针对每一种基本类型提供了一个对应的引用类型，这就是包装类。

包装类最常见的用法就是用于该类型对应的基本类型和字符串之间进行相互转换。
例如：
1.Byte用于byte和String之间的相互转换。
2.Integer用于int和String之间的相互转换。
3.Double用于double和String之间的相互转换。

把基本类型的数据封装成其对应的包装类型, 则称之为自动装箱。
Integer ii = 100; //自动装箱.
把包装类型的对象拆解成其对应的基本类型, 则称之为自动拆箱。
Integer ii = 100;
i1 += 200; //自动装箱.
自动拆装箱都是JDK5的新特性。

包装类测试

笔者测试最常用的Integer。

public class Run {
    public static void main(String[] args) {
        System.out.println("Integer.MAX_VALUE = " + Integer.MAX_VALUE);
        System.out.println("Integer.MIN_VALUE = " + Integer.MIN_VALUE);
        System.out.println("--**************--");
        Integer a =10;
        Integer b=21;
        int c = a+b;
        System.out.println("a+b = " + (a + b));
        System.out.println("c = " + c);
        System.out.println("--**************--");
        Integer d = new Integer("998");
        Integer e = new Integer(999);
        System.out.println("d = " + d);
        System.out.println("e = " + e);
        System.out.println("--**************--");

        //String转int方法1
        String string1 = a + "5";
        System.out.println("string1 = " + string1);
        Integer integer1 = new Integer(string1);
        //数据类型不对时会产生异常
        //Exception in thread "main" java.lang.NumberFormatException: For input string: "105t"
        //	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
        //	at java.lang.Integer.parseInt(Integer.java:580)
        //	at java.lang.Integer.<init>(Integer.java:867)
        //	at com.ac.IntegerDemo6.Run.main(Run.java:21)

        int m = integer1.intValue();
        System.out.println("integer1.intValue() = " + integer1.intValue());
        System.out.println("String.valueOf(string1) = " + String.valueOf(string1));

        //String转int方法2
        String string2 = a + "8";
        System.out.println("string2 = " + string2);
        int n = Integer.parseInt(string2);
        System.out.println("Integer.parseInt(string2) = " + Integer.parseInt(string2));
    }
}

执行后：

Integer.MAX_VALUE = 2147483647
Integer.MIN_VALUE = -2147483648
--**************--
a+b = 31
c = 31
--**************--
d = 998
e = 999
--**************--
string1 = 105
integer1.intValue() = 105
String.valueOf(string1) = 105
string2 = 108
Integer.parseInt(string2) = 108

Process finished with exit code 0

可以看出，方法2中直接使用Integer.parseInt(字符串对象);要比方法1手动先调用构造方法创建包装类实例对象，再转换为数字简单很多。

方法1这种手动装箱与拆箱的方式比较麻烦。

Date类

Date类用于创建可以记录某个时间点的实例对象。

C#中也有类似的功能函数，label1.text = DateTime.Now.ToString();事实上，笔者之前做C#桌面上位机开发，作为面向度娘及面向CSDN编程的低水平程序猿，笔者印象中只用得到为数不多的功能函数，用的上的时候查阅完全来得及，也就没有刻意去记。。。

话不多说，上代码：

import java.util.Date;

public class Run {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println("date1 = " + date1);//无参构造获取当前时间

        long longint1 = System.currentTimeMillis();//获取当前时间距1970年元旦的ms值
        System.out.println("longint1 = " + longint1);
        Date date2 = new Date(longint1);
        System.out.println("date2 = " + date2);//有参方式获取当前时间

        Date date3 = new Date();
        date3.setTime(System.currentTimeMillis() - 10*60*60*1000);//设置时间偏差为10h前
        System.out.println("date3.getTime() = " + date3.getTime());//获取当前时间距1970年元旦的ms值

        System.out.println("date3.toLocaleString() = " + date3.toLocaleString());
        //格式化字符串为xxxx-xx-xx xx:xx:xx的格式，已过时但还能用
    }
}

运行后：

date1 = Thu Apr 01 18:51:04 CST 2021
longint1 = 1617274265011
date2 = Thu Apr 01 18:51:05 CST 2021
date3.getTime() = 1617238265011
date3.toLocaleString() = 2021-4-1 8:51:05

Process finished with exit code 0

所以。。。用的上的时候再查好像也来得及。。。CSDN和度娘都是好东西。。。

SimpleDateFormat类

主要也就是2个功能。。。

Date对象格式化为String对象

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

public class Run {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println("date1 = " + date1);//查看当前时间date1 = Wed Mar 31 20:23:15 CST 2021

        SimpleDateFormat simpledateformat1 = new SimpleDateFormat();

        String format = simpledateformat1.format(date1);
        System.out.println("format = " + format);//转化为format = 21-3-31 下午8:23 格式的字符串


        SimpleDateFormat simpledateformat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //y:年 M:月 d:天 H:小时 m:分钟 s:秒
        String format1 = simpledateformat2.format(date1);
        System.out.println("format1 = " + format1);//转化为format1 = 2021-03-31 20:26:31 格式的字符串

    }
}

执行后：

date1 = Thu Apr 01 18:59:11 CST 2021
format = 21-4-1 下午6:59
format1 = 2021-04-01 18:59:11

Process finished with exit code 0

String对象格式化为Date对象

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

public class Run {
    public static void main(String[] args) throws ParseException {
        //创建传入数据
        String time1 = "2021-03-11 11:11:11";
        String time2 = "2001-03-11";
        //设置传入数据的格式
        SimpleDateFormat simpledateformat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat simpledateformat2 = new SimpleDateFormat("yyyy-MM-dd");

        //使用转化方法产生新对象
        Date date1 = simpledateformat1.parse(time1);
        Date date2 = simpledateformat2.parse(time2);

        System.out.println("date1 = " + date1);
        System.out.println("date2 = " + date2);

    }
}

执行后：

date1 = Thu Mar 11 11:11:11 CST 2021
date2 = Sun Mar 11 00:00:00 CST 2001

Process finished with exit code 0

注意：这种方式可能由于实际传入的字符串对象同自定义SimpleDateFormat类的实例对象时设置的格式不同导致转换失败，故笔者先抛出异常。。。使用try catch当然更好。。。

工具类

本文上方有提及过，Arrays是工具类。。。

工具类有2个要求：
1.构造方法需要private修饰（防止用户实例化对象或继承及改写）
2.成员方法都用static修饰（直接被加载到方法区，不创建对象即可使用）

自定义工具类

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

public class DateUtils {
    //私有化构造方法，防止用户创建实例对象
    private DateUtils(){
    }

    //方法使用static修饰
    //将日期按某格式转化为字符串
    public static String Date2String(Date date, String pattern){
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.format(date);
    }

    //将字符串时间按某格式转为日期格式
    public static Date String2Date(String time,String pattern) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.parse(time);

    }
}

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

public class Run {
    public static void main(String[] args) throws ParseException {
        Date date1 = new Date();
        System.out.println("date1 = " + date1);
        String time1 = DateUtils.Date2String(date1,"yyyy/MM/dd");
        System.out.println("time1 = " + time1);

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

        String time2 = "2021/11/11 11:11:11";
        Date date2 = DateUtils.String2Date(time2,"yyyy/MM/dd HH:mm:ss");
        System.out.println("date2 = " + date2);
    }
}

运行后：

date1 = Thu Apr 01 19:10:00 CST 2021
time1 = 2021/04/01
--**********--
date2 = Thu Nov 11 11:11:11 CST 2021

Process finished with exit code 0

日后就可以把常用的方法收集起来，封装为自定义类，方便使用。。。C语言中称之为库函数studio.h，C#与C++中称之为dll。核心思想都差不多。。。都是封装与调用的老套路。。。

Calendar类

Date类中有很多过时方法（过时了也能用），Calendar类中有类似功能的方法。

import java.util.Calendar;
import java.util.Scanner;

public class Run {
    public static void main(String[] args) {
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(2021,11,12);
        calendar1.add(Calendar.YEAR,-1);
        int year = calendar1.get(Calendar.YEAR);
        System.out.println("year = " + year);
        int month = calendar1.get(Calendar.MONTH);
        System.out.println("month = " + month);
        int dayOfMonth = calendar1.get(Calendar.DAY_OF_MONTH);
        System.out.println("dayOfMonth = " + dayOfMonth);
        int dayOfWeek = calendar1.get(Calendar.DAY_OF_WEEK);
        System.out.println("dayOfWeek = " + dayOfWeek);

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

		//以下为判断每年的2月份有几天
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i <3 ; i++) {
            System.out.println("请您输入某一年!");
            int year1 = sc.nextInt();
            Calendar calendar = Calendar.getInstance();
            calendar.set(year1,2,1);//设置为某年的3月1日
            calendar.add(Calendar.DAY_OF_MONTH,-1);
            //前一天即为2月最后一天
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            //这一天即为本月份有几天
            System.out.println(day);
        }

    }
}

运行后：

year = 2020
month = 11
dayOfMonth = 12
dayOfWeek = 7
--***********************--
请您输入某一年!
2019
28
请您输入某一年!
2020
29
请您输入某一年!
2021
28

Process finished with exit code 0

。。。歪果仁的的思维方式比较奇特。。。
按照0为1月（11为12月），1为周日（7为周六）计算。。。
在Calendar的方法中，
calendar1.set(2021,11,12); calendar1.add(Calendar.YEAR,-1);执行后设定的日期其实为2020.12.12。。。

。。。是不是很神奇！！！！！！

最后

以上就是温婉鞋子为你收集整理的Java SE基础（十四）常用API概述Object类Arrays排序包装类Date类SimpleDateFormat类工具类Calendar类的全部内容，希望文章能够帮你解决Java SE基础（十四）常用API概述Object类Arrays排序包装类Date类SimpleDateFormat类工具类Calendar类所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。