【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小时３分钟
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
}
【Java】-NO.16.EBook.4.Java.1.007-【疯狂Java讲义第3版 李刚】- Java基础类的更多相关文章
- 【Java】-NO.16.EBook.4.Java.1.011-【疯狂Java讲义第3版 李刚】- AWT
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.011-[疯狂Java讲义第3版 李刚]- AWT Style:EBook Series:Java ...
- 【Java】-NO.16.EBook.4.Java.1.012-【疯狂Java讲义第3版 李刚】- Swing
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.011-[疯狂Java讲义第3版 李刚]- Swing Style:EBook Series:Jav ...
- 【Java】-NO.16.EBook.4.Java.1.012-【疯狂Java讲义第3版 李刚】- JDBC
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.012-[疯狂Java讲义第3版 李刚]- JDBC Style:EBook Series:Java ...
- 【Java】-NO.16.EBook.4.Java.1.005-【疯狂Java讲义第3版 李刚】- 枚举
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.005-[疯狂Java讲义第3版 李刚]- 枚举 Style:EBook Series:Java Si ...
- 【Java】-NO.16.EBook.4.Java.1.006-【疯狂Java讲义第3版 李刚】- 垃圾回收
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.006-[疯狂Java讲义第3版 李刚]- 垃圾回收 Style:EBook Series:Java ...
- 【Java】-NO.16.EBook.4.Java.1.008-【疯狂Java讲义第3版 李刚】- 集合/容器
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.008-[疯狂Java讲义第3版 李刚]- 集合 Style:EBook Series:Java Si ...
- 【Java】-NO.16.EBook.4.Java.1.009-【疯狂Java讲义第3版 李刚】- 泛型
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.009-[疯狂Java讲义第3版 李刚]- 泛型 Style:EBook Series:Java Si ...
- 【Java】-NO.16.EBook.4.Java.1.010-【疯狂Java讲义第3版 李刚】- 异常
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.010-[疯狂Java讲义第3版 李刚]- 异常 Style:EBook Series:Java Si ...
- 【Java】-NO.16.EBook.4.Java.1.001-【疯狂Java讲义第3版 李刚】- UML
1.0.0 Summary Tittle:[Java]-NO.16.EBook.4.Java.1.001-[疯狂Java讲义第3版 李刚]- Style:EBook Series:Java Since ...
随机推荐
- YAML入门
概要 YAML(是YAML Ain't Markup Language的缩写,尾音的发音类似Camel)是一种序列化数据的语言(类似json, xml),使用轻量高可读性的语法描述list, dict ...
- Centos 7上Docker私有仓库Registry实战
1. 关于Registry 官方的Docker hub是一个用于管理公共镜像的好地方,我们可以在上面找到我们想要的镜像,也可以把我们自己的镜像推送上去.但是,有时候,我们的使用场景需要我们拥有一个私有 ...
- java封装实现Excel建表读写操作
对 Excel 进行读写操作是生产环境下常见的业务,网上搜索的实现方式都是基于POI和JXL第三方框架,但都不是很全面.小编由于这两天刚好需要用到,于是就参考手写了一个封装操作工具,基本涵盖了Exce ...
- chfn是用来改变你的finger讯息
finger 总览 finger[-lmsp][user...][user host...][[]] 参数: -s Finger显示用户的登录名,真名,终端名以及写状态(如果写被禁止,在终端名后显示一 ...
- python3.6利用pyinstaller模块打包程序为.exe可执行程序
步骤: 1.安装pyinstaller模块:(必须在联网情况下进行) 操作原理: python3.6已经自带了pip,所以只需要在cmd中执行 pip install pyinstaller 就可以安 ...
- day1 一、编程语言与计算机五大组成部分
一.编程与编程语言 1.什么是编程语言 语言是一个事物与另一个事物沟通的介质. 编程语言是程序员与计算机沟通的介质. 2.什么是编程 编程就是程序员按照某种编程的语法规范将自己想让计算机做的事情表达出 ...
- 洛谷P1135 奇怪的电梯【bfs】
题目:https://www.luogu.org/problemnew/show/P1135 题意: 一共有n层楼,在第i层可以往上或往下$k_i$层. 问从$a$层到$b$层至少需要多少乘多少次电梯 ...
- 洛谷P1101 单词方阵【暴力】【字符串】
题目描述 给一n×nn \times nn×n的字母方阵,内可能蕴含多个“yizhong”单词.单词在方阵中是沿着同一方向连续摆放的.摆放可沿着 888 个方向的任一方向,同一单词摆放时不再改变方向, ...
- [No000012F]WPF(7/7) - 样式，触发器和动画
WPF Tutorial : Beginning [^] WPF Tutorial : Layout-Panels-Containers & Layout Transformation [^] ...
- [No0000B0]ReSharper操作指南1/16-入门与简介
安装指南 在安装之前,您可能需要检查系统要求. ReSharper是一个VisualStudio扩展.它支持VisualStudio2010,2012,2013,2015和2017.安装完成后,您将在 ...