Java BigInteger类,BigDecimal类,Date类,DateFormat类及Calendar类用法示例

本文实例讲述了Java BigInteger类,BigDecimal类,Date类,DateFormat类及Calendar类用法。分享给大家供大家参考,具体如下:

BigInteger类

package cn.itcast_01;
import java.math.BigInteger;
/*
 * BigInteger:可以让超过Integer范围内的数据进行运算
 *
 * 构造方法:
 * BigInteger(String val)
 */
public class BigIntegerDemo {
  public static void main(String[] args) {
    // 这几个测试,是为了简单超过int范围内,Integer就不能再表示,所以就更谈不上计算了。
    // Integer i = new Integer(100);
    // System.out.println(i);
    // // System.out.println(Integer.MAX_VALUE);
    // Integer ii = new Integer("2147483647");
    // System.out.println(ii);
    // // NumberFormatException
    // Integer iii = new Integer("2147483648");
    // System.out.println(iii);
    // 通过大整数来创建对象
    BigInteger bi = new BigInteger("2147483648");
    System.out.println("bi:" + bi);
  }
}

运行结果:

bi:2147483648

BigInteger的运算方法

package cn.itcast_02;
import java.math.BigInteger;
/*
 * public BigInteger add(BigInteger val):加
 * public BigInteger subtract(BigInteger val):减
 * public BigInteger multiply(BigInteger val):乘
 * public BigInteger divide(BigInteger val):除
 * public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
 */
public class BigIntegerDemo {
  public static void main(String[] args) {
    BigInteger bi1 = new BigInteger("100");
    BigInteger bi2 = new BigInteger("50");
    // public BigInteger add(BigInteger val):加
    System.out.println("add:" + bi1.add(bi2));
    // public BigInteger subtract(BigInteger val):减
    System.out.println("subtract:" + bi1.subtract(bi2));
    // public BigInteger multiply(BigInteger val):乘
    System.out.println("multiply:" + bi1.multiply(bi2));
    // public BigInteger divide(BigInteger val):除
    System.out.println("divide:" + bi1.divide(bi2));
    // public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
    BigInteger[] bis = bi1.divideAndRemainder(bi2);
    System.out.println("商:" + bis[0]);
    System.out.println("余数:" + bis[1]);
  }
}

运行结果:

add:150
subtract:50
multiply:5000
divide:2
商:2
余数:0

BigDecimal类

不可变的、任意精度的有符号十进制数

package cn.itcast_01;
/*
 * 看程序写结果:结果和我们想的有一点点不一样,这是因为float类型的数据存储和整数不一样导致的。它们大部分的时候,都是带有有效数字位。
 *
 * 由于在运算的时候,float类型和double很容易丢失精度,演示案例。所以,为了能精确的表示、计算浮点数,Java提供了BigDecimal
 *
 * BigDecimal类:不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。
 */
public class BigDecimalDemo {
  public static void main(String[] args) {
    System.out.println(0.09 + 0.01);
    System.out.println(1.0 - 0.32);
    System.out.println(1.015 * 100);
    System.out.println(1.301 / 100);
    System.out.println(1.0 - 0.12);
  }
}

运行结果:

0.09999999999999999
0.6799999999999999
101.49999999999999
0.013009999999999999
0.88

BigDecimal的运算

package cn.itcast_02;
import java.math.BigDecimal;
/*
 * 构造方法:
 *     public BigDecimal(String val)
 *
 * public BigDecimal add(BigDecimal augend)加
 * public BigDecimal subtract(BigDecimal subtrahend)减
 * public BigDecimal multiply(BigDecimal multiplicand)乘
 * public BigDecimal divide(BigDecimal divisor)除
 * public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):商,几位小数,如何舍取
 */
