Java第九章总结（常用类）

已于 2022-05-11 20:07:16 修改
阅读量400 收藏
点赞数
文章标签： java 开发语言
于 2022-05-09 19:17:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66935612/article/details/124605097
版权

目录

9.1包装类

9.1（1）手动装箱/手动拆箱

自动装箱/自动拆箱（java5新特性）

1.什么是自动装箱和自动拆箱？

2.自动装箱和自动拆箱的好处？

9.1.1Integer类

9.1.2Double类

​编辑

Double 类的常用常量

9.1.3Boolean类

9.1.4Character类

9.1.5Number类

9.2Math类

9.2.1Math类的描述

9.2.2常用数学运算方法

9.3随机数

9.3.1Math.random()方法

9.3.2Random类

9.4日期时间类

9.4.1Date类

9.4.2Calendar类

9.5小结

9.1包装类

2···

 前6个都是Number的子类

9.1（1）手动装箱/手动拆箱

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

        // 123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换。
        // 基本数据类型 -(转换为)->引用数据类型（装箱）
        Integer i = new Integer(123);

        // 将引用数据类型--(转换为)-> 基本数据类型
        float f = i.floatValue();
        System.out.println(f); //123.0

        // 将引用数据类型--(转换为)-> 基本数据类型（拆箱）
        int retValue = i.intValue();
        System.out.println(retValue); //123
    }
}

自动装箱/自动拆箱（java5新特性）

1.什么是自动装箱和自动拆箱？

  • 自动装箱：基本数据类型自动转换成包装类。
  • 自动拆箱：包装类自动转换成基本数据类型

2.自动装箱和自动拆箱的好处？

  • 方便编程
  • 有了自动拆箱之后，Number类中的方法就用不着了
  • public class IntegerTest05 {
    public static void main(String[] args) {
        // 900是基本数据类型
        // x是包装类型
        // 基本数据类型 --(自动转换)--> 包装类型：自动装箱
        Integer x = 900; // 等同于：Integer z = new Integer(900);
        System.out.println(x);

        // x是包装类型
        // y是基本数据类型
        // 包装类型 --(自动转换)--> 基本数据类型：自动拆箱
        int y = x;
        System.out.println(y);
    }
}

    注意：自动装箱底层实际上还是new对象了。

  • public class IntegerTest05 {
    public static void main(String[] args) {
        // z是一个引用，z是一个变量，z还是保存了一个对象的内存地址。
        Integer z = 1000; // 等同于：Integer z = new Integer(1000);
        
        // 分析为什么这个没有报错呢？
        // +两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱。将z转换成基本数据类型
        // 在java5之前你这样写肯定编译器报错。
        System.out.println(z + 1);//1001

        Integer a = 1000; // Integer a = new Integer(1000); a是个引用，保存内存地址指向对象。
        Integer b = 1000; // Integer b = new Integer(1000); b是个引用，保存内存地址指向对象。
        System.out.println(a == b); //false
    }
}

    注意：

  • == 这个运算符不会触发自动拆箱机制
  • == 永远判断的都是两个对象的内存地址是否相同。
  • 只有 + - * / 等运算的时候才会触发自动拆箱机制

9.1.1Integer类

Integer类是基本数据类型int的包装器类，是抽象类Number的子类，位于java.lang包中。
Integer类在对象中包装了一个基本类型int的值，也就是每个Integer对象包含一个int类型的字段。在Integer源码中如下定义：
private final int value;
构造方法
Integer类提供了两种构造方法：它们都会返回一个Integer对象

（1）Integer(int value);

Integer number=new Integer(7);

（2）Integer(String str); //要注意的是字符串不能包含非数字字符，否则会抛出NumberFormatException

Integer number=new Integer("7");

（3）除此之外，还可以给Integer对象直接赋值，如：Integer a = 10;一些重要的方法

常用方法

 例题9.1创建一个 Demo类，其中首先使用Integer类的 parseInt方法将一个字符串转换为i"nt数据:然后创建一个 Integer对象，并调用其equals方法与转换的int数据进行比较;最后演示使用Integer类的toBinaryString方法、toHexString方法、toOctalString方法和 toString方法将int 数据转换为二进制、十六进制、八进制和不常使用的十五进制表示形式。代码如下:

package 第九章;

