java-常用类

java为了帮助我们编程，在java编译器中包含了很多常用类便于我们使用

在下面我们将会讲解：Math，System，Object和Arrays类：

类查看方法

我们在实际生活中用到的类的种类和方法都是冰山一角，但我们也会遇到一些奇怪的要求

所以我们应该了解的不仅只有我们常用的方法

首先我们先学会怎么查看常用类的方法

网上查询
idea编译器上，CTRL+左键点击所查看类，即可进入该类的源代码

Math类

math类包含执行基本数字运算

math不用创造对象，直接使用即可

math类常用方法：

方法名	说明
public static int abs（int a）	返回参数绝对值
public static double ceil(double a)	返回大于等于参数的最小double值，整数
public static double floor(double a)	返回小于等于参数的最小double值，整数
public static int round(float a)	按照四舍五入原则返回最接近参数的int值
public static int max(int a,int b)	返回两个int值中的较大值
public static int min(int a,int b)	返回两个int值中的较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值【0.0，1.0）

拓展：

public static double random()：

可以采用（int）（Math.random()*n）来获取【0，n）之间的随机整数值

System类

System类包含几个有用的类字段和方法

System不能被实例化

System类常用方法：

方法名	说明
public static void exit(int status)	终止当前运行的java虚拟机，非0表示异常终止
public static long currentTimeMillis()	返回当前的时间（以ms为单位）

拓展：

public static void exit(int status)：

status一般为0，表示正常终止->System.exit(0)；

public static long currentTimeMillis()：

表示从当前时间到1970年1月1日的时间差，以毫秒为单位

可以采用System.currentTimeMillis()*1.0/1000/60/60/24/365得到当前时间与1970年差

可以采用时间差来表示程序运行时间差

public class Demo1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

Object类

Object类是类层次结构的根，每个类都可以将Object类作为超根，直接或间接继承该类

构造方法：public Object（）

Object类常用方法：

方法名	说明
object.toString	返回带表示形式的object（需重写）
object.equal(Object object1)	比较两者地址是否相同（若比较数据需重写）

拓展：

object.toString：

这里的toString返回的是由编译器编写的表示形式，我们如果希望得到object的表达形式需要重写

可采用Alt+insert方法快速重写

这里是未重写的：

public class Demo1 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.changeName("HOU");
        demo2.changeAge(18);
        //调用demo2就是调用demo2.toString
        System.out.println(demo2);
        System.out.println(demo2.toString());
    }
}

//这里当作一个类
public class Demo2 {

    String name;
    int age;

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

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

编译结果：

tostring.Demo2@1b6d3586
tostring.Demo2@1b6d3586

这里给出编译器自动编写的字符串表示形式

这里是重写的：

public class Demo1 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.changeName("HOU");
        demo2.changeAge(18);
        //调用demo2就是调用demo2.toString
        System.out.println(demo2);
        System.out.println(demo2.toString());
    }
}

public class Demo2 {

        String name;
        int age;

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

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

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

编译结果：

Demo2{name='HOU', age=18}

这里可以清楚得到该对象的信息

object.equal(Object object1)：

这里的toString返回的两个对象的地址比较，我们如果希望得到两个对象的内容比较需要重写

可采用Alt+insert方法快速重写

这里是未重写的：

public class Demo1 {

        String name;
        int age;

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

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

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

        //设置两个完全相同的对象，来判断他们内容是否相同
        Demo1 demo1 = new Demo1();
        Demo1 demo11 = new Demo1();

        demo1.changeName("HOU");
        demo1.changeAge(18);

        demo11.changeName("HOU");
        demo11.changeAge(18);

        //采用equal判断：(这里不成功的原因是因为：Object中的equal针对地址进行判断)
        System.out.println(demo1.equals(demo11));
    }
}

编译结果：

false

我们可以看到根据地址来判断，必然是false

这里是重写的：

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

        //设置两个完全相同的对象，来判断他们内容是否相同
        Demo1 demo1 = new Demo1();
        Demo1 demo11 = new Demo1();

        demo1.changeName("HOU");
        demo1.changeAge(18);

        demo11.changeName("HOU");
        demo11.changeAge(18);

        //采用equal判断：(这里不成功的原因是因为：Object中的equal针对地址进行判断)
        //我们需要更改Demo1类中的equal，重写使其满足内容相等判断
        //在更改判断后，出现true
        System.out.println(demo1.equals(demo11));
    }
}

public class Demo1 {

        String name;
        int age;

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

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

