Java学习系列（三）

1.正则表达式

一个字符串其实就是一个简单的正则表达式，例如?Hello World?正则表达式匹配 "Hello World" 字符串。

.（点号）：匹配任何一个字符，如："a" 或 "1"

^ ：定义了以什么开始

\d+ ： 匹配一个或多个数字

? ：设置括号内的选项是可选的

\. ：匹配 "."，可以匹配的实例："5", "1.5" 和 "2.21"

[0-9]+ ：匹配多个数字

[0-9] ：匹配单个数字

+ ：匹配一个或者多个

abc$ ：匹配字母?abc?并以?abc?结尾

$ ：匹配输入字符串的结束位置

?例：

^[a-zA-Z0-9_-]{3,15}$

• ^?表示匹配字符串的开头。
• [a-zA-Z0-9_-]?表示字符集，包含小写字母、大写字母、数字、下划线和连接字符?-。
• {3,15}?表示前面的字符集最少出现 3 次，最多出现 15 次，从而限制了用户名的长度在 3 到 15 个字符之间。
• $?表示匹配字符串的结尾。

量词

• *：匹配前面的模式零次或多次。
• +：匹配前面的模式一次或多次。
• ?：匹配前面的模式零次或一次。
• {n}：匹配前面的模式恰好 n 次。
• {n,}：匹配前面的模式至少 n 次。
• {n,m}：匹配前面的模式至少 n 次且不超过 m 次。.

字符类

• [ ]：匹配括号内的任意一个字符。例如，[abc]?匹配字符 "a"、"b" 或 "c"。
• [^ ]：匹配除了括号内的字符以外的任意一个字符。例如，[^abc]?匹配除了字符 "a"、"b" 或 "c" 以外的任意字符。

边界匹配

• ^：匹配字符串的开头。
• $：匹配字符串的结尾。
• \b：匹配单词边界。
• \B：匹配非单词边界。

分组和捕获

• ( )：用于分组和捕获子表达式。
• (?: )：用于分组但不捕获子表达式。

特殊字符

• \：转义字符，用于匹配特殊字符本身。
• .：匹配任意字符（除了换行符）。
• |：用于指定多个模式的选择。

?2.正则表达式 -?修饰符（标记）

标记不写在正则表达式里，标记位于表达式之外，格式如下：

/pattern/flags

修饰符	含义	描述
i	ignore - 不区分大小写	将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。
g	global - 全局匹配	查找所有的匹配项。
m	multi line - 多行匹配	使边界字符?^?和?$?匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。
s	特殊字符圆点?.?中包含换行符?\n	默认情况下的圆点?.?是匹配除换行符?\n?之外的任何字符，加上?s?修饰符之后,?.?中包含换行符 \n。

3.正则表达式 -?运算符优先级

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。

相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：

运算符	描述
\	转义符
(), (?:), (?=), []	圆括号和方括号
*, +, ?, {n}, {n,}, {n,m}	限定符
^, $, \任何元字符、任何字符	定位点和序列（即：位置和顺序）
|	替换，"或"操作 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food"。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。

?

以下是一些常见正则表达式运算符按照优先级从高到低的顺序：

• 转义符号：?\?是用于转义其他特殊字符的转义符号。它具有最高的优先级。

  示例：\d、\.?等，其中?\d?匹配数字，\.?匹配点号。

• 括号：?圆括号?()?用于创建子表达式，具有高于其他运算符的优先级。

  示例：(abc)+?匹配 "abc" 一次或多次。

• 量词：?量词指定前面的元素可以重复的次数。

  示例：a*?匹配零个或多个 "a"。

• 字符类：?字符类使用方括号?[]?表示，用于匹配括号内的任意字符。

  示例：[aeiou]?匹配任何一个元音字母。

• 断言：?断言是用于检查字符串中特定位置的条件的元素。

  示例：^?表示行的开头，$?表示行的结尾。

• 连接：?连接在没有其他运算符的情况下表示字符之间的简单连接。

  示例：abc?匹配 "abc"。

• 管道：?管道符号?|?表示"或"关系，用于在多个模式之间选择一个。

  示例：cat|dog?匹配 "cat" 或 "dog"。

4.Stream(流)、File(文件)

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 的控制台输入由 System.in 完成。

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。

从 BufferedReader 对象读取一个字符要使用 read() 方法，每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。