public class Demo {
	public static void main(String[] args) {
		int num = Integer.parseInt("456");// 将字符串转换为int类型
		Integer iNum = Integer.valueOf("456");// 通过构造函数创建一个Integer对象
		System.out.println("int数据与Integer对象的比较：" + iNum.equals(num));
		String str2 = Integer.toBinaryString(num);// 获取数字的二进制表示
		String str3 = Integer.toHexString(num);// 获取数字的十六进制表示
		String str4 = Integer.toOctalString(num);// 获取数字的八进制表示
		String str5 = Integer.toString(num, 15);// 获取数字的十五进制表示
		System.out.println("456的二进制表示为：" + str2);
		System.out.println("456的十六进制表示为：" + str3);
		System.out.println("456的八进制表示为：" + str4);
		System.out.println("456的十五进制表示为：" + str5);
		System.out.println("圆周率π的值为：" + Math.PI);
		System.out.println("自然对数底数e的值为：" + Math.E);
	}
}

int常量:

[static int] MAX_VALUE：值为 231－1 的常量，它表示 int 类型能够表示的最大值。
[static int] MIN_VALUE：值为 －231 的常量，它表示 int 类型能够表示的最小值。
[static int] SIZE： 用来以二进制补码形式表示 int 值的比特位数。
[static Class] TYPE：表示基本类型 int 的 Class 实例。
[static int] BYTES：返回int值所占的字节数。

例题9.2在项目中创建类GetCon，在主方法实现Integer类的常量值输出

public class GetCon {
// 创建类GetCon
	public static void main(String args[]) { // 主方法
		int maxint = Integer.MAX_VALUE; // 获取Integer类的常量值
		int minint = Integer.MIN_VALUE;
		int intsize = Integer.SIZE;
		System.out.println("int类型可取的最大值是：" + maxint); // 将常量值输出
		System.out.println("int类型可取的最小值是：" + minint);
		System.out.println("int类型的二进制位数是：" + intsize);
	}
}

9.1.2Double类

Double 类中的构造方法有如下两个。

    Double(double value)：构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。

Double double1 = new Double(5.556); // 以 double 类型的变量作为参数创建 Double 对象
    
    Double(String str)：构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。

Double double2 = new Double("5.486"); // 以 String 类型的变量作为参数创建 Double 对象

常用方法

 例题9.3创建一个useDouble类，首先使用double类的valueOf方法创建一个Double对象然后使用Double的常用方法对该对象进行操作，并查看结果

public class useDouble {
	public static void main(String[] args) {
		Double dNum = Double.valueOf("3.14"); // 通过构造函数创建一个Integer对象
		System.out.println("3.14是否为非数字值：" + Double.isNaN(dNum.doubleValue()));// 判断是否为非数字值
		System.out.println("3.14转换为int值为：" + dNum.intValue());// 转换为int类型
		System.out.println("值为3.14的Double对象与3.14的比较结果：" + dNum.equals(3.14));// 判断大小
		System.out.println("3.14的十六进制表示为：" + Double.toHexString(dNum));// 转换为十六进制
	}
}

Double 类的常用常量

在 Double 类中包含了很多常量，其中较为常用的常量如下。

    MAX_VALUE:值为 1.8E308 的常量，它表示 double 类型的最大正有限值的常量。
    
    MIN_VALUE：值为 4.9E-324 的常量，它表示 double 类型数据能够保持的最小正非零值的量。
    
    NaN：保存 double 类型的非数字值的常量。
    
    NEGATIVE_INFINITY：保持 double 类型的负无穷大的常量。
    
    POSITIVE_INFINITY：保持 double 类型的正无穷大的常量。
    
    SIZE：用秦以二进制补码形式表示 double 值的比特位数。
    
    TYPE：表示基本类型 double 的 Class 实例。


 

9.1.3Boolean类

Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。

构造方法

1、Boolean(boolean value)

该方法创建一个表示value参数的Boolean对象，示例如下：

Boolean b = new Boolean(true);
2、Boolean(String str)

该方法以String变量作为参数创建Boolean对象，如果String参数不为null且在忽略大小写时等于true,则分配一个表示true的值的Boolean对象，否则获得一个false值的Boolean对象，示例如下：

Boolean bool = new Boolean("ok");
常用方法

 例题9.4在项目中创建GetBoolean，在主方法中以不同的构造方法创建Boolean对象并调用booleanvalue（）方法将创建对象重新转换为boolean数据输出

public class GetBoolean {
	public static void main(String args[]) { // 主方法
		Boolean b1 = new Boolean(true); // 创建Boolean对象
		Boolean b2 = new Boolean("ok"); // 创建Boolean对象
		System.out.println("b1：" + b1.booleanValue());
		System.out.println("b2：" + b2.booleanValue());
	}
}

 

