04-Java基础-正则&系统类

正则表达式、Pattern 类和Matcher类、 Math类、Random类、System类、BigInteger类、BigDecimal类、Date类、Calendar类

正则表达式

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。

[] 表示单个字符

• 字符类
  [abc]       a、b 、c
  [^abc]     任何除了 a、b 、c 的单个字符 （否定）
  [a-zA-Z]     a到 z 或 A到 Z，两头的字母包括在内
  [a-d[m-p]]     a到d 或 m 到 p的单个字符，同[a-dm-p] (并集)
  [a-c&&[ab]]   a、b （交集）
  [0-9]        0到9的字符都包括

• 预定义字符类
  "."   任何字符。"." 一个字符， ".." 两个字符
  "\d"   数字：[0-9]，""表示转移字符，如果表示"\d",需要"\d"
  "\D"   非数字: [^0-9]
  "\s"   一个空白字符: [ \t\n\x0B\f\r]
  "\S"   非空白字符
  "\w"   单词字符：[a-zA-Z_0-9]
  "\W"   非单词字符

• 数量词
  "X?"   X出现一次或一次也没有   "[abc]?" : "a"、"b"、"c"、""
  "X"     没有字符或只包含X的字符串,即不出现其它字符  "[abc]" : ""、只包含a\b\c的字符串（aca）
  "X+"   X出现一次或多次，不出现其它字符   "[abc]+" : 只包含a\b\c的字符串（aca）
  "X{n}"   X出现恰好 n 次，不出现其它字符   "[abc]{2}" : 只包含a\b\c的字符串,且a\b\c只出现2次 (bc)
  "X{n,}"   X出现至少 n 次，不出现其它字符   "[abc]{2,}" : 只包含a\b\c的字符串,且a\b\c至少出现2次 (bcc)
  "X{n,m}"   X出现至少 n 次，但是不超过 m 次，不出现其它字符   "[abc]{2,3}" : 只包含a\b\c的字符串,且a\b\c至少出现2次，不超过3次 (bcc)

• 正则表达式的分割功能
  public String[] split(String regex);

String string = "luffy.naruto.kakashi";
String[] strings = string.split("\\.");

String string1 = "luffy naruto kakashi";
String[] strings1 = string.split(" ");

 for (int i = 0; i < strings.length; i++) {
     System.out.println(strings[i]);
}

• 正则表达式的替换功能
  public String replaceAll(String regex,String replacement)

String ss = "test111haha";
 ss = ss.replaceAll("\\d", "");

• 正则表达式的分组功能
  捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 （（A）（B（C））） 中，存在四个这样的组：
  1 ((A)(B(C)))
  2 (A)
  3 (B(C))
  4 (C)
  可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。
  还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

// 叠词 快快乐乐
String regex = "(.)\\1(.)\\2";  \\1表示第一组又出现一次，\\2表示第二组又出现一次
// 叠词 高兴高兴
String regex = "(..)\\1";

Pattern 类和Matcher类

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

Pattern pattern = Pattern.compile("a*b");           // 获取到正则表达式
Matcher matcher = pattern.matcher("aaaab");   // 获取匹配器
boolean isMatch = matcher.matches();                // 看是否能匹配
System.out.println(isMatch);

System.out.println("aaaab".matches("a*b"));   // 与上面结果一样

把一个字符串中的手机号码获取出来:

String string = "我的电话号码是13888888888，曾经用过18987654321，还用过17222222222";
String regex = "1[3578]\\d{9}";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern1.matcher(string);
while (matcher.find()){
    System.out.println(matcher.group());
}

Math类