    @Override
    public boolean equals(Object o) {
            //首先判断被比较对象是否是同一个对象
            if (this == o) return true;
            //这里判断被比较对象是否为null，且判断是否属于同一个类
            if (o == null || getClass() != o.getClass()) return false;

            Demo1 demo1 = (Demo1) o;

            //这里判断是否age相同
            if (age != demo1.age) return false;
            //这里判断是否name相同
            return name != null ? name.equals(demo1.name) : demo1.name == null;
        }
}

编译结果：

true

因为根据内容判断，两者相同，故为true

Arrays

Arrays类包含于操作数组的各种方法

Arrays也不需要创建对象

方法名	说明
public static String toString（int[] a）	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

案例展示：

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        int[] arrays = {23,34,14,56};

        System.out.println("排序前：" + Arrays.toString(arrays));
        Arrays.sort(arrays);
        System.out.println("排序后：" + Arrays.toString(arrays));
    }


}

编译结果：

排序前：[23, 34, 14, 56]
排序后：[14, 23, 34, 56]

基本类型包装类

java中包含许多类型，包括int，float，double等

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据：

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

这里仅对Integer做出概述讲解：

Integer：包装一个对象中原始类型int的值

创建方法：

public Integer(int value);
public Integer(String value);

实例：

//jdk8格式
Integer i1 = new Integer(123);
Integer i2 = new Integer("123");

下面介绍一下基本类型包装类最常用的使用方法：
int和String类型的相互转换：

int->String:

int number = 100;
String s1 = " " + number;

int number =100;
String s2 = String.valueOf(number);

String->int:

String s = "100";
Integer i = Integer.valueOf(s);
int x = i.intValue();

String s = "100";
int y = Integer.parseInt(s);//注意这里可能会出错，所以该方法需要抛出错误

案例：字符串数据排序

要求字符串“91 27 46 38 50”以字符串“27 38 46 50 91”的顺序输出：

public class Demo2 {

    public static void main(String[] args) {
        //创建字符串
        String s = "91 27 46 38 50";
        //字符串分离(以空格区分)
        String[] arr = s.split(" ");
        //字符串分别带入数组
        int[] arrays = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arrays[i] = Integer.parseInt(arr[i]);
        }
        //对字符串排序
        Arrays.sort(arrays);
        //导出给新字符串(这里采用StringBuilder方便使用append累加后续数组)
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arrays.length; i++) {
            if(i == arrays.length - 1){
                sb.append(arrays[i]);
            }else {
                sb.append(arrays[i]).append(" ");
            }
        }
        System.out.println(sb);
    }
}

最后介绍一下自动装箱和自动拆箱：

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

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

        //装箱：
        Integer i = new Integer(100);
        //自动装箱：
        Integer ii = 100;
        //拆箱：
        ii = ii.intValue() + 200;
        //自动拆箱：
        ii = ii + 200;

        //这里注意，当Integer为null时，不能操作：
        Integer iii = null;
        if(iii != null){
            iii += 200;
        }
    }
}

Date类

Date代表了一个特定时间，准确到毫秒

（与System.currentTimeMills()有些相似）

创建方法：

//分配一个Date对象并初始化，以便它代表被分配的时间，精确到毫秒
Public Date()
//分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
public Date(long date)

常用方法：

方法名	说明
public long getTime()	获取的是日期对象从1970.1.1 0:0:0 到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

拓展：

public long getTime()：

这里同理和System.currentTimeMills()采用System.out.println(d1.getTime()*1.0/1000/60/60/24/365);来获取年份

SimpleDateFormat类

SimpleDateFormat类是具体的类，用于以区域设置敏感的方式格式化和解析日期

日期和时间格式由时间模式字符串指定，在日期和时间模式字符串中，从‘A’到“Z”以及“a”到“z”引号的字母被解释为表示日期或时间字符串的组件的模式字母

常用的模式字母以及对应关系如下：

字母	日期
y	年
M	月
d	日
H	时
m	分
s	秒

SimpleDateFormat构造方式：

//默认构造方式
SimpleDateFormat sdf1 = new SimpleDateFormat();
//自定义构造方式
String pattern = "yyyy年MM月dd日 HH:mm:ss"；
SimpleDateFormat sdf2 = new SimpleDateFormat(pattern);

然后我们讲解一下格式化和解析：

格式化（从Date到String）：

String s1 = sdf1.format(date);

解析(从String到Date):

Date dd = sdf3.parse(ss);

下面我们给出一个格式化和解析实例：

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