Boolean常量

Boolean提供了以下几个常量：

1、TRUE:对应基值true的Boolean对象

2、FALSE:对应基值false的Boolean对象

3、TYPE：基本类型boolean的Class对象

9.1.4Character类

Character类在对象中包装了一个基本类型char的值。一个Character类型的对象包含类型为char的单个字段。

构造方法

Character(char value)

该类的构造函数必须是一个char类型的数据。通过该构造函数创建的Character类对象包含由char类型参数提供的值，一旦Character类被创建，它包含的数值就不能改变，示例如下：

Character mychar = new Character("s");

Character常用方法

加

 例题9.5在项目里创建UpperOrLower，在主方法中创建Character类的对象，通过判断字符大小写来确定转换

public class UpperOrLower {
	public static void main(String args[]) { // 主方法
		Character mychar1 = new Character('A'); // 声明Character对象
		Character mychar2 = new Character('a'); // 声明Character对象
		if (Character.isUpperCase(mychar1)) {// 判断是否为大写字母
			System.out.println(mychar1 + "是大写字母 ");
			System.out.println("转换为小写字母的结果： " + Character.toLowerCase(mychar1));// 转换为小写
		}
		if (Character.isLowerCase(mychar2)) {// 判断是否为小写字母
			System.out.println(mychar2 + "是小写字母");
			System.out.println("转换为大写字母的结果： " + Character.toUpperCase(mychar2));// 转换为大写
		}
	}
}

Character常量

Character类提供了大量表示特定字符的常量，例如：

1、CONNECTOR_PUNCTUATION:返回byte型值，表示Unicode规范中的常规类别"Pc";

2、UNASSIGNED:返回byte型值，表示Unicode规范中的常规类别"Ca";

3、TITLECASE_LETTER:返回byte型值，表示Unicode规范中的常规类别"Lt";

9.1.5Number类

是前几个的父类

一般情况下我们会使用数据的基本数据类型：byte、int、short、long、double、float、boolean、char；
对应的包装类型也有八种：Byte、Integer、Short、Long、Double、Float、Character、Boolean;
包装类型都是用final声明了，不可以被继承重写；
Number类是java.lang包下的一个抽象类，提供了将包装类型拆箱成基本类型的方法，所有基本类型（数据类型）的包装类型都继承了该抽象类，并且是final声明不可继承改变；
 


 

9.2Math类

9.2.1Math类的描述

在运算中，Math提供了基本的数学常数，如三角函数、指数、对数运算的双曲函数等。
 

9.2.2常用数学运算方法

1.三角函数

 例题9.6在项目里创建TrigonometricFunction类，在类主方法中调用Math类提供的三角函数运算方法，并输出结果

public class TrigonometricFunction {
	public static void main(String[] args) {
		// 取90度的正弦
		System.out.println("90度的正弦值：" + Math.sin(Math.PI / 2));
		System.out.println("0度的余弦值：" + Math.cos(0)); // 取0度的余弦
		// 取60度的正切
		System.out.println("60度的正切值：" + Math.tan(Math.PI / 3));
		// 取2的平方根与2商的反正弦
		System.out.println("2的平方根与2商的反弦值："
				+ Math.asin(Math.sqrt(2) / 2));
		// 取2的平方根与2商的反余弦
		System.out.println("2的平方根与2商的反余弦值："
				+ Math.acos(Math.sqrt(2) / 2));
		System.out.println("1的反正切值：" + Math.atan(1)); // 取1的反正切
		// 取120度的弧度值
		System.out.println("120度的弧度值：" + Math.toRadians(120.0));
		// 取π/2的角度
		System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI / 2));
	}
}

 

2.指数函数方法

例题9.7 在项目里创建ExponentFunction类，在类的主方法里调用Math类提供的指数函数运算方法，并输出结果

public class ExponentFunction {
	public static void main(String[] args) {
		System.out.println("e的平方值：" + Math.exp(2)); // 取e的2次方
		// 取以e为底2的对数
		System.out.println("以e为底2的对数值：" + Math.log(2));
		// 取以10为底2的对数
		System.out.println("以10为底2的对数值：" + Math.log10(2));
		System.out.println("4的平方根值：" + Math.sqrt(4)); // 取4的平方根
		System.out.println("8的立方根值：" + Math.cbrt(8)); // 取8的立方根
		System.out.println("2的2次方值：" + Math.pow(2, 2)); // 取2的2次方
	}
}

 

3.取整函数方法

例题9.8在项目里创建IntFunction类，调用Math类提供的实现取整函数方法，并输出结果

