您的位置：首页 > 编程语言 > Java开发

day14 java基础（正则表达式，System类，Random类，Math类，BigInteger类，BigDecimal类，Date类，Calendar类）

2019-08-12 22:26 337 查看

----------------------------总结----------------------------------------
1:正则表达式(理解)
(1)就是符合一定规则的字符串
(2)常见规则
A:字符
x 字符 x。举例：‘a’表示字符a
\ 反斜线字符。
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\u000D’)

B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括

C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? \.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi

E:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
(3)常见功能：(分别用的是谁呢?)
A:判断功能
String类的public boolean matches(String regex)
B:分割功能
String类的public String[] split(String regex)
C:替换功能
String类的public String replaceAll(String regex,String replacement)
D:获取功能
Pattern和Matcher
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");

find():查找存不存在
group():获取刚才查找过的数据
(4)案例
A:判断电话号码和邮箱
B:按照不同的规则分割数据
C:把论坛中的数字替换为*
D:获取字符串中由3个字符组成的单词

2:Math(掌握)
(1)针对数学运算进行操作的类
(2)常见方法(自己补齐)
A:绝对值
B:向上取整
C:向下取整
D:两个数据中的大值
E:a的b次幂
F:随机数
G:四舍五入
H:正平方根
(3)案例：
A:猜数字小游戏
B:获取任意范围的随机数

3:Random(理解)
(1)用于产生随机数的类
(2)构造方法:
A:Random() 默认种子，每次产生的随机数不同
B:Random(long seed) 指定种子，每次种子相同，随机数就相同
(3)成员方法:
A:int nextInt() 返回int范围内的随机数
B:int nextInt(int n) 返回[0,n)范围内的随机数

4:System(掌握)
(1)系统类,提供了一些有用的字段和方法
(2)成员方法(自己补齐)
A:运行垃圾回收器
B:退出jvm
C:获取当前时间的毫秒值
D:数组复制

5:BigInteger(理解)
(1)针对大整数的运算
(2)构造方法
A:BigInteger(String s)
(3)成员方法(自己补齐)
A:加
B:减
C:乘
D:除
E:商和余数

6:BigDecimal(理解)
(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法
A:BigDecimal(String s)
(3)成员方法：
A:加
B:减
C:乘
D:除
E:自己保留小数几位

7:Date/DateFormat(掌握)
(1)Date是日期类，可以精确到毫秒。
A:构造方法
Date()
Date(long time)
B:成员方法
getTime()
setTime(long time)
C:日期和毫秒值的相互转换
案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
A:SimpleDateFormat(String pattern) 给定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的转换
a:Date – String
format()

b:String -- Date
parse()
C:案例：
制作了一个针对日期操作的工具类。

8:Calendar(掌握)
(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
C:设置日历对象的年月日
(4)案例：
计算任意一年的2月份有多少天?

package cn.itcast_01;

import java.util.Scanner;

校验qq号码：
```
1.要求必须是5-15位数字
```
```
2.0不能开头
```

*/
public class RegexDemo {
public static void main(String[] args) {
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你的QQ账号：”);
String s = sc.nextLine();

// 调用方法1
boolean b = checkQQ(s);
if(b){
System.out.println("校验成功！");
}else{
System.out.println("输入错误！");
}
System.out.println("--------------------");

// 调用方法2
boolean b2 = checkQQ(s);
if(b2){
System.out.println("校验成功！");
}else{
System.out.println("输入错误！");
}
System.out.println("--------------------");

}

// 方法1 自创笨方法
public static boolean checkQQ(String s){
boolean flag = true;
// 验证字符串长度
if(s.length()<5||s.length()>15){
flag = false;
return flag;
}

// 必须都是数字，且开头不能是0
// 将字符串转化成字符数组
char arr [] =s.toCharArray();

// 判断开头是否为0
if(arr[0]=='0'){
flag=false;
return flag;
}

// 判断是否都为数字
for(int x =0;x<arr.length;x++ ){
if(!(arr[x]=='0'||arr[x]=='1'||arr[x]=='2'||arr[x]=='3'||arr[x]=='4'||arr[x]=='5'||arr[x]=='6'||arr[x]=='7'
||arr[x]=='8'||arr[x]=='9')){
flag = false;
return flag;
}
}
return flag;
}

// 方法2 主要是调用java方法
public static boolean checkQQ2(String s ){
// 定义一个返回值变量
boolean flag = true;

// 判断字符串长度
if(s.length()>=5&&s.length()<=15){
if(!s.startsWith("0")){
char arr [] = s.toCharArray();
for(int x=0;x<arr.length;x++){
if(!Character.isDigit(arr[x])){
flag =false;
return flag;
}
}
}else{
flag =false;
return flag;
}

}else{
flag = false;
return false;
}
return flag;

}

package cn.itcast_01;

import java.util.Scanner;

正则表达式：符合一定规则的字符串。
*/
public class RegexDemo2 {
public static void main(String[] args) {
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你的QQ账号：”);
String s = sc.nextLine();
```
// 调用方法1
boolean b = checkQQ(s);
if(b){
System.out.println("校验成功！");
}else{
System.out.println("输入错误！");
}
```
}
public static boolean checkQQ(String s){
String Regex ="[1-9][0-9]{4,14}";
// public boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
boolean flag = s.matches(Regex);
return flag;
}
}

A:字符
x 字符 x。举例：‘a’表示字符a
\ 反斜线字符。
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\ua000D’)

