【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】- Java基础类
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 } }
正则表达式:
正则表达式所支持的合法字符
字符 解释
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 = { "kongyeeku@163.com" , "kongyeeku@gmail.com", "ligang@crazyit.org", "wawa@abc.xx", "a@a.com", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@aa.com" }; 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\ // kongyeeku@163.com是一个有效的邮件地址! // kongyeeku@gmail.com是一个有效的邮件地址! // ligang@crazyit.org是一个有效的邮件地址! // wawa@abc.xx不是一个有效的邮件地址! // a@a.com不是一个有效的邮件地址! // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@aa.com不是一个有效的邮件地址!
// 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 }