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) { //1 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)); //3 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)); //4 System.out.println(Math.max(10, 20)); System.out.println(Math.min(10, 20)); //5 System.out.println(Math.pow(10, 3)); //6 System.out.println(Math.random()); //7 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) { //1 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()); //空参构造器每次产生的种子不一样，产生的随机数不一样 } //2 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("=============================="); //3 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); //2 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) { //1 Calendar rightNow = Calendar.getInstance();//生成的是Calemdar类的子类GregorianCalendar的对象 System.out.println(rightNow); //2 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; } }