public class BigDecimalDemo {
  public static void main(String[] args) {
    // System.out.println(0.09 + 0.01);
    // System.out.println(1.0 - 0.32);
    // System.out.println(1.015 * 100);
    // System.out.println(1.301 / 100);
    BigDecimal bd1 = new BigDecimal("0.09");
    BigDecimal bd2 = new BigDecimal("0.01");
    System.out.println("add:" + bd1.add(bd2));
    System.out.println("-------------------");
    BigDecimal bd3 = new BigDecimal("1.0");
    BigDecimal bd4 = new BigDecimal("0.32");
    System.out.println("subtract:" + bd3.subtract(bd4));
    System.out.println("-------------------");
    BigDecimal bd5 = new BigDecimal("1.015");
    BigDecimal bd6 = new BigDecimal("100");
    System.out.println("multiply:" + bd5.multiply(bd6));
    System.out.println("-------------------");
    BigDecimal bd7 = new BigDecimal("1.301");
    BigDecimal bd8 = new BigDecimal("100");
    System.out.println("divide:" + bd7.divide(bd8));
    System.out.println("divide:"
        + bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP));
    System.out.println("divide:"
        + bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));
  }
}

运行结果:

add:0.10
-------------------
subtract:0.68
-------------------
multiply:101.500
-------------------
divide:0.01301
divide:0.013
divide:0.01301000

Date类

Date概述

package cn.itcast_01;
import java.util.Date;
/*
 * Date:表示特定的瞬间,精确到毫秒。
 *
 * 构造方法:
 *     Date():根据当前的默认毫秒值创建日期对象
 *     Date(long date):根据给定的毫秒值创建日期对象
 */
public class DateDemo {
  public static void main(String[] args) {
    // 创建对象
    Date d = new Date();
    System.out.println("d:" + d);
    // 创建对象
    // long time = System.currentTimeMillis();
    long time = 1000 * 60 * 60; // 1小时
    Date d2 = new Date(time);
    System.out.println("d2:" + d2);
  }
}

运行结果:

d:Fri Mar 22 14:09:43 CST 2019
d2:Thu Jan 01 09:00:00 CST 1970

日期和毫秒值的相互转换

package cn.itcast_02;
import java.util.Date;
/*
 * public long getTime():获取时间,以毫秒为单位
 * public void setTime(long time):设置时间
 *
 * 从Date得到一个毫秒值
 *     getTime()
 * 把一个毫秒值转换为Date
 *     构造方法
 *     setTime(long time)
 */
public class DateDemo {
  public static void main(String[] args) {
    // 创建对象
    Date d = new Date();
    // 获取时间
    long time = d.getTime();
    System.out.println(time);
    // System.out.println(System.currentTimeMillis());
    System.out.println("d:" + d);
    // 设置时间
    d.setTime(1000);
    System.out.println("d:" + d);
  }
}

运行结果:

1553235006473
d:Fri Mar 22 14:10:06 CST 2019
d:Thu Jan 01 08:00:01 CST 1970

DateFormat

是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。

Date -- String(格式化)

String -- Date(解析)

DateFormat是抽象类,所以使用其子类SimpleDateFormat

package cn.itcast_03;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 * Date   --   String(格式化)
 *     public final String format(Date date)
 *
 * String -- Date(解析)
 *     public Date parse(String source)
 *
 * DateForamt:可以进行日期和字符串的格式化和解析,但是由于是抽象类,所以使用具体子类SimpleDateFormat。
 *
 * SimpleDateFormat的构造方法:
 *     SimpleDateFormat():默认模式
 *     SimpleDateFormat(String pattern):给定的模式
 *       这个模式字符串该如何写呢?
 *       通过查看API,我们就找到了对应的模式
 *       年 y
 *       月 M
 *       日 d
 *       时 H
 *       分 m
 *       秒 s
 *
 *       2014年12月12日 12:12:12
 */
public class DateFormatDemo {
  public static void main(String[] args) throws ParseException {
    // Date -- String
    // 创建日期对象
    Date d = new Date();
    // 创建格式化对象
    // SimpleDateFormat sdf = new SimpleDateFormat();
    // 给定模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    // public final String format(Date date)
    String s = sdf.format(d);
    System.out.println(s);
    //String -- Date
    String str = "2008-08-08 12:12:12";
    //在把一个字符串解析为日期的时候,请注意格式必须和给定的字符串格式匹配
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date dd = sdf2.parse(str);
    System.out.println(dd);
  }
}