B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括

C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? .
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi

E:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

--------------------------知识点1----------------------------------
package cn.itcast_02;

import java.util.Scanner;

判断功能
public boolean matches(String regex)

需求：
判断手机号码是否满足要求

分析：
1.键盘录入手机号
2.定义手机号码的规则
13246578981
18217228963
13123457896
13134539875
```
3.调用功能，判断即可
4.输出结果
```
*/
public class RegexDemo {
public static void main(String[] args) {
// 键盘录入手机号码
Scanner sc = new Scanner(System.in);
// 提示信息
System.out.println(“请输入手机号码：”);
String s = sc.nextLine();

// 定义规则
String Regex =“1[38]\d{9}”;
System.out.print(s);
System.out.println(" "+s.matches(Regex));

}
}
--------------------------知识点2----------------------------------
package cn.itcast_02;

import java.util.Scanner;

需求：
校验邮箱

分析：
1.键盘录入邮箱
2.定义手机号码的规则
15135678976@qq.com
liuyi@163.com
lingqingxia@126.com
fengqingyang@sina.com.cn
fqy@itcast.cn
3.调用功能，判断即可
4.输出结果
*/
public class RegexTest {
public static void main(String[] args) {
// 键盘录入邮箱
Scanner sc = new Scanner(System.in);
// 提示信息
System.out.println(“请输入邮箱：”);
String email = sc.nextLine();
```
// 定义规则
String Regex ="[a-zA-Z_0-9]+@[a-zA-Z_0-9]+(\\.[a-zA-Z_0-9]{2,3})+";
System.out.print(email);
System.out.println(" "+email.matches(Regex));
```
}
}
--------------------------知识点3----------------------------------
package cn.itcast_03;
/*
分割功能练习

*/
public class RegexDemo {
public static void main(String[] args) {
// 定义字符串1
String s1 = “aa,bb,cc”;

// 直接分割
String [] str1Array = s1.split(",");
for(int x=0;x<str1Array.length;x++){
System.out.println(str1Array[x]);
}
System.out.println("-----------------");

// 定义字符串2
String s2 = "aa bb cc";
// 直接分割
String [] str2Array = s2.split(" ");
for(int x=0;x<str2Array.length;x++){
System.out.println(str2Array[x]);
}
System.out.println("-----------------");

// 定义字符串3
String s3 = "aa  bb       cc";
// 直接分割
String [] str3Array = s3.split(" +");
for(int x=0;x<str3Array.length;x++){
System.out.println(str3Array[x]);
}
System.out.println("-----------------");

// 定义字符串4    硬盘上的路径我们用\\表示
String s4 = "C:\\Users\\wudi\\Desktop\\Java API";
// 直接分割
String [] str4Array = s4.split("\\\\");
for(int x=0;x<str4Array.length;x++){
System.out.println(str4Array[x]);
}
System.out.println("-----------------");

// 定义字符串5
String s5 = "aa.bb.cc";
// 直接分割
String [] str5Array = s5.split("\\.");
for(int x=0;x<str5Array.length;x++){
System.out.println(str5Array[x]);
}
System.out.println("-----------------");

}
}
--------------------------知识点4----------------------------------
package cn.itcast_03;

import java.util.Scanner;

分割功能
public String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串。

需求：
```
qq搜索好友：
```
```
性别：女
```
```
范围："18-24"
```
```
age>=18&&age<=24
```