public class IntFunction {
	public static void main(String[] args) {
		// 返回第一个大于等于参数的整数
		System.out.println("使用ceil()方法取整：" + Math.ceil(5.2));
		// 返回第一个小于等于参数的整数
		System.out.println("使用floor()方法取整：" + Math.floor(2.5));
		// 返回与参数最接近的整数
		System.out.println("使用rint()方法取整：" + Math.rint(2.7));
		// 返回与参数最接近的整数
		System.out.println("使用rint()方法取整：" + Math.rint(2.5));
		// 将参数加上0.5后返回最接近的整数
		System.out.println("使用round()方法取整：" + Math.round(3.4f));
		// 将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
		System.out.println("使用round()方法取整：" + Math.round(2.5));
	}
}

 

 4.取最大值，最小值，绝对值函数方法

 

 例题9.9在项目创建AnyFunction类，在类的主方法调用Math类提供的最大值方法，并输出结果

public class AnyFunction {
	public static void main(String[] args) {
		System.out.println("4和8较大者:" + Math.max(4, 8)); 
		 // 取两个参数的最小值
		System.out.println("4.4和4较小者：" + Math.min(4.4, 4));
		System.out.println("-7的绝对值：" + Math.abs(-7)); // 取参数的绝对值
	}

 

9.3随机数

在java中提供了两种方法 Math类的random方法还有Random类提供的方法

9.3.1Math.random()方法

在编写代码的过程中难免要用到随机数，有时生成数很简单，但有时生成很复杂。本文总结了常见的生成随机数的方法。
生成常见随机数的方法
1、[ 0,1 )
double d = Math.random();
2、double型[0,99)
double d = Math.random()*99;
3、int型[0,99)
int i = (int) Math.random()*99;
总结：99是可以变的，如果要生成[0,50)，
那就int i = (int) Math.random()*50;
4、int型[0,99]
int i = (int) Math.random()*100;
5、[m,n)
double d = m+Math.random()*(n-m);
6、[m,n]
double d = m+Math.random()*(n-m+1);

例题9.10使用 Math.random（)方法一个间年的猜数字小诳戏，要求:使用 Math.random()方法生成一个0~100间的想机双于公A用尸物入有阕的数子，判断输入的数字是否与随机生成的数字匹配,如来个匹配，呢小相应的B忌，如采匹配，则表示猜中,游戏结束。代码如下

import java.util.Scanner;

public class NumGame {
	public static void main(String[] args) {
		System.out.println("——————猜数字游戏——————\n");
		int iNum;
		int iGuess;
		Scanner in = new Scanner(System.in);// 创建扫描器对象，用于输入
		iNum = (int) (Math.random() * 100);// 生成1到100之间的随机数
		System.out.print("请输入你猜的数字：");
		iGuess = in.nextInt(); // 输入首次猜测的数字
		while ((iGuess != -1) && (iGuess != iNum))// 判断输入的数字不是-1或者基准数
		{
			if (iGuess < iNum)// 若猜测的数字小于基准数，则提示用户输入的数太小，并让用户重新输入
			{
				System.out.print("太小，请重新输入：");
				iGuess = in.nextInt();
			} else// 若猜测的数字大于基准数，则提示用户输入的数太大，并让用户重新输入
			{
				System.out.print("太大，请重新输入：");
				iGuess = in.nextInt();
			}
		}
		if (iGuess == -1)// 若最后一次输入的数字是-1，循环结束的原因是用户选择退出游戏
		{
			System.out.println("退出游戏！");
		} else// 若最后一次输入的数字不是-1，用户猜对数字，获得成功，游戏结束
		{
			System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum);
		}
		System.out.println("\n———————游戏结束———————");
	}

