Java=Object类，Date类，Calendar类，Math类，System类相关方法

于 2020-03-06 20:42:02 发布
阅读量425 收藏 3
点赞数 2
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/appandroid/article/details/104703379
版权

Object类是所有类的父类,所有对象(包括数组)都具有该类中的一些方法

 

1.toString方法

toString方法:
	作用: 返回该对象的字符串表示
    默认字符串表示的形式:
			包名.类名@地址值
            比如:com.abc.abc_Object01.Cat@4554637c
	
    在实际开发中,我们通常会重写toString方法,将本类返回的地址值改成返回该对象中的内容

注意事项:
        我们重写了toString之后,当调用对象的toString方法时,返回的不再是地址值,而是具体的属性值
        实际上,我们不需要手动调用toString方法,
              
                因为我们打印变量名d,编译器会自动调用d.toString(),
                其实打印就是toString方法的方法返回值
         总之:
                System.out.println(变量名.toString())
                等价于
                System.out.println(变量名);    

2. equals方法

equals方法:
    作用:判断其他某个对象是否与此对象“相等”。
    默认比较的是什么???
        默认比较的是两个对象的地址值!!!
    在实际开发中,我们也会重写equals方法,将本来的比较地址值改成比较内容

//重写equals
    //使用IDea工具即可,alt+inseret
    @Override
    public boolean equals(Object o) {
        //合法性判断
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        对象名 at = (对象名) o;
        //判断是 必须是 当前对象的age和比较对象的age相同,且当前对象的name和比较对象的name相同,才返回true
        return age == at.age &&
                Objects.equals(name, at.name);
    }

3.native本地方法

有native修饰的方法我们称为本地方法,不是用Java写的,使用底层c/c++写的

扩展(equals和==的区别)

对于基本类型:
    == 比较基本类型的数值
    equals 没有该方法

对于引用类型:
    == 比较引用类型的地址值
    equals 默认比较地址值,如果子类重写了,按照重写比较规则比较(一般会比较内容)   

4.Objects类

Objects类,我们称之为工具类(其内部所有的方法都是静态的)
    在Objects中有一个方法:
	public static boolean equals(Object a, Object b);
	用于判断两个对象,是否"相等",并且避免了空指针异常,该方法源码如下:
	public static boolean equals(Object a, Object b) { 
        return (a == b) || (a != null && a.equals(b)); 
    }

二.Date类

包:java.util.Date
作用: 代表某一个时间点,可以精确到毫秒

Date类的构造方法

public Date(); 创建一个Date对象,代表当前的系统时间
public Date(long millis); 创建一个Date对象,代表距离国际基准时间millis毫秒后的那个时间
    					国际基准时间: 
							(英国): 1970.01.01 00:00:00
                            (中国): 1970.01.01 08:00:00
                                
public class TestDemo {
    public static void main(String[] args) {
        //1.创建一个Date对象
        Date d = new Date();
        //Fri Mar 06 10:39:24 CST 2020
        System.out.println(d);
        //2创建一个Date对象
        Date dd = new Date(0L);
        //Thu Jan 01 08:00:00 CST 1970
        System.out.println(dd); //标准时间
    }
}

Date类的常用方法

public long getTime(); 获取当前Date对象距离基准时间的毫秒值
public void setTime(long time); 修改当前Date对象距离标准时间的毫秒值
    
public class TestDemo {
    public static void main(String[] args) {
        //3.常用成员方法
        Date now = new Date(); //当前的系统时间
        long time = now.getTime();
        System.out.println(time);//583903946

        now.setTime(1000L);
        System.out.println(now);
    }
}

DateFormat类的作用

作用: 让时间日期和具体的文本之间来回转换

格式化: Date对象 转成 时间字符串
解析:   时间字符串 转回 Date对象
    
例如:
    new Date()  -->  "2020年03月06日 18点30分26秒" 格式化
    "2020年03月06日 18点30分26秒"  --> Date对象  解析      

DateFormat类的构造方法

我们不是DateFormat(抽象类),使用的其子类(SimpleDateFormat)
public  SimpleDateFormat(String pattern);以指定的格式/模式创建SimpleDateFormat对象
这里的参数pattern表示我们想要的时间字符串的格式/模式
    想要这种格式:
			"xxxx年xx月xx日 xx:xx:xx"
    对应的pattern这么写呢?
            "yyyy年MM月dd日 HH:mm:ss"    
    我们只需要记住:
			y -- 年
            M -- 月
            d -- 日
            H -- 时
            m -- 分
            s -- 秒

DateFormat类的成员方法

public String format(Date date); 格式化方法
public Date parse(String time); 解析方法
 
public class TestDemo {
    public static void main(String[] args) throws ParseException {
        //1.创建一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.格式化 format
        Date now = new Date();
        String nowStr = sdf.format(now);
        System.out.println(nowStr);
        //3.解析 parse
        System.out.println("============");
        Date date = sdf.parse("2020年04月07日 12:26:20"); //异常,使用快捷键 alt+回车,再回车
        System.out.println(date);
    }
}