*/
public class RegexDemo2 {
public static void main(String[] args) {
// 定义一个字符串
String age = “18-24”;

// 定义以规则
String Regex = "-";

// 调用方法
String [] Stringarr = age.split(Regex);

// 将字符串转化成int类型数据
int startAge = Integer.parseInt(Stringarr[0]);
int endAge = Integer.parseInt(Stringarr[1]);

// 键盘录入数据
Scanner sc = new Scanner(System.in);
// 提示输入数据
System.out.println("请输入年龄：");
// 接收数据
int yourAge = sc.nextInt();

if(yourAge>=startAge && yourAge<=endAge){
System.out.println("你是我想找的");
}else{
System.out.println("你不是我要找的，你走吧");
}

}
}
--------------------------知识点5----------------------------------
package cn.itcast_03;

import java.util.Arrays;

分割功能：
我有如下一个字符串:”91 27 46 38 50”
请写代码实现最终输出结果是：”27 38 46 50 91”

*/
public class RegexTest {
public static void main(String[] args) {
// 定义字符串
String s = “91 27 46 38 50”;

// 调用方法
System.out.println(method(s));

}
public static String method(String s){
// 将字符串进行分割
String [] stringArray = s.split(" ");
int arr []=new int [stringArray.length];

// 将字符串数组转化成int类型数组
for(int x=0;x<stringArray.length;x++){
arr[x] = Integer.parseInt(stringArray[x]);
}

// 数组进行排序
Arrays.sort(arr);

// 将数组转换成指定格式字符串
String s1 ="\"";
for(int x =0;x<arr.length;x++){
if(x==arr.length-1){
s1 +=arr[x];
}else{
s1 +=arr[x];
s1 +=" ";
}
}
s1 +="\"";
return s1;

}
}
--------------------------知识点6----------------------------------
package cn.itcast_04;
/*

替换功能：
论坛中不能出现数字字符，用*替换

public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串

*/
public class RegexDemo {
public static void main(String[] args) {
// 定义一个字符串
String s = “h7e9l4l4ow6o6r84ldwo33aijava”;
```
// 定义正则表达式
String regex = "\\d";
String ss = "*";
String s2 = s.replaceAll(regex, ss);
System.out.println(s2);
```
}
}
--------------------------知识点7----------------------------------
package cn.itcast_05;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

获取功能
Pattern和Matcher类的使用

*/
public class RegexDemo {
public static void main(String[] args) {

// 模式匹配器的调用模式
// 指定为字符串的正则表达式必须首先被编译为此类的实例。
Pattern p = Pattern.compile("a*b");
// 通过模式对象得到匹配器对象，这个是被需要匹配的字符串
Matcher m = p.matcher("aaaaab");
// 调用匹配器对象功能
boolean b = m.matches();
System.out.println(b);

// 这个判断有点复杂，我们直接用字符串做
String s ="aaaaab";
String regex = "a*b";
boolean result = s.matches(regex);
System.out.println(result);

}

}
--------------------------知识点8----------------------------------
package cn.itcast_05;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

获取功能：
获取由三个字符组成的单词
qw,e,err,da,ssf,a,sdf,fa,adf,fas,fafda,fawer,fafdgh,afaq,wwer,eee,ddf,fawy,ghrs,sgd,qwert

*/
public class RegexDemo2 {
public static void main(String[] args) {
// 定义字符串
String s =“qw,e,err,da,ssf,a,sdf,fa,adf,fas,fafda,fawer,fafdgh,afaq,wwer,eee,ddf,fawy,ghrs,sgd,qwert”;

// 定义正则表达式
String regex = "\\b\\w{3}\\b";

// 把规则编译成模式对象
Pattern p = Pattern.compile(regex);

// 通过模式对象得到匹配对象
Matcher m = p.matcher(s);

// 调用匹配器功能
//boolean result = m.matches();
https://System.out.println(result);

// boolean b = m.find();
// System.out.println(b);
// String ss = m.group();
// System.out.println(ss);
//
// b = m.find();
// https://System.out.println(b);
// String ss1 = m.group();
// System.out.println(ss1);
// System.out.println("------------");

// 循环改进
// 注意： 错误java.lang.IllegalStateException:
// 在调用group之间必须先调用find方法
// while(m.find()){
String ss2 = m.group();
System.out.println(ss2);
// }
}

}
--------------------------知识点9----------------------------------
package cn.itcast_01;

