Math、Random、System、BigInteger、Date、DateFormat、Calendar类,正则表达式_DAY14

1:Math&大数据类四则运算

X abs(X x)

double random()         产生随机数

double ceil(double a)   向上取整

double floor(double a)  向下取整

X max/min(X x,X y)

double pow(double a, double b)   返回a的b次方

round(double a)    四舍五入,即该值加上0.5,然后去floor

例子:

/*
* Math:
* 静态常量:
* 1:Math.E : 自然对数的底数 Math.PI: 圆周率
* 主要方法:
* 2:public static double abs(int c) 取绝对值
* 3:public static double ceil(double a) 向上取整
* public static double floor(double a) 向下取整
* 4:public static double max(double a,double b) 取最大值
* public static double min(double a,double b) 取最小值
* 5:public static double pow(double a, double b) 返回第一个参数的第二个参数次幂的值。
* 6:public static double random() [0,1)
* 7:public static long round(double a) 四舍五入
*/
public class Demo { public static void main(String[] args) {
//
System.out.println(Math.E);
System.out.println(Math.PI);
//2获取绝对值
int a = -10;
System.out.println(Math.abs(a));
byte b = 10;
System.out.println(Math.abs(b));
//
System.out.println(Math.ceil(1.1));
System.out.println(Math.ceil(1.8));
System.out.println(Math.ceil(-1.1));
System.out.println(Math.ceil(-1.8)); System.out.println(Math.floor(1.1));
System.out.println(Math.floor(1.8));
System.out.println(Math.floor(-1.1));
System.out.println(Math.floor(-1.8)); //
System.out.println(Math.max(10, 20));
System.out.println(Math.min(10, 20)); //
System.out.println(Math.pow(10, 3));
//
System.out.println(Math.random()); //
System.out.println(Math.round(1.1));
System.out.println(Math.round(1.8));
System.out.println(Math.round(-1.1));
System.out.println(Math.round(-1.8));
} }

注释:产生随机数的random实际调用的是Random类随机数,方法如下:

public static double random() {

Random rnd = randomNumberGenerator;

if (rnd == null) rnd = initRNG();

return rnd.nextDouble();

}

2:Random

(1)是产生伪随机数的类。

(2)构造方法:

A:Random r = new Random();  //每次调用该对象时,默认产生不同的种子

B:random r = new Random(long seed);

注意:种子一样,随机数一样。

例子:

import java.util.Random;

/*
* Random类:伪随机数生成类
* 构造方法:
* 1:public Random() 使用一个任意的不重复的数作为种子生成对象
* 2:public Random(long seed) 使用一个指定的数作为种子生成对象
*
* 主要方法:
* 3:public int nextInt() 及其重载,根据不同类型生成随机数,
* 4:public int nextInt(int n) 产生[0,n)之间的随机数
*/
public class Demo2 { public static void main(String[] args) { //
Random random = new Random();
for (int i = 0; i < 10; i++) {
System.out.println(random.nextInt()); //空参构造器每次产生的种子不一样,产生的随机数不一样
}
System.out.println("==============================");
Random random2 = new Random();
for (int i = 0; i < 10; i++) {
System.out.println(random2.nextInt()); //空参构造器每次产生的种子不一样,产生的随机数不一样
} //
System.out.println("==============================");
Random random3 = new Random(1l); //种子一样,产生的随机数也一样
for (int i = 0; i < 10; i++) {
System.out.println(random3.nextInt());
}
System.out.println("=============================="); //种子一样,产生的随机数也一样
Random random4 = new Random(1l);
for (int i = 0; i < 10; i++) {
System.out.println(random4.nextInt());
}
System.out.println("=============================="); //
Random random5 = new Random();
for (int i = 0; i < 100; i++) {
System.out.println(random5.nextInt(100)); //产生[0,100)之间的随机整数
} }
}

(3)掌握的方法:

public int nextInt(int n):产生在[0,n)之间的随机数。

3:System(掌握)

(1)系统类,通过了静态的方法供我们使用。

(2)要掌握的功能:

A:exit(int i)  //退出VM   终止当前正在运行的 Java 虚拟机,i=0,便是正常退出,i!=0,表示异常退出。

B:currentTimeMillis() //获取当前毫秒值  可以用来测算程序运行的时间