生成字符 (char)(‘a’ + Math.random() * (‘z’ - ‘a’ +1);a到z

例题9.11在项目中创建MathRandomChar类在类中编写GetRandomChar（）方法生成随机字符，并在主方法中输出字符

public class MathRandomChar {
	// 定义获取任意字符之间的随机字符
	public static char GetRandomChar(char cha1, char cha2) {
		return (char) (cha1 + Math.random() * (cha2 - cha1 + 1));
	}

	public static void main(String[] args) {
		// 获取a~z之间的随机字符
		System.out.println("任意小写字符" + GetRandomChar('a', 'z'));
		// 获取A~Z之间的随机字符
		System.out.println("任意大写字符" + GetRandomChar('A', 'Z'));
		// 获取0~9之间的随机字符
		System.out.println("0到9任意数字字符" + GetRandomChar('0', '9'));
	}

 


 

9.3.2Random类

Random类中的常用方法

Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。下面对这些方法做一下基本的介绍：

a、public boolean nextBoolean()：是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。

b、public double nextDouble()：是生成一个随机的double值，数值介于[0,1.0)之间。

c、public int nextInt()：是生成在-231到231-1之间int值。如果需要生成指定区间的int值，则需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。

d、public int nextInt(int n)：是生成一个介于[0,n)的区间int值，包含0而不包含n。如果想生成指定区间int值，也需要进行一定的数学变换，具体参看下面的使用示例中的代码。

e、public void setSeed(long seed)：是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。

f、 public float nextFloat(int n)：返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。

g、 public long nextLong():返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

h、public double nextGaussian():返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。

2、Random类使用示例

使用Random类，一般是生成指定区间的随机数字，下面就一一介绍如何生成对应区间的随机数字。以下生成随机数的代码均使用以下Random对象r进行生成：

Random r = new Random();

a、生成[0,1.0)区间的小数
  double d1 = r.nextDouble();//直接使用nextDouble方法获得。

b、生成[0,5.0)区间的小数

  double d2 = r.nextDouble() * 5;//因为扩大5倍即是要求的区间。同理，生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。
1
c、生成[1,2.5)区间的小数

 double d3 = r.nextDouble() * 1.5 + 1;//生成[1,2.5)区间的随机小数，则只需要首先生成[0,1.5)区间的随机数字，然后将生成的随机数区间加1即可。
 

例题9.12使用Random模拟抢红包功能

import java.text.DecimalFormat;
import java.util.Random;
import java.util.Scanner;

/**
 * 模拟微信抢红包功能
 */
public class RedBags { //创建一个RedBags类
	public static void main(String[] args) {
		System.out.println("—————————模拟微信抢红包—————————\n"); 
		Scanner sc = new Scanner(System.in); //控制台输入
		System.out.print("请输入要装入红包的总金额（元）："); 
		double total = sc.nextDouble(); //输入“红包的总金额”
		System.out.print("请输入红包的个数（个）："); 
		int bagsnum = sc.nextInt(); //输入“红包的个数”
		double min = 0.01; //初始化“红包的最小金额”
		Random random = new Random(); //创建随机数对象random
		DecimalFormat df = new DecimalFormat("###,###,###.##"); //创建DecimalFormat类的对象df，并设置格式
		for (int i = 1; i < bagsnum; i++) { //设置“循环”
			double safe = (total - (bagsnum - i) * min) / (bagsnum - i); //通过公式模拟数学中的离散模型
			double money = (double) random.nextInt((int) ((safe - min) * 100)) / 100 + min; //根据离散模型得到每个红包的金额
			total = total - money; //替换total的值
			String temp = df.format(money); //调用format()方法，对数字money格式化
			System.out.println("第" + i + "个红包：" + temp + "元"); //输出结果
		}
		String left = df.format(total); //调用format()方法，对数字total格式化
		System.out.println("第" + bagsnum + "个红包：" + left + "元"); //输出结果
		sc.close(); //关闭控制台输入
	}
}

 

9.4日期时间类

9.4.1Date类

  G 年代标志符
  y 年
  M 月
  d 日
  h 时 在上午或下午 (1~12)
  H 时 在一天中 (0~23)
  m 分
  s 秒
  S 毫秒
  E 星期
  D 一年中的第几天
  F 一月中第几个星期几
  w 一年中第几个星期
  W 一月中第几个星期
  a 上午 / 下午 标记符 
  k 时 在一天中 (1~24)
  K 时 在上午或下午 (0~11)
  z 时区

DateFormat类

DateFormat子类：
DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化和分析日期或时间。DateFormat类中最重要的两个方法是format和parse，简单来说format（是将日期Date类的对象转化为用户所能看懂的字符串形式如2019年1月28日 ）parse（是将用户所能看懂的字符串形式的日期转化为日期Date类）
常用静态工厂方法：



（1）getInstance()方法，使用SHORT样式的日期和时间获取格式化的日期和时间程序，输出样式：2019/1/28 下午5:23

（2）getDateInstance()方法，获取具有默认语言环境的默认格式样式的日期格式化程序，输出样式：2019/1/28

   getDateInstance(int style)方法    //style为下面的日期长度参数，如SHORT

   getDateInstance(int style,Locale alocale)方法    //alocale为语言环境，如CHINA

（3）getDateTimeInstance()方法，获取具有默认语言环境的默认格式样式的日期和时间格式化程序,输出样式：2019/1/28 下午5:23:12

   getDateTimeInstance(int datastyle,int timestyle)方法   //datastyle为下面的日期长度参数，timestyle为时间长度参数

   getDateTimeInstance(int datastyle,int timestyle,Locale alocale)方法

（4）getTimeInstance()方法，获取具有默认语言环境的默认格式样式的时间格式化程序，输出样式：下午5:23:12

   getTimeInstance(int style)方法    //style为下面的时间长度参数

   getTimeInstance(int style,Locale alocale)方法    //alocale为语言环境，如CHINA

（5）getCalendar()方法，获取与此日期/时间格式化程序关联的日历。

（6）getNumberFormat()方法，获取此日期/时间格式化程序用于格式化和解析时间的数字格式化程序。

例题9.13使用Date类的getTime方法获得从1970年1月1日00：00：00GMT到现在的毫秒数并输出

import java.util.Date;
public class DateTest {
	public static void main(String[] args) {
		Date date = new Date(); 				// 创建现在的日期
		long value = date.getTime(); 			// 获得毫秒数
		System.out.println("日期：" + date);
		System.out.println("到现在所经历的毫秒数为： " + value);
	}

 



可以将不同的选项传递给这些工厂方法来控制结果的长度; 从SHORT到MEDIUM到LONG到FULL到DEFAULT。确切的结果取决于区域设置，但通常：
SHORT：              2019/1/28                                                        下午5:23
MEDIUM：            2019年1月28日                                              下午5:23:12
LONG：                 2019年1月28日                                              CST 下午5:23:12
FULL：                  2019年1月28日星期一                                  中国标准时间 下午5:23:12
DEFAULT：          2019年1月28日                                              下午5:23:12
 

SimpleDateFormat类：
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。它允许格式化（日期 - >文本），解析（文本 - >日期）和规范化。
日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串，从带引号的字母 'A'来'Z'和'a'到 'z'被解释为代表的日期或时间字符串的组件模式字母。可以使用单引号（'）引用文本以避免解释。 "''"代表单引号。不解释所有其他字符; 它们只是在格式化过程中被复制到输出字符串中，或​​者在解析过程中与输入字符串匹配。
以下模式字母（从所有其他字符限定 'A'到'Z'和从'a'到 'z'保留）：
 

字母

日期或时间组件

举例

G

时代指示符

AD

y

年

1996; 96

M

一年中的月份

July; Jul;07

w

一年中的周数

27

W

一月中的周数

2

D

一年中的天数

189

d

一个月的天数

10

F

一个月中的周数

2

E

一周中的天数

Tuesday; Tue

a

上午/下午标记

AM;PM

H

一天中的小时数（0-23）

0

k

一天中的小时数（1-24）

24

K

上午/下午中的小时数（0-11）

0

h

上午/下午中的小时数（1-12）

12

m

一小时中的分钟数

30

s

一分钟中的秒钟数

55

S

毫秒数

978

z

时区

Pacific Standard Time; PST;GMT-08:00;CST

Z

时区

-0800

例题9.14使用DateFormat类的getInstance方法和SimpleDateFormat类的构造方法

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class DateFormatTest {
	public static void main(String[] args) {
		// 创建日期
		Date date = new Date();
		// 创建不同的日期格式
		DateFormat df1 = DateFormat.getInstance();
		DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE");
		DateFormat df3 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 EE", Locale.CHINA);
		DateFormat df4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE", Locale.US);
		DateFormat df5 = new SimpleDateFormat("yyyy-MM-dd");
		DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");
		// 将日期按照不同格式进行输出
		System.out.println("-------将日期时间按照不同格式进行输出------");
		System.out.println("按照Java默认的日期格式: " + df1.format(date));
		System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date));
		System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : " + df3.format(date));
		System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，区域为美国: " + df4.format(date));
		System.out.println("按照指定格式 yyyy-MM-dd: " + df5.format(date));
		System.out.println("按照指定格式 yyyy年MM月dd日: " + df6.format(date));
	}
}

 

9.4.2Calendar类

Calendar类是日历类，提供操作日历字段的方法

知识点1：获取Calendar对象的方法

想得到一个Calendar类对象的话，不能采用new对象的方式。因为Calendar类的构造函数被protected修饰符修饰

应该

 Calendar calBegin = Calendar.getInstance();

 常用方法

 

 例题9.15使用Calendar类输出2022年“北京一张家口”冬奥会的倒计时

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

/**
 * 输出2022年冬奥会倒计时（暂定冬奥会举办时间为2022年2月2日）
 */
public class OlympicWinterGames { //创建OlympicWinterGames类
	public static void main(String[] args) {
		System.out.println("——————————冬奥会倒计时——————————\n"); 
		Date date = new Date(); //实例化Date
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); //创建SimpleDateFormat对象，制定目标格式
        String today = simpleDateFormat.format(date);// 调用format方法，格式化时间，转换为指定方法
        System.out.println("今天是" + today); //输出当前日期
        long time1 = date.getTime(); //计算“自 1970 年 1 月 1 日 00:00:00 至当前时间所经过的毫秒数
        Calendar calendar = Calendar.getInstance(); //使用默认时区和语言环境获得一个日历calendar
        calendar.set(2022, 2-1, 4); //设置日历calendar中的 YEAR、MONTH 和 DAY_OF_MONTH 的值
        long time2 = calendar.getTimeInMillis(); //计算“自 1970 年 1 月 1 日 00:00:00 至 2022 年 2 月 2 日所经过的毫秒数
        long day = (time2 - time1)/(24 * 60 * 60 * 1000); //计算2022 年 2 月 2 日距离当前时间的天数
        System.out.println("距离2022年“北京-张家口”冬奥会还有 " + day + " 天！");
	}
}

 

