Java IO框架

流

是内存与存储设备(硬盘)之间传输数据的通道。

数据借助流来传输。

流的分类

按方向来分：

输入流：将存储设备中的内容读入内存
输出流：将内存中的内容写入存储设备中

按单位来分：

字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据

按照功能来分：

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

字节流

字节流的父类(抽象类)：

InputStream(字节输入流)：
- ```
public int read(){}
```
OutpStream(字节输出流)：
- ```
public void write(int n){}
```

抽象类不能实例化，所以需要引用其子类，例如：FileInputStream等

文件字节流

FileInputStream

package com.qf.chap15_1;import java.io.FileInputStream;public class Demo01 {public static void main(String[] args) throws Exception{//1.    创建FileInputStream，并指定文件路径FileInputStream fis = new FileInputStream("d:\\aaa.txt");   //因为不确定文件是否肯定存在，有一个小异常，所以需要抛出异常//2.    读取文件//2.1   单个字节读取//fis.read(); 特点：只能挨个读取字节；当读取结束就返回 -1/*int data = 0;   //保存读取的字节while ((data=fis.read())!=-1){//System.out.println(data);     返回得是ASCII码，需要进行强制转换System.out.print((char)data);}System.out.println();*///2.2   一次性读取多个字节//学渣法/*byte[] buf = new byte[3];int count = fis.read(buf);  //把流里的字节读取出来，放进字节数组buf当中去System.out.println(new String(buf));System.out.println(count);int count2= fis.read(buf);System.out.println(new String(buf,0,count2));System.out.println(count2);*///学霸法byte[] buf = new byte[3];int count = 0;while ((count= fis.read(buf))!=-1){//返回读取元素的个数System.out.println(new String(buf,0,count));    //表示字符串buf的从下标0到下标count的元素}//3.    关闭fis.close();System.out.println("执行完毕");}
}
结果：
abc
de
执行完毕

FunnyTime：文件读完之后没有可读取内容，返回了-1

FileOutputStream

package com.qf.chap15_1;import java.io.FileOutputStream;public class Demo02 {public static void main(String[] args) throws Exception{//1.    创建文件字节输出流对象FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true); //同样抛出异常//2.    写入文件(不需要自己提前在D盘创建文件)fos.write(97);fos.write('b');fos.write('c');              //结果为abcString string = "helloworld";fos.write(string.getBytes());   //获取该字符串对应的字符数组 结果为abchelloworld//当创建流时添加"true"，就不会清空，没执行一次就会写入一次，执行两次之后结果为：abchelloworldhelloworld//3.    关闭fos.close();System.out.println("执行完毕");}
}
结果：
执行完毕

字节流复制文件

基本思想：输入流+输出流

package com.qf.chap15_1;import java.io.FileInputStream;
import java.io.FileOutputStream;public class Demo03 {public static void main(String[] args) throws Exception{//1.    创建输入流(提前保存图片)FileInputStream fis = new FileInputStream("d:\\点赞.png");   //2.    创建输出流FileOutputStream fos = new FileOutputStream("d:\\002.png");//3.    一边读，一边写byte[] buf = new byte[1024];int count = 0;  //保存实际读取的字节个数while ((count = fis.read(buf))!=-1){fos.write(buf,0,count);}//4.    关闭流fis.close();fos.close();System.out.println("复制完毕");}
}
结果：
复制完毕    (相应位置有相同的照片)

字节缓冲流

缓冲流：

提高IO效率，减少访问磁盘次数
数据存储在缓冲区当中，flush是将缓存区的内容写入文件中，也可以直接close

输出文件数据：

package com.qf.chap15_1;import java.io.BufferedInputStream;
import java.io.FileInputStream;public class Demo04 {public static void main(String[] args) throws Exception {//1.    创建BufferedInputStreamFileInputStream fis = new FileInputStream("d:\\aaa.txt");BufferedInputStream bis = new BufferedInputStream(fis);    //实例化缓冲流时需要传一个节点流(底层流)//2.    读取int data=0;while ((data=bis.read())!=-1){      // private static int DEFAULT_BUFFER_SIZE = 8192;System.out.print((char)data);}//当第二次读取的时候发现缓冲区有，就不会读取硬盘，效率也就很快//也可以自己创建一个缓冲区byte[] buf = new byte[1024];int count = 0;while ((count=bis.read(buf))!=-1){System.out.println(new String(buf,0,count));}//3.    关闭  关闭bis也就可以关闭fis了bis.close();}
}
结果：
abcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefg

在文件中写入数据：

package com.qf.chap15_1;import java.io.BufferedOutputStream;
import java.io.FileOutputStream;public class Demo05 {public static void main(String[] args) throws Exception{//1.    创建字节输出缓冲流FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");BufferedOutputStream bos = new BufferedOutputStream(fos);//2.    写入文件for (int i=0;i<10;i++){bos.write("helloworld\n".getBytes()); //getBytes()：返回一个字节数组   写入容量为8k的缓冲区了bos.flush();    //刷新了硬盘 这样才能在文档中看到输出}//3.    关闭(内部会调用flush方法)bos.close();}
}

对象流

包括ObjectOutputStream/ObjectInputStream

增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能
- writeObject(Object obj) 向流中写入一个对象：序列化
- readObject() 从流中读取一个对象：反序列化

使用ObjectOutputStream实现对象的序列化：

要求：序列化的类必须实现Serializable接口

先创建Student类：

package com.qf.chap15_1;import java.io.Serializable;public class Student implements Serializable {  //标记一下这个Student类可以序列化private String name;private int age;//无参构造public Student() {}//带参构造public Student(int age, String name) {this.age = age;this.name = name;}//getter and setterpublic int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}//toString@Overridepublic String toString() {return "Student{" +"age=" + age +", name='" + name + '\'' +'}';}
}

测试范例：

package com.qf.chap15_1;import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;public class Demo06 {public static void main(String[] args) throws Exception{//1.    创建对象流FileOutputStream fos = new FileOutputStream("d:\\stu.bin"); //二进制文件ObjectOutputStream oos = new ObjectOutputStream(fos);//2.    实现序列化/写入操作Student zhangsan = new Student(20,"张三");Student lisi = new Student(22,"李四");ArrayList<Student> list = new ArrayList<>();list.add(zhangsan);list.add(lisi);oos.writeObject(lisi);//3.    关闭oos.close();System.out.println("序列化完毕");}
}
结果：
序列化完毕

反序列化

package com.qf.chap15_1;import java.io.FileInputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;public class Demo07 {public static void main(String[] args) throws Exception{//1.    创建对象流FileInputStream fis = new FileInputStream("d:\\stu.bin");ObjectInputStream ois = new ObjectInputStream(fis);//2.    读取文件(反序列化)//Student s = (Student) ois.readObject();//Student s2 = (Student) ois.readObject();Object list = ois.readObject();ArrayList<Student> list1 = (ArrayList<Student>) list;//Student s2 = (Student) ois.readObject(); 第二次读取时会出现异常EOFException//3.    关闭ois.close();System.out.println("执行完毕");System.out.println(list.toString());}
}
结果：
Exception in thread "main" java.lang.ClassCastException: com.qf.chap15_1.Student cannot be cast to java.util.ArrayListat com.qf.chap15_1.Demo07.main(Demo07.java:18)

总结序列化和反序列化注意事项

序列化类中必须要实现Serializable接口
序列化类中对象属性要求实现Serializable接口
serialVersionUID/序列化版本号ID一样，可以保证序列化的类和反序列化的类是同一个类
使用transient(瞬间的)修饰属性，该属性就不可以序列化了
静态属性不可以序列化/不能保存到硬盘上
借助集合，序列化多个对象

字节流

字符编码

ISO-8859-1：收录出ASCII外多国的文字符号，只有一个字节，最多只能表示256个字符
UTF-8：针对Unicode码表的可变长度字符编码(1~3B)
GB2312:简体中文
GBK:简体中文、扩充
BIG5：台湾，繁体中文

当编码方式和解码方式不一样时会出现乱码，举例：

package com.qf.chap15_2;import java.io.FileInputStream;
import java.io.FileNotFoundException;public class Demo01 {public static void main(String[] args) throws Exception {//1.    创建FileInputStream对象FileInputStream fis = new FileInputStream("d:\\hello.txt");//2.    读取int data = 0;while((data=fis.read())!=-1){   //一次性读取一个字符System.out.println((char)data);}//3.    关闭fis.close();}
}

当hello.txt中是英文时可以正常输出，但是当改成汉语时会出现乱码。

因为.txt是UTF-8编码，如图所示：

由于每个汉字是3B，而读取时是一个字节一个字节读取的，进行了拆分，所以出现了问题。所以要是用字符流读取含有中文文件。

字符流

字符流的父类(抽象类)：

Reader：字符输入流
Writer：字符输出流

文件字符流

FileReader

package com.qf.chap15_2;import java.io.FileReader;public class Demo02 {public static void main(String[] args) throws Exception{//1.    创建FileReader 文件字符输入流FileReader fr = new FileReader("d:\\hello.txt");//2.    读取//2.1   单个字符读取//int data = 0;//while ((data=fr.read())!=-1){   //读取一个字符(3个B)//    System.out.println((char)data);//}//2.2   创建字符缓冲区char[] buf = new char[2];   int count = 0;while ((count= fr.read(buf))!=-1){System.out.println(new String(buf,0,count));   //通过new字符串来打印字符数组}//3.    关闭fr.close();}
}
结果:
按时
上课

FileWriter

package com.qf.chap15_2;import java.io.FileWriter;public class Demo03 {public static void main(String[] args) throws Exception{//1.    创建FileWriter对象FileWriter fw = new FileWriter("d:\\write.txt");//2.    写入for (int i=0;i<10;i++){fw.write("java\r\n"); //换行fw.flush();}//3.    关闭fw.close();System.out.println("执行完毕");}
}
结果：
执行完毕

使用字符流复制文本文件

图片等其他二进制文件无法复制(图片没有字符编码，两次转换之后就发生错误)

package com.qf.chap15_2;import java.io.FileReader;
import java.io.FileWriter;public class Demo04 {public static void main(String[] args) throws Exception{//1.    创建FileReader和FileWriterFileReader fr = new FileReader("d:\\write.txt");FileWriter fw = new FileWriter("d:\\write2.txt");//2.     读写int data = 0;while ((data=fr.read())!=-1){fw.write(data);fw.flush(); //刷新缓冲区}//3.    关闭fr.close();fw.close();System.out.println("复制完毕");}
}
结果：
复制完毕

字符缓冲流

特点：

高效读写
支持输入换行符
可一次写一行、读一行

分类：

BufferedReader

package com.qf.chap15_2;import java.io.BufferedReader;
import java.io.FileReader;
import java.nio.Buffer;public class Demo05 {public static void main(String[] args) throws Exception{//1.    创建缓冲流FileReader fr = new FileReader("d:\\write.txt");BufferedReader br = new BufferedReader(fr);//2.    读取//2.1   第一种方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count=br.read(buf))!=-1){//            System.out.println(new String(buf,0,count));
//        }//2.2   第二种方式，一行一行的读取String line = null;while ((line=br.readLine())!=null){System.out.println(line);}//3.    关闭br.close(); //fr也就关闭了}
}
结果：
java
java
java
java
java
java
java
java
java
java

BufferedWriter

package com.qf.chap15_2;import java.io.BufferedWriter;
import java.io.FileWriter;public class Demo06 {public static void main(String[] args) throws Exception{//1.    创建BufferWriter对象FileWriter fw = new FileWriter("d:\\buffer.txt");BufferedWriter bw = new BufferedWriter(fw);//2.    写入for (int i = 0; i < 10; i++) {bw.write("好好学习");bw.newLine();   //写入一个换行符 = /r/nbw.flush();}//3.    关闭bw.close();System.out.println("执行完毕");}
}
结果：
执行完毕

打印流

PrintWriter:

封装了print()/println()方法，支持写入后换行
支持数据原样打印

package com.qf.chap15_2;import java.io.PrintWriter;public class Demo07 {public static void main(String[] args) throws Exception{//1.    创建打印流PrintWriter pw = new PrintWriter("d:\\print.txt");//2.    打印pw.println(97);      //结果就是97，不会变成apw.println(true);pw.println(3.14);pw.println('a');//3.    关闭pw.close();System.out.println("执行完毕");}
}
结果：
执行完毕

转换流

特点：

可将字节转换为字符流
可设置字符的编码方式

分类：

InputStreamReader

是硬盘到内存/字节到字符的桥梁

package com.qf.chap15_3;import java.io.FileInputStream;
import java.io.InputStreamReader;public class Demo01 {public static void main(String[] args) throws Exception{//1.    创建InputStreamReader对象FileInputStream fis = new FileInputStream("d:\\write.txt");//InputStreamReader isr = new InputStreamReader(fis,"utf-8"); //编码相同时结果正常InputStreamReader isr = new InputStreamReader(fis,"gbk");   //结果出现乱码//2.    读取文件int data = 0;while ((data=isr.read())!=-1){System.out.println((char)data);}//3.    关闭isr.close();}
}

OutputStreamWriter

package com.qf.chap15_3;import java.io.FileOutputStream;
import java.io.OutputStreamWriter;public class Demo02 {public static void main(String[] args) throws Exception{//1.    创建OutputStreamWriterFileOutputStream fos = new FileOutputStream("d:\\info.txt");OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");//2.    写入for (int i = 0; i < 10; i++) {osw.write("我爱吃菠萝\r\n");osw.flush();}//3.    关闭osw.close();System.out.println("执行成功");}
}
结果：
执行成功

File类

概念：代表物理盘中的一个文件或者文件夹

文件操作和文件夹操作范例

package com.qf.chap15_4;import javax.xml.crypto.Data;
import java.io.File;
import java.util.Date;public class Demo01 {public static void main(String[] args) throws Exception {separator();fileOpe();directoryOpe();}//1.    分隔符public static void separator(){System.out.println("路径分隔符"+ File.pathSeparator);System.out.println("名称分隔符"+File.separator);}//2.    文件操作public static void fileOpe() throws Exception{//① 创建文件File file = new File("d:\\file.txt");   //创建了文件对象，但是文件是不存在的System.out.println(file);if(!file.exists()) {boolean b = file.createNewFile();System.out.println("创建结果：" + b);                  //生成文件}//② 删除文件//直接删除//System.out.println("删除结果："+file.delete());//使用jvm退出时删除//file.deleteOnExit();//Thread.sleep(5000); //休眠5s之后，jvm退出时就会删除文件//③ 获取文件信息System.out.println("获取文件的绝对路径"+file.getAbsolutePath()); //如果创建文件时没有d:\\，就会在该项目下进行创建System.out.println("获取路径"+file.getPath());System.out.println("获取文件名称"+file.getName());System.out.println("获取父目录"+file.getParent());System.out.println("获取文件长度"+file.length());System.out.println("文件的创建时间"+new Date(file.lastModified()).toLocaleString());//4.    判断System.out.println("是否可写"+file.canWrite()); //右键文件→属性→只读System.out.println("是否是文件"+file.isFile());  //区别是文件还是文件夹System.out.println("是否隐藏"+file.isHidden()); //右键文件→属性→隐藏}//3.    文件夹操作public static void directoryOpe() throws Exception{//① 创建文件夹File dir = new File("d:\\aaa\\bbb\\ccc");System.out.println(dir);if(!dir.exists()){//dir.mkdir();   只能创建单极目录System.out.println("创建结果："+dir.mkdirs()); //创建多级目录}//② 删除文件//直接删除  要求：只能删除最下级文件夹，并且该文件夹为空//System.out.println("删除结果："+dir.delete());//使用jvm删除//dir.deleteOnExit();//Thread.sleep(5000);     //比较有趣的是，如果重复执行jvm删除，ccc文件夹会出现然后被删除//③ 获取文件夹信息System.out.println("获取绝对路径："+dir.getAbsolutePath());System.out.println("获取路径:"+dir.getPath());System.out.println("获取文件夹名称:"+dir.getName());System.out.println("获取父目录："+dir.getParent());System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());//④ 判断System.out.println("是否是文件夹："+dir.isDirectory());System.out.println("是否是隐藏："+dir.isHidden());//⑤ 遍历文件夹File dir2 = new File("d:\\图片");String[] files = dir2.list();   //用dir2.list()获得一个字符串类型的数组System.out.println("-----------------------");for (String file : files) {         //对该数组进行遍历System.out.println(file);}}
}
结果
路径分隔符;
名称分隔符\
d:\file.txt
获取文件的绝对路径d:\file.txt
获取路径d:\file.txt
获取文件名称file.txt
获取父目录d:\
获取文件长度11
文件的创建时间2022-6-5 20:30:40
是否可写false
是否是文件true
是否隐藏true
d:\aaa\bbb\ccc
获取绝对路径：d:\aaa\bbb\ccc
获取路径:d:\aaa\bbb\ccc
获取文件夹名称:ccc
获取父目录：d:\aaa\bbb
获取创建时间：2022-6-6 9:12:39
是否是文件夹：true
是否是隐藏：false
-----------------------
微信图片_20220606091639.png

FileFilter接口

当调用File类中的listFiles()方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才能出现在listFiles()的返回值中

File[] files2 = dir2.listFiles(new FileFilter() {   //使用匿名内部类的方法进行传递@Overridepublic boolean accept(File pathname) {//添加筛选条件    只要jpg文件if(pathname.getName().endsWith(".jpg")) {return true;}return false;}
});
for (File file : files2) {System.out.println(file.getName());
}

递归遍历文件夹和递归删除文件夹

package com.qf.chap15_4;import java.io.File;public class ListDemo {public static void main(String[] args) {System.out.println("----递归遍历文件夹----");lisDir(new File("d:\\myfiles"));System.out.println("----递归删除文件夹----");deleteDir(new File("d:\\myfiles"));}//1.    递归遍历文件夹public static void lisDir(File dir){File[] files = dir.listFiles();System.out.println(dir.getAbsolutePath());if(files!=null&&files.length>0){for (File file : files) {//如果file还是文件夹，就将其传递给lisDir进行递归if(file.isDirectory()){lisDir(file);}else {System.out.println(file.getAbsolutePath());}}}}//2.    递归删除文件夹public static void deleteDir(File dir){File[] files = dir.listFiles();if(files!=null && files.length>0){for (File file : files) {if(file.isDirectory()){deleteDir(file);    //递归}else {//删除文件，但是文件夹没有删除System.out.println(file.getAbsolutePath()+"删除："+file.delete());}}}//再删除文件夹System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());}
}
结果：
----递归遍历文件夹----
d:\myfiles
d:\myfiles\新建XLSX工作表.xlsx
d:\myfiles\新建文件夹
d:\myfiles\新建文件夹\新建PPT演示文稿.ppt
d:\myfiles\新建文件夹\新建文本文档.txt
d:\myfiles\新建文件夹 (2)
d:\myfiles\新建文件夹 (2)\新建DOC文档.docx
d:\myfiles\新建文件夹 (2)\新建文本文档.txt
d:\myfiles\新建文本文档.txt
----递归删除文件夹----
d:\myfiles\新建XLSX工作表.xlsx删除：true
d:\myfiles\新建文件夹\新建PPT演示文稿.ppt删除：true
d:\myfiles\新建文件夹\新建文本文档.txt删除：true
d:\myfiles\新建文件夹删除：true
d:\myfiles\新建文件夹 (2)\新建DOC文档.docx删除：true
d:\myfiles\新建文件夹 (2)\新建文本文档.txt删除：true
d:\myfiles\新建文件夹 (2)删除：true
d:\myfiles\新建文本文档.txt删除：true
d:\myfiles删除：true

集合补充：Properties

是属性集合，继承了HashTable，线程安全

特点:

可以存储属性名和属性值(键值对)
属性名和属性值都是字符串类型
没有泛型
和流有关

范例：

package com.qf.chap15_4;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;public class Demo02 {public static void main(String[] args) throws Exception{//1.    创建集合Properties properties = new Properties();//2.    添加数据properties.setProperty("username","张三");properties.setProperty("age","20");System.out.println(properties.toString());//3.    遍历//3.1   keyset//3.2   entryset//3.3   stringPropertyNames()Set<String> pronames = properties.stringPropertyNames();for (String proname : pronames) {System.out.println(proname+"========"+properties.getProperty(proname));}//4.    和流有关的方法//①----list----//PrintWriter pw = new PrintWriter("d:\\print.txt");//properties.list(pw);//pw.close(); //结果打印在print.txt当中//②----store----//FileOutputStream fos = new FileOutputStream("d:\\store.properties");//properties.store(fos,"注释");//fos.close();//③----load----Properties properties2 = new Properties();FileInputStream fis = new FileInputStream("d:\\store.properties");properties2.load(fis);fis.close();System.out.println(properties2);}
}
结果：
{age=20, username=张三}
age========20
username========张三
{age=20, username=张三}

总结

流的概念：

内存和存储设备之间传输数据的通道

流的分类：

输入流、输出流；字节流、字符流；节点流、过滤流；

序列化、反序列化：

将对象通过流写入到文件，或者将对象通过流读取到内存
必须实现Serializable接口

File对象：

代表物理盘符中的一个文件或者文件夹

Java塈百日而求新，念三番未发，其二相关推荐

Java塈百日而求新，念三番未发，其一
Java集合框架详解集合概念:对象的容器,定义了对多个对象进行操作的常用方法.可实现数组的功能. 和数组的区别: 数组长度固定,集合长度不固定数组可以存储基本类型和引用类型,集合只能存储引用类型 ...
Visual Age for Java_VisualAge for Java使用技巧
VisualAge for Java使用技巧杨旭青 IBM 的VisualAge for Java 是一个功能强大. 灵活的Java 编程环境, 本文介绍几个与 ...
java解压，压缩.gz文件
/* * gz文件是linux下常见的压缩格式.使用 java.util.zip.GZIPInputStream即可,压缩是 java.util.zip.GZIPOutputStream ...
唯有作茧自缚，方可破茧成蝶
作茧自缚,原是贬义词,比喻做了某件事,结果使自己受困;或者说是自己给自己找麻烦.可是,在我的世界里,它代表的从不是这个意思.于我而言,唯有作茧自缚,方可破茧成蝶. 一开始做这个决定的时候,没想到今天会 ...
java未发现数据源名称并且未指定默认驱动程序_转：java.sql.SQLException: [Microsoft][ODBC 驱动程序管理器] 未发现数据源名称并且未指定默认驱动程序...
在Win7 64位系统下,使用Java+Access数据库编程,用Java连数据库时,出现错误提示,如下: Java java.sql.SQLException: [Microsoft][ODBC 驱 ...
java念整数你的程序要读入一个整数，范围是[-100000,100000]。然后，用汉语拼音将这个整数的每一位输出出来。如输入1234，则输出： yi er san si
念整数(5分) 题目内容: 你的程序要读入一个整数,范围是[-100000,100000].然后,用汉语拼音将这个整数的每一位输出出来. 如输入1234,则输出: yi er san si 注意,每个 ...
7-25 念数字（15 分）Java与C++
7-25 念数字(15 分) 输入一个整数,输出每个数字对应的拼音.当整数为负数时,先输出fu字.十个数字对应的拼音如下: 0: ling 1: yi 2: er 3: san 4: si 5: wu ...
Java实现蓝桥杯VIP 算法提高分分钟的碎碎念
算法提高分分钟的碎碎念时间限制:1.0s 内存限制:256.0MB 问题描述以前有个孩子,他分分钟都在碎碎念.不过,他的念头之间是有因果关系的.他会在本子里记录每一个念头,并用箭头画出这个念头的 ...
java数字相减_Java的百日计划（day14）
###14.01_常见对象(正则表达式的概述和简单使用) * A:正则表达式 * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串.其实就是一种规则.有自己特殊的应用. * 作用:比 ...

Java塈百日而求新，念三番未发，其二