1.0.0 Summary
Tittle：【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】- Java基础类
Style：EBook
Series：Java
Since：2017-09-19
End：....
Total Hours：...
Degree Of Diffculty：2
Degree Of Mastery：2
Practical Level：2
Desired Goal：2
Archieve Goal：....
Gerneral Evaluation：...
Writer:kingdelee
Related Links：
http://www.cnblogs.com/kingdelee/
1.输出系统属性
public class SystemTest
{
public static void main(String[] args) throws Exception
{
// 获取系统所有的环境变量
Map<String,String> env = System.getenv();
for (String name : env.keySet())
{
System.out.println(name + " ---> " + env.get(name));
}
// 获取指定环境变量的值
System.out.println(System.getenv("JAVA_HOME"));
// 获取所有的系统属性
Properties props = System.getProperties();
// 将所有系统属性保存到props.txt文件中
props.store(new FileOutputStream("props.txt")
, "System Properties");
// 输出特定的系统属性
System.out.println(System.getProperty("os.name"));
}
}
2.System.identityHashCode()与.hashcode()
// 1. System.identityHashCode()与.hashcode()，前者返回的是精确的hash地址，唯一标识对象，即便hashcode被重写，identityHashCode也不变。
public class IdentityHashCodeTest
{
public static void main(String[] args)
{
// 下面程序中s1和s2是两个不同对象
String s1 = new String("Hello");
String s2 = new String("Hello");
// String重写了hashCode()方法——改为根据字符序列计算hashCode值，
// 因为s1和s2的字符序列相同，所以它们的hashCode方法返回值相同
System.out.println(s1.hashCode()
+ "----" + s2.hashCode());
// s1和s2是不同的字符串对象，所以它们的identityHashCode值不同
System.out.println(System.identityHashCode(s1)
+ "----" + System.identityHashCode(s2));
String s3 = "Java";
String s4 = "Java";
// s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
System.out.println(System.identityHashCode(s3)
+ "----" + System.identityHashCode(s4));
}
}
public class RuntimeTest
{
public static void main(String[] args)
{
// 获取Java程序关联的运行时对象
Runtime rt = Runtime.getRuntime();
System.out.println("处理器数量："
+ rt.availableProcessors());
System.out.println("空闲内存数："
+ rt.freeMemory());
System.out.println("总内存数："
+ rt.totalMemory());
System.out.println("可用最大内存数："
+ rt.maxMemory());
}
}
public class ExecTest
{
public static void main(String[] args)
throws Exception
{
Runtime rt = Runtime.getRuntime();
// 运行记事本程序
rt.exec("notepad.exe");
}
}
Cloneable：
// 1.实现Cloneable接口，对对象进行浅克隆。两个对象不是同一个对象，但其浅引用是一样的。
class Num{
private int num;
public Num(int num) {
this.num = num;
}
}
class Address
{
String detail;
Num num;
public Address(String detail)
{
this.detail = detail;
}
public void setNum(Num num) {
this.num = num;
}
public Num getNum() {
return num;
}
}
// 实现Cloneable接口
class User implements Cloneable
{
int age;
Address address;
public User(int age)
{
this.age = age;
address = new Address("广州天河");
}
// 通过调用super.clone()来实现clone()方法
public User clone()
throws CloneNotSupportedException
{
return (User)super.clone();
}
}
public class CloneTest
{
public static void main(String[] args)
throws CloneNotSupportedException
{
User u1 = new User(29);
u1.address.setNum(new Num(5));
// clone得到u1对象的副本。
User u2 = u1.clone();
// 判断u1、u2是否相同
System.out.println(u1 == u2); //F
// 判断u1、u2的address是否相同
System.out.println(u1.address == u2.address); //T
System.out.println(u1.address.getNum() == u2.address.getNum()); // T
}
}
Objects：
// 1.当不确定对象是否为null时，使用Objects.的方法可以获得 toString,hashcode,requireNonNull
public class ObjectsTest
{
// 定义一个obj变量，它的默认值是null
static ObjectsTest obj;
public static void main(String[] args)
{
// 输出一个null对象的hashCode值，输出0
System.out.println(Objects.hashCode(obj));
// 输出一个null对象的toString，输出null
System.out.println(Objects.toString(obj));
// 要求obj不能为null，如果obj为null则引发异常
System.out.println(Objects.requireNonNull(obj
, "obj参数不能是null！"));
}
}
Math：
public class MathTest
{
public static void main(String[] args)
{
/*---------下面是三角运算---------*/
// 将弧度转换角度
System.out.println("Math.toDegrees(1.57)："
+ Math.toDegrees(1.57));
// 将角度转换为弧度
System.out.println("Math.toRadians(90)："
+ Math.toRadians(90));
// 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
// 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
// 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
// 计算三角余弦。
System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
// 计算值的双曲余弦。
System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2 ));
// 计算正弦
System.out.println("Math.sin(1.57 )：" + Math.sin(1.57 ));
// 计算双曲正弦
System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2 ));
// 计算三角正切
System.out.println("Math.tan(0.8 )：" + Math.tan(0.8 ));
// 计算双曲正切
System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1 ));
// 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
/*---------下面是取整运算---------*/
// 取整，返回小于目标数的最大整数。
System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));
// 取整，返回大于目标数的最小整数。
System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
// 四舍五入取整
System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));
/*---------下面是乘方、开方、指数运算---------*/
// 计算平方根。
System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));
// 计算立方根。
System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
// 返回欧拉数 e 的n次幂。
System.out.println("Math.exp(2)：" + Math.exp(2));
// 返回 sqrt(x2 +y2)
System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));
// 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
System.out.println("Math.IEEEremainder(5 , 2)："
+ Math.IEEEremainder(5 , 2));
// 计算乘方
System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
// 计算自然对数
System.out.println("Math.log(12)：" + Math.log(12));
// 计算底数为 10 的对数。
System.out.println("Math.log10(9)：" + Math.log10(9));
// 返回参数与 1 之和的自然对数。
System.out.println("Math.log1p(9)：" + Math.log1p(9));
/*---------下面是符号相关的运算---------*/
// 计算绝对值。
System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
// 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
System.out.println("Math.copySign(1.2, -1.0)："
+ Math.copySign(1.2, -1.0));
// 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
// 则返回 1.0；如果参数小于 0，则返回 -1.0。
System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
/*---------下面是大小相关的运算---------*/
// 找出最大值
System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));
// 计算最小值
System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));
// 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
System.out.println("Math.nextAfter(1.2, 1.0)："
+ Math.nextAfter(1.2, 1.0));
// 返回比目标数略大的浮点数
System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));
// 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
System.out.println("Math.random()：" + Math.random());
}
}
Arrays.asList与ArrayList
前者获得 的 new ArrayList实际上是Arrays类中的静态内部类，即 java.util.Arrays$ArrayList 与 java.util.ArrayList 是两个不一样的东西！
前者是没有add等方法的，说明其只是一个无法进行增加删除元素的数组。
/** 随机给定范围内N个不重复的数 方法一：最简单最易理解的两重循环去重
* 最简单最基本的方法
* @param min 指定范围最小值
* @param max 指定范围最大值
* @param n 随机数个数
*/
public static int[] randomCommon(int min, int max, int n){
if (n > (max - min + 1) || max < min) {
return null;
}
int[] result = new int[n];
int count = 0;
while(count < n) {
int num = (int) (Math.random() * (max - min)) + min;
boolean flag = true;
for (int j = 0; j < n; j++) {
if(num == result[j]){
flag = false;
break;
}
}
if(flag){
result[count] = num;
count++;
}
}
return result;
}
/**随机给定范围内N个不重复的数 方法二：利用HashSet的特征，只能存放不同的值
* 利用HashSet的特征，只能存放不同的值
* @param min 指定范围最小值
* @param max 指定范围最大值
* @param n 随机数个数
* @param set HashSet<Integer> 随机数结果集
*/
public static void randomSet(int min, int max, int n, HashSet<Integer> set) {
if (n > (max - min + 1) || max < min) {
return;
}
for (int i = 0; i < n; i++) {
// 调用Math.random()方法
int num = (int) (Math.random() * (max - min)) + min;
set.add(num);// 将不同的数存入HashSet中
}
int setSize = set.size();
// 如果存入的数小于指定生成的个数，则调用递归再生成剩余个数的随机数，如此循环，直到达到指定大小
if (setSize < n) {
randomSet(min, max, n - setSize, set);// 递归
}
}
最优的方法：
/**
* 随机指定范围内N个不重复的数 方法三：排除已随机到的数
* 在初始化的无重复待选数组中随机产生一个数放入结果中，
* 将待选数组被随机到的数，用待选数组(len-1)下标对应的数替换
* 然后从len-2里随机产生下一个随机数，如此类推
* 即，游标作为范围从右到左进行缩小，使未选中的值都在游标的左侧，根据游标每次取出左侧的值
* @param max 指定范围最大值
* @param min 指定范围最小值
* @param n 随机数个数
* @return int[] 随机数结果集
*/
public static int[] randomArray(int min,int max,int n){
int len = max-min+1;
if(max < min || n > len){
return null;
}
//初始化给定范围的待选数组
int[] source = new int[len];
for (int i = min; i < min+len; i++){
source[i-min] = i;
}
int[] result = new int[n];
Random rd = new Random();
int index = 0;
for (int i = 0; i < result.length; i++) {
//待选数组0到(len-2)随机一个下标
index = Math.abs(rd.nextInt() % len--);
//将随机到的数放入结果集
result[i] = source[index];
System.out.println("index:" + index + ", len:" + len + ", source:" + Arrays.toString(source) + ",source[index]:" + source[index]);
//将待选数组中被随机到的数，用待选数组(len-1)下标对应的数替换
source[index] = source[len];
System.out.println("index:" + index + ", len:" + len + ", source:" + Arrays.toString(source) + ",source[index]:" + source[index]);
}
return result;
}
BigDecimal精度计算：
// 1. BigDecimal 精确大数据间的运算
// 1.1. 一定要使用字符串作为参数传入构造器，或者使用valueOf()，否则使用double类型的作为参数传入就会出现精度丢失！
public class BigDecimalTest
{
public static void main(String[] args)
{
BigDecimal f1 = new BigDecimal("0.05");
BigDecimal f2 = BigDecimal.valueOf(0.01);
BigDecimal f3 = new BigDecimal(0.05);
System.out.println("使用String作为BigDecimal构造器参数：");
System.out.println("0.05 + 0.01 = " + f1.add(f2));
System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
System.out.println("0.05 / 0.01 = " + f1.divide(f2));
System.out.println("valueOf：");
System.out.println("0.05 + 0.01 = " + f2.add(f1));
System.out.println("0.05 - 0.01 = " + f2.subtract(f1));
System.out.println("0.05 * 0.01 = " + f2.multiply(f1));
System.out.println("0.05 / 0.01 = " + f2.divide(f1));
System.out.println("使用double作为BigDecimal构造器参数：");
System.out.println("0.05 + 0.01 = " + f3.add(f2));
System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
System.out.println("0.05 / 0.01 = " + f3.divide(f2));
// 使用String作为BigDecimal构造器参数：
// 0.05 + 0.01 = 0.06
// 0.05 - 0.01 = 0.04
// 0.05 * 0.01 = 0.0005
// 0.05 / 0.01 = 5
// valueOf：
// 0.05 + 0.01 = 0.06
// 0.05 - 0.01 = -0.04
// 0.05 * 0.01 = 0.0005
// 0.05 / 0.01 = 0.2
// 使用double作为BigDecimal构造器参数：
// 0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
// 0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
// 0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
// 0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125
}
}
// 1.通用的BigDecimal加减乘除
public class Arith {
// 默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
// 构造器私有，让这个类不能实例化
private Arith() {
}
// 提供精确的加法运算。
public static double add(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.add(b2).doubleValue();
}
// 提供精确的减法运算。
public static double sub(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.subtract(b2).doubleValue();
}
// 提供精确的乘法运算。
public static double mul(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.multiply(b2).doubleValue();
}
// 提供（相对）精确的除法运算，当发生除不尽的情况时.
// 精确到小数点以后10位的数字四舍五入。
public static double div(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static void main(String[] args) {
System.out.println("0.05 + 0.01 = " + Arith.add(0.05, 0.01));
System.out.println("1.0 - 0.42 = " + Arith.sub(1.0, 0.42));
System.out.println("4.015 * 100 = " + Arith.mul(4.015, 100));
System.out.println("123.3 / 100 = " + Arith.div(123.3, 100));
}
}
时间：
// 1. .add()与.roll()的区别，add会进位或者退位，roll只能在当前位操作，如果需要进位或者退位则roll操作无效
public class CalendarTest
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
// 取出年
System.out.println(c.get(YEAR));
// 取出月份
System.out.println(c.get(MONTH));
// 取出日
System.out.println(c.get(DATE));
// 分别设置年、月、日、小时、分钟、秒
c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23
System.out.println(c.getTime());
// 将Calendar的年前推1年
c.add(YEAR , -1); //2002-11-23 12:32:23
System.out.println(c.getTime());
// 将Calendar的月前推8个月
c.roll(MONTH , -8); //2002-03-23 12:32:23
System.out.println(c.getTime());
Calendar cal1 = Calendar.getInstance();
cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23
cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23
System.out.println(cal1.getTime());
Calendar cal2 = Calendar.getInstance();
cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31
// 因为进位到后月份改为2月，2月没有31日，自动变成29日
cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29
System.out.println(cal2.getTime());
Calendar cal3 = Calendar.getInstance();
cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23
// MONTH字段“进位”，但YEAR字段并不增加
cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23
System.out.println(cal3.getTime());
Calendar cal4 = Calendar.getInstance();
cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31
// MONTH字段“进位”后变成2，2月没有31日，
// YEAR字段不会改变，2003年2月只有28天
cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28
System.out.println(cal4.getTime());
}
}
// 1.set是延迟加载，只有在get的时候才会生效。
public class LazyTest
{
public static void main(String[] args)
{
Calendar cal = Calendar.getInstance();
// cal.set(2003 , 7 , 31, 20, 10); //2003-8-31 20:10
cal.set(2003 , 7 , 31); //2003-8-31 20:10
// 将月份设置为9月，但9-31不存在，故本应进1位 为10-01，由于延迟修改没有get不会立即生效，此时又将day改为5,9-5存在，故get时输出9-5.
cal.set(MONTH , 8);
// System.out.println(cal.getTime()); //①
// cal.set(HOUR_OF_DAY , 5); //②
cal.set(DATE , 5); //②
System.out.println(cal.getTime()); //③
}
}
// 1. Calender 的容错机制默认开启，cal.setLenient(false);会关闭容错，set不符合的数值时会抛异常
public class LenientTest
{
public static void main(String[] args)
{
Calendar cal = Calendar.getInstance();
// 结果是YEAR字段加1，MONTH字段为1（二月）
cal.set(MONTH , 13); //①
System.out.println(cal.getTime());
// 关闭容错性
cal.setLenient(false);
// 1. Calender 的容错机制默认开启，cal.setLenient(false);会关闭容错，set不符合的数值时会抛异常
cal.set(MONTH , 13); //②
System.out.println(cal.getTime());
}
}
public class NewDatePackageTest
{
public static void main(String[] args)
{
// -----下面是关于Clock的用法-----
// 获取当前Clock
Clock clock = Clock.systemUTC();
// 通过Clock获取当前时刻
System.out.println("当前时刻为：" + clock.instant()); // 当前时刻为：2017-09-19T08:33:29.259Z
// 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
System.out.println(clock.millis()); // 1505810009628
System.out.println(System.currentTimeMillis()); // 1505810009628
// -----下面是关于Duration的用法-----
Duration d = Duration.ofSeconds(6000);
System.out.println("6000秒相当于" + d.toMinutes() + "分"); // 6000秒相当于100分
System.out.println("6000秒相当于" + d.toHours() + "小时"); // 6000秒相当于1小时
System.out.println("6000秒相当于" + d.toDays() + "天"); // 6000秒相当于0天
// 在clock基础上增加6000秒，返回新的Clock
Clock clock2 = Clock.offset(clock, d);
// 可看到clock2与clock1相差1小时40分
System.out.println("当前时刻加6000秒为：" +clock2.instant()); // 当前时刻加6000秒为：2017-09-19T10:13:29.629Z
// -----下面是关于Instant的用法-----
// 获取当前时间
Instant instant = Instant.now();
System.out.println(instant); // 2017-09-19T08:33:29.629Z
// instant添加6000秒（即100分钟），返回新的Instant
Instant instant2 = instant.plusSeconds(6000);
System.out.println(instant2); // 2017-09-19T10:13:29.629Z
// 根据字符串中解析Instant对象
Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
System.out.println(instant3); // 2014-02-23T10:12:35.342Z
// 在instant3的基础上添加5小时4分钟
Instant instant4 = instant3.plus(Duration.ofHours(5).plusMinutes(4));
System.out.println(instant4); // 2014-02-23T15:16:35.342Z
// 获取instant4的5天以前的时刻
Instant instant5 = instant4.minus(Duration.ofDays(5));
System.out.println(instant5); // 2014-02-18T15:16:35.342Z
// -----下面是关于LocalDate的用法-----
LocalDate localDate = LocalDate.now();
System.out.println(localDate); // 2017-09-19
// 获得2014年的第146天
localDate = LocalDate.ofYearDay(2014, 146);
System.out.println(localDate); // 2014-05-26
// 设置为2014年5月21日
localDate = LocalDate.of(2014, Month.MAY, 21);
System.out.println(localDate); // 2014-05-21
// -----下面是关于LocalTime的用法-----
// 获取当前时间
LocalTime localTime = LocalTime.now();
// 设置为22点33分
localTime = LocalTime.of(22, 33); // 22:33
System.out.println(localTime); // 22:33
// 返回一天中的第5503秒
localTime = LocalTime.ofSecondOfDay(5503);
System.out.println(localTime); // 01:31:43
// -----下面是关于localDateTime的用法-----
// 获取当前日期、时间
LocalDateTime localDateTime = LocalDateTime.now();
// 当前日期、时间加上25小时３分钟
LocalDateTime future = localDateTime.plusHours(25).plusMinutes(3);
System.out.println("当前日期、时间的25小时3分之后：" + future); // 当前日期、时间的25小时3分之后：2017-09-20T17:36:29.721
// 下面是关于Year、YearMonth、MonthDay的用法示例-----
Year year = Year.now(); // 获取当前的年份
System.out.println("当前年份：" + year); // 输出当前年份 // 当前年份：2017
year = year.plusYears(5); // 当前年份再加5年
System.out.println("当前年份再过5年：" + year); // 当前年份再过5年：2022
// 根据指定月份获取YearMonth
YearMonth ym = year.atMonth(10);
System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份 // year年10月：2022-10
// 当前年月再加5年，减3个月
ym = ym.plusYears(5).minusMonths(3);
System.out.println("year年10月再加5年、减3个月：" + ym); // year年10月再加5年、减3个月：2027-07
MonthDay md = MonthDay.now();
System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日 // 当前月日：--09-19
// 设置为5月23日
MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
System.out.println("5月23日为：" + md2); // 输出--05-23 // 5月23日为：--05-23
}
}
正则表达式：
正则表达式所支持的合法字符
字符 解释
x 字符x(x可以代表任何合法的字符)
\0mnn 八进制数0mnm所表示的字符
\xhh 十六进制0xhh所表示的字符
\uhhhh 十六进制0xhhhh所表示的Unicode字符
\t 制表符('\u0009')
\n 换行符('\u000A')
\r 回车符('\u000D')
\f 换页符('\u000C')
\a 报警符('\u0007')
\e Escape符('\u001B')
\ce x对应的控制符
正则表达式中的特殊字符
特殊字符 说明
$ 匹配一行的结尾。(要匹配$字符本身，使用\$，下同)
^ 匹配一行的开头
() 标记子表达式的开始、结束位置
[] 用于确定中括号表达式的开始、结束位置
{} 用于标记前面字表达式的出现频度
* 指定前面字表达式出现 0次或多次
+ 1次或多次
? 0次或1次
. 匹配除换行符 \n 之外的任何字符
\ 转义字符
| 或
预定义字符
预定义字符 说明
. 匹配任何字符
\d 匹配0-9所有数字
\D 匹配非数字
\s 匹配所有的空白符，包括空格、制表符、回车符、换页符、换行符等
\S 匹配所有的非空白字符
\w 匹配所有的单次字符，包括0-9数字，26个英文字母，下划线 _
\W 匹配所有的飞单词字符
方括号表达式
方括号表达式 说明
枚举 如[abc]，表示a、b、c中任意一个字符；
范围 - 如[a-f]。表示a-f范围内的任意字符
求否 ^ 如[^abc]，表示非a b c的任意字符， [^a-f]表示非a-f的任意字符
与 && 如[a-z&&[def]]，即a-z好[def]的交集，即 d e f
并 如[a-d[m-p]]，即[a-dm-p]
边界匹配符
边界匹配符 说明
^ 行开头
$ 行结尾
\b 单词的边界
\B 非单词的边界
\A 输入的开头
\G 前一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符
\z 输入的结尾
三种模式的数量表示符
贪婪模式 勉强模式 占用模式 说明
X? X?? X?? X表达式出现 0次或者1次
X* X*? X*? 0次或多次
X+ X+? X+? 1次或多次
X{n} X{n}? X{n}? n次
X{n,} X{n,}? X{n,}? 最少出现n次
X{n,m} X{n,m}? X{n,m}? 最少n次最多m次
public class MatchesTest
{
public static void main(String[] args)
{
String a = "\\"; // 即： \
String b = "\\\\"; // 即： \\
Matcher matcher1 = Pattern.compile("\u0041\\\\").matcher("A\\");
matcher1.find();
String group = matcher1.group();
System.out.println(group); // A\
String[] mails =
{
"[email protected]" ,
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]"
};
String mailRegEx = "\\w{3,20}@\\w+\\.(com|org|cn|net|gov)";
Pattern mailPattern = Pattern.compile(mailRegEx);
Matcher matcher = null;
for (String mail : mails)
{
if (matcher == null)
{
matcher = mailPattern.matcher(mail);
}
else
{
matcher.reset(mail);
}
String result = mail + (matcher.matches() ? "是" : "不是")
+ "一个有效的邮件地址！";
System.out.println(result);
}
}
}
//A\
// [email protected]是一个有效的邮件地址！
// [email protected]是一个有效的邮件地址！
// [email protected]是一个有效的邮件地址！
// [email protected]不是一个有效的邮件地址！
// [email protected]不是一个有效的邮件地址！
// [email protected]不是一个有效的邮件地址！
// 1. pattern = Pattern.compile("abc") 定义匹配条件，pattern.matcher("aaabbbcccabc") 去匹配主体
// 1.2. 简写为 boolean matches = Pattern.matches("abc", "aaabbbabc");
// 2. 如果需要获取匹配内容，应用Matcher matcher1 = Pattern.compile("abc").matcher("aaabbbabc");
public class FindGroup {
public static void main(String[] args) {
// 1. pattern = Pattern.compile("abc") 定义匹配条件，pattern.matcher("aaabbbcccabc") 去匹配主体
Pattern pattern = Pattern.compile("abc");
Matcher matcher = pattern.matcher("aaabbbcccabc");
boolean b = matcher.matches();
// 1.2. 简写为 boolean matches = Pattern.matches("abc", "aaabbbabc");
boolean matches = Pattern.matches("abc", "aaabbbabc");
// 2. 如果需要获取匹配内容，应用Matcher matcher1 = Pattern.compile("abc").matcher("aaabbbabc");
Matcher matcher1 = Pattern.compile("abc").matcher("aaabbbabc");
// 使用字符串模拟从网络上得到的网页源码
String str = "我想求购一本《疯狂Java讲义》，尽快联系我13500006666"
+ "交朋友，电话号码是13611125565"
+ "出售二手电脑，联系方式15899903312";
// 创建一个Pattern对象，并用它建立一个Matcher对象
// 该正则表达式只抓取13X和15X段的手机号，
// 实际要抓取哪些电话号码，只要修改正则表达式即可。
Matcher m = Pattern.compile("((13\\d)|(15\\d))\\d{8}").matcher(str);
// 将所有符合正则表达式的子串（电话号码）全部输出
while (m.find()) {
System.out.println(m.group());
}
}
}
Matcher的几个方法：
find：返回的是一个boolean类型的子串集，一般用while()来取出判断。
group：返回子串集中当前索引的子串。
public class StartEnd {
public static void main(String[] args) {
// 创建一个Pattern对象，并用它建立一个Matcher对象
String regStr = "Java is very easy!";
System.out.println("目标字符串是：" + regStr);
Matcher m = Pattern.compile("\\w+").matcher(regStr);
while (m.find()) {
System.out.println(m.group() + "子串的起始位置：" + m.start() + "，其结束位置：" + m.end());
}
}
}
//目标字符串是：Java is very easy!
//Java子串的起始位置：0，其结束位置：4
//is子串的起始位置：5，其结束位置：7
//very子串的起始位置：8，其结束位置：12
//easy子串的起始位置：13，其结束位置：17
public class StringReg
{
public static void main(String[] args)
{
String[] msgs =
{
"Java has regular expressions in 1.4",
"regular expressions now expressing in Java",
"Java represses oracular expressions"
};
for (String msg : msgs)
{
System.out.println(msg.replaceFirst("re\\w*" , "哈哈:)"));
System.out.println(Arrays.toString(msg.split(" ")));
}
}
}
//Java has 哈哈:) expressions in 1.4
//[Java, has, regular, expressions, in, 1.4]
//哈哈:) expressions now expressing in Java
//[regular, expressions, now, expressing, in, Java]
//Java 哈哈:) oracular expressions
//[Java, represses, oracular, expressions]
public class Reg {
public static void main(String args[]) {
String[] dataArr = {"moson", "mon", "smson", "mon"};
String patternStr = ".*m(o+s+o+)n"; //* 表示零次或多次 +表示一次或多次
boolean result = Pattern.matches(patternStr, dataArr[0]);
if (result) {
System.out.println("字符串" + dataArr[0] + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + dataArr[0] + "匹配模式" + patternStr + "失败");
}
patternStr = ".?m(o+)n"; //？ 表示一次或零次
result = Pattern.matches(patternStr, dataArr[1]);
if (result) {
System.out.println("字符串" + dataArr[1] + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + dataArr[1] + "匹配模式" + patternStr + "失败");
}
patternStr = ".+m(o+)n";
result = Pattern.matches(patternStr, dataArr[2]);
if (result) {
System.out.println("字符串" + dataArr[2] + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + dataArr[2] + "匹配模式" + patternStr + "失败");
}
patternStr = "m(o+)n";
result = Pattern.matches(patternStr, dataArr[3]);
if (result) {
System.out.println("字符串" + dataArr[3] + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + dataArr[3] + "匹配模式" + patternStr + "失败");
}
System.out.println("---------test[]------------------");
String[] dataArr1 = {"ban", "ben", "bin", "bon", "bun", "byn", "baen"};
patternStr = "b[aeoy]+n"; //表示匹配[]中任意一个字符，注意，只能是一个，此处可通过添加+来增加
for (String str : dataArr1) {
boolean result1 = Pattern.matches(patternStr, str);
if (result1) {
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");
}
}
System.out.println("---------test()------------------");
String[] dataArr2 = {"ban", "ben", "bin", "bon", "bun", "byn", "baen"};
patternStr = "b(ae|o)n"; //表示匹配()中多个字符，可通过|来添加匹配
for (String str : dataArr2) {
boolean result2 = Pattern.matches(patternStr, str);
if (result2) {
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");
}
}
System.out.println("---------test - ------------------");
String[] dataArr3 = {"1", "10", "101", "1010", "100+"};
patternStr = "[0-9]+";
for (String str : dataArr3) {
boolean result3 = Pattern.matches(patternStr, str);
if (result3) {
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");
}
}
System.out.println("---------test '\'d ------------------");
String[] dataArr4 = {"1", "10", "101", "1010", "100+"};
for (String str : dataArr4) {
patternStr = "\\d+"; //\\d代表数字
boolean result4 = Pattern.matches(patternStr, str);
if (result4) {
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");
}
}
System.out.println("---------test String split ------------------");
String str1 = "薪水,职位 姓名;年龄 性别";
String[] dataArr5 = str1.split("[,\\s;]"); //String中可以使用split，\\s表示空格
for (String strTmp : dataArr5) {
System.out.println(strTmp);
}
System.out.println("---------test '\'w ------------------");
String[] dataArr6 = {"a100", "b20", "c30", "df10000", "gh0t"};
for (String str : dataArr6) {
patternStr = "\\w+\\d+";
boolean result6 = Pattern.matches(patternStr, str);
if (result6) {
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");
} else {
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");
}
}
System.out.println("--------- Pattern split 分割 ------------------");
String str = "2007年12月11日";
Pattern p = Pattern.compile("[年月日]");
String[] dataArr7 = p.split(str); //使用正则分割
for (String strTmp : dataArr7) {
System.out.println(strTmp);
}
System.out.println("--------- String replaceAll ------------------");
str = "10元 1000人民币 10000元 100000RMB";
str = str.replaceAll("(元|人民币|RMB)", "￥"); //String的replaceAll采用正则替换
System.out.println(str);
System.out.println("--------- String find 依次往下查找匹配的对象 ------------------");
p = Pattern.compile("m(o+)n", Pattern.CASE_INSENSITIVE);
// 用Pattern类的matcher()方法生成一个Matcher对象
Matcher m = p.matcher("moon mooon Mon mooooon Mooon");
StringBuffer sb = new StringBuffer();
// 使用find()方法查找第一个匹配的对象
boolean result8 = m.find();
// 使用循环找出模式匹配的内容替换之,再将内容加到sb里
while (result8) {
m.appendReplacement(sb, "moon");
result8 = m.find();
}
// 最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；
m.appendTail(sb);
System.out.println("替换后内容是" + sb.toString());
System.out.println("--------- String goup ------------------");
String s = "person[0].name";
Pattern pattern = Pattern.compile("[a-z|0-9]+\\[\\d+\\].[a-z|0-9]+");
Matcher matcher = pattern.matcher(s);
boolean b = Pattern.matches("[a-z|0-9]+\\[\\d+\\].[a-z|0-9]+", s);
System.out.println(b);
pattern = Pattern.compile("\\[\\d+\\]");
matcher = pattern.matcher(s);
if (matcher.find()) {
System.out.println(matcher.group(0));
}
System.out.println("--------- String goup ------------------");
String regex = "([a-zA-Z]+[0-9]+)";
pattern = Pattern.compile(regex);
String input = "age45 salary500000 50000 title";
// String input = "age45";
matcher = pattern.matcher(input);
sb = new StringBuffer();
while (matcher.find()) {
System.out.println(matcher.group(1));
String replacement = matcher.group(1).toUpperCase();
matcher.appendReplacement(sb, replacement);
}
matcher.appendTail(sb);
System.out.println("替换完的字串为" + sb.toString());
}
@Test
public void t1() {
// TODO Auto-generated method stub
String str = "Hello,World! in Java.";
Pattern pattern = Pattern.compile("W(or)(ld!)");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
System.out.println("Group 0:" + matcher.group(0));//得到第0组——整个匹配
System.out.println("Group 1:" + matcher.group(1));//得到第一组匹配——与(or)匹配的
System.out.println("Group 2:" + matcher.group(2));//得到第二组匹配——与(ld!)匹配的，组也就是子表达式
System.out.println("Start 0:" + matcher.start(0) + " End 0:" + matcher.end(0));//总匹配的索引
System.out.println("Start 1:" + matcher.start(1) + " End 1:" + matcher.end(1));//第一组匹配的索引
System.out.println("Start 2:" + matcher.start(2) + " End 2:" + matcher.end(2));//第二组匹配的索引
System.out.println(str.substring(matcher.start(0), matcher.end(1)));//从总匹配开始索引到第1组匹配的结束索引之间子串——Wor
}
// Group 0:World!
// Group 1:or
// Group 2:ld!
// Start 0:6 End 0:12
// Start 1:7 End 1:9
// Start 2:9 End 2:12
// Wor
String regEx = "count(\\d+)(df)";
String s = "count000dfdfsdffaaaa1";
Pattern pat = Pattern.compile(regEx);
Matcher mat = pat.matcher(s);
if(mat.find()){
System.out.println(mat.group(2));
}
// mat.group() 输出为 count000df
// mat.group(1) 输出为 000
// mat.group(2) 输出为 df
// 如果没有括号会有异常。这就是（） 的作用。
}
}
public class NumberFormatTest
{
public static void main(String[] args)
{
// 需要被格式化的数字
double db = 1234000.567;
// 创建四个Locale，分别代表中国、日本、德国、美国
Locale[] locales = {Locale.CHINA, Locale.JAPAN
, Locale.GERMAN, Locale.US};
NumberFormat[] nf = new NumberFormat[12];
// 为上面四个Locale创建12个NumberFormat对象
// 每个Locale分别有通用数值格式器、百分比格式器、货币格式器
for (int i = 0 ; i < locales.length ; i++)
{
nf[i * 3] = NumberFormat.getNumberInstance(locales[i]);
nf[i * 3 + 1] = NumberFormat.getPercentInstance(locales[i]);
nf[i * 3 + 2] = NumberFormat.getCurrencyInstance(locales[i]);
}
for (int i = 0 ; i < locales.length ; i++)
{
String tip = i == 0 ? "----中国的格式----" :
i == 1 ? "----日本的格式----" :
i == 2 ? "----德国的格式----" :"----美国的格式----";
System.out.println(tip);
System.out.println("通用数值格式："
+ nf[i * 3].format(db));
System.out.println("百分比数值格式："
+ nf[i * 3 + 1].format(db));
System.out.println("货币数值格式："
+ nf[i * 3 + 2].format(db));
}
}
// ----中国的格式----
// 通用数值格式：1,234,000.567
// 百分比数值格式：123,400,057%
// 货币数值格式：￥1,234,000.57
// ----日本的格式----
// 通用数值格式：1,234,000.567
// 百分比数值格式：123,400,057%
// 货币数值格式：￥1,234,001
// ----德国的格式----
// 通用数值格式：1.234.000,567
// 百分比数值格式：123.400.057%
// 货币数值格式：¤ 1.234.000,57
// ----美国的格式----
// 通用数值格式：1,234,000.567
// 百分比数值格式：123,400,057%
// 货币数值格式：$1,234,000.57
}
public class SimpleDateFormatTest
{
public static void main(String[] args)
throws ParseException
{
Date d = new Date();
// 创建一个SimpleDateFormat对象
SimpleDateFormat sdf1 = new SimpleDateFormat("Gyyyy年中第D天");
// 将d格式化成日期，输出：公元2014年中第101天
String dateStr = sdf1.format(d);
System.out.println(dateStr);
// 一个非常特殊的日期字符串
String str = "14###三月##21";
SimpleDateFormat sdf2 = new SimpleDateFormat("y###MMM##d");
// 将日期字符串解析成日期，输出：Fri Mar 21 00:00:00 CST 2014
System.out.println(sdf2.parse(str));
}
}
public class DateFormatTest
{
public static void main(String[] args)
throws ParseException
{
// 需要被格式化的时间
Date dt = new Date();
// 创建两个Locale，分别代表中国、美国
Locale[] locales = {Locale.CHINA, Locale.US};
DateFormat[] df = new DateFormat[16];
// 为上面两个Locale创建16个DateFormat对象
for (int i = 0 ; i < locales.length ; i++)
{
df[i * 8] = DateFormat.getDateInstance(SHORT, locales[i]);
df[i * 8 + 1] = DateFormat.getDateInstance(MEDIUM, locales[i]);
df[i * 8 + 2] = DateFormat.getDateInstance(LONG, locales[i]);
df[i * 8 + 3] = DateFormat.getDateInstance(FULL, locales[i]);
df[i * 8 + 4] = DateFormat.getTimeInstance(SHORT, locales[i]);
df[i * 8 + 5] = DateFormat.getTimeInstance(MEDIUM , locales[i]);
df[i * 8 + 6] = DateFormat.getTimeInstance(LONG , locales[i]);
df[i * 8 + 7] = DateFormat.getTimeInstance(FULL , locales[i]);
}
for (int i = 0 ; i < locales.length ; i++)
{
String tip = i == 0 ? "----中国日期格式----":"----美国日期格式----";
System.out.println(tip);
System.out.println("SHORT格式的日期格式："
+ df[i * 8].format(dt));
System.out.println("MEDIUM格式的日期格式："
+ df[i * 8 + 1].format(dt));
System.out.println("LONG格式的日期格式："
+ df[i * 8 + 2].format(dt));
System.out.println("FULL格式的日期格式："
+ df[i * 8 + 3].format(dt));
System.out.println("SHORT格式的时间格式："
+ df[i * 8 + 4].format(dt));
System.out.println("MEDIUM格式的时间格式："
+ df[i * 8 + 5].format(dt));
System.out.println("LONG格式的时间格式："
+ df[i * 8 + 6].format(dt));
System.out.println("FULL格式的时间格式："
+ df[i * 8 + 7].format(dt));
}
String str1 = "2014-12-12";
String str2 = "2014年12月10日";
// 下面输出 Fri Dec 12 00:00:00 CST 2014
System.out.println(DateFormat.getDateInstance().parse(str1));
// 下面输出 Wed Dec 10 00:00:00 CST 2014
System.out.println(DateFormat.getDateInstance(LONG).parse(str2));
// 下面抛出 ParseException异常
// System.out.println(DateFormat.getDateInstance().parse(str2));
}
// ----中国日期格式----
// SHORT格式的日期格式：17-9-22
// MEDIUM格式的日期格式：2017-9-22
// LONG格式的日期格式：2017年9月22日
// FULL格式的日期格式：2017年9月22日 星期五
// SHORT格式的时间格式：上午9:45
// MEDIUM格式的时间格式：9:45:39
// LONG格式的时间格式：上午09时45分39秒
// FULL格式的时间格式：上午09时45分39秒 CST
//----美国日期格式----
// SHORT格式的日期格式：9/22/17
// MEDIUM格式的日期格式：Sep 22, 2017
// LONG格式的日期格式：September 22, 2017
// FULL格式的日期格式：Friday, September 22, 2017
// SHORT格式的时间格式：9:45 AM
// MEDIUM格式的时间格式：9:45:39 AM
// LONG格式的时间格式：9:45:39 AM CST
// FULL格式的时间格式：9:45:39 AM CST
// Fri Dec 12 00:00:00 CST 2014
// Wed Dec 10 00:00:00 CST 2014
}
public class NewFormatterParse
{
public static void main(String[] args)
{
// 定义一个任意格式的日期时间字符串
String str1 = "2014==04==12 01时06分09秒";
// 根据需要解析的日期、时间字符串定义解析所用的格式器
DateTimeFormatter fomatter1 = DateTimeFormatter
.ofPattern("yyyy==MM==dd HH时mm分ss秒");
// 执行解析
LocalDateTime dt1 = LocalDateTime.parse(str1, fomatter1);
System.out.println(dt1); // 输出 2014-04-12T01:06:09
// ---下面代码再次解析另一个字符串---
String str2 = "2014$$$四月$$$13 20小时";
DateTimeFormatter fomatter2 = DateTimeFormatter
.ofPattern("yyy$$$MMM$$$dd HH小时");
LocalDateTime dt2 = LocalDateTime.parse(str2, fomatter2);
System.out.println(dt2); // 输出 2014-04-13T20:00
}
// 2014-04-12T01:06:09
// 2014-04-13T20:00
}
public class NewFormatterTest
{
public static void main(String[] args)
{
DateTimeFormatter[] formatters = new DateTimeFormatter[]{
// 直接使用常量创建DateTimeFormatter格式器
DateTimeFormatter.ISO_LOCAL_DATE,
DateTimeFormatter.ISO_LOCAL_TIME,
DateTimeFormatter.ISO_LOCAL_DATE_TIME,
// 使用本地化的不同风格来创建DateTimeFormatter格式器
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.MEDIUM),
DateTimeFormatter.ofLocalizedTime(FormatStyle.LONG),
// 根据模式字符串来创建DateTimeFormatter格式器
DateTimeFormatter.ofPattern("Gyyyy%%MMM%%dd HH:mm:ss")
};
LocalDateTime date = LocalDateTime.now();
// 依次使用不同的格式器对LocalDateTime进行格式化
for(int i = 0 ; i < formatters.length ; i++)
{
// 下面两行代码的作用相同
System.out.println(date.format(formatters[i]));
System.out.println(formatters[i].format(date));
}
}
// 2017-09-22
// 2017-09-22
// 09:53:20.208
// 09:53:20.208
// 2017-09-22T09:53:20.208
// 2017-09-22T09:53:20.208
// 2017年9月22日 星期五 9:53:20
// 2017年9月22日 星期五 9:53:20
// 上午09时53分20秒
// 上午09时53分20秒
// 公元2017%%九月%%22 09:53:20
// 公元2017%%九月%%22 09:53:20
}