long l1=System.currentTimeMillis();

//code...

long l2=System.currentTimeMillis();

System.out.println(l2-l1);  //输出中间代码运行时间

C:arraycopy() //arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束

D:public static Properties getProperties()   获取系统属性值

例子:

/*
* System类:系统类
* 主要方法:
* 1:public static void gc() 运行垃圾回收器。
* 2:public static void exit(int status) 终止当前正在运行的 Java 虚拟机。
* 3:public static long currentTimeMillis() 获取当前时间毫秒值,根据协调世界时间。可以用来检测程序运行时间
* 4:public static Properties getProperties() 确定当前的系统属性。
*/
public class Demo3 { public static void main(String[] args) { //3:获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); //4:获取系统属性
System.out.println(System.getProperties()); //2:
System.out.println("i love java!");
System.exit(0);
System.out.println("i hate java!");
} }

gc():调用 gc()方法暗示着 Java 虚拟机做了一些努力来回收未用对象

finalize():当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重写 finalize 方法,以配置系统资源或执行其他清除。

4:BigInteger类和Bigdecimal类

import java.math.BigInteger;
import java.util.Arrays; /*
* 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)
* 构造器:
* BigInteger(String val) //将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
*/ /*
* BigDecimal:支持任意精度的小数
* 方法:
* public BigDecimal add(BigDecimal augend) 加法
* public BigDecimal subtract(BigDecimal subtrahend) 减法
* public BigDecimal multiply(BigDecimal multiplicand) 乘法
* public BigDecimal divide(BigDecimal divisor) 除法
* public BigDecimal[] divideAndRemainder(BigDecimal divisor) //返回商和余数
* 构造器:
* BigDecimal(String val) //将BigDecimal 的字符串表示形式转换为 BigDecimal。
public class Demo4 { public static void main(String[] args) { BigInteger bi = new BigInteger("11111111111"); // 将 BigInteger 的十进制字符串表示形式转换为 BigInteger
BigInteger bi2 = new BigInteger("2"); System.out.println(bi.add(bi2));
System.out.println(bi.subtract(bi2));
System.out.println(bi.multiply(bi2));
System.out.println(bi.divide(bi2)); System.out.println(Arrays.toString(bi.divideAndRemainder(bi2))); System.out.println(4099.99-969.01);//3130.9799999999996
BigDecimal b1=new BigDecimal(4099.99);
BigDecimal b2=new BigDecimal(969.01); //误差减小了一点点
System.out.println(b1.subtract(b2));//3130.979999999999790816218592226505279541015625 } }

5:日期(理解)

(1)Date:

表示一个日期类。大部分方法过时,被Calendar替代。

构造方法:

Date d = new Date();

Date d = new Date(long time);

获取毫秒值:

public long getTime()// 获取毫秒数

public void setTime(long time) //设置毫秒数

例子:

import java.util.Date;

/*
* Date类:
* 类 Date 表示特定的瞬间,精确到毫秒。就是表示时间的。
* 构造方法:
* 1:public Date()分配 Date 对象并初始化此对象,以表示分配它的时间(精确到毫秒), 获取当前时间
* 2:public Date(long date) 根据毫秒值,创建日期对象。
* 主要方法:
* 3:public long getTime() 获取毫秒数
* 4:public void setTime(long time) 设置毫秒数
*/
public class Demo5 { public static void main(String[] args) { //获取当前时间
Date date = new Date();
System.out.println(date); Date date3 = new Date(System.currentTimeMillis());
System.out.println(date3); //
Date date2 = new Date(1645645766712l);
System.out.println(date2); //3,4
System.out.println("=========================");
Date date4 = new Date();
long time = date4.getTime();
System.out.println(time); date4.setTime(1234566788l);
System.out.println(date4);
} }

(2)DateFormat:

对日期进行格式化和对字符串解析的类

String -- Date:

解析:par  se(转换的意思)

//将一个字符串日期,转成一个date日期>>>经常做的

String date = "2014年09月25日 12时24分15";

DateFormat dateFormat2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");

Date parse = dateFormat2.parse(date);

System.out.println(parse);

Date -- String:

格式化:format(“要符合的日期格式”)

DateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日  HH时mm分ss秒");//格式 yyyy年MM月dd日  HH时mm分ss秒