public class Person {

// 成员变量
private String name;
private int age;

// 构造方法
public Person(){}

public Person(String name,int age){
this.age = age;
this.name = name;
}

// 获取方法
public String getName() {
return name;
}

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

public int getAge() {
return age;
}

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

@Override
public String toString() {
return "Person [name="+ name +",age="+age+"]";
}

@Override
protected void finalize() throws Throwable {
System.out.println("当前对象被回收了"+this);
super.finalize();
}

}
--------------------------知识点10----------------------------------
package cn.itcast_01;
/*

System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法：

public static void gc() ：运行垃圾回收器
public static void exit(int status)
public static long currentTimeMillis()
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

*/
public class SystemDemo {
public static void main(String[] args) {
Person p = new Person(“赵雅芝”,60);
System.out.println§;
```
p=null;
System.gc();
```
}
}

--------------------------知识点11----------------------------------
package cn.itcast_02;
/*

System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法：

public static void gc() ：运行垃圾回收器
public static void exit(int status):终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
public static long currentTimeMillis():返回以毫秒为单位的当前时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

*/
public class SystemDemo {
public static void main(String[] args) {
https://System.out.println(“林青霞”);
https://System.exit(0);
https://System.out.println(“赵雅芝”);

System.out.println(System.currentTimeMillis());

// 统计程序运行时间
long start = System.currentTimeMillis();
for(int x=0;x<10000;x++){
System.out.println("hello world");
}
long end = System.currentTimeMillis();
System.out.println("程序运行总时间："+(end-start)+"毫秒");

}
}
--------------------------知识点12----------------------------------
package cn.itcast_03;

import java.util.Arrays;

System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法：

public static void gc() ：运行垃圾回收器
public static void exit(int status):终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
public static long currentTimeMillis():返回以毫秒为单位的当前时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

*/
public class SystemDemo {
public static void main(String[] args) {
// 定义数组
int [] arr = {11,22,33,44,55,66};
int [] arr2 = {1,2,3,4,5,6};
```
System.arraycopy(arr, 1, arr2, 2, 2);

System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
```
}
}
--------------------------知识点13----------------------------------
package cn.itcast_01;

import java.util.Random;

Random:产生随机数的类
构造方法：
Random() ：没有给种子，用的是默认种子，当前时间是毫秒级
创建一个新的随机数生成器。

Random(long seed) ：给出指定的种子
使用单个 long 种子创建一个新的随机数生成器。

给定种子后，每次得到的随机数相同。
成员方法：

public int nextInt()：返回的是int范围类的随机数
public int nextInt(int n)：返回的是[0,n)之间的随机数。

*/
public class RandomDemo {
public static void main(String[] args) {
// 创建对象
Random r = new Random(10); // 给定种子

for(int x =0;x<10;x++){
// public int nextInt()：返回的是int范围类的随机数
int num = r.nextInt();
System.out.println("num:"+num);
}
System.out.println("-------------------");

for(int x =0;x<10;x++){
// public int nextInt(int n)：返回的是[0,n)之间的随机数。
int num1 = r.nextInt(10);
System.out.println("num1:"+num1);
}
System.out.println("-------------------");

}
}
--------------------------知识点14----------------------------------
package cn.itcast_01;
/*

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
成员变量：
E
public static final double E
比任何其他值都更接近 e（即自然对数的底数）的 double 值。

PI
public static final double PI
比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

成员方法：
public static int abs(int a)：绝对值
public static double ceil(double a)：向上取整数
public static double floor(double a)：向下取整
public static int max(int a,int b) ：最大值
public static double pow(double a,double b)：a的b次幂
public static double random()：随机数[0.0,1)
public static int round(float a) :四舍五入
public static double sqrt(double a)：正平方根

*/
public class MathDemo {
public static void main(String[] args) {
//public static final double E
System.out.println(“E:”+Math.E);

//public static final double PI
System.out.println("PI:"+Math.PI);

// public static int abs(int a)：绝对值
System.out.println("abs:"+Math.abs(-1));

// public static double ceil(double a)：向上取整数
System.out.println("ceil:"+Math.ceil(-1.9288));

//public static double floor(double a)：向下取整
System.out.println("floor:"+Math.floor(-1.9288));

// public static int max(int a,int b) ：最大值
System.out.println("max:"+Math.max(-1.9288,2));

// 	public static double pow(double a,double b)：a的b次幂
System.out.println("pow:"+Math.pow(2,3));

// public static double random()：随机数[0.0,1)
System.out.println("random:"+Math.random());

// public static int round(float a) :四舍五入
System.out.println("round:"+Math.round(1.23));

// public static double sqrt(double a)：正平方根
System.out.println("sqrt:"+Math.sqrt(4));

}
}
--------------------------知识点15----------------------------------
package cn.itcast_02;