三.Calendar类

作用:也是表示某个时间点
Calendar的获取对象的方式:
	创建其子类GregorianCalendar类的对象(目前不使用)
    使用Calendar的静态方法【推荐方式】:
			Calendar c = Calendar.getInstance(); //就会创建一个子类对象,返回  

注意:在Calendar类中,月份(0-11)代表我们的(1-12)
 
/**
 * YEAR=2020,
 * MONTH=2,
 * DAY_OF_MONTH=6,
 * HOUR_OF_DAY=11,
 * MINUTE=30,
 * SECOND=24,
 * MILLISECOND=813
 */
public class TestCalendar {
    public static void main(String[] args) {
        //1.获取一个Calendar对象
        Calendar cc = Calendar.getInstance();
        System.out.println(cc);
    }
}

Calendar类中常见的方法

public int get(int field); 获取日历对象中某个成员变量的值,其中参数代表该成员变量的编号!!
    
public void set(int field,int value); 修改日历对象中某个成员的值
    
public void add(int field,int value); 增加日历对象中某个成员的值    
    
public class TestCalendar {
    public static void main(String[] args) {
        //1.获取一个Calendar对象
        Calendar cc = Calendar.getInstance();
        System.out.println(cc);

        //2.获取Calendar对象中某个成员的值
        print(cc);
        //3.修改Calendar对象中某个成员的值
        cc.set(Calendar.YEAR,3000);
        cc.set(Calendar.MONTH,3);
        cc.set(Calendar.DAY_OF_MONTH,3);
        print(cc);
        //4.增加Calendar对象中某个成员的值
        cc.add(Calendar.YEAR,3000);
        cc.add(Calendar.MONTH,3);
        cc.add(Calendar.DAY_OF_MONTH,3);
        print(cc);
    }

    public static void print(Calendar cc){
        int year = cc.get(Calendar.YEAR);
        System.out.println(year);

        int month = cc.get(Calendar.MONTH);
        System.out.println(month);

        int day = cc.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        System.out.println("==========");
    }
}
   
注意事项:
	a.Calendar类中,month从0到11,我们是从1-12
    b.时间日期,也是有大小之分, 时间越靠后我们认为其越大

四：Math类

Math中主要包含了一些数学运算相关的方法
Math类中这些方法都是静态的(通过类名就可以直接调用,Math当做一个工具类)  

public double abs(double d); //求绝对值,如果是正数,那么不变,如果负数那么把负号去掉
public double ceil(double d);//向上取整 
public double floor(double d);//向下取整
public long round(double d);// 四舍五入到整数
public double pow(double d1,double d2);//求次幂(次方)

public class TestMath {
    public static void main(String[] args) {
//        public double abs(double d); //求绝对值,如果是正数,那么不变,如果负数那么把负号去掉
        double abs = Math.abs(-3.4);
        System.out.println(abs);
//        public double ceil(double d);//向上取整
        double ceil = Math.ceil(3.2);
        System.out.println(ceil);
//        public double floor(double d);//向下取整
        double floor = Math.floor(3.6);
        System.out.println(floor);

//        public long round(double d);// 四舍五入到整数
        long round = Math.round(3.01);
        System.out.println(round);

//        public double pow(double d1,double d2);//求次幂(次方)
        //3*3*3*3
        double pow = Math.pow(3, 4);
        System.out.println(pow);
    }
}
注意:
	ceil只要有小数部分不是0,那么就向整数为进1
    floor无论如何,小数部分不要,只要整数部分
    Math.ceil(3.0); ===> 3.0
	Math.floor(3.0); ===> 3.0


五.System

System类中包含几个静态的变量和静态的方法,并且该类是不能创建对象的
经过我们对System类源码的研究,发现System类的构造被私有化了
    public final class System {
        /** Don't let anyone instantiate this class */
        private System() {
        }
    }    

System类的常见方法

public static void exit(int status); 退出JVM虚拟机,按照惯例,参数写0即可!!
    
public class TestSystem {
    public static void main(String[] args) {
        //1.试图创建一个System对象
//        System s = new System(); //报错! 因为System的构造私有化了
        //2.exit
        for (int i = 0; i < 10; i++) {
            System.out.println("我爱Java"+i);
            //退出JVM,整个Java程序都会结束
            System.exit(0);
//            break; //结束当前的循环,如果循环后面还有代码可以继续执行
        }

        System.out.println(".....");
    }
}

public static long currentTimeMillis(); 获取当前系统之间的毫秒值(距离基准时间的毫秒值)
    
