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小时3分钟
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 }
}

  

正则表达式:

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

正则表达式所支持的合法字符
字符 解释
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对应的控制符

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP


正则表达式中的特殊字符
特殊字符 说明
$ 匹配一行的结尾。(要匹配$字符本身,使用\$,下同)
^ 匹配一行的开头
() 标记子表达式的开始、结束位置
[] 用于确定中括号表达式的开始、结束位置
{} 用于标记前面字表达式的出现频度
* 指定前面字表达式出现 0次或多次
+ 1次或多次
? 0次或1次
. 匹配除换行符 \n 之外的任何字符
\ 转义字符
| 或

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

    预定义字符
预定义字符 说明
. 匹配任何字符
\d 匹配0-9所有数字
\D 匹配非数字
\s 匹配所有的空白符,包括空格、制表符、回车符、换页符、换行符等
\S 匹配所有的非空白字符
\w 匹配所有的单次字符,包括0-9数字,26个英文字母,下划线 _
\W 匹配所有的飞单词字符

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

    方括号表达式
方括号表达式 说明
枚举 如[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]

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

    边界匹配符
边界匹配符 说明
^ 行开头
$ 行结尾
\b 单词的边界
\B 非单词的边界
\A 输入的开头
\G 前一个匹配的结尾
\Z 输入的结尾,仅用于最后的结束符
\z 输入的结尾

【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】-  Java基础类-LMLPHP

    三种模式的数量表示符
贪婪模式 勉强模式 占用模式 说明
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
}

  

  

  

04-25 07:37