import java.util.Scanner;

获取任意区间的随机数
分析：

1.键盘录入两个数据start，end；

```
2.随机获取之间的一个随机数
```
```
写一个功能实现
```
```
注意：Math.random() [0.0,1.0)
```
```
3.输出随机数
```
*/
public class MathDemo {
public static void main(String[] args) {
// 键盘录入边界区间数据
Scanner sc = new Scanner(System.in);
// 提示输入数据
System.out.println(“请输入区间左边界：”);
int start = sc.nextInt();
System.out.println(“请输入区间右边界：”);
int end = sc.nextInt();
for(int x=0;x<100;x++){
// 调用方法
System.out.println(“随机数：”+method(start,end));
}
}
public static int method(int start ,int end){
int c = end-start+1;
int result =(int)(Math.random()*c+start);
return result;
}
}
--------------------------知识点16----------------------------------
package cn.itcast_01;

import java.math.BigInteger;

/*
*

*/
public class BigIntegerDemo {
public static void main(String[] args) {
Integer i1 =new Integer(100);
System.out.println(i1);

Integer i2=new Integer(Integer.MAX_VALUE);
System.out.println(i2);

Integer i3=new Integer("2147483647");
System.out.println(i3);

// NumberFormatException
//Integer i4=new Integer("2147483648");
https://System.out.println(i4);

// 通过大整数来创造对象
BigInteger bi = new BigInteger("2147483648");
System.out.println("bi:"+bi);

}
}
--------------------------知识点17----------------------------------
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 bi = new BigInteger(“100”);
BigInteger bi2 = new BigInteger(“50”);
//public BigInteger add(BigInteger val)：加
System.out.println(“add:”+bi.add(bi2));

//public BigInteger subtract(BigInteger val)：减
System.out.println(“subtract:”+bi.subtract(bi2));

//public BigInteger multiply(BigInteger val)：乘
System.out.println(“multiply:”+bi.multiply(bi2));

//public BigInteger divide(BigInteger val)：除
System.out.println(“divide:”+bi.divide(bi2));

//public BigInteger[] divideAndRemainder(BigInteger val)：返回商和余数的数组
BigInteger [] arr = bi.divideAndRemainder(bi2);
System.out.println(“商：”+arr[0]);
System.out.println(“余:”+arr[1]);
}
}
--------------------------知识点18----------------------------------
package cn.itcast_01;
/*
看程序写结果:结果和我们想的有点不一样，因为float类型的数据存储和整数不一样导致，他们大部分时候，都带有有效数字位。

为了能精确的表示、计算浮点数，Java提供了BigDecimal。

由于在运算的时候，float类型和double很容易丢失精度

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.015100);
System.out.println(1.301 /100);
```
System.out.println( 1.0- 0.12);
```
}
}
--------------------------知识点19----------------------------------
package cn.itcast_02;

import java.math.BigDecimal;

构造方法：
public BigDecimal(String val)
将 BigDecimal 的字符串表示形式转换为 BigDecimal。
字符串表示形式由可选符号 ‘+’ (’\u002B’) 或 ‘-’ (’\u002D’) 组成，
后跟零或多个十进制数字（“整数”）的序列，可以选择后跟一个小数，
也可以选择后跟一个指数。
运算方法：
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) {
https://System.out.println(0.09 + 0.01);
https://System.out.println(1.0 - 0.32);
https://System.out.println(1.015100);
https://System.out.println(1.301 /100);
https://System.out.println( 1.0- 0.12);

//public BigDecimal add(BigDecimal augend)
BigDecimal bd = new BigDecimal(“0.01”);
BigDecimal bd2 = new BigDecimal(“0.09”);
System.out.println(“add:”+bd.add(bd2));

//public BigDecimal subtract(BigDecimal subtrahend)
bd = new BigDecimal(“1.0”);
bd2 = new BigDecimal(“0.32”);
System.out.println(“subtract:”+bd.subtract(bd2));
System.out.println("---------------");

//public BigDecimal multiply(BigDecimal multiplicand)
bd = new BigDecimal(“1.015”);
bd2 = new BigDecimal(“100”);
System.out.println(“multiply:”+bd.multiply(bd2));
System.out.println("---------------");

//public BigDecimal divide(BigDecimal divisor)
bd = new BigDecimal(“1.301”);
bd2 = new BigDecimal(“100”);
System.out.println(“divide:”+bd.divide(bd2));
System.out.println("---------------");

//public BigDecimal divide(BigDecimal divisor,int scale,
// int roundingMode) :商几位，小数如何舍去
bd = new BigDecimal(“1.301”);
bd2 = new BigDecimal(“100”);
System.out.println(“BigDecimal divide:”+bd.divide(bd2,4,BigDecimal.ROUND_HALF_UP));
}
}
--------------------------知识点20----------------------------------
package cn.itcast_01;

import java.util.Date;

类 Date 表示特定的瞬间，精确到毫秒
构造方法：
Date()
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间
（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）
以来的指定毫秒数。
*/
public class DateDemo {
public static void main(String[] args) {
// 创建对象
Date d = new Date();
System.out.println(d);
```
long time = System.currentTimeMillis();
Date d1 = new Date(time);
System.out.println(d1);
```
}
}
--------------------------知识点21----------------------------------
package cn.itcast_02;