public class TestSystem02 {
    public static void main(String[] args) {
        //1.获取当前系统时间的毫秒值
        //long millis = System.currentTimeMillis();
        //System.out.println(millis);
        //2. String StringBuilder  用于字符串拼接的性能测试

        long start = System.currentTimeMillis();

 
        //5万次的StringBuilder拼接 耗时27毫秒 0.027秒
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 50000; i++) {
            sb.append(i);
        }

        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start)+"毫秒");
        //算法: 空间复杂度(占用的内存) 时间复杂度(运行花费的时间)
    }
}

 

other--other--other--other--other--other--other--other--other--other--other--other--other--other-

请编写程序，从控制台接收一个“生日”，格式：yyyy-MM-dd，程序要能够计算并打印他来到世界xx天。
	注意：“生日”必须早于“当前日期”，否则提示：生日必须早于当前日期！
public  static  void dayToCurrentNumber(){

        Scanner scn = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你的生日：格式为：yyyy-MM-dd:");
            String str = scn.nextLine();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = null;
            try {
                date = sf.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            Date now = new Date();
            long days = (now.getTime() - date.getTime()) / (1000 * 3600 * 24);

            if (days > 0) {
                System.out.println("恭喜你，你来到世界" + days + "天了");
            } else {
                System.out.println("生日必须早于当前日期！");
            }
        }
    }
  请编写程序，从控制台分别接收两个“生日”，格式：yyyy年MM月dd日，程序要能够计算并打印：第一个生日大于/小于第二个生日。
	注意：要求验证生日日期必须早于当前日期

 public static   void inputDate(){
        Scanner scn = new Scanner(System.in);
        while (true) {
            System.out.println("请输入第一个生日：格式为：yyyy年MM月dd日：");
            String str1= scn.nextLine();
            System.out.println("请输入第二个生日：格式为：yyyy年MM月dd日：");
            String str2= scn.nextLine();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日");
            Date date1 = null;
            Date date2= null;
            try {
                date1 = sf.parse(str1);
                date2 = sf.parse(str2);
            } catch (ParseException e) {
                e.printStackTrace();
            }

            Date now = new Date();
            if ((now.getTime()-date1.getTime())<0||(now.getTime()-date2.getTime())<0){
                System.out.println("生日日期必须早于当前日期！");
            }

            if ((date1.getTime()-date2.getTime())>0){
                System.out.println("第一个生日大于第二个生日！");
            }else{
                System.out.println("第一个生日小于第二个生日！");
            }
        }

        }

//获取当前系统 时间
Date now=new Date();
        DateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String nowTime=sf.format(now);
        System.out.println("系统当前时间为："+nowTime);


//
请编写程序，从控制台接收一个“日期”，格式：yyyy-MM-dd，程序将其转换为：xxxx年xx月xx日的格式输出到控制台。
 public  static  void dateCoverd(){
        Scanner scn = new Scanner(System.in);
        while (true) {
            System.out.println("请输入一个日期：格式为：yyyy-MM-dd:");
            String str1 = scn.nextLine();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
            Date date1 = null;
            try {
                date1 = sf.parse(str1);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy日MM月dd日");
            String outputStr = sdf.format(date1);
            System.out.println("日期转为：" + outputStr);

        }
    }
  Calendar clr = Calendar.getInstance();
        int year = clr.get(Calendar.YEAR);
        int month = clr.get(Calendar.MONTH)+1;
        int day = clr.get(Calendar.DAY_OF_MONTH );
        int hour = clr.get(Calendar.HOUR_OF_DAY);
        int minutes = clr.get(Calendar.MINUTE);
        int seconds = clr.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+day+"日 "+hour+"时"+minutes+"分"+seconds+"秒");


   Calendar clr = Calendar.getInstance();
        //修改Calendar对象中某个成员的值
        clr.set(Calendar.YEAR,1949);
        clr.set(Calendar.MONTH,9);
        clr.set(Calendar.DAY_OF_MONTH,1);
        switch (clr.get(Calendar.DAY_OF_WEEK)){
            case 1:
                System.out.println("1949年10月1日 是 星期日");
                break;
            case 2:
                System.out.println("1949年10月1日 是 星期一");
                break;
            case 3:
                System.out.println("1949年10月1日 是 星期二");
                break;
            case 4:
                System.out.println("1949年10月1日 是 星期三");
                break;
            case 5:
                System.out.println("1949年10月1日 是 星期四");
                break;
            case 6:
                System.out.println("1949年10月1日 是 星期五");
                break;
            case 7:
                System.out.println("1949年10月1日 是 星期六");
                break;
        }

 

  System.out.println("3的5次幂:"+Math.pow(3,5));
        System.out.println("3.2向上取整的结果:"+Math.ceil(3.2));
        System.out.println("3.8向下取整的结果:"+Math.floor(3.8));
        System.out.println("5.6四舍五入取整的结果:"+Math.round(5.6) );



  List<Integer> list = new ArrayList<>();
        long start = System.currentTimeMillis();
        for (int i=0;i<10000000;i++){
            list.add(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start)+"毫秒");

 

 

 

hnbyboy
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值