// abs(); 返回参数的绝对值。
Math.abs(-10); // 10
// ceil(); 返回大于等于( >= )给定参数的的最小整数,结果是double值
Math.ceil(12.3); // 13.0
// floor();  返回小于等于（<=）给定参数的最大整数 ,结果是double值
Math.floor(12.6); // 12.0
// max(); 返回两个参数中的最大值。 
Math.max(12, 13);
// min(); 返回两个参数中的最小值。 
Math.min(12, 13);
// pow(); 返回第一个参数的第二个参数次方。double
Math.pow(2, 3); // 8
// random(); 返回一个随机数。 默认生成[0.0, 1.0)随机数
Math.random();
// round(); 它表示**四舍五入**，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
Math.round(11.3); // 11
// sqrt(); 求参数的算术平方根。 
Math.sqrt(4); // 2.0

Random类

/*
  根据种子计算随机数，第二种 指定了种子，每次运行结果相同。第一种 默认种子为纳秒值，每次运行都不一样
 */
Random random = new Random();
System.out.println(random.nextInt()); // int范围伪随机数

Random random1 = new Random(1000);
System.out.println(random1.nextInt());
System.out.println(random1.nextInt());

random.nextInt(100); // 生成 [0, 100)随机数，包括0，不包括100

System类

System 类包含一些有用的类字段和方法。

// 运行垃圾回收器,系统会默认调用finalize() 回收垃圾，gc()相当于手动调用finalize()。
// public static void gc();
System.gc();
// 终止正在运行的Java虚拟机，根据惯例，非0表示异常退出
// public static void exit(int status)
System.exit(0);
// 1970年开始，当前时间戳，毫秒
// public static long currentTimeMillis()
System.currentTimeMillis();
// 从指定源数组中复制一个数组，复制从指定位置开始，到目标数组的指定位置结束
// pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
int[] src = {11, 22, 33, 44, 55};
int[] dest = new int[8];
System.arraycopy(src, 1, dest, 0, 3); // 从src中下标为1的元素开始拷贝3个元素，从dest数组的0下标开始存
for (int i = 0; i < dest.length; i++) {
    System.out.println(dest[i]);
}

BigInteger类

可以让超过Integer范围内的数据进行运算。
构造方法：
public BigInteger(String val)；

String s = "222222222222222";
BigInteger bigInteger = new BigInteger(s);
String s1 = "111111111111111";
BigInteger bigInteger1 = new BigInteger(s1);

BigInteger newBigInteger = bigInteger.add(bigInteger1);  // 加

newBigInteger = bigInteger.subtract(bigInteger1); // 减

newBigInteger = bigInteger.multiply(bigInteger1); // 乘

newBigInteger = bigInteger.divide(bigInteger1); // 除 商取整数
BigInteger[] bigIntegers = bigInteger.divideAndRemainder(bigInteger1); // 商 和 余数
for (int i = 0; i < bigIntegers.length; i++) {
    System.out.println(bigIntegers[i]);
}

BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度，所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal。
不可变的、任意精度的有符号十进制数。

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)

Date类

表示特定的瞬间，精确到毫秒。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
Date(long millisec)

返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
long getTime( )
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
void setTime(long time)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
int compareTo(Date date)

• 使用 SimpleDateFormat 格式化日期

// 将date转换为时间字符串
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println(dateFormat.format(date));

// 将时间字符串转换为date
String string = "2000年01月01日 08:09:10";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
try {
     Date date2 = simpleDateFormat.parse(string);
     System.out.println(date2);
} catch (ParseException e) {
}          

Calendar类

Calendar calendar = Calendar.getInstance();
System.out.println(calendar);
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = calendar.get(Calendar.HOUR);
int hour1 = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int second = calendar.get(Calendar.SECOND);
// 星期，英语国家星期从星期日开始计算
int weekday = calendar.get(Calendar.DAY_OF_WEEK);

calendar.add(Calendar.YEAR, 1);  // 第一个参数 + 1
System.out.println(calendar.get(Calendar.YEAR)); // 2019

calendar.set(Calendar.YEAR, 2000); // 修改指定字段
System.out.println(calendar.get(Calendar.YEAR)); // 2000