一周学完Java基础

学习 java

同步于我博客，欢迎关注小魁的学习博客

（一）准备工作

0.下载jdk：官方下载

安装，添加环境变量...

1.工欲善其事必先利其器--我选择Sublime

• 配置sublime的Java编译系统

  工具->编译系统->新建编译系统
  
  写入

{
    "shell_cmd": "javaRun \"$file\"",
    "file_regex": "^(...*?):([0-9]*):?([0-9]*)",
    "working_dir": "${file_path}",
    "selector": "source.java",
    // 中文乱码问题
    "encoding":"gbk",
    "variants":[
        // 编译并在CMD中运行
        {
        "name":"java CMD Run",
        "shell":true,
        "shell_cmd":"start cmd /c \"javaRun \"$file\" & pause\""
        }
   ]
}

保存为JavaRun.sublime-build

• 再在Jdk安装目录下新建一个JavaRun.bat的批处理

再写入：

@ECHO OFF  
cd %~dp1  
ECHO Compiling %~nx1.......  
IF EXIST %~n1.class (  
    DEL %~n1.class  
)  
javac  %~nx1  
IF EXIST %~n1.class (  
    ECHO -----------OUTPUT-----------  
    java %~n1  
)  

2.helloword 走一波

先选择java的编译系统,就是第一步修改（新建）的。

Ctrl+B 运行一波

-----------------更新线------2017年12月29日 13:36:58-----------

PS：解决中文乱码以及编译报错的方法
jdk安装目录/bin/JavaRun.bat中编译命令改为：javac -encoding UTF-8 ...

sublime中编译系统javaRun.sublime-build增加一行
"encoding":"gbk"

（二）Java基础

1.数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

注意：char： 与c语言不同,为两个字节（16位）
　　　　　　　是Unicode的编码，所以可以存放一个中文字符
　　　 float： 32个二进制位：
　　　 　　　　1位符号位
　　　 　　　　23位位数位（小数点后）
　　　 　　　　８位指数位（00000000 - 11111111）-127~127
　　　 　　　　0代表0，255代表无穷大

• 数据类型的隐式转换：

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

byte a = 3;
byte b = 4;
byte c = a + b;
// 报错：可能会损失精度。
// byte 与byte(或short、char)进行运算时候会提升精度为int。

• 字符串的加法：

System.out.println("hello"+'a'+2);
/**
* -----------OUTPUT-----------  
* helloa2
* 解释：任何数据类型，用 + 与字符串相连接都会产生字符串
**/
System.out.println("5+5="+5+5);
/**
* -----------OUTPUT-----------  
* 5+5=55
* 解释：运算顺序是从左往右算。
**/

2.运算符

• 算术运算(略)
• 前自增与后自增

int a = 5,b = 5;
System.out.println("(a++)= " + (a++));
System.out.println(" a   = " + a);
System.out.println("(++b)= " + (++b));
System.out.println(" b   = " + b);
/**
* -----------OUTPUT-----------  
* (a++)= 5
* a    = 6
* (++b)= 6
*  b   = 6
**/
int x = 4;
//  y =   4  +  6  + 60; 
int y = (x++)+(++x)+(x*10);
System.out.println(y);
/**
* -----------OUTPUT-----------  
* 70
**/

• 逻辑运算符：

&(按位与) ，|（按位或），！（非），^（异或），~（按位取反）。
&&（短路与）， ||（短路或）【短路特性】

Ps: ^（异或运算符）特点：一个数对另一个数异或两次，得该数本身。

// 不借助第三方变量，交换两个变量的值
int a = 3,b=5;
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + " b = "+b);
/**
* -----------OUTPUT-----------  
* a = 5 b = 3
**/

• 位移运算

<< : 左移 左边最高位丢弃，右边补0
>>: 右移 最高位是什么，左边就补什么。
>>>:无符号右移 无论最高位是什么，左边都补0.

// 最有效率的计算7*8
System.out.println(7<<3);

• 三目运算符（略）

