目录
9.1 包装类
Java是一种面向对象的语言,但在Java中不能定义基本数据类型的对象,为了能将基本数据类型视为对象进行处理,Java提出了包装类的概念,它主要是将基本数据类型封装在包装类中,这样便可以把这些基本数据类型转换为对象进行处理.如下表所示:
包装类 | 对应基本数据类型 | 包装类 | 对应基本数据类型 |
Byte | byte | Short | short |
Integer | int | Long | long |
Float | float | Double | double |
Character | character | Boolean | boolean |
注:Java是可以直接处理基本数据类型的,但在有些情况下需要将其作为对象来处理,这时就需要将其转换为包装类,这里的包装类相当于基本数据类型与对象类型之间的一个桥梁.
9.1.1 Integer类
Integer类在对象中包装了一个基本数据类型int的值,该类的对象包含了一个int类型的字段,此外,该类提供了多个方法,能在int类型和String类型之间相互转换,同时还提供了其他一些处理int类型时非常有用的常量和方法.
1.构造方法:
(1) Integer(int number) 该方法以Int型变量作为参数来获取Integer对象
Integer number = new Integer(7);
(2) Integer(String str) 该方法以String型变量作为参数来获取INteger对象
Integer number = new Integer("45");
2.常用方法
方法 | 返回值 | 功能描述 |
valueOf(String str) | Integer | 返回保存指定的String值的Integer对象 |
parseInt(String str) | int | 返回包含在由str指定的字符串中的数字的等价整数值 |
toString() | String | 返回一个表该Integer值的String对象 |
toBinaryString (int i) | String | 以二进制无符号整数形式返回一个整数参数的字符串表达形式 |
toHexString(int i) | String | 以十六进制无符号整数形式返回一个整数参数的字符串表达形式 |
toOctalString(int i) | String | 以八进制无符号整数形式返回一个整数参数的字符串表达形式 |
equals(Object IntegerObj) | boolean | 比较此对象与指定的对象是否相等 |
intValue() | int | 以int型返回此Integer对象 |
shortValue() | short | 以short型返回此Integer对象 |
byteValue() | byte | 以byte类型返回此Integer的值 |
compareto(Integeranother Integer) | int | 在数字上比较两个Integer对象 |
例9.1代码
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);
// TODO Auto-generated method stub
}
}
3.常量
Integer类提供了以下4个常量:
MAX_VALUE:表示int类型可取的最大值
MIN_VALUE:表示int类型可取的最小值;
SIZE:用来以二进制补码形式表示int值的位数;
TYPE:表示基本类型int的Class实例;
例9.2代码
public class Demo {
public static void main(String[] args) {
int maxint = Integer.MAX_VALUE; //主方法
int minint = Integer.MIN_VALUE; //获取Integer类的常数值
int intsize = Integer.SIZE;
System.out.println("int类型可取的最大值是:" + maxint); //将常量值输出
System.out.println("int类型可取的最小值是:" + minint);
System.out.println("int类型的二进制位数是:" + intsize);
}
}
9.1.2 Double类
Double类在对象中包装一个基本类型为double的值,每个Double的类对象都包含一个double类型的字段.
1.构造方法:
(1) Double(double value)
Double number = new Double(3.14);
(2) Double(String str)
Double number = new Double("3.14");
2.常用方法
方法 | 返回值 | 功能描述 |
valueOf(String str) | Double | 返回保存用参数字符串str表示的double值的Double对象 |
parseDouble(String s) | double | 返回一个新的double值<该值被初始化为用指定String表示的值,这与Double类的valueOf方法一样 |
doubleValue() | double | 以double形式返回此Double对象 |
isNaN() | boolean | 如果此double值是非数字(NaN)值,则返回true |
intValue() | int | 以int形式返回double值 |
byteValue() | byte | 以byte形式返回Double对象值(通过强制转换) |
longValue() | long | 以long形式返回此double的值(通过强制转换为long类型) |
compareTo(Double d) | int | 对两个Double对象进行数值比较,如果两个值相等,返回值0;如果调用对象的数值小于d的数值,则返回负值;如果调用数值对象的数值大于d的数值,则返回正值. |
equals(Object obj) | boolean | 将此对象与指定的对象相比较 |
toString() | String | 返回此Double对象的字符串表示形式 |
toHexString(double d) | String | 返回double参数的十六进制字符串表示形式 |
例9.3代码
public class useDouble {
public static void main(String[] args) {
Double dNum = Double.valueOf("3.14"); // 通过构造函数创建一个Double对象
System.out.println("3.14是否为非数值:" +Double.isNaN(dNum.doubleValue()));
//判断是否为非数值
System.out.println("3.14转换为int值为:" + dNum.doubleValue());// 转换为int类型
System.out.println("值为3.14的Double对象与3.14比较的结果:" + dNum.equals(3.14)); //判断大小
System.out.println("3.14的十六进制表示为:" +Double.toHexString(dNum)); //转换为十六进制
// TODO Auto-generated method stub
}
}
3.常量
Double类主要提供以下常量:
(1) MAX_EXPONENT:返回int值,表示有限double变量可能具有的最大指数;
(2) MIN_EXPONENT:返回int值,表示标准化double变量可能具有的最小指数;
(3)NEGATIVE_INFINITY:返回double值,保存double类型的负无穷大值的常量;
(4)POSITIVE_INFINITY:返回double值,保存double类型的正无穷大值的常量;
9.1.3 Boolean类
Boolean类将基本类型为boolean的值包装在一个对象中,一个Boolean类型的对象只包含一个类型的boolean的字段.
1.构造方法
(1)Boolean(boolean value)
Boolean b = new Boolean(true);
(2) Boolean(String str)
Boolean boo1 = new Boolean("ok");
2.常用方法
方法 | 返回值 | 功能描述 |
booleanValue() | boolean | 将Boolean对象的值以对应的boolean |
equals(Object obj) | boolean | 判断调用该方法的对象与obj是否相等. |
parseBoolean(String s) | boolean | 将该字符串参数解析为boolean值 |
toString() | String | 返回表示该boolean 值的String对象 |
valueOf(String s) | boolean | 返回一个用指定的字符串表示值的boolean值 |
例9.4
public class GetBoolean {
public static void main(String[] args) { //主方法
Boolean b1 = new Boolean(true); //创建类的对象
Boolean b2 = new Boolean("ok"); //创建类的对象
System.out.println("b1:" + b1.booleanValue());
System.out.println("b2:" + b2.booleanValue());
// TODO Auto-generated method stub
}
}
3.常量:
Boolean提供了以下3个常量:
(1)TRUE:对应基值true 的 Boolean 对象。
(2)FALSE:对应基值false 的Boolean对象。
(3)TYPE:基本类型 boolean 的 Class 对象。
9.1.4 Character类
Character 类在对象中包装一个基本类型为 char 的值,该类提供了多种方法,以确定字有(小写字母、数字等),并可以很方便地将字符从大写转换成小写,反之亦然。
1.构造方法
Character类的构造方法语法如下:
Character(char value)
该类的构造方法的参数必须是一个char类型的数据。通过该构造方法将一个char类型装成一个Character 类对象。一旦 Character 类被创建,它包含的数值就不能改变了。
例如,以char 型变量作为参数,创建 Character 对象。代码如下:
Character mychar = new Character('s');
2.常用方法 表9.5 Character类的常用方法
例 9.5
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.isUpperCase(mychar2)) {
System.out.println( mychar2 + "是小写字母");//判断是否是小写字
System.out.println("转换为大写字母的结果:" + Character.toUpperCase(mychar2));
//转换为大写
}
}
}
3. 常量
Character 类提供了大量表示特定字符的常量,例如:
(1)CONNECTOR PUNCTUATION:返回1byte 型值,表示Unicode规范中的常规类别“Pc”。
(2)UNASSIGNED:返回 byte 型值,表示 Unicode规范中的常规类别“Cn”。
(3)TITLECASE LETTER: 返回 byte型位值,表示Unicode 规范中的常规类别“Lt”。
9.1.5 Number 类
对于数值型的包装类,它们有一个共同的父类——Number类,该类是一个抽象类,它是Byte、Integer、Short、Long、Float和double类的父类。其子类必须提供将表示的数值转换为byte、int、short、long、float、double的方法。
Number类的方法分别被Number的各子类所实现,在Number类的所有子类中都包含以上这几种方法。
9.2 Math 类
9.2.1 Math 类概述
Math.数学方法
Math.PI //表示圆周率PI的值
Math.E //表示自然数对数底数e的值
System.out.println("圆周率Π的值为:" +Math.PI);
System.out.println("自然对数底数e的值为:" +Math.E);
9.2.2 常用数学运算方法
1.三角函数方法
方法 | 返回值 | 功 能描述 |
sin(doiuble a) | double | 返回角的三角正弦 |
cos(double a) | double | 返回角的三角余弦 |
tan(double a) | double | 返回角的三角正切 |
asin(double a) | double | 返回一个值的反正弦 |
acos(double a) | double | 返回一个值的反余弦 |
atan(double a) | double | 返回一个值的反正切 |
toRadians(double angdeg) | double | 将角度转换为弧度 |
toDegrees(double angdeg) | double | 将弧度转换为角度 |
例9.6
public class TrigonometricFunction { //创建类TrigonometricFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
//取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.acos(Math.sqrt(2) / 2));
System.out.println("1的反正切值:" + Math.atan(1));//取1的反正切
//取120°的弧度角
System.out.println("120度的弧度值:" + Math.toRadians(120.0));
//取n/2的角度
System.out.println("n/2的角度值:" + Math.toDegrees(Math.PI / 2));
}
}
2.指数函数方法
方法 | 返回值 | 功能描述 |
exp(double a) | double | 用于获取e的a次方,即取e^a |
double log(double a) | double | 用于取自然对数,即取lna的值 |
double log10(double a) | double | 用于取底数为10的对数 |
sqrt(double a) | double | 用于取a的平方根,其中a的值不能为负值 |
cbrt(double a) | double | 用于取a的立方根 |
pow(double a,double b) | double | 用于取a的b次方 |
例9.7
public class ExponentFunction {//创建类ExponentFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("e的平方值:" + Math.exp(2)); //取e的2次方
//取以e为底2的对数
System.out.println("以e为底2的对数值:" + Math.log(2)); //取e的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
public class IntFunction {
public static void main(String[] args) {
System.out.println("使用ceil()方法取整:" +Math.ceil(5.2));
//返回第一个大于等于参数的整数
System.out.println("使用fioor()方法取整:" +Math.floor(2.5));
//返回第一个小于等于参数的整数
System.out.println("使用rint()方法取整:" +Math.rint(2.7));
//返回与参数想接近的整数
System.out.println("使用rint()方法取整:" +Math.rint(2.5));//
System.out.println("使用round()方法取整:" +Math.round(3.4f));
//将参数加上0.5后返回最接近的整数
System.out.println("使用round()方法取整:" +Math.round(2.5));
//将参数加上0.5后返回最接近的整数,并将结果强制转换为长整型
// TODO Auto-generated method stub
}
}
4.取最大值,最小值,绝对值函数方法
例9.9
public class AnyFunction {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("4和8较大者:" + Math.max(4, 8));//取两个参数的最小值
System.out.println("4.4和4较小者:" + Math.max(4.4, 4));
System.out.println("-7的绝对值:" + Math.abs(-7));//去参数的绝对值
}
}
9.3 随机数
9.3.1 Math.random()方法
在Math 类中存在一个random()方法,用于生成随机数字,该方法默认生成大于等于 0.0 小于 1.0的 double 型随机数,即 0<=Math.randomO<1.0,虽然Math.random()方法只可以生成0~1之间的 double图9.11所示。型数字,但只要在Math.random()语句上稍加处理就可以使用这个方法生成任意范围的随机数.
例9.10
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); //生成0到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("——————————————游戏结束—————————————");
// TODO Auto-generated method stub
}
}
除了随机生成数字以外,使用Math类的random()方法还可以随机生成字符,例如,可以使用下面代码生成 a~z之间的字符:
(char)('a'+Math.random()*('z'-'a'+1));
通过上述表达式可以求出更多的随机字符,如 A~Z之间的随机字符,进而推理出求任意两个字符之间的随机字符,可以使用以下语句表示:
(char)(chal+Math.random()*(cha2-chal+1));
例9.11
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'));
// TODO Auto-generated method stub
}
}
9.3.2 Random 类
除了Math类中的random()方法可以获取随机数之外,Java中还提供了一种可以获取随机数的方式,那就是java.util.Random类,该类表示一个随机数生成器,可以通过实例化一个Random 对象创建一个随机数生成器。语法如下:
Random r=new Random();
其中,r是指 Random 对象。
以这种方式实例化对象时,Java 编译器以系统当前时间作为随机数生成器的种子,因为每时每刻的时间不可能相同,所以生成的随机数将不同,但是如果运行速度太快,也会生成两次运行结果相同的随机数。
同时也可以在实例化Random类对象时,设置随机数生成器的种子。语法如下:
Random r=new Random(seedValue);
r:Random类对象。
seedValue:随机数生成器的种子。
方法 | 返回值 | 功能描述 |
nexInt() | int | 返回一个随机整数 |
nextInt(int n) | int | 返回大于等于0小于n的随机整数 |
nextLong() | long | 返回一个随机长整型值 |
nextBoolean() | boolean | 返回一个随机布尔型值 |
nextFloat() | float | 返回一个随机浮点型值 |
nextDouble() | double | 返回一个随机双精度型值 |
nextGaussian() | double | 返回一个概率密度为高斯分布的双精度值 |
import java.util.Random;
import java.util.Scanner;
public class RedBags { //创建一个RedBags类
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("——————模拟微信抢红包——————\n");
Scanner sc = new Scanner(System.in);//控制台输入
System.out.println("请输入要装入红包的总金额(元): ");
double total = sc.nextDouble(); //输入“红包总金额”
System.out.println("请输入红包的个数(个): ");
int bagsnum = sc.nextInt(); //输入“红包个数”
double min = 0.01; //初始化“红包的最小金额”
Random random = new Random();//创建随机数对象random
for (int i = 1; i< bagsnum; i++) { //设置“循环”
/*
* 通过公式模拟数学中的离散模拟计算一个红包可以放的最大金额
* 本次红包可用最大金额 = 可分配金额 - (红包总数 * 已发出的红包数) * 红包的最小金额
*/
double max = total - (bagsnum - i) * min;
double bound = max - min; //设置随机金额的取值范围
/*
* 据随机金额的取值范围,随机生成红包金额
* 由于nextInt(int bound)只能用整数做参数,所以先将bound乘100(小数点向右挪两位)
* 获取到一个整数后,将这个整数除100(小数点向左挪两位)并转换成与金额相同的浮点类型
*/
double safe = (double) random.nextInt((int) (bound * 100)) / 100;
double money = safe + min;//最后加上红包的最小金额,以防safe出现0值
total = total - money; //替换total的值
System.out.println("第"+i+"个红包:" + String.format("%.2f,money")+ "元");
System.out.println("第"+bagsnum+"个红包:" +String.format("%.2f,total")+ "元");
sc.close();//关闭控制台输入
}
}
}
9.4日期时间类
9.4.1 Date类
Date类用于表示日期时间,它位于java.util包中,程序中使用该类表示时间时,需要使用其构造方法创建Date类的对象.
构造方法 | 功能描述 |
Date() | 分配Date对象并初始化此对象,以表示分配它的时间 |
Date(long date) | 分配Date对象并初始化此对象,以表示自从标准基准时间(即1970年1月1日00:00:00GMT)以来的指定毫秒数 |
Date(int year,int month,int date) | 已过时 |
Date(int year,int month,int date,int hrs, int min) | 已过时 |
Date(int year,int month,int date,int hrs, int min,int sec) | 已过时 |
Date(String) | 已过时 |
说明: Date 类的后4种构造方法已经显示过时,他们已经被Calendar 的相应方法或者 DateFormat 类相应方法取代了,后面介绍这两个类。
long timeMillis = System.currentTimeMillis();
Date date= new Date(timeMillis);
import java.util.Date;
public class DateTest { //创建类DateTest
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
Date date = new Date(); //创建现在的日期
long value = date.getTime(); //获得毫秒数
System.out.println("日期: " + date); //输出信息
System.out.println("到现在所以经历的毫秒数为: " + value); //输出信息
}
}
说明: 由于 Date 类创建对象的时间是变化的,所以每次运行程序在控制台所输出的结果都是不一样的。
DateFormat类是日期/时间格式化子类的抽象类,它位于java.text包中,可以按照指定的格式对
日期或时间进行格式化。DateFormat提供了很多类方法, 以获得基于默认或给定语言环境和多种格
式化风格的默认日期/时间Formatter,格式化风格包括 SH ORT、MEDIUM、LONG和FULL等4种,分别如下:
SHORT:完全为数字,如 12.13.52 或 3:30pm。 MEDIUM:较长,如 Jan 12,1952。
YLONG:更长,如 January12,1952 或3:30:32pn
FULL:完全指定,如 Tuesday、April 12、1952 AD或 3:30:42pm PST。
DateFormat df = DateFormat.geDateInstance();
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class DateFormatTest {//创建类DateFormatTest
public static void main(String[] args) {//主方法
//创建日期
Date date = new Date();
//创建不同的日期格式
DateFormat df1 = DateFormat.getInstance();
DateFormat df2 = new SimpleDateFormat("yyy-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("yyy-MM-dd");
DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");
//将日期按照不同格式进行输出
System.out.println("-------将日期时间按照不同格式进行输出-------");
System.out.println("按照Java默认的日期格式:" + df1.format(date));
System.out.println("按照指定格式yyy-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.2 Calender 类
Calendar 提供了一个类方法 getInstance,以获得此类型的一个通用的对象。Calendar的getInstance方法返回一个Calendar 对象,其日历字段已由当前日期和时间初始化。使用方法如下:
Calendar rightNow = Calendar.getInstaance();
说明:从上表可看出,add 方法和roll 方法都用来为给定的日历字段添加或减去指定时间量或,它们的主要区别在于: 使用add方法时会影响大的字段,像数学加法的进位或错位,而使用roll方法设置的日期字段只是进行增加减少,不会改变更大的字段。
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class OlympicWinterGames {//创建一个OlympicWinterGames类
public static void main(String[] args) { //主方法
System.out.println("————————冬奥会倒计时——————————");//输出信息
Date date= new Date();//实例化Date
//创建SimpleDateFormat 对象,指定目标格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
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中的年,月,日的值。因为月份是从0开始计算的,所以这里要减1 calendar.set(2022,2-1,4);
//计算2022年2月4日距离当前时间相差天数
long time2 = calendar.getTimeInMillis(); //计算2022年2月4日距离当前时间相差的天数
long day = (time2 - time1)/(1000 * 60 * 60 * 24);
System.out.println("距离2022年“北京——张家口”冬奥会还有 " +day+ "天!");//输出信息
}
}