public class Demo3 {
    public static void main(String[] args) throws ParseException {

        Date date = new Date();
        //格式化：（将日期格式化成日期字符串）
        //普通构造：
        //构造方法构造出SDF类型
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        //SDF对象方法，使sdf根据date转化为String
        String s1 = sdf1.format(date);
        System.out.println(s1);
        //特殊构造：
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s2 = sdf2.format(date);
        System.out.println(s2);

        //解析：（将日期字符串化成日期）
        String ss = "2022-10-15 15:42:12";
        SimpleDateFormat sdf3 =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf3.parse(ss);
        System.out.println(dd);
    }
}

解析结果：

22-6-10 下午5:08//普通构造格式化
2022年06月10日 17:08:07//自定义构造格式化
Sat Oct 15 15:42:12 CST 2022//解析

下面我们给出一个案例：

需求：定义一个日常工具类，包含两个方法，把日期转换为指定格式的字符串；把字符串解析为指定格式的日期。

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

public class Demo1 {
    public static void main(String[] args) throws ParseException {
        //测验date->String：
        Date d1 = new Date();
        String format = "yyyy年MM月dd日 HH:mm:ss";
        System.out.println(Demo2.dateToString(d1,format));

        //测试String->Date：
        String s = "2022年10月15日 15:02:22";
        System.out.println(Demo2.stringToDate(s,format));
    }
}

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

/*
* 工具类：
* 构造方法私有
* 成员函数静态
* */
public class Demo2 {
    //构造函数私有
    private Demo2(){}

    //第一个dateToString：(返回String，参数有Date date和String pattern)
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf1 = new SimpleDateFormat(format);
        String ss = sdf1.format(date);
        return ss;
    }

    //第二个StringToDate:（返回Date，参数有String s和String pattern）
    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf1 = new SimpleDateFormat(format);
        Date dd = sdf1.parse(s);
        return dd;
    }
}

Calender类

Canlender为了某一时刻和一组日历字段的转换提供了一些方法，并为操作日历字段提供了一些方法

Canlender提供了一个类方法getInstance用于获取Calender对象，其日历字段已使用当前日期和时间初始化：

//固定句式得到日期相关
Calendar c = Calendar.getInstance();
//直接输出所有
System.out.println(c);

编译结果：

java.util.GregorianCalendar[time=1654852717299,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=5,WEEK_OF_YEAR=24,WEEK_OF_MONTH=2,DAY_OF_MONTH=10,DAY_OF_YEAR=161,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=5,HOUR_OF_DAY=17,MINUTE=18,SECOND=37,MILLISECOND=299,ZONE_OFFSET=28800000,DST_OFFSET=0]

Canlender常用方法：

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstact void add(int field,int amount)	根据日历规则，对当前日历进行调整（增加或减去）
public final void set(int year,int month,int date)	设置当前日历的年月日

下面给出相关代码说明：

import java.util.Calendar;

public class Demo1 {
    public static void main(String[] args) {
        //固定句式得到日期相关
        Calendar c = Calendar.getInstance();

        //得到部分信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年"+month+ "月"+date +"日");

        //add方法：
        c.add(Calendar.YEAR,-3);
        int year1 = c.get(Calendar.YEAR);
        int month1 = c.get(Calendar.MONTH) + 1;
        int date1 = c.get(Calendar.DATE);
        System.out.println(year1 + "年"+month1+ "月"+date1 +"日");

        //set方法：
        c.set(2002,10,15);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH) + 1;
        int date2 = c.get(Calendar.DATE);
        System.out.println(year2 + "年"+month2+ "月"+date2 +"日");
    }
}

编译结果：

2022年6月10日
2019年6月10日
2002年11月15日

下面给出关于Calendar的最后一个案例：
需求：获取任意一年的二月有多少天

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Scanner;
import java.util.concurrent.CancellationException;

public class Demo2 {
    public static void main(String[] args) {
        //Scanner录入年份：
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份:");
        int year = sc.nextInt();

        //设置时间为三月1日，并把时间倒退一日:
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);
        c.add(Calendar.DATE,-1);
        int date = c.get(Calendar.DATE);

        //输出即可
        System.out.println(year + "年的二月份有：" + date + "天");
    }
}

编译结果：

请输入年份:
2002
2002年的二月份有：28天

Process finished with exit code 0

结束语

好的，关于一些常用类的方法我们介绍到这里

posted @ 2022-07-06 15:26 秋落雨微凉阅读(285) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

qiuluoyuweiliang

java-常用类

java-常用类

类查看方法

Math类

System类

Object类

Arrays

基本类型包装类

Date类

SimpleDateFormat类

Calender类

结束语

公告