3.键盘输入

import java.util.Scanner; //引入包
class  testScanner{
    public static void main(String[] args) {
        // 实例化一个对象
        Scanner sc = new Scanner(System.in); 
        System.out.println("请输入一个数");
        // 调用方法
        int x = sc.nextInt();
        System.out.println(x);
    }
}

4.流程控制（参见C语言跳过）

补：java 中的foreach

for(int i : arr){  
    ......  
} 

（三）面向对象

1.类与对象

• 对象：对象是类的一个实例,有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

• 类：类是一个模板，它描述一类对象的行为和状态。

1.1 类变量：

• 局部变量：
  在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

  • 访问修饰符不能用于局部变量；
  • 局部变量只在声明它的方法、构造方法或者语句块中可见；
  • 局部变量是在栈上分配的。
  • 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

• 成员变量：
  成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

• 类变量：
  类变量也声明在类中，方法体之外，但必须声明为static类型。

  • 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
  • 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
  • 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
  • 静态变量在程序开始时创建，在程序结束时销毁。
  • 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
  • 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
  • 静态变量可以通过：ClassName.VariableName的方式访问。

1.2 类方法

一个类可以拥有多个方法。

• 构造方法
  每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

• this 关键字

  • 类属性：
    java中 this关键字用来区分类变量与类方法中形参变量重名问题。但是建议无论重名都类变量在类方法中都加上this关键字
  • 类方法：
    a.调用本类普通方法：可以使用this.方法();
    b.调用本类中的构造方法：用this();
    在本类中调用本类中的普通方法可以直接使用方法名，但是为了规范建议调用类中的普通方法一律用this.方法名()

• 方法的重载
  方法名称相同，参数类型或者个数不同，调用的时候会按照传递的参数和类型和个数选择不同的方法体。

class functions {
    public static void main(String[] args) {
        // 用不同的参数调用add()方法
        System.out.println("add(3,8) =" + add(3,8));
        System.out.println("add(3,8,7) =" +add(3,8,7));
        System.out.println("add(3.1,8.5) =" + add(3.1,8.5));
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static double add(double a,double b){
        return a+b;
    }
    public static int add(int a,int b,int c){
        return a+b+c;
    }
}
/*
-----------OUTPUT-----------  
add(3,8) = 11
add(3,8,7) = 18
add(3.1,8.5) = 11.6
 */

1.3 创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

public class classTest{
    public static void main(String[] args) {
        // 实例化一个对象 传入构造方法所需的参数
        Dog cat = new Dog("haha");
        cat.barking();
        cat.setAge(5);
        System.out.println("getAge : "+cat.getAge());
        cat.aboutMe();
    }
}
class Dog{
    String name;
    int age;
    // 构造方法：在对象实例化的时候自动运行
    public Dog(String name){
        this.name = name;
    }
    public void barking(){
        System.out.println("汪汪");
    }
    public void setAge(int n){
        age = n;
    }
    public int getAge(){
        return age;
    }
    public void aboutMe(){
        System.out.println("name ："+name+"| age: "+age);
    }
}

1.4 java中的主方法

java语言最大的特点就在于主方法。

• public:主方法是程序的开始，所以这个方法对任何操作都是可见的；
• static:次方法可以不实例化直接使用；
• void:主方法是一切程序的开始，没有返回值；
• main:系统规定的方法名；
• String args[]:程序运行时传的参数。

1.5 代码块

写在｛｝内的代码称为一个代码块
Java代码块分为4种：普通代码块、构造块、静态块、同步代码块（等待多线程）。

• 构造块：将一个代码块写在一个类里，就是一个构造块。
  构造块在每一次实例化时都会调用，并且优先于构造方法
• 静态块：一个代码块用static修饰，就是一个静态块。
  静态块只会调用一次，且优先于静态块。

优先级:
　　【构造方法】<【构造块】<【静态块】

public class blockTest {
    public static void main(String[] args) {
        bTest t1 = new bTest("t1");
        bTest t2 = new bTest("t2");
    }
}
class bTest {
    public String name;
    public bTest(String name){
        this.name = name;
        System.out.println(this.name+" 构造方法运行");
    }
    // 构造块 
    {
        System.out.println(this.name+" 构造块运行");
    }
    // 静态块
    static {
        System.out.println("静态块运行");
    }
}

运行结果：

-----------OUTPUT-----------
静态块运行
null 构造块运行
t1 构造方法运行
null 构造块运行
t2 构造方法运行

2.封装

两层含义：

• 把对象的属性和方法打包成一个整体
• 把不需要让外界知道的信息隐藏起来

2.1 权限修饰符（访问修饰符）

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Javav支持 4 种不同的访问权限。

• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

权限表：

2.2 权限继承

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

2.3 static关键字

static 修饰的属性、方法不用实例化就可使用

• 修饰类属性
  一个类中的属性希望定义成公共属性，则可以在声明属性前加入static关键字
• 修饰方法
  若将类的static属性封装，则必须提供一个访问此属性的static方法。
  