String format = dateFormat.format(new Date());

System.out.println(format);

例子:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date; /*
* 日期格式化类:
* DateFormat:是日期/时间格式化子类的抽象类
* public final String format(Date date) 将一个 Date 格式化为日期/时间字符串。
* public Date parse(String source) 将字符串转成Date对象
* SimpleDateFormat:具体的时间格式化工具
* 构造:
* public SimpleDateFormat() 空参构造,使用默认格式
* public SimpleDateFormat(String pattern) 根据指定模式创建日期格式化类对象
*/
public class Demo6 { public static void main(String[] args) throws ParseException {
//日期对象转字符串
Date date = new Date(); //创建要被格式化的日期对象
System.out.println(date); SimpleDateFormat sdf = new SimpleDateFormat(); //使用默认的格式创建日期格式化对象
String format = sdf.format(date); //调用日期格式化对象的方法格式化日期
System.out.println(format); //打印格式化好的字符串日期 System.out.println("=================="); Date date2 = new Date(); //创建要被格式化的日期对象
String model = "yyyy年MM月dd日 HH:mm:ss"; //定义日期表示模式(格式)
SimpleDateFormat sdf2 = new SimpleDateFormat(model); //使用指定的格式创建日期格式化对象
String format2 = sdf2.format(date2); //调用日期格式化对象的方法格式化日期
System.out.println(format2); //打印格式化好的字符串日期 System.out.println("===================");
//字符串转日期对象
String sDate = "2015-04-04 11:48:43"; //定义字符串类型的日期
String model2 = "yyyy-MM-dd HH:mm:ss"; //定义日期表示模式(格式)
SimpleDateFormat sdf3 = new SimpleDateFormat(model2);//使用指定的格式创建日期格式化对象
Date parseDate = sdf3.parse(sDate); //调用日期格式化对象的方法将日期按照指定的格式转成Date对象
System.out.println(parseDate); //打印Date对象
} }

(3)Calendar:

日历类,对日期进行了更细的划分,可以获取日历的每个字段值。

根据日历字段获取对应的值:

get(Calendar.相应字段)

设置年月日:

一般情况下,都是由getInstance()获取Calendar对象

在特殊业务需求时,需要进行判断

set(int year,int month,int date)

返回一个Date类型的对象

getTime()

修改指定日历的值:

add(int field,int value) //此处的field要用Calendar来调用,如Calendar.YEAR

例子:

import java.util.Calendar;

/*
* Calendar:日历类对象
*
* 创建对象:1:Calendar rightNow = Calendar.getInstance();
*
* 主要方法:
* 2:public int get(int field) 通过指定的字段(key),获取对应的值
* 注意:月份是0-11 其余字段正常
* 3:public abstract void add(int field,int amount) 给指定的字段值添加指定的量
* 4:public final void set(int year, int month, int date) 给指定的字段赋值,但是是直接给值
* public final Date getTime() 将日历对象转成Date对象
*/
public class Demo7 { public static void main(String[] args) {
//
Calendar rightNow = Calendar.getInstance();//生成的是Calemdar类的子类GregorianCalendar的对象
System.out.println(rightNow); //
int year = rightNow.get(Calendar.YEAR);
System.out.println(year); //3:public abstract void add(int field,int amount)
rightNow.add(Calendar.YEAR, 1);
System.out.println(rightNow.get(Calendar.YEAR)); // 计算机中2016.3.4 现实生活中 2016.4.4
rightNow.add(Calendar.MONTH, 1);
System.out.println(rightNow.get(Calendar.MONTH));// 计算机中2016.4.4 现实生活中 2016.5.4 rightNow.add(Calendar.DAY_OF_MONTH, -10); // 计算机中2016.3.24 现实生活 2016.4.24
System.out.println(rightNow.get(Calendar.MONTH));
System.out.println(rightNow.get(Calendar.DAY_OF_MONTH)); //4:public final void set(int year, int month, int date)//设置日期,并且以Data类型对象输出
Calendar rightNow2 = Calendar.getInstance();
rightNow2.set(2015, 0,1);
System.out.println(rightNow2.getTime());
} }
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date; /*
* 请计算伟大祖国多少天了?
*/
public class Test { public static void main(String[] args) throws ParseException { //得到现在时间的毫秒值
long rightNow = new Date().getTime();
//得到建国时间的毫秒值
// 方法1:
// String sBirthday = "1949-10-01";
// String model = "yyyy-MM-dd";
// DateFormat df = new SimpleDateFormat(model);
// Date dBirthday = df.parse(sBirthday); // 方法2
Calendar cBirthday = Calendar.getInstance();
cBirthday.set(1949, 10, 1);
Date dBirthday = cBirthday.getTime(); //Calendar的getTime 返回Date对象
long lBirthday = dBirthday.getTime(); //Date的getTime 返回Long类型的毫秒值 //根据毫秒值计算天数
long time = rightNow-lBirthday;
int days = (int)(time/1000/60/60/24); System.out.println(days);
}
}
import java.util.Calendar;