运行结果:

2019年03月22日 14:11:01
Fri Aug 08 12:12:12 CST 2008

日期工具类

package cn.itcast_04;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 这是日期和字符串相互转换的工具类
 *
 * @author 风清扬
 */
public class DateUtil {
  private DateUtil() {
  }
  /**
   * 这个方法的作用就是把日期转成一个字符串
   *
   * @param d
   *      被转换的日期对象
   * @param format
   *      传递过来的要被转换的格式
   * @return 格式化后的字符串
   */
  public static String dateToString(Date d, String format) {
    // SimpleDateFormat sdf = new SimpleDateFormat(format);
    // return sdf.format(d);
    return new SimpleDateFormat(format).format(d);
  }
  /**
   * 这个方法的作用就是把一个字符串解析成一个日期对象
   *
   * @param s
   *      被解析的字符串
   * @param format
   *      传递过来的要被转换的格式
   * @return 解析后的日期对象
   * @throws ParseException
   */
  public static Date stringToDate(String s, String format)
      throws ParseException {
    return new SimpleDateFormat(format).parse(s);
  }
}

运行结果:

2019年03月22日 14:11:42
Fri Aug 08 12:12:12 CST 2008

package cn.itcast_04;
import java.text.ParseException;
import java.util.Date;
/*
 * 工具类的测试
 */
public class DateUtilDemo {
  public static void main(String[] args) throws ParseException {
    Date d = new Date();
    // yyyy-MM-dd HH:mm:ss
    String s = DateUtil.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
    System.out.println(s);
    String s2 = DateUtil.dateToString(d, "yyyy年MM月dd日");
    System.out.println(s2);
    String s3 = DateUtil.dateToString(d, "HH:mm:ss");
    System.out.println(s3);
    String str = "2014-10-14";
    Date dd = DateUtil.stringToDate(str, "yyyy-MM-dd");
    System.out.println(dd);
  }
}

运行结果:

2019年03月22日 14:12:18
2019年03月22日
14:12:18
Tue Oct 14 00:00:00 CST 2014

测试来到世上多少天

package cn.itcast_05;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/*
 * 算一下你来到这个世界多少天?
 *
 * 分析:
 *     A:键盘录入你的出生的年月日
 *     B:把该字符串转换为一个日期
 *     C:通过该日期得到一个毫秒值
 *     D:获取当前时间的毫秒值
 *     E:用D-C得到一个毫秒值
 *     F:把E的毫秒值转换为年
 *       /1000/60/60/24
 */
public class MyYearOldDemo {
  public static void main(String[] args) throws ParseException {
    // 键盘录入你的出生的年月日
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入你的出生年月日:");
    String line = sc.nextLine();
    // 把该字符串转换为一个日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date d = sdf.parse(line);
    // 通过该日期得到一个毫秒值
    long myTime = d.getTime();
    // 获取当前时间的毫秒值
    long nowTime = System.currentTimeMillis();
    // 用D-C得到一个毫秒值
    long time = nowTime - myTime;
    // 把E的毫秒值转换为年
    long day = time / 1000 / 60 / 60 / 24;
    System.out.println("你来到这个世界:" + day + "天");
  }
}

Calendar类

(1)日历类,封装了所有的日历字段值,通过统一的方法根据传入不同的日历字段可以获取值。

(2)如何得到一个日历对象呢?

Calendar rightNow = Calendar.getInstance();

本质返回的是子类对象

(3)成员方法

A:根据日历字段得到对应的值
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
C:设置日历对象的年月日

(4)案例:

计算任意一年的2月份有多少天?

package cn.itcast_01;
import java.util.Calendar;
/*
 * Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。
 *
 * public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量,并且是int类型。
 */
public class CalendarDemo {
  public static void main(String[] args) {
    // 其日历字段已由当前日期和时间初始化:
    Calendar rightNow = Calendar.getInstance(); // 子类对象
    // 获取年
    int year = rightNow.get(Calendar.YEAR);
    // 获取月
    int month = rightNow.get(Calendar.MONTH);
    // 获取日
    int date = rightNow.get(Calendar.DATE);
    System.out.println(year + "年" + (month + 1) + "月" + date + "日");
  }
}

