常见对象中的问题4
14.01如何校验一个QQ号码案例
/*
需求：
校验QQ号码
要求必须是5-15位数字
0不能开头
分析：
A:键盘录入一个QQ号码
B:写一个功能实现校验
C:调用功能，输出结果
*/
public class RegexDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的QQ号码：");
String qq = sc.nextLine();
System.out.println("checkQQ:" +checkQQ(qq));
}
/*
写一个功能校验
两个明确：
明确返回值类型：boolean
明确参数列表:String qq
*/
public static boolean checkQQ(String qq) {
boolean flag = true;
//校验长度
if(qq.length()>=5 && qq.length()<=15) {
//0不能开头
if(!qq.startsWith("0")) {
//必须是数字
char[] chs = qq.toCharArray();
for(int x = 0;x<chs.length;x++) {
char ch = chs[x];
if(!Character.isDigit(ch)) {
flag = false;
break;
}
}
}else {
flag = false;
}
}else {
flag = false;
}
return flag;
}
}
14.02正则表达式的概述和基本使用
/*
正则表达式：符合一定规则的字符串
是指一个用来藐视或者匹配一系列符合某个句法规则的字符串的
单个字符串，其实就是第一种规则。有自己特殊的应用。
*/
14.03正则表达式的组成规则
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单词边界
就是不是单词的地方
举例：djadj a jdaodl/da…dads/d/sa.?D
E:Greedy数量词
X?X.一次或一次也没有
X*X,零次或多次
X+X,一次或多次
X{N} X,恰好n次
X{N, }X,至少n次
X{n,m} X,至少n次，但是不超过m次
14.04手机号的检测
import java.util.Scanner;
/*
判断功能
public boolean matches(String regex)
分割功能
public String[] split(String regex)
替换功能
public String replaceAll(String regex,String replacement)
获取功能
Pattern和Matcher类的使用
*/
public class RegexDemo {
//需求：判断手机号码是否满足要求
public static void main(String[] args) {
//A:键盘录入手机号
Scanner sc = new Scanner(System.in);
System.out.println("请输入手机号：");
String phone = sc.nextLine();
//B:定义手机号码规则
String regex = "1\\d{10}";
//C:调用方法
boolean flag = phone.matches(regex);
//输出
System.out.println("flag:"+flag);
}
}
14.05邮箱检测
import java.util.Scanner;
public class RegrxTest {
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]{2,6}\\.[a-zA-Z_0-9] {2,3}";
//调用结果(定义变量=变量名.方法调规则)
boolean flag = email.matches(regex);
System.out.println(flag);
}
}
14.06正则表达式的分割功能
import java.util.Scanner;
public class RegexDemo {
public static void main(String[] args) {
//定义一个年龄搜索范围
String ages = "18-24";
//定义规则
String regex = "-";
//调用方法
String[] strArray = ages.split(regex);
//如何得到Int类型呢？
int startAge = Integer.parseInt(strArray[0]);
int endAge = Integer.parseInt(strArray[1]);
//键盘录入年龄
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄：");
int age = sc.nextInt();
//判断范围
if(age >= startAge && age<=endAge) {
System.out.println("你是我的菜");
}else if(age>endAge){
System.out.println("你真丑，滚");
}else if(age<startAge) {
System.out.println("你太小了在过几年吧");
}
}
}
14.07分割功能
public class RegexDemo2 {
public static void main(String[] args) {
//定义一个字符串
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("-----------------------");
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("-----------------------");
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("-----------------------");
String s4 = "C:\\Users\\1\\Desktop\\JAVA_Movies\\day14\\avi";
String[] str4Array = s4.split("\\\\");
for(int x = 0;x <str4Array.length;x++) {
System.out.println(str4Array[x]);
}
System.out.println("-----------------------");
}
}
14.08把字符串中的数字排序案例
import java.util.Arrays;
/*
我有如下一个字符串："91 27 46 38 50"
请写代码实现最终输出结果是:"27 38 46 50 91"
分析：
A:定义一个字符串
B:把字符串进行分割，得到一个字符串数组
C:把字符串数组变成int数组
D:对Int数组排序
E:把排序后的Int数组在组装成一个字符串
F:输出字符串
*/
public class RegexTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//把字符串进行分割，得到一个字符串数组
String[] strArray = s.split(" ");
//把字符串数组转换成int数组
int[] arr = new int[strArray.length];
//遍历字符串，并且把字符串strArray[x]的数据赋值给arr[x]
for(int x =0;x <arr.length;x++) {
arr[x] = Integer.parseInt(strArray[x]);
}
//利用Arrays方法对Int数组排序
Arrays.sort(arr);
//把排序后的Int数组在组装成一个字符串创建对象
StringBuilder sb = new StringBuilder();
//遍历数组，链式编程添加每个元素后加" "空格
for(int x = 0 ;x < arr.length;x++) {
sb.append(arr[x]).append(" ");
}
//去除最后一个空格
String result = sb.toString().trim();
//输出字符串
System.out.println("result:" +result);
}
}
14.09正则表达式的替换功能
/*
替换功能：
public String replaceAll(String regex,
String replacement)
用给定的替换替换与给定的regular expression匹配的此字符串的每个子字符串。
*/
public class RegexDemo {
public static void main(String[] args) {
//public String replaceAll(String regex,String replacement)
//用字符串替换给定字符串
String s = "你好啊135464486742546435dsadad";
//我要去除所有的数字，用*代替
String regex = "\\d";
String ss = "*";
String result = s.replaceAll(regex, ss);
System.out.println("替换结果是："+result);
}
}
14.10Pattetn和Matcher的概述
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 = "aaaab";
String regex = "a*b";
boolean bb = s.matches(regex);
System.out.println(bb);
}
}
14.11Math类的概述和方法使用
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
da jia ting wo shuo,jin tian xia yu ,bu shang wan zi xi,gao xing bu?
步骤：
A:把正则表达式编译成模式对象
B:通过模式对象得到匹配器对象
C:调用匹配对象的功能
*/
public class RegexDemo2 {
public static void main(String[] args) {
//定义字符串
String s = "da jia ting wo shuo,jin tian xia yu ,bu shang wan zi xi,gao xing bu?";
//规则
String regex = "\\b\\w{3}\\b";
//把规则编译成模式对象
Pattern p = Pattern.compile(regex);
//通过模式对象得到匹配器对象
Matcher m = p.matcher(s);
//调用匹配器对象的功能
//通过find方法就是查找有没没有满足条件的子串
//public boolean find();
boolean flag = m.find();
System.out.println(flag);
//如何得到值
//注意：一定要先find(),才能group()
//public String group();
String ss = m.group();
System.out.println(ss);
//用循环改进
while(m.find()) {
System.out.println(m.group());
}
}
}
14.12Math类概述和使用方法
/*
Math：用于算数运算的类
成员变量：public static final double PI
public static final double E
成员方法：
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 int min(int a ,int b)：最小值
public static double pow(double a ,double b):a的b次幂
public static double random():随机数[0.0,1.0]
public static int round(float a)：四舍五入
public static int round(double a)：四舍五入
public static double sqrt(double a):正平方根
*/
public class MathDemo {
public static void main(String[] args) {
//public static final double PI
System.out.println("PI:"+Math.PI);
//public static final double E
System.out.println("E:"+Math.E);
System.out.println("-----------------");
//public static int abs(int a):绝对值
System.out.println("abs:"+Math.abs(10));
System.out.println("abs:"+Math.abs(-10));
System.out.println("------------------");
//public static double ceil(double a):向上取整（天花板）
System.out.println("ceil:"+Math.ceil(12.00000001));
System.out.println("ceil:"+Math.ceil(12.999999999));
System.out.println("------------------");
//public static double floor(double a):向下取整（地板）
System.out.println("floor:"+Math.floor(12.000001));
System.out.println("floor:"+Math.floor(12.999999999));
System.out.println("------------------");
//public static int max(int a ,int b)：最大值
System.out.println("max:"+Math.max(10, 20));
//public static int min(int a ,int b)：最小值
System.out.println("min:"+Math.min(10, 20));
System.out.println("------------------");
//public static double pow(double a ,double b):a的b次幂
System.out.println("POW:"+Math.pow(2,3));
System.out.println("--------------------");
//public static double random():随机数[0.0,1.0]
System.out.println("random:"+Math.random());
System.out.println("----------------------");
//double和float的精准度不同
//public static int round(float a)：四舍五入
System.out.println("round:"+Math.round(5.6));
//public static int round(double a)：四舍五入
System.out.println("round:"+Math.round(5.6));
System.out.println("---------------------");
//public static double sqrt(double a):正平方根
System.out.println("sqrt:"+Math.sqrt(4));
}
}
14.13如何获取任意范围内的随机数案例
import java.util.Scanner;
/*
需求：请设计一个方法，可以实现获取任意范围内的随机数
分析：
A:键盘录入两个数据
int start
int end
B:想办法获取 在start到end之间的随机数
我写一个功能实现这个效果，得到一个随机数
C:输出这个随机数
*/
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<Math.random();x++) {
int num = getRandom(start, end);
System.out.println(num);
}
}
/*
写一个功能
两个明确：
返回值类型：int
参数列表：int start,int end
*/
public static int getRandom(int start,int end) {
int number = (int)(Math.random()*(end - start+1))+start;
return number;
}
}
14.14Random类的概述和使用方法
import java.util.Random;
/*
Random：产生随机数的类
构造方法：
public Random();没有给种子，用的是默认种子，是当前时间的毫秒值
public Random(long seed):给出指定的种子，随机数一样
成员方法：
public int nextInt()：返回的是Int范围内的随机数
public int nextint(int n ):反教会的是0到n的随机数
*/
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//int num = r.nextInt();返回的是Int范围内的随机数
int num = r.nextInt(10);
System.out.println(num);
}
}
14.15System类中exit()的方法
/*
System类包含一些有用的字段和方法，他不能被实例化
方法：
public static void gc():运行垃圾回收器
public static void exit(int status):种植当前正在运行的JAVA虚拟机。参数用作状态码；根据惯例，非0的状态码表示异常终止
System.out.println(System.currentTimeMillis());
*/
public class SystemDemo {
public static void main(String[] args) {
// System.out.println("我喜欢奥利给");
// System.exit(0);
// System.out.println("奥利给喜欢我");
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for(int x = 0;x<1000000;x++) {
System.out.println("hello"+x);
}
long end = System.currentTimeMillis();
System.out.println("此次运行共消耗时间"+(end-start)/1000+"秒");
}
}
14.17System类中的arraycopy(）
import java.util.Arrays;
/*
System类包含一些有用的字段和方法，他不能被实例化
方法：
public static void gc():运行垃圾回收器
public static void exit(int status):种植当前正在运行的JAVA虚拟机。参数用作状态码；根据惯例，非0的状态码表示异常终止
System.out.println(System.currentTimeMillis());
public statci void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
参数：
src-源数组
srcPos-源素组中的起始位置
dest-目标数组
destPos-目标数组中的起始位置
length-要复制的数组元素的数量
*/
public class SystemDemo {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};
int[] arr2 = {6,7,8,9,10};
//将第二个数组第二个位置复制第一个数组第一个位置往后数两个元素替换数组二的位置
System.arraycopy(arr, 1, arr2, 2, 2);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
}
}
14.18BigInteger的概述和构造方法
import java.math.BigInteger;
public class BigIntergerDemo {
public static void main(String[] args) {
//将int类型的100转化为包装类100；
Integer i = new Integer(100);
System.out.println(i);
//int范围的最大值
//System.out.println(Integer.MAX_VALUE);
Integer ii = new Integer("2147483647");
System.out.println(ii);
//java.lang.NumberFormatException（格式化有问题）
// Integer iii = new Integer("2147483648");
// System.out.println(iii);
//更大的整数，需要导包在Math包下
BigInteger b = new BigInteger("2147483648");
System.out.println(b);
}
}
14.19BigInteger的加减乘除的使用
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对象
BigInteger b1 = new BigInteger("100");
BigInteger b2 = new BigInteger("50");
//加法
System.out.println("加："+b1.add(b2));
//减法
System.out.println("减："+b1.subtract(b2));
//乘法
System.out.println("乘:"+b1.multiply(b2));
//除法
System.out.println("除："+b1.divide(b2));
System.out.println("--------------------");
//商和余数
BigInteger[] big = b1.divideAndRemainder(b2);
System.out.println("商："+big[0]);
System.out.println("余："+big[1]);
}
}
14.21BigDecimal的加减乘除法的使用
import java.math.BigDecimal;
/*
构造方法：
public BigDecimal(String val)
public BigDecimal add(BigDecimal augend)
public BigDecimal subract(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) {
BigDecimal big1 = new BigDecimal("0.09");
BigDecimal big2 = new BigDecimal("0.01");
//加
System.out.println("add:"+big1.add(big2));
//减
System.out.println("subtract:"+big1.subtract(big2));
//乘
System.out.println("multiply:"+big1.multiply(big2));
//除
System.out.println("divide:"+big1.divide(big2));
//dig1..
System.out.println("divide:"+big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP));
}
}
14.27Calendar类的概述和获取日历字段的方法
import java.util.Calendar;
/*
Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH
DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为
操作日历字段提供一些方法
成员方法：
public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int data)
*/
public class CalendarDemo {
public static void main(String[] args) {
//其日历字段已由当前日期和时间初始化
Calendar c = Calendar.getInstance();
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year);
//获取月，月从0 开始所以要加1
int month = c.get(Calendar.MONTH);
System.out.println(month);
int date = c.get(Calendar.DATE);
System.out.println(date);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
}
}
14.28Calendar类的add()和set()方法
import java.util.Calendar;
/*
p public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int data)
*/
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, 5);
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year);
//获取月，月从0 开始所以要加1
int month = c.get(Calendar.MONTH);
System.out.println(month);
int date = c.get(Calendar.DATE);
System.out.println(date);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
c.add(Calendar.MONTH, 10);
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH);
date = c.get(Calendar.DATE);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
//public final void set(int year,int month,int date)设置当前日历的年月日
c.set(2055, 1, 1);
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH);
date = c.get(Calendar.DATE);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
}
}
14.29如何获取任意年费的2月份有多少天案例
/*
获取任意一年的二月有多少天
分析：
A:键盘录入任意的年份
B:设置日历对象的年月日
年就是A输入的数据
月是2
日是1
C:把时间往前推一天就是二月的最后一天
D:获取这一天输出即可
*/
import java.util.Calendar;
import java.util.Scanner;
public class CalendarDemo {
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);
//把时间往前推一天，就一定是二月的最后一天
c.add(Calendar.DATE, -1);
System.out.println(c.get(Calendar.DATE));
}
}
总结
1.正则表达式（Regex）
（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单词边界
就是不是单词的地方
举例：djadj a jdaodl/da…dads/d/sa.?D
E:Greedy数量词
X?X.一次或一次也没有
X
X,零次或多次
X+X,一次或多次
X{N} X,恰好n次
X{N, }X,至少n次
X{n,m} X,至少n次，但是不超过m次
（3）常见功能：
A:判断功能public boolean matches(String regex)
B:分割功能public String[] split(String regex)
C:替换功能public String replaceAll(String regex,
String replacement)
D:获取功能
Pattern p = Pattern.compile(“a
b”);
Matcher m = p.matcher(“aaaaab”);
find();查找存不存在
group():获取刚才查找过的数据
（4）案例
A:判断电话号码和邮箱
B:安装不同的规则分割数据
C:把论坛中的数字替换为*
D:获取字符串中由三个字符组成的单词
2.Math
（1）针对数学运算进行操作的类
（2）常见方法
A:绝对值
B:向上取整
C:向下取整
D:两个数据中的大值
E:a的b次幂
F:随机数
G:四舍五入
H:正平方根
代码：
/*
Math：用于算数运算的类
成员变量：public static final double PI
public static final double E
成员方法：
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 int min(int a ,int b)：最小值
public static double pow(double a ,double b):a的b次幂
public static double random():随机数[0.0,1.0]
public static int round(float a)：四舍五入
public static int round(double a)：四舍五入
public static double sqrt(double a):正平方根
*/
public class MathDemo {
public static void main(String[] args) {
//public static final double PI
System.out.println("PI:"+Math.PI);
//public static final double E
System.out.println("E:"+Math.E);
System.out.println("-----------------");
//public static int abs(int a):绝对值
System.out.println("abs:"+Math.abs(10));
System.out.println("abs:"+Math.abs(-10));
System.out.println("------------------");
//public static double ceil(double a):向上取整（天花板）
System.out.println("ceil:"+Math.ceil(12.00000001));
System.out.println("ceil:"+Math.ceil(12.999999999));
System.out.println("------------------");
//public static double floor(double a):向下取整（地板）
System.out.println("floor:"+Math.floor(12.000001));
System.out.println("floor:"+Math.floor(12.999999999));
System.out.println("------------------");
//public static int max(int a ,int b)：最大值
System.out.println("max:"+Math.max(10, 20));
//public static int min(int a ,int b)：最小值
System.out.println("min:"+Math.min(10, 20));
System.out.println("------------------");
//public static double pow(double a ,double b):a的b次幂
System.out.println("POW:"+Math.pow(2,3));
System.out.println("--------------------");
//public static double random():随机数[0.0,1.0]
System.out.println("random:"+Math.random());
System.out.println("----------------------");
//double和float的精准度不同
//public static int round(float a)：四舍五入
System.out.println("round:"+Math.round(5.6));
//public static int round(double a)：四舍五入
System.out.println("round:"+Math.round(5.6));
System.out.println("---------------------");
//public static double sqrt(double a):正平方根
System.out.println("sqrt:"+Math.sqrt(4));
}
}
（3）案例
A:猜数字小游戏
B:获取任意范围的随机数
代码：
import java.util.Scanner;
/*
需求：请设计一个方法，可以实现获取任意范围内的随机数
分析：
A:键盘录入两个数据
int start
int end
B:想办法获取 在start到end之间的随机数
我写一个功能实现这个效果，得到一个随机数
C:输出这个随机数
*/
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++) {
int num = getRandom(start, end);
System.out.println(num);
}
}
/*
写一个功能
两个明确：
返回值类型：int
参数列表：int start,int end
/
public static int getRandom(int start,int end) {
int number = (int)(Math.random()
(end – start+1))+start;
return number;
}
}
3.Random
（1）用于产生随机数的类
（2）构造方法：
A:Random()默认种子，每次产生的随机数不同
B:Random(long seed)指定种子，每次种子相同，随机数相同
（3）成员方法
A:int nextInt() 返回int 范围内的随机数
B:int nextInt(int n) 返回0到n范围的随机数
代码：
import java.util.Random;
/*
Random：产生随机数的类
构造方法：
public Random();没有给种子，用的是默认种子，是当前时间的毫秒值
public Random(long seed):给出指定的种子，随机数一样
成员方法：
public int nextInt()：返回的是Int范围内的随机数
public int nextint(int n ):反教会的是0到n的随机数
*/
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//int num = r.nextInt();返回的是Int范围内的随机数
int num = r.nextInt(10);
System.out.println(num);
}
}
4.System
（1）系统类，提供了一些有用的字段和方法
（2）成员方法
A:运行垃圾回收器exit(0);
B:退出JVMSystem.out.println(System.currentTimeMillis());
C:获取当前时间的毫秒值currentTimeMillis();
D:复制数组arraycopy
/*
System类包含一些有用的字段和方法，他不能被实例化
方法：
public static void gc():运行垃圾回收器
public static void exit(int status):种植当前正在运行的JAVA虚拟机。参数用作状态码；根据惯例，非0的状态码表示异常终止
System.out.println(System.currentTimeMillis());
public statci void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
参数：
src-源数组
srcPos-源素组中的起始位置
dest-目标数组
destPos-目标数组中的起始位置
length-要复制的数组元素的数量
*/
public class SystemDemo {
public static void main(String[] args) {
// System.out.println(“我喜欢奥利给”);
// System.exit(0);
// System.out.println(“奥利给喜欢我”);
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for(int x = 0;x<1000000;x++) {
System.out.println(“hello”+x);
}
long end = System.currentTimeMillis();
System.out.println(“此次运行共消耗时间”+(end-start)/1000+“秒”);
}
}
//数组替换
public class SystemDemo {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};
int[] arr2 = {6,7,8,9,10};
//将第二个数组第二个位置复制第一个数组第一个位置往后数两个元素替换数组二的位置
System.arraycopy(arr, 1, arr2, 2, 2);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
}
}
5.BigInteger
（1）针对大整数的运算
（2）构造方法
BigInteger(String s)
（3）成员方法
A:加add
B:减subtract
C:乘multiply
D:除divide
E:商和余数divideAndRemainder
代码：
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对象
BigInteger b1 = new BigInteger("100");
BigInteger b2 = new BigInteger("50");
//加法
System.out.println("加："+b1.add(b2));
//减法
System.out.println("减："+b1.subtract(b2));
//乘法
System.out.println("乘:"+b1.multiply(b2));
//除法
System.out.println("除："+b1.divide(b2));
System.out.println("--------------------");
//商和余数
BigInteger[] big = b1.divideAndRemainder(b2);
System.out.println("商："+big[0]);
System.out.println("余："+big[1]);
}
}
6.BigDecimal
（1）浮点数据做运算，会丢失精度，所以，针对浮点数据的操作建议采用
7.Calendar
（1）日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段介意获取值
（2）如何得到一个日历对象呢？
Calendar c = Calendar.getInstance();
本质返回的是子类对象
（3）成员方法
A:根据日历字段得到对应的值
B:根据日历字段和一个正负数确定是添加还是减去对于日历字段的值
C:设置日历对象的年月日
代码：
import java.util.Calendar;
/*
public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int data)
*/
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, 5);
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year);
//获取月，月从0 开始所以要加1
int month = c.get(Calendar.MONTH);
System.out.println(month);
int date = c.get(Calendar.DATE);
System.out.println(date);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
c.add(Calendar.MONTH, 10);
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH);
date = c.get(Calendar.DATE);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
//public final void set(int year,int month,int date)设置当前日历的年月日
c.set(2055, 1, 1);
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH);
date = c.get(Calendar.DATE);
System.out.println("今天是"+year+"年"+(month+1)+"月"+date+"日");
}
}
（4）案例
计算任意一年的2月份有多少天、
代码：
/*
获取任意一年的二月有多少天
分析：
A:键盘录入任意的年份
B:设置日历对象的年月日
年就是A输入的数据
月是2
日是1
C:把时间往前推一天就是二月的最后一天
D:获取这一天输出即可
*/
import java.util.Calendar;
import java.util.Scanner;
public class CalendarDemo {
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);
//把时间往前推一天，就一定是二月的最后一天
c.add(Calendar.DATE, -1);
System.out.println(c.get(Calendar.DATE));
}
}