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;
} }