课程链接：https://edu.aliyun.com/course/1012

第1~6章 关于线程：https://blog.csdn.net/weixin_43494837/article/details/113764127?spm=1001.2014.3001.5501

（思维导图在最后）

————————————————————————————————————

第7章：Java基础类库

课时26：StringBuffer类

  • String类是所有项目开发中一定会使用到的一个功能类，并且这个类拥有如下的特点：

    • 每个字符串的常量都属于一个String类的匿名对象，并且不可更改；
    • String类有两个常量池：静态常量池、运行时常量池；
    • String类的对象实例化，建议使用直接赋值的形式完成，这样可以直接将对象保存在常量池中，以方便重用。

  • String类的弊端：内容不允许修改。所以为了解决此问题，Java专门提供了StringBuffer类来实现字符串内容的修改处理。

  • String与StringBuffer对比：

    • 引用传递：

      • String类对象引用传递：

        public class JavaDemo{public static void main(String[] args) {String str = "Hello ";change(str);System.out.println(str); // 输出：Hello }public static void change(String temp) {temp += "World !"; // 内容并没有发生改变}
}

      • StringBuffer类对象引用传递：

        public class JavaDemo{public static void main(String[] args) {StringBuffer buf = new StringBuffer("Hello ");change(buf);System.out.println(buf); // 输出：Hello World !}public static void change(StringBuffer temp) {temp.append("World !"); // 内容发生了改变}
}

  • 实际上大部分的情况下，很少会出现有字符串内容的改变，这种改变指的并不是针对静态常量池的改变。

    public class JavaDemo{public static void main(String[] args) {String strA = "pikaqiu";String strB = "pi" + "ka" + "qiu";System.out.println(strA == strB); // 输出：true}
}

    上述strB对象的内容并不算是改变，它在程序编译后，实际上相当于：

    StringBuffer buf = new StringBuffer();
buf.append("pi").append("ka").append("qiu");

    所有的“+”在编译之后都变为了StringBuffer中的append()方法，并且在程序中，StringBuffer类与String类对象之间本来就可以直接互相转换：

    • String类对象变为StringBuffer类对象：依靠StringBuffer类的构造方法；
    • 所有类对象都可以通过toString()方法变为String类型。

  • 在StringBuffer类中，除了支持字符串内容的修改外，也提供有String类所不具备的方法：

    • 插入数据：public StringBuffer insert(int offset, 数据类型 b)

      public class JavaDemo{public static void main(String[] args) {StringBuffer buf = new StringBuffer();buf.append("qiu").insert(0, "pi").insert(2, "ka");System.out.println(buf); // 输出：pikaqiu}
}

    • 删除指定范围的数据：public StringBuffer delete(int start, int end)

      public class JavaDemo{public static void main(String[] args) {StringBuffer buf = new StringBuffer();buf.append("Hello World!").delete(5, 11);System.out.println(buf); // 输出：Hello!}
}

    • 字符串内容反转：public StringBuffer reverse()

      public class JavaDemo{public static void main(String[] args) {StringBuffer buf = new StringBuffer();buf.append("Hello World!").reverse();System.out.println(buf); // 输出：!dlroW olleH}
}

  • 与StringBuffer类相似的还有一个StringBuilder类，它是在JDK1.5开始提供的，并且提供的方法与StrIngBuffer功能相同，区别是：StringBuffer类中的方法是线程安全的，全部使用了sybchronized关键字，而StringBuilder类是非线程安全的。

  • 面试题：请解释String、StringBuffer、StringBuilder的区别？

    • String类是字符串的首选类型，其最大的特点是内容不允许修改，而StringBuffer与StringBuilder类的内容允许修改；
    • StringBuffer是在JDK1.0的时候就提供的，是线程安全的操作，而StringBuilder类是在JDK1.5的时候才提供的，是非线程安全的操作。

课时27：CharSequence接口

  • CharSequene是一个描述字符串结构的接口，在这个接口里面一般有三种常用的子类：

    • String类：

      public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

    • StringBuffer类：

      public final class StringBuffer
extends Object
implements Serializable, CharSequence

    • StringBuilder类：

      public final class StringBuilder
extends Object
implements Serializable, CharSequence

  • 只要有字符串就可以为CharSequence实例化：

    public class JavaDemo{public static void main(String[] args) {CharSequence str = "pikaqiu"; // 子类实例向父接口转型}
}

  • CharSequence接口的操作方法：

    • 获取指定索引字符：public char charAt(int index)

    • 获取字符串的长度：public int length()

    • 截取部分字符串：public CharSequence subSequence(int start, int end)

      public class JavaDemo{public static void main(String[] args) {CharSequence str = "pikaqiu"; // 子类实例向父接口转型CharSequence sub = str.subSequence(2, 7);System.out.println(sub); // 输出：kaqiu}
}

课时28：AutoCloseable接口

  • AutoCloseable主要是用于日后进行资源开发的处理上，以实现资源（如文件、网络、数据库）的自动关闭（释放资源）。

  • AutoCloseable接口时在JDK1.7时提供的，并且该接口只提供一个方法：

    • 关闭方法：public void close() throws Exception

  • 范例（发送消息）：

    • 手工实现资源的处理：

      interface IMessage {public void send(); // 发送消息
}
class NetMessage implements IMessage {private String msg;public NetMessage(String msg) {this.msg = msg;}public boolean open() {System.out.println("【OPEN】打开消息发送通道。");return true;}@Overridepublic void send() {if (this.open()) System.out.println("【*** 发送消息 ***】");}public void close() {System.out.println("【CLOSE】关闭消息发送通道。");}
}
public class JavaDemo{public static void main(String[] args) {NetMessage nm = new NetMessage("pikaqiu");nm.send();nm.close();}
}

    • 实现自动关闭处理（使用AutoCloseable + 异常处理）：

      interface IMessage extends AutoCloseable { // 继承AutoCloseable接口public void send(); // 发送消息
}
class NetMessage implements IMessage {private String msg;public NetMessage(String msg) {this.msg = msg;}public boolean open() {System.out.println("【OPEN】打开消息发送通道。");return true;}@Overridepublic void send() {if (this.open()) System.out.println("【*** 发送消息 ***】");}public void close() {System.out.println("【CLOSE】关闭消息发送通道。");}
}
public class JavaDemo{public static void main(String[] args) {// 以下的try...catch...，为JDK1.7以后提供的// 它是带资源try语句（try-with-resource）的简化形式// 使用：实现AutoCloseable接口的实例放在try()中，离开try{}块时将自动调用close()方法try (IMessage nm = new NetMessage("pikaqiu")) { // 需要进行异常处理nm.send(); // 只发送，无需手动关闭} catch (Exception e) {}}
}

课时29：Runtime类

  • Runtime描述的是运行时的状态，也就是说在整个JVM中，Runtime类是唯一一个与JVM运行状态有关的类，并且会默认提供有一个该类的实例化对象。

  • 查看Runtime类源码可以发现，其采用的是单例设计模式，所以在每个JVM进程里面是只提供有一个Runtime类对象的。

  • 由于Runtime类属于单例设计模式，所以如果要想获取实例化对象，就可以依靠类中的getRuntime()方法：

    • 获取实例化对象：public static Runtime getRuntime()

    • 获取本机CPU内核数：public int availableProcessors()

      （内核数实际上决定了并发访问量的最佳状态）

      public class JavaDemo{public static void main(String[] args) {Runtime run = Runtime.getRuntime();System.out.println(run.availableProcessors());}
}

    • 获取最大可用内存空间：public long maxMemory()

    • 获取可用内存空间：public long totalMemory()

    • 获取空闲内存空间：public long freeMemory()

    • 手工进行GC处理：public void gc()

public class JavaDemo{public static void main(String[] args) throws Exception {Runtime run = Runtime.getRuntime();System.out.println("【1】MAX_MEMORY：" + run.maxMemory());System.out.println("【1】TOTAL_MEMORY：" + run.totalMemory());System.out.println("【1】FREE_MEMORY：" + run.freeMemory());String str = "";for (int i = 0; i < 10000; i++) {str += i; // 产生大量垃圾空间}System.out.println("【2】MAX_MEMORY：" + run.maxMemory());System.out.println("【2】TOTAL_MEMORY：" + run.totalMemory());System.out.println("【2】FREE_MEMORY：" + run.freeMemory());Thread.sleep(2000);run.gc(); // 手工GCSystem.out.println("【3】MAX_MEMORY：" + run.maxMemory());System.out.println("【3】TOTAL_MEMORY：" + run.totalMemory());System.out.println("【3】FREE_MEMORY：" + run.freeMemory());}
}
  • 面试题：请问什么是GC？如何处理？

    • GC（Garbage Collector）垃圾收集器：可以由系统自动调用，或使用Runtime类的gc()手工调用的垃圾释放功能。

课时30：System类

  • 系统输出采用的就是System类，System类的其它方法如下：

    • 数组拷贝：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
    • 获取当前的日期实际数值：public static long currenTimeMillis()
    • 进行垃圾回收：public static void gc()

  • 范例：

    • 操作耗时的统计：

      public class JavaDemo{public static void main(String[] args) {long start = System.currentTimeMillis();Runtime run = Runtime.getRuntime();String str = "";for (int i = 0; i < 10000; i++) {str += i; // 产生大量垃圾空间}long end = System.currentTimeMillis();System.out.println("操作耗时：" + (end - start));}
}

  • 在System类里也提供由gc()方法，但其实它就是调用了Runtime类中的gc()：Runtime.getRuntime().gc();

  • 在Java中，手工进行GC处理只有Runtime类的gc()。

课时31：Cleaner类

  • Cleaner类是在JDK1.9之后提供的一个对象清理操作，其主要的功能是进行finialize()方法的替代。

    • 在C++语言里有两种特殊的函数：构造函数（功能跟Java一样）、析构函数（对象手工回收），而在Java里面所有的垃圾空间都是通过GC自动回收的，所以很多情况下是不需要使用析构函数的。

    • 但Java本身依然提供了给用户收尾的操作，每个实例化对象在回收之前至少给它一个喘息的机会，最初实现对象收尾的处理就是Object类中所提供的finalize()方法：

      @Deprecated(since="9")
protected void finalize() throws Throwable

  • 范例：

    • 传统回收：

      • Member类：

        class Member {public Member() {System.out.println("【构造】在一个雷电交加的日子里，林强诞生了。");}public void finalize() throws Exception {System.out.println("【回收】最终你都要挂的。");throw new Exception("我还要再活500年~");}
}

      • 主类实现：

        • 系统自动GC：

          public class JavaDemo{public static void main(String[] args) {Member mem = new Member(); // 诞生mem = null; // 成为垃圾
//        输出：
//        【构造】在一个雷电交加的日子里，林强诞生了。}
}

        • 手动GC：

          public class JavaDemo{public static void main(String[] args) {Member mem = new Member(); // 诞生mem = null; // 成为垃圾System.gc();
//        输出：
//        【构造】在一个雷电交加的日子里，林强诞生了。
//        【回收】最终你都要挂的。}
}

        • GC语句后输出：

          public class JavaDemo{public static void main(String[] args) {Member mem = new Member(); // 诞生mem = null; // 成为垃圾System.gc();System.out.println("太阳照常升起，地球照样转动。");
//        输出：
//        【构造】在一个雷电交加的日子里，林强诞生了。
//        太阳照常升起，地球照样转动。
//        【回收】最终你都要挂的。}
}

      但是从JDK1.9开始，这一操作已不建议使用，而是建议使用AutoCloseable或java.lang.ref.Cleaner（Cleaner也支持有AutoCloseable）。

    • 使用Cleaner回收：

      import java.lang.ref.Cleaner;class Member implements Runnable {public Member() {System.out.println("【构造】在一个雷电交加的日子里，林强诞生了。");}@Overridepublic void run() {System.out.println("【回收】最终你都要挂的。");}
}
class MemberCleaning implements AutoCloseable { // 实现清除的处理private static final Cleaner cleaner = Cleaner.create(); // 创建一个清除处理private Member member;private Cleaner.Cleanable cleanable;public MemberCleaning() {this.member = new Member(); // 创建新对象this.cleanable = this.cleaner.register(this, this.member); // 注册使用的对象}@Overridepublic void close() throws Exception {this.cleanable.clean(); // 启动多线程}
}
public class JavaDemo{public static void main(String[] args) throws Exception {try (MemberCleaning mc = new MemberCleaning()) {} catch (Exception e) {}
//        输出：
//        【构造】在一个雷电交加的日子里，林强诞生了。
//        【回收】最终你都要挂的。}
}

  • 在新一代的清除回收处理过程中，更多情况下考虑的是多线程的使用，即：为了防止有可能造成的延迟处理，所以许多对象回收前的处理都是单独通过一个线程来完成的。

课时32：对象克隆

  • 对象克隆：就是对象的复制，而且属于全新的复制。即：使用已有对象内容创建 一个新的对象。

  • 对象克隆需要使用Object类中的clone()方法：

    • 对象克隆：protected Object clone() throws CloneNotSupportedExcepton

  • 所有的类都会继承Object类，所以所有的类都一定会有clone()方法，但并不是所有的类都希望被克隆，所以如果想要实现对象克隆，那么对象所在的类需要实现Cloneable接口，而此接口并没有提供任何方法，因为它描述的是一种能力。（接口有三大主要作用，但如果只按基础性开发的理解，只有两个：标准、能力。）

  • 范例：

    class Member implements Cloneable {private String name;private int age;public Member(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "【" + super.toString() + "】name = " + this.name + "，age = " + this.age;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class JavaDemo{public static void main(String[] args) throws Exception {Member memberA = new Member("林强", 30);Member memberB = (Member) memberA.clone();System.out.println(memberA);System.out.println(memberB);
//        输出：
//        【Member@75412c2f】name = 林强，age = 30
//        【Member@3796751b】name = 林强，age = 30}
}

  • 在开发中，如果不是非常特别的需求下，很少会出现有对象克隆的需求。

第8章：数字操作类

课时33：Math数学计算类

  • 程序就是一个数学的处理过程，所以Java语言本身也提供有相应的数字处理的类库支持。

  • Math类：进行数学计算，提供基础的计算公式。其构造方法被私有化，并且提供的所有方法都是静态方法，即：这些方法都可以通过类名称直接调用。

public class JavaDemo{public static void main(String[] args) {System.out.println(Math.abs(-10.1)); // 绝对值：10.1System.out.println(Math.max(10.2, 20.3)); // 较大值：20.3System.out.println(Math.log(2)); // 对数：0.6931471805599453System.out.println(Math.round(15.1)); // 四舍五入：15System.out.println(Math.round(-15.5)); // 四舍五入：-15System.out.println(Math.round(15.51)); // 四舍五入：16System.out.println(Math.pow(2, 3)); // 幂次：8.0(2的3次方)}
}

  • 自定义四舍五入并设置保留指定小数位的方法（Math类中未提供，它只提供基础的数学公式）：

    class MathUtil {private MathUtil() {}/*** 实现数值的四舍五入，并可设置保留小数位数* @param num 进行四舍五入的数字* @param scale 要保留的小数位数* @return 四舍五入后的结果*/public static double round(double num, int scale) {return Math.round(num * Math.pow(10, scale)) / Math.pow(10, scale);}
}
public class JavaDemo{public static void main(String[] args) {System.out.println(MathUtil.round(19.86273, 2)); // 19.86}
}

课时34：Random随机数生成类

  • java.util.Random类：产生随机数。

  • Random类的方法：

    • 产生一个不大于边界的随机正整数：public int nextInt(int bound)

  • 案例：

    • 生成随机数：

      import java.util.Random;
public class JavaDemo{public static void main(String[] args) {Random rand = new Random();for (int i = 0; i < 10; i++) {System.out.print(rand.nextInt(100) + " ");}}
}

    • 随机生成彩票号：

      import java.util.Random;
public class JavaDemo{public static void main(String[] args) {int[] data = new int[7];Random rand = new Random();int foot = 0;while(7 > foot) {int num = rand.nextInt(37);if (isUse(num, data)) data[foot ++] = num;}java.util.Arrays.sort(data);for (int i = 0; i < data.length; i++) {System.out.print(data[i] + " ");}}/*** 判断输入的数字是否可以使用（不为0且不在数组中）* @param num 判断的数字* @param temp 判断的数组* @return 可以使用就返回true，否则就返回false*/public static boolean isUse(int num, int[] temp) {if (0 == num) return false;for (int i = 0; i < temp.length; i++) {if (num == temp[i]) return false;}return true;}
}

课时35：大数字处理类

  • 大数字操作类：可以实现海量数字的计算，但能提供的也只是基础计算。
  • 如数字很大，超过了double范围，那么就没有数值类型可以保存了。而大数字如果要进行加法计算，那么就要逐位拆分进行计算，并且还要进行进位处理。因此，为了解决此问题，提供了两个大数字操作类：BigInteger、BigDecimal。

  • 当数字很大时，只能使用字符串来进行描述：

    • BigInteger类构造方法：public BigInteger(String val)
    • BigDecimal类构造方法：public BigDecimal(String val)

  • BigInteger类：

    import java.math.BigInteger;
public class JavaDemo{public static void main(String[] args) {BigInteger bigA = new BigInteger("2323232325678973132133232233232232323");BigInteger bigB = new BigInteger("2323232323232233232232323");System.out.println("加法操作：" + bigA.add(bigB));System.out.println("减法操作：" + bigA.subtract(bigB));System.out.println("乘法操作：" + bigA.multiply(bigB));System.out.println("除法操作：" + bigA.divide(bigB));}
}
    • 求余：public BigInteger[] divideAndRemainder(BigInteger val)
    import java.math.BigInteger;
public class JavaDemo{public static void main(String[] args) {BigInteger bigA = new BigInteger("2323232325678973132133232233232232323");BigInteger bigB = new BigInteger("2323232323232233232232323");BigInteger[] result = bigA.divideAndRemainder(bigB);System.out.println("商：" + result[0] + "，余：" + result[1]);}
}

  • BigDecimal类：

    import java.math.BigDecimal;
public class JavaDemo{public static void main(String[] args) {BigDecimal bigA = new BigDecimal("2323232325678973132133232233232232323");BigDecimal bigB = new BigDecimal("2323232323232233232232323");System.out.println("加法操作：" + bigA.add(bigB));System.out.println("减法操作：" + bigA.subtract(bigB));System.out.println("乘法操作：" + bigA.multiply(bigB));BigDecimal[] result = bigA.divideAndRemainder(bigB);System.out.println("商：" + result[0] + "，余：" + result[1]);}
}
    • 除法（存在数据进位问题）：public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
    • 实现四舍五入处理：
    import java.math.BigDecimal;
import java.math.RoundingMode;
class MathUtil {private MathUtil() {}public static double round(double num, int scale) {return new BigDecimal(num).divide(new BigDecimal(1.0), scale, RoundingMode.HALF_UP).doubleValue();}
}
public class JavaDemo{public static void main(String[] args) {System.out.println(MathUtil.round(19.6352, 2)); // 19.64}
}

  • 如果计算的数，没有超过基本数据类型所包含的位数，强烈不建议使用大数字类，因为它们计算性能很差。

  • Math类的处理，由于使用的都是基本数据类型，所以性能一定要高于大数字类。

第9章：日期操作类

课时36：Date日期处理类

  • 从整体的java来讲，一直在强调简单java类组合的主要设计来自于数据表的结构，那么在数据表的结构常用的类型有：数字、字符串、日期。

  • 在Java里提供有一个java.util.Date的类，可以直接实例化这个类来获取当前的日期时间。

import java.util.Date;
public class JavaDemo{public static void main(String[] args) {Date date = new Date();System.out.println(date); // 输出：Fri Jan 22 16:35:44 CST 2021}
}

  • 观察Date类的构造方法：

    public Date() {this(System.currentTimeMillis());
}

    public Date(long date) {fastTime = date;
}

    可以发现：Date类，只是对long数据的包装。

  • Date与long的转换：

    • 将long转为Date：public Date(long date)
    • 将Date转为long：public long getTime()
    import java.util.Date;
public class JavaDemo{public static void main(String[] args) {Date date = new Date();System.out.println(date); // 输出：Fri Jan 22 16:43:44 CST 2021long current = date.getTime();current += 864000 * 1000; // 10天的毫秒数System.out.println(new Date(current)); // 输出：Mon Feb 01 16:43:44 CST 2021}
}

课时37：SimpleDateFormat日期处理类

  • 虽然Date类可以获取当前的日期时间，但默认情况下Date类输出的格式并不为我们所习惯，所以为了格式化日期，java.text包中提供有SimpleDateFormat类。

  • SimpleDateFormat类提供的方法：

    • 格式化日期（继承DateFormat类）：public final String format(Date date)
    • 将字符串转为日期（继承DateFormat类）：public Date parse(String source) throws ParseException
    • 构造方法：public SimpleDateFormat(String pattern)
      • 日期格式：年（yyyy）、月（MM）、日（dd）、时（HH）、分（mm）、秒（ss）、毫秒（SSS）
import java.text.SimpleDateFormat;
import java.util.Date;
public class JavaDemo{public static void main(String[] args) {Date date = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");String str = sdf.format(date);System.out.println(str); // 输出：2021-01-22 16:53:36.101}
}
  • 字符串与日期之间的转换：
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class JavaDemo{public static void main(String[] args) throws ParseException {String birthday = "1846-11-11 11:11:11.111";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");Date date = sdf.parse(birthday);System.out.println(date); // 输出：Wed Nov 11 11:11:11 CST 1846}
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class JavaDemo{public static void main(String[] args) throws ParseException {String birthday = "1846-13-11 11:11:11.111"; // 月份为13月SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");Date date = sdf.parse(birthday);System.out.println(date); // 输出：Mon Jan 11 11:11:11 CST 1847}
}

当字符串定义的日期时间数字超过指定范围时，会自动进行进位。

  • String类字符串，可以向所有类型转换，包括基本数字类型和日期类型，所以其是一个万能的类型。

第10章：正则表达式

课时38：认识正则表达式

  • String是一个非常万能的类型，因为String不仅仅可以支持各种字符串的处理操作，也支持向各数据类型转换的功能，所以在开发中，只要是用户输入的信息，基本上都用String来表示。但向其它数据类型转换的时候，为了保证转换的正确性，往往需要进行一些复杂的验证处理。

  • 范例：

    • 传统数字判断：

      public class JavaDemo{public static void main(String[] args) {String str = "123";if (isNumber(str)) {int num = Integer.parseInt(str);System.out.println(num * 2); // 246}}public static boolean isNumber(String str) {char[] data = str.toCharArray();for (int i = 0; i < data.length; i++) {if ('9' < data[i] || '0' > data[i]) return false;}return true;}
}

    • 使用正则表达式进行数字判断：

      public class JavaDemo{public static void main(String[] args) {String str = "123";if (str.matches("\\d+")) {int num = Integer.parseInt(str);System.out.println(num * 2); // 246}}
}

  • 正则表达式最早是从Perl语言里发展来的，但在JDK1.4之前，如果要用正则表达式则需要引入其它的jar文件；在JDK1.4之后，才被JDK所支持，提供有java.util.regex开发包，并且String类中也有方法直接支持正则处理。

课时39：常用正则标记

  • 要想进行正则的处理操作，那么首先就要对常用的正则标记有所掌握。

  • 从JDK1.4开始提供有java.util.regex开发包，这个包里提供有一个Pattern类，这个类里定义有所有支持的正则标记：

    • 单个字符匹配：

      • 任意字符：表示由任意字符组成；

        public class JavaDemo{public static void main(String[] args) {String str = "a"; // 要判断的数据String regex = "a"; // 正则表达式System.out.println(str.matches(regex)); // 输出：true}
}

      • \\：匹配“\”

      • \n：匹配换行；

      • \t：匹配制表符；

    • 单个字符集（可以从里面任选一个字符进行匹配）：

      • [abc]：表示可以是字母a、b、c中的任意一个：

        public class JavaDemo{public static void main(String[] args) {String regex = "[abc]"; // 正则表达式System.out.println("a".matches(regex)); // 输出：trueSystem.out.println("q".matches(regex)); // 输出：falseSystem.out.println("aq".matches(regex)); // 输出：false}
}

      • [^abc]：表示不是字母a、b、c中的任意一个：

        public class JavaDemo{public static void main(String[] args) {String regex = "[^abc]"; // 正则表达式System.out.println("a".matches(regex)); // 输出：falseSystem.out.println("q".matches(regex)); // 输出：trueSystem.out.println("aq".matches(regex)); // 输出：false}
}

      • [a-zA-Z]：表示为一个任意字母，不区分大小写：

        public class JavaDemo{public static void main(String[] args) {String regex = "[a-zA-Z]"; // 正则表达式System.out.println("a".matches(regex)); // 输出：trueSystem.out.println("aa".matches(regex)); // 输出：falseSystem.out.println("A".matches(regex)); // 输出：trueSystem.out.println("AA".matches(regex)); // 输出：falseSystem.out.println("1".matches(regex)); // 输出：false}
}

      • [0-9]：表示为一位数字：

        public class JavaDemo{public static void main(String[] args) {String regex = "[0-9]"; // 正则表达式System.out.println("a".matches(regex)); // 输出：falseSystem.out.println("1".matches(regex)); // 输出：trueSystem.out.println("11".matches(regex)); // 输出：false}
}

    • 单个简化字符集：

      • .：匹配一个任意字符：

        public class JavaDemo{public static void main(String[] args) {String regex = "."; // 正则表达式System.out.println("a".matches(regex)); // 输出：trueSystem.out.println("aa".matches(regex)); // 输出：falseSystem.out.println("1".matches(regex)); // 输出：trueSystem.out.println("11".matches(regex)); // 输出：false}
}

      • \d：等价于“[0-9]”：

        public class JavaDemo{public static void main(String[] args) {String regex = "\\d"; // 正则表达式System.out.println("a".matches(regex)); // 输出：falseSystem.out.println("1".matches(regex)); // 输出：trueSystem.out.println("11".matches(regex)); // 输出：false}
}

      • \D：等价于“[^0-9]”：

        public class JavaDemo{public static void main(String[] args) {String regex = "\\D"; // 正则表达式System.out.println("a".matches(regex)); // 输出：trueSystem.out.println("1".matches(regex)); // 输出：falseSystem.out.println("11".matches(regex)); // 输出：false}
}

      • \s：匹配空格/换行/制表符：

        public class JavaDemo{public static void main(String[] args) {String regex = "\\s"; // 正则表达式System.out.println("a".matches(regex)); // 输出：falseSystem.out.println(" ".matches(regex)); // 输出：true}
}

      • \w：匹配字母/数字/下划线，等价于“[a-zA-Z0-9_]”;

      • \W：匹配非字母/数字/下划线，等价于“[^\w]”，等价于“[^a-zA-Z0-9_]”;

    • 边界匹配：

      • ^：匹配边界开始；
      • $：匹配边界结束。

    • 数量表示（默认加上数量表达式才可以匹配多个字符）：

      • ?：表示可以出现0或1次；
      • *：表示可以出现0或1或多次；
      • +：表示可以出现1或多次；
      • {n}：匹配的长度正好为n次；
      • {n,}：匹配的长度为n次以上；
      • {n, m}：匹配的长度为n~m次。

    • 逻辑表达式：连接多个正则：

      • 表达式X表达式Y：表达式X后紧跟表达式Y；
      • 表达式X|表达式Y：满足表达式X或表达式Y即可。
      • (表达式)：为表达式设置一个整体描述，可以为整体描述设置数量单位。

课时40：String类对正则的支持