  • static 方法不能直接访问非static属性、方法，只能调用static属性、方法
  • 非 static方法可以访问static属性、方法。

3.继承

严格来讲就是扩充一个类已有的功能。

• 用extents关键字
• 子类又被称为派生类
• 父类被称为超类（Super Class）

格式：class 子类 extents父类｛｝

3.1 继承的限制

• java不允许多重继承，但允许多层继承【单继承】；
• 私有属性、方法隐式继承，非私有操作显示继承；

• 在子类对象构造前一定会默认调用父类的构造，以保证父类先实例化子类后实例化；

• super(); 指父类的构造函数
  当父类中有无参数的构造方法时，子类的构造函数首先会默认执行super();,此时子类构造方法中写super();不写都一样。而父类中无有参构造方法则必须写上才会执行。

3.2 继承的覆写

子类定义属性、方法时，出现与父类重名的情况时，就会出现属性、方法的覆写。

• 方法的覆写
  子类定义了和父类方法名称、返回值类型、参数类型及个数完全相同 的方法时就称为方法的覆写
  被子类覆写的方法不能拥有比父类更严格的访问控制权限

• 属性的覆盖
  子类中定义了与父类完全相同的属性名（开发中不存在的）

**【补充】this() super()只能写在构造方法的第一句，且只能存在一个。 **

3.3 继承的终结--final关键字

• 使用fianl关键字定义的类不能再有子类，即任何类都不能继承final修饰的类
  String 类就是 final修饰的，所以String不允许被继承
• 使用final修饰的方法不能被覆写
• 使用final修饰的变量成了一个常量
  常量定义时就必须进初始化，否则会语法出错

4.多态性

• 方法的多态性: 重载与覆写；
• 对象的多态性：父子类的对象转换

【补充】java提供一个关键字 instanceof

对象 instaceof 类 // 返回boolean

多态性的意义是为了实现范型

4.1 抽象类

抽象方法：没有方法体的方法，必须由abstract关键字修饰

抽象类是指在普通类中增加抽象方法,拥有抽象方法的类一定属于抽象类抽象类必须使用abstract修饰（ps:抽象类中可以全都是具体方法）

• 抽象类不能实例化，只能由其他类继承
• 抽象类的子类必须覆写抽象类中的全部抽象方法
• 抽象类不能使用final修饰，因为抽象类必须有子类
• 就是抽象类中没有任何抽象方法，但是只要是用abstract修饰的类都不能拿来直接实例化

4.2 接口

如果一个类只由抽象方法和全局常量组成，往往将其定义成一个接口
在Java中使用interface关键字来定义接口
Java中接口主要用来解决单继承的问题

• 接口必须要有子类，但一个子类可以实现（implements）多个接口,避免了单继承的局限
• 接口的子类（如果不是抽象类），必须覆写接口中全部的抽象方法
• 接口的对象可以利用子类的对象向上转型进行实例化操作

4.3 抽象类与接口的区别

4.4 多态的实现--Object类

Object 类是所有类的父类。
任何一个类向上转型都能得到一个Object类
利用Object类可以接受全部类的对象（向上转型）
Object 类中提供了一个无参构造函数，所以如果一个类没有写构造函数，他默认会继承Object的无参构造。
Object类中提供的方法

• public String toString() //取得对象信息（String类覆写了此方法）
• public boolean equals(Object obj) //对象比较
• public int hashCode() //取得对象哈希码

以上方法，在任意对象都存在

5.总结实例 java实现的链表（范式）

（四）包及访问控制

java中包的主要用于将不同的文件进行分割，解决同名文件冲突问题，而设置的不同目录

• 定义包的格式：package 包名；//（多级包用.分割）
• 注意事项：
  