/*
* 如何获得任意年份二月有多少天?
*/
public class Test2 { public static void main(String[] args) { int fdays = getFdays(2004);
System.out.println(fdays);
} public static int getFdays(int year) {
Calendar calendar = Calendar.getInstance();
calendar.set(year, 2, 1);
calendar.add(Calendar.DAY_OF_MONTH, -1); return calendar.get(Calendar.DAY_OF_MONTH);
} }
import java.util.Calendar;
/*
* 获取昨天的此时此刻
*/
public class Test3 { public static void main(String[] args) { Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, -1);
System.out.println(calendar.getTime());
} }

6:正则表达式(掌握用法)

(1)符合一定规则的字符串。

(2)规则:

A:字符

x 字符 x

\\ 反斜线字符

\r 回车符

\n 换行符

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 单词边界

就是指这里出现的不能使单词字符。

he;wor xixi

E:Greedy 数量词

X? X,一次或一次也没有

X* X,零次或多次

X+ X,一次或多次

X{n} X,恰好 n 次

X{n,} X,至少 n 次

X{n,m} X,至少 n 次,但是不超过 m 次

F:组的概念(按照小括号从左开始编号,每一个对应着一个组)

(a(b(c)d(e)))

第一组:a(b(c)d(e))

第二组:b(c)d(e)

第三组:c

第四组:e

将来我们就可以通过编号来获取组中内容。组0表示整个表达式。

(3)通过String类的功能使用正则表达式

A:判断功能

public boolean matches(String regex)

B:分割功能

public String[] split(String regex)

C:替换功能

public String replaceAll(String regex,String newString)

记住:

叠次:

在同一个字符串中,右边引用左边:"(.)\\1+"

在后一个字符串中引用前面的字符串的组内容:"(.)\\1+","$1"

例子:

import java.util.Arrays;

/*
* 正则表达式:
* 字符串结合正则的使用
* 1:public boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
* 2:public String[] split(String regex) 按照指定规则切割字符串,生成对应字符串数组
* 3:public String replaceAll(String regex, String 替换的字符串)
*/
public class Demo2 { public static void main(String[] args) {
//1:
//定义被匹配的字符串
String s = "qxq";
String s2 = "qeq";
//定义正则规则
String regex = "q[aeiou]q"; boolean matches = s.matches(regex);
System.out.println(matches);
boolean matches2 = s2.matches(regex);
System.out.println(matches2); //2:
/*
切割字符串"aa,bb,cc"
切割字符串"aa.bb.cc"
切割字符串"-1 99 4 23"
切割字符串"-1 99 4 23"
*/
//定义被匹配的字符串
String s3 = "aa,bb,cc"; String regex2 = ",";
String[] split = s3.split(regex2);
// System.out.println(Arrays.toString(split));
for (int i = 0; i < split.length; i++) {
String string = split[i];
System.out.print(string+" ");
}
System.out.println("=========================="); String s4 = "aa.bb.cc";
String regex3 = "\\."; // .需要转义,\也需要转义
String[] split2 = s4.split(regex3);
System.out.println(Arrays.toString(split2)); System.out.println("==========================");
String s5 = "-1 99 4 23";
String regex4 = " ";
String[] split3 = s5.split(regex4);
System.out.println(Arrays.toString(split3)); System.out.println("==========================");
String s6 = "-1 99 4 23";
String regex5 = " +"; //+代表一个或者多个空格
String[] split4 = s6.split(regex5);
System.out.println(Arrays.toString(split4)); //3:字符串中,凡是数字就使用"*"代替
String s7 = "asdfsa21323sdf21";
String regex6 = "\\d"; // \d代表数字 ,加一个\表示转义
// String regex6 ="[0-9]"; //与上面的等价
// String regex6 ="[0,1,2,3,4,5,6,7,8,9]"; //与上面的等价
System.out.println(s7.replaceAll(regex6, "*"));
} }