9.5小结

 本章主要讲解了Java 中吊用尖的使用万法，包括封装基本数据类型的包装类、Math 数学运算类、Random随机数尖、Date 尖以仅 Calendar 尖，在买际升发中，这些类经常会用到，希望通过本章的学习，读者能够熟练掌握Java 中常用类的使用方法，并能够在实际开发中灵活应用。

遇見即是上上籤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java各知识点详细总结(毕向东笔记整理)
03-01
第六章：常用类 API 122API 122 API 122API 122API 122API 122API 122-139139139 第七章：集合框架（容器） +其他类对象使用 139 -199 第八章：IO 流 199 -280 第九章：GUIGUIGUI编程 280 -284 第十章：网络编程 284...
第九章Java常用量总结
Le_2967330的博客
05-23 437
9.1包装类 Java是一种面向对象的语言，但在Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如int型数值的包装类Integer，boolean型的包装类Boolean等，这样便可以把这些基本数据类型转换为对象进行处理。Java中的包装类及其对应的基本数据类型如下表所示。 包装类及其对应的基本数数据类型 包装类 对应基本数据类型 Byte byte Integer ...
java基础中如何使用int？
2301_76740033的博客
03-20 357
看到int很多小伙伴都觉得眼熟，因为在python我们是把它作为函数来讲的。但是在java中，它是一种基本的数据类型，而且是属于整数类型的一种。相信大多数人对int在java中的用法不是很了解，作为基础内容是必不可少的学习模块，下面我们就讲讲in的定义、取值，以及它的实例。以上就是我们关于java中int基本数据类型的学习，这里区别于以往python中的int函数，同样是java模块中比较重要的知识点，学习的时候要重点记忆。它是32位、有符号的以二进制补码表示的整数。int最常用的类型,用来表示一个整数。
java学习之最大整数
wjher
05-23 522
java学习之最大整数 代码如下 public class myMaxInt { public static void main(String[] args) { int int_max=java.lang.Integer.MAX_VALUE; System.out.println("int的最大是为："+int_max); }
Java第九章总结
爱吃香菜的book
05-26 444
9.1 包装类 Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中。 9.1.1 Integer类 Integer类在对象中包装了一个基本数据类型int的值，该类包含一个int了类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时提供了其他一些处理int类型是非常有用的常量和方法。 1. 构造方法 Integer类有以下两种构造方法 （1）Integer（i.
Java重点知识总结
07-30
第9章 流的概念 字节流的类的作用、类层次 字符流的类的作用、类层次 随机文件存取类作用 第10章 URL、URLConnection类支持的协议 TCP Socket： 服务器端ServerSocket、客户端Socket (了解) 第11章 JDBC连接步骤用到...
java面试视频.part15.rar
06-05
包含代码 视频总共压缩了19包，需要全部下载完才能解压 适合java求职找工作的小伙伴 ...第8章 Java多线程与并发 第9章 Java多线程与并发-原理 第10章 Java常用类库与技巧 第11章 Java框架-Spring 第12章 课程总结与展望
java面试视频.part12.rar
06-05
包含代码 视频总共压缩了19包，需要全部下载完才能解压 适合java求职找工作的小伙伴 ...第8章 Java多线程与并发 第9章 Java多线程与并发-原理 第10章 Java常用类库与技巧 第11章 Java框架-Spring 第12章 课程总结与展望
java中一维数组的常识(菜鸟教程)
m0_49151953的博客
01-28 559
注意:当我们使用 double[] doubles=new double[2];去初始化一个数组的时候。 如果是整数类型，int，byte，short，long类型，初始值为0 如果是小数类型(float，double)，那么初始值为0.0 如果是boolean类型，里面元素的初始值为false 如果是char类型数组，它里面的初始值为:’\u0000’(什么都没有) 如果是引用数据类型(类、数组、接口、String)，那么初始值为null(代表没有指向任何的对象) 我们可以通过下标去取值，也可以通过
Java中INT_MIN和INT_MAX怎么表示(Integer.MAX_VALUE和Integer.MIN_VALUE)
Myblog
12-11 4480
java int 类整数的最大值是 2 的 31 次方 - 1 = 2147483648 - 1 = 2147483647 可以用 Integer.MAX_VALUE 表示它，即 int value = Integer.MAX_VALUE; Integer.MAX_VALUE + 1 = Integer.MIN_VALUE = -2147483648 一般用于找最小最大 如果比较找最小先定义min为 Integer.MAX_VALUE 如果找最大定义max=Integer.MAX_VALUE+1 ...
java中Integer.parseInt用法详细分析（全）
码农研究僧的博客
07-05 3万+
前言 将数字字符串转化成原生整型数据 属于java.lang.Integer 是原生类型整型的包裹类 函数方法 1.pareInt(String s) 将字符串s转换为十进制的数字，默认为十进制 public static void main(String[] args) { int num=Integer.parseInt("100"); System.out.println(num); } 2.pareInt(String s,int redix) radix
java max(int integer)_Java整数类型原语是否在转换类型的MAX_INT处“加盖”？
weixin_40002336的博客
02-25 362
我试图找出一些非常奇怪的Java行为 . 我有一个涉及double的公式，但是“保证”给出一个整数答案 - 具体来说，是一个无符号的32位整数(唉，Java不能很好) . 不幸的是，我的答案有时不正确 .最终我发现了这个问题，但对我来说这个行为仍然很奇怪：一个 double 直接转换为 int 似乎被限制在 MAX_INT 为有符号整数，而 double 转换为 long 然后被转换为 int 给...
integer比较_傻傻分不清？Integer、new Integer() 和 int 的面试题
weixin_39533432的博客
12-01 132
基本概念的区分1、Integer 是 int 的包装类，int 则是 java 的一种基本数据类型2、Integer 变量必须实例化后才能使用，而int变量不需要3、Integer 实际是对象的引用，当new一个 Integer时，实际上是生成一个指针指向此对象；而 int 则是直接存储数据值4、Integer的默认值是null，int的默认值是0Integer、new Integer() 和 i...
MaxInt
qingfeng45697的专栏
04-08 2392
MaxInt：一个Integer整型的最大值   2009-06-10 19:46:13|  分类： delphi|举报|字号 订阅 声明：const MaxInt = High(Integer); 描述：MaxInt常量给出一个Integer类型所允许的最大数值。 这个值通常是2^32 –1 ＝ 2147483647，但并不保证在所有的De
java int 的最大值 Integer.MAX_VALUE 是 2147483647 / 二十一亿多的一个整数
热门推荐
tfish的专栏
09-27 24万+
java int 类整数的最大值是 2 的 31 次方 - 1 = 2147483648 - 1 = 2147483647 可以用 Integer.MAX_VALUE 表示它，即 int value = Integer.MAX_VALUE; Integer.MAX_VALUE + 1 = Integer.MIN_VALUE = -2147483648 再大的数就要用 long （最大值...
Java之int及它的取值范围
fly_Xiaoma的博客
12-24 2万+
int是Java中的8种基本类型之一，一个int值占4个byte（8个二进制位） 8中基本类型所占字节分别是多少： int  4个字节 short  2个字节 long  8个字节 char  2个字节 float  4个字节 double  8个字节 boolean 没有提供size的方法 思考：一个int，它的取值范围是多少呢？在内存中又是怎么存储的呢？ 答案：它的取值范围是...
java第八章实用类
最新发布
05-20
Java第八章实用类主要介绍了Java中常用的一些类和接口，例如字符串处理类、日期时间类、随机数类、正则表达式类、集合框架等。这些类和接口在Java编程中经常被使用，掌握它们对于编写高效、健壮的程序非常重要。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

遇見即是上上籤

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值