import java.util.Date;

成员方法：
public long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT
以来此 Date 对象表示的毫秒数。
public void setTime(long time)
设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT
以后 time 毫秒的时间点。
*/
public class DateDemo {
public static void main(String[] args) {
// 创建对象
Date d = new Date();
System.out.println(d.getTime());
System.out.println("-------------");
```
d.setTime(1000);
System.out.println(d);
```
}
}
--------------------------知识点22----------------------------------
package cn.itcast_01;

import java.util.Calendar;

Calendar 类是一个抽象类，它为特定瞬间与一组诸如
```
YEAR、MONTH、DAY_OF_MONTH、HOUR
```

等 日历字段之间的转换提供了一些方法，并为操作日历字段

（例如获得下星期的日期）提供了一些方法

public int get(int field):返回给定日历字段的值。

日历类中的每个字段都是静态的成员变量，并且是int类型。

Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。

Calendar 的 getInstance 方法返回一个 Calendar 对象，

其日历字段已由当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();

*/
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 day = rightNow.get(Calendar.DAY_OF_MONTH);

// 时
int hour = rightNow.get(Calendar.HOUR_OF_DAY);

// 分
int minute = rightNow.get(Calendar.MINUTE);

// 秒
int second = rightNow.get(Calendar.SECOND);

System.out.println(year+"年"+(month+1)+"月"+day+"日  "+hour+":"+minute+":"+second);

}
}
--------------------------知识点23----------------------------------
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 Nowtime = Calendar.getInstance();

// 获取年
int year = Nowtime.get(Calendar.YEAR);

// 获取月
int month  = Nowtime.get(Calendar.MONTH);

// 获取日
int day  = Nowtime.get(Calendar.DATE);

System.out.println(year+"年"+month+"月"+day+"日");

// 	public void add(int field,int amount):根据给定的日历字段和对应的时间，来对当前的日历进行操作

// 获取年
Nowtime.add(Calendar.YEAR, -1);
year = Nowtime.get(Calendar.YEAR);

// 获取月
month = Nowtime.get(Calendar.MONTH);

// 获取日
day = Nowtime.get(Calendar.DATE);

Nowtime.add(Calendar.YEAR, -1);
System.out.println(year+"年"+month+"月"+day+"日");
System.out.println("-----------------------------");

// 直接设置年月日
Nowtime.set(2011,11,11);
// 获取年
Nowtime.add(Calendar.YEAR, -1);
year = Nowtime.get(Calendar.YEAR);

// 获取月
month = Nowtime.get(Calendar.MONTH);

// 获取日
day = Nowtime.get(Calendar.DATE);

Nowtime.add(Calendar.YEAR, -1);
System.out.println(year+"年"+month+"月"+day+"日");
System.out.println("-----------------------------");

}
}
--------------------------知识点24----------------------------------
package cn.itcast_02;

import java.util.Calendar;
import java.util.Scanner;

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

分析：
1.键盘录入年份
2.设置日历为
年：键盘录入
月： 2
日：1
3.往前减一天，得到日数

*/
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日

// 获取日
int day = c.get(Calendar.DATE);

// 减1天
c.add(Calendar.DATE, -1);

day = c.get(Calendar.DATE);

// 输出结果
System.out.println(year+"年的2月有"+day+"天.");

}
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航