例子(重要):

import java.util.Arrays;

/*
* 正则表达式分组:
* 0 ((A)(B(C)))
* 1 (A)(B(C))
* 2 \A
* 3 B(C)
* 4 \C
* 1:叠词切割:"sdqqfgkkkhjppppkl "
* 2:将叠词替换成单个字符
*/
public class Demo3 { public static void main(String[] args) {
String s = "sdsqqfgkkkhjppppkl";
String regex = "(.)\\1+"; //按照重复出现的字符切割
String[] arr= s.split(regex); System.out.println(Arrays.toString(arr)); String s2 = "sdaaafghccccjkqqqqql";
String regex2 = "(.)\\1+";
String replaceAll = s2.replaceAll(regex2, "$1"); //按连续重复出现的字符换成单个字符
System.out.println(s2);
System.out.println(replaceAll); } }

 (4)

  常规的正则使用:Pattern与Mathcher

  常规使用步骤:

    Pattern p = Pattern.compile("a*b");

    Matcher m = p.matcher("aaaaab");

    boolean b = m.matches();

例子:

/*String str = "da jia zhu yi le, ming tian bu fang jia, xie xie!";想要获取3个字母组成的单词
*/ String str = "da jia zhu yi le, ming tian bu fang jia, xie xie!";
String reg = "\\b[a-z]{3}\\b";
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(str);
while(m.find())
{
System.out.println(m.start()+"..."+m.end());
System.out.println("sub:"+str.substring(m.start(),m.end()));
System.out.println(m.group());
}

(5)案例:

A:校验电话号码

    /**
* 正则表达式:验证手机号
*/
public static final String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";

B:校验qq邮箱

/**
* 是否是邮件校验
*/
public class test9 {
public static void main(String[] args) {
String email="22282815808@qq.com";
checkEmail(email);
}
public static void checkEmail(String email){
String regex="[1-9][0-9]{1,14}@qq.com";
Boolean b=email.matches(regex);
System.out.println(b);
}
}

C:我要学编程

/**
* 我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
* 将字符串还原成:“我要学编程”。
*/
public class Test10 {
public static void main(String[] args) {
// 先将字符串中的.去掉, .去掉后,字符串就变了,所以用字符串的替换.
String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
String s2=s.replaceAll("\\.",""); // 将没有.的字符串进行叠词的处理,多个重叠的字保留一个.
String s3=s2.replaceAll("(.)\\1+","$1");
System.out.println(s3);
}
}

D:检验qq号是否符合规则

例子:

/*
* 请验证一个字符串是否为qq号 要求:5-15位数字,不能以0开头
*
* 经过对比,发现使用正则表达式匹配字符串更简单。
*/
public class Demo { public static void main(String[] args) {
String qq = "12345";
System.out.println(checkQQ(qq));
System.out.println(checkQQ2(qq));
}
private static boolean checkQQ(String qq) {
//定义布尔类型变量,记录判断结果,默认是正确的
boolean flag = true; if (qq.length() < 5 || qq.length() > 15) { //判断是否长度不符
flag = false;
} else { //长度符合
if (qq.startsWith("0")) { //判断是否以0开头
flag = false;
} else { //不以0开头
char[] chs = qq.toCharArray(); //获取qq字符串的字节数组 for (int i = 0; i < chs.length; i++) { //遍历字符数组
if (!(chs[i] >= '0' && chs[i] <= '9')) { //判断是否不是数字
flag = false;
break;
}
} }
}
return flag;
} private static boolean checkQQ2(String qq) {
String regex = "[1-9][0-9]{4,14}";//定义一个正则规则
boolean b = qq.matches(regex); //让字符串去适应判断这个规则
return b;
} }
上一篇:java.io.IOException: Could not locate executable null\bin\winutils.exe in the Hadoop binaries.


下一篇:21.云计算&大数据_linux基础知识(18)什么是linux_Linux 命令与文件的搜寻