  • package 语句必须是程序的第一条可执行代码；
  • package 语句在一个Java文件中只能有一个；
  • 如果没有package 默认无包名。

• 包的导入
  用关键字 import 导入；
  必须写在类定义之前，package语句之后。

• 权限控制--- 权限表

（五）异常

• Error与Exception的区别

  • Error : 指JVM错误，代码编译时被发现，这时候程序并没有执行，修改代码1️以解决。
  • Exception : 程序运行过程中产生的异常，程序可以使用异常处理捕获并解决。

• 异常处理格式：

try{
    // 可能出现异常的语句
}[catch (异常类型 对象)｛
    // 异常处理
｝catch（异常类型 对象）｛
    // 异常处理
｝
...]
[fianlly {
    // 不论是否出现异常，都执行统一代码
}

由于Java中的对象可以自动向上转型，所以Exception可以接收所有异常
处理多个异常的时候，捕获范围小的异常要放在前面

• throws与throw 关键字

  • throws关键字用于方法定义上，将方法内可能出现的异常抛出给被调用处理
  • throw 手动抛出一个异常

• RuntimeException 类
  编译的时候不会强制要求处理异常，如果没有处理又发生了异常，将交给jvm处理。
  RuntimeException类及其子类异常可以通过编译

• assert断言
  格式: assert 逻辑运算 : 提示字符串 ;
  程序运行到assert的时候，若逻辑运算符为假。则程序停止并抛出java.lang.AssertError 异常
  断言不是自动启动的需要用户用控制，在运行时增加-ea参数

• 自定义异常
  自定义异常需要继承Exception（强制异常处理）或RuntimeException（选择性异常处理）

（六）Java常见类库

1.StringBuffer类

Java中的String类型表示的字符串一旦声明就不可更改，String字符串对象每一次改变，都是对象的指向地址发生了改变，之前的引用就变为了垃圾，所以String对象不适合用于会频繁修改的字符串。
StringBuffer则解决了这个问题。其定义的字符串内容可以被修改（即在原地址上进行增、删、改）

• String与StringBuffer的相互转换

  • String -> StringBuffer : 利用StringBuffer的构造方法
    StringBuffer buf = new StringBuffer("www.heykui.cn");
  • String -> StringBuffer : 利用StringBuffer中的append方法
  • StringBuffer -> String : 利用StringBuffer中的toString方法
  • StringBuffer -> String : 利用String的构造方法

• 常用方法

  • 构造方法：空参构造
    　　　　　有参构造：StringBuffer buf = new StringBuffer("www.heykui.cn");

  • append(String s)
    将指定的字符串追加到此字符序列

  • delete(int start, int end)
    移除此序列的子字符串中的字符
  • insert(int offset, int i)
    将 int 参数的字符串表示形式插入此序列中
  • replace(int start, int end, String str)
    使用给定 String 中的字符替换此序列的子字符串中的字符。
  • 下面方法与String中类似
  • char charAt(int index)
    返回此序列中指定索引处的 char 值。
  • int capacity()
    返回当前容量。
  • void ensureCapacity(int minimumCapacity)
    确保容量至少等于指定的最小值。
  • void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    将字符从此序列复制到目标字符数组 dst。
  • void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    将字符从此序列复制到目标字符数组 dst。
  • int indexOf(String str)
    返回第一次出现的指定子字符串在该字符串中的索引
  • int indexOf(String str, int fromIndex)
    从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引
  • int lastIndexOf(String str)
    返回最右边出现的指定子字符串在此字符串中的索引。
  • int lastIndexOf(String str, int fromIndex)
    返回 String 对象中子字符串最后出现的位置。
  • int length()
    返回长度（字符数）。
  • void setCharAt(int index, char ch)
    将给定索引处的字符设置为 ch。
  • void setLength(int newLength)
    设置字符序列的长度。
  • CharSequence subSequence(int start, int end)
    返回一个新的字符序列，该字符序列是此序列的子序列。
  • String substring(int start)
    返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
  • String substring(int start, int end)
    返回一个新的 String，它包含此序列当前所包含的字符子序列。
  • String toString()
    返回此序列中数据的字符串表示形式。## 标题 ##

2.Runtime 类

利用Runtime类可以启动新的线程或者进行相关环境操作（如取得内存空间或者释放垃圾）
Runtime使用了单列模式通过Runtime.getRuntime(）获得对象的实例

• 常用方法
  
  • public static Runtime getRuntime()
    取得Runtime的实例化对象
  • public long maxMemory()
    返回最大可用内存大小
  • public long totalMemory()
    返回所有可用内存大小
  • public long freeMemory()
    返回所有空余内存
  • public void gc()
    执行垃圾回收
  • public Process exec(String command) throws IOException
    创建新的进程

3.System 类

提供一些系统的支持操作

• 常用方法
  
  • public static void arraycopy(Object src,int srcPos,Object dess,int length)
    数组复制
  • public static long currentTimeMillis()
    取得当前时间戳
  • public static void gc()
    垃圾回收

System 类的gc()方法是间接调用Runtime的gc()方法，既System.gc()与Runtime.getRuntime().gc()完全等价

4.对象的克隆

在Object类中存在一个方法clone用于对象的克隆
protected Object clone() throws CloneNotSupportException;
此方法是用protected修饰的，所以子类必须覆写此方法才能被克隆。
此方法抛出一个异常CloneNotSupportException(不支持的克隆对象)，是因为Java中不是所有的类都支持克隆操作，Java提供了一个标识接口Cloneable(接口中没有任何方法)来区分可以被克隆的类。

5.数学操作类

• Math 类
  Math类中提供的方法都是Static的，可以直接由类名进行调用

6.Random 类

java.util.Random 类是一个专门产生随机数的操作类

• 常用方法
  
  • public Random() 【构造方法】
    创建一个Random实例
  • public Random(long seed)【构造方法】
    创建一个Random实例并设置一个随机种子
  • public nextInt(int bound)
    产生一个不大于指定边界的随机数

7.日期处理类

7.1 java.util.Data 日期处理

• 常用方法
  
  • public Data() 【构造】
    实例化Data对象
  • public Data(long data) 【构造】
    将时间戳变为Data对象
  • public long getTime()
    将当前日期变为时间戳

7.2 java.text.SimpleDataFormat 日期格式化

• 常用方法
  
  • public SimpleDataFormat(String pattern) 【构造】
    传入时间标记实例化对象
  • public fianl String format(Data data)
    将日期格式化为字符串
  • public Data parse(String source) throws ParseException
    将字符串格式化为日期数据
  • [ps]常用时间标记: yyy(年) MM(月) dd(日) HH(时) mm(分) ss(秒) SSS(毫秒)

7.3 java.util.Calendar 精确时间操作

Calendar 是一个抽象类通过getInstance()方法获得对象实例（单列模式）

• 常用方法
  
  • 查手册

8.比较器

java提供了3个数组操作类

8.1 Arrays类(java.util.Arrays)

• 常用方法
  
  • public static boolean equal(int [] a,int[] b)
    判断两个数组是否相等(多次重载)
  • public static void fill(int[] a,int val)
    将指定内容填充到数组中（多次重载）
  • public static void sort(int[] a)
    排序（多次重载）
  • public static int binarySearch(int [] a,int val)
    二分查找（多次重载）
  • public static String toString(int [] a)
    数组转换成字符串（多次重载）

8.2 比较器 Comparable

普通数组可以通过直接调用Arrays.sort(int[] a)排序，但是对象数组中每个位置存的都是对象的地址不能直接依据大小排序。但是Arrays中任然重载了一个Arrays.sort(Object[] a),此方法可以直接针对对象数组进行排序
使用前提：对象所在的类一定要实现Comparable接口 否则会报ClassCastException异常

public interface Comparable<T>{
    public int compareTo(T o);
}

覆写compareTo()方法时需要返回三种结果：1（>0）,-1(<0),0(=0)

8.3 匿名比较器 -- Lambda表达式

如果对象数组没有实现Comparable接口，可以使用lambda表达式来临时定义比较方法

public static void main(String[] args) {
    book b1[] = new book[] {
        new book("java入门经典",79.45),
        new book("python简单教程",59.00),
        new book("sql开发天书",63.45),
        new book("node.js实战",48.50)
    };
    // lambda表达式
    java.util.Arrays.sort(b1,(x,y)->{
        if (x.p > y.p) {
            return 1;
        }else if (x.p < y.p) {
            return -1;              
        }else{
            return 0;
        }
    });
    // 输出
    for (book one :b1 ) {
        System.out.print(one);
    }

-----------OUTPUT-----------
书名： node.js实战价格： 48.5
书名： python简单教程价格： 59.0
书名： sql开发天书价格： 63.45
书名： java入门经典价格： 79.45

9.基本数据类型的转换

9.1 int ---> String

int a = 6534;
// 1.加个空串
String s1 = a + "";
// 2.用String.valueOf()方法
String s2 = String.valueOf(a);
// 3.用Integer对象的toString()方法
Integer i1 = new Integer(a);
String s3 = i1.toString();
// 4.用Integer的静态方法toString(int i)
String s4 = Integer.toString(a);

9.2 String ---> int

String s = "4327";
int i;
// 1.用Integer构造函数将String转换成Integer
//    再用Integer对象的intValue()方法转换成int
Integer i2 = new Integer(s);
i = i2.intValue();
// 2.用Integer的静态方法parseInt(String s)      
i = Integer.parseInt(s);

9.3 String ---> 各种类型

//  8种基本数据类型包装类中，有7种都有parseXxx()的方法，
//  可以将7种字符串表现形式转换为基本数据类型（其中 Character没有）
String s2 = "3.1415";
float x = Float.parseFloat(s2); 
double z = Double.parseDouble(s2);

10.正则表达式

10.1 正则标记

10.2 String 类对正则的支持

10.3 java.util.regex 包

此包下有Pattern类和Matcher类具体查API

10.4 正则练习

• 匹配叠词

/**
 * eg1: 快快乐乐,BBAA
 * eg2: baba,高兴高兴
 */
// \\1代表第一组，\\2代表第二组
String r = "(.)\\1(.)\\2";     // 匹配 AABB 形
String r2 = "(..)\\1";         // ABAB 形
System.out.println("快快乐乐".matches(r));
System.out.println("AABB".matches(r));
System.out.println("高兴高兴".matches(r2));
System.out.println("baba".matches(r2));
/ */

-----------OUTPUT-----------
true
true
true
true

• 还原字符

/**
 * eg:我我我。。。要。。。要。。学。。。学学。。编编。。编编编。。。程。
 *   out: 我要学编程。
 */
String s2 ="我我我。。。要。。。要。。要。。。。学。。。学学。。编编。。编编编。。。程。";
String r4 = "(.)\\1+";
s2 = s2.replaceAll("。","");
String out = s2.replaceAll(r4,"$1");
System.out.println(out);

==================================END=============================