运行结果:

2019年3月22日

Clander的add和set方法

package cn.itcast_02;
import java.util.Calendar;
/*
 * public void add(int field,int amount):根据给定的日历字段和对应的时间,来对当前的日历进行操作。
 * public final void set(int year,int month,int date):设置当前日历的年月日
 */
public class CalendarDemo {
  public static void main(String[] args) {
    // 获取当前的日历时间
    Calendar c = Calendar.getInstance();
    // 获取年
    int year = c.get(Calendar.YEAR);
    // 获取月
    int month = c.get(Calendar.MONTH);
    // 获取日
    int date = c.get(Calendar.DATE);
    System.out.println(year + "年" + (month + 1) + "月" + date + "日");
    // // 三年前的今天
    // c.add(Calendar.YEAR, -3);
    // // 获取年
    // year = c.get(Calendar.YEAR);
    // // 获取月
    // month = c.get(Calendar.MONTH);
    // // 获取日
    // date = c.get(Calendar.DATE);
    // System.out.println(year + "年" + (month + 1) + "月" + date + "日");
    // 5年后的10天前
    c.add(Calendar.YEAR, 5);
    c.add(Calendar.DATE, -10);
    // 获取年
    year = c.get(Calendar.YEAR);
    // 获取月
    month = c.get(Calendar.MONTH);
    // 获取日
    date = c.get(Calendar.DATE);
    System.out.println(year + "年" + (month + 1) + "月" + date + "日");
    System.out.println("--------------");
    c.set(2011, 11, 11);
    // 获取年
    year = c.get(Calendar.YEAR);
    // 获取月
    month = c.get(Calendar.MONTH);
    // 获取日
    date = c.get(Calendar.DATE);
    System.out.println(year + "年" + (month + 1) + "月" + date + "日");
  }
}

运行结果:

2019年3月22日
2024年3月12日
--------------
2011年12月11日

获取任意一年的二月有多少天

package cn.itcast_03;
import java.util.Calendar;
import java.util.Scanner;
/*
 * 获取任意一年的二月有多少天
 *
 * 分析:
 *     A:键盘录入任意的年份
 *     B:设置日历对象的年月日
 *       年就是A输入的数据
 *       月是2
 *       日是1
 *     C:把时间往前推一天,就是2月的最后一天
 *     D:获取这一天输出即可
 */
public class CalendarTest {
  public static void main(String[] args) {
    // 键盘录入任意的年份
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入年份:");
    int year = sc.nextInt();
    // 设置日历对象的年月日
    Calendar c = Calendar.getInstance();
    c.set(year, 2, 1); // 其实是这一年的3月1日
    // 把时间往前推一天,就是2月的最后一天
    c.add(Calendar.DATE, -1);
    // 获取这一天输出即可
    System.out.println(c.get(Calendar.DATE));
  }
}

运行结果:

请输入年份:
2019
28