//示范了用 read() 方法从控制台不断读取字符直到用户输入 q
//使用 BufferedReader 在控制台读取字符
 
import java.io.*;
 
public class BRRead {
    public static void main(String[] args) throws IOException {
        char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

运行结果如下:
runoob
r
u
n
o
o
b

q
q

从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。

//使用 BufferedReader 在控制台读取字符
import java.io.*;
 
public class BRReadLines {
    public static void main(String[] args) throws IOException {
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        System.out.println("Enter lines of text.");
        System.out.println("Enter 'end' to quit.");
        do {
            str = br.readLine();
            System.out.println(str);
        } while (!str.equals("end"));
    }
}

?运行结果如下:

Enter lines of text.

Enter 'end' to quit.

This is line one

This is line one

This is line two

This is line two

end

end

PrintStream 继承了 OutputStream类，并且实现了方法 write()。write() 也可以用来往控制台写操作。?

import java.io.*;
 
//演示 System.out.write().
public class WriteDemo {
    public static void main(String[] args) {
        int b;
        b = 'A';
        System.out.write(b);
        System.out.write('\n');
    }
}

一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

输入流和输出流的类层次图：

FileInputStream流用于从文件读取数据，它的对象可以用关键字 new 来创建。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：1.

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：2.

//1.
InputStream f = new FileInputStream("C:/java/hello");
//2.
File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);

FileOutputStream类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两个构造方法可以用来创建 FileOutputStream 对象：

也可以使用一个文件对象来创建一个输出流来写文件：

//1.
OutputStream f = new FileOutputStream("C:/java/hello")
//2.
File f = new File("C:/java/hello");
OutputStream fOut = new FileOutputStream(f);

import java.io.*;
 
public class fileStreamTest {
    public static void main(String[] args) {
        try {
            byte bWrite[] = { 11, 21, 3, 40, 5 };
            OutputStream os = new FileOutputStream("test.txt");
            for (int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // writes the bytes
            }
            os.close();
 
            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
 
            for (int i = 0; i < size; i++) {
                System.out.print((char) is.read() + "  ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上

//文件名 :fileStreamTest2.java
import java.io.*;
 
public class fileStreamTest2 {
    public static void main(String[] args) throws IOException {
 
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建
 
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
 
        writer.append("中文输入");
        // 写入到缓冲区
 
        writer.append("\r\n");
        // 换行
 
        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
 
        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
 
        fop.close();
        // 关闭输出流,释放系统资源
 
        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象
 
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同
 
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
 
        fip.close();
        // 关闭输入流,释放系统资源
 
    }
}

5.文件和I/O

File类中有两个方法可以用来创建文件夹：

• mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
• mkdirs()方法创建一个文件夹和它的所有父文件夹。

import java.io.File;
 
public class CreateDir {
    public static void main(String[] args) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        // 现在创建目录
        d.mkdirs();
    }
}

注意：?Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ，路径依然能够被正确解析。

一个目录其实就是一个 File 对象，它包含其他文件和文件夹。

如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。

可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。

import java.io.File;
 
public class DirList {
    public static void main(String args[]) {
        String dirname = "/tmp";
        File f1 = new File(dirname);
        if (f1.isDirectory()) {
            System.out.println("目录 " + dirname);
            String s[] = f1.list();
            for (int i = 0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                    System.out.println(s[i] + " 是一个目录");
                } else {
                    System.out.println(s[i] + " 是一个文件");
                }
            }
        } else {
            System.out.println(dirname + " 不是一个目录");
        }
    }
}

运行结果如下：
目录 /tmp
bin 是一个目录
lib 是一个目录
demo 是一个目录
test.txt 是一个文件
README 是一个文件
index.html 是一个文件
include 是一个目录

删除文件可以使用?java.io.File.delete()?方法。

以下代码会删除目录?/tmp/java/，需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。

import java.io.File;
 
public class DeleteFileDemo {
    public static void main(String[] args) {
        // 这里修改为自己的测试目录
        File folder = new File("/tmp/java/");
        deleteFolder(folder);
    }
 
    // 删除文件及目录
    public static void deleteFolder(File folder) {
        File[] files = folder.listFiles();
        if (files != null) {
            for (File f : files) {
                if (f.isDirectory()) {
                    deleteFolder(f);
                } else {
                    f.delete();
                }
            }
        }
        folder.delete();
    }
}