更多关于java算法相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • 深入理解Java多线程与并发编程

    一.多线程三大特性 多线程有三大特性:原子性.可见性.有序性. 原子性 (跟数据库的事务特性中的原子性类似,数据库的原子性体现是dml语句执行后需要进行提交): 理解:即一个操作或多个操作,要么全部执行并且执行的过程中不会被任何因素打断,要么都不执行. 一个很经典的例子就是银行账户转账问题: 比如从账户A向账户B转1000元,那么必然包括2个操作:从账户A减去1000元,往账户B加上1000元.这2个操作必须要具备原子性才能保证不出现一些意外的问题. 我们操作数据也是如此,比如i = i+1:其

  • 详解Java中Thread 和Runnable区别

    Thread 和Runnable 关系 Thread类是接口Runnable的一个实现类. public class Thread implements Runnable 源码分析 Thread Threa类运行的时候调用start()方法,源代码如下: 调用start()方法,实际运行的是start0方法,方法声明如下: private native void start0() native表明这个方法是个原生函数,即这个函数是用C/C++实现的,被编译成DLL,由Java调用. native

  • 详解Java引用类型的参数也是值传递

    简述 调用方法的时候,有需要传参数的情况.在Java中,参数的类型有基本类型和引用类型两种. 一开始听到一个说法,Java没有引用传递,但是一直没有太多的思考在上面,直到前不久玩数组的时候,突然间发现把数组引用变量作为参数传递到一个方法当中进行操作之后,再去访问原数组,尽然改变了.于是乎,就想到了之前在C++里面学过的引用传递,突然有一种错愕的感觉,就查了一些资料,探究当Java引用类型变量作为参数传递给方法的时候,到底是值传递还是引用传递. 结论:如果将Java引用类型变量作为参数传递给方法,

  • Java常用工具类—集合排序

    一.集合排序概述 1.主要内容 集合中的基本数据类型排序 集合中的字符串排序 Comparator接口 Comparable接口 回顾: //数组的排序 int[] arr= {2,3,4,5,2,1}; Arrays.sort(arr); 2.集合排序方法 使用Collections类的sort(List list)方法 sort(List list)是根据元素的自然顺序对指定列表按升序进行排序. 二.对基本数据类型和字符串类型进行排序 1.对基本数据类型排序 List中只能存放对象,要想存放

  • 4位吸血鬼数字的java实现思路与实例讲解

    这个问题来源于Java编程思想一书,所谓"吸血鬼数字"就是指位数为偶数的数字,可以由一对数字相乘而得到,而这对数字各包含乘积的一半位数字,其中从偶数位数字中选取的数字可以任意排列.例如: 1260=21*60,1827=21*87,2187=27*81-- 先列出结果: 一共7个: 1260=21*60,1395=15*93,1435=41*35,1530=51*30,1827=87*21,2187=27*81,6880=86*80 第一种思路对所有的4位数进行穷举,假设这个4位数是a

  • 详解Java包装类及自动装箱拆箱

    Java包装类 基本类型 大小 包装器类型 boolean / Boolean char 16bit Boolean byte 8bit Byte short /16bit Short int 32bit Integer long 64bit Long float 32bit Float double 64bit Double void / Void Java 的包装类有两个主要的目的: Java包装类将基本数据类型的值"包装"到对象中,对基本数据类型的操作变为了对对象进行操作,从而使

  • 浅谈java String不可变的好处

    一.java内部String类的实现: java 8: public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */ private final char value[]; } java 9 及之后:(使用coder标识了编码) public final class Stri

  • 详解JAVA中的Collection接口和其主要实现的类

    Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的"子接口"如List和Set,详细信息可见官方文档http://tool.oschina.net/uploads/apidocs/jdk-zh/java/util/

  • Java中缀表达式转后缀表达式实现方法详解

    本文实例讲述了Java中缀表达式转后缀表达式实现方法.分享给大家供大家参考,具体如下: 本文先给出思路与方法,最后将给出完整代码 项目实战: https://www.jb51.net/article/158335.htm 算法综述: 一.中缀表达式转后缀表达式: 1.中缀表达式要转后缀表达式,首先需要两个Stack(栈),其中一个应用于存放字符,另一个用于存放数字. 2.读到数字直接存入数字栈中,读到字符时,要咸鱼栈内前一元素(字符)进行比较,当当前(要存入的字符)优先级大于迁移字符时才存入,否

  • Javascript的this详解

    在理解javascript的this之前,首先先了解一下作用域. 作用域分为两种: 1.词法作用域:引擎在当前作用域或者嵌套的子作用域查找具有名称标识符的变量.(引擎如何查找和在哪查找.定义过程发生在代码书写阶段) 2.动态作用域:在运行时被动态确定的作用域. 词法作用域和动态作用域的区别是:词法作用域是在写代码或定义时确定的:动态作用域是在运行时确定的. this的绑定规则 this是在调用时被绑定,取决于函数的调用位置.由此可以知道,一般情况下(非严格模式下),this都会根据函数调用(调用

随机推荐