JAVA文件操作

最新推荐文章于 2026-06-12 16:25:22 发布

转载最新推荐文章于 2026-06-12 16:25:22 发布 · 684 阅读

文章标签：

#java #exception #string #file #import #class

Java 专栏收录该内容

13 篇文章

订阅专栏

JAVA文件操作（一）
1、课程名称：JAVA文件操作
File、输入、输出流、对象序列化
2、知识点
2.1、上次课程的主要知识点
1、 String与StringBuffer的区别
? String一旦声明之后内容不可改变，可以直接赋值，连接可以用+号
? StringBuffer的内容可以改变，必须实例化之后赋值
2、 Class类的作用
? Class表示反射机制，表示一切类的组成
? 通过Class.forName()可以找到一个类，之后通过newInstance()实例化，但是要求使用此种方式的时候类中必须存在无参构造方法。
3、比较器 —— Comparable
? 用于为一个对象进行排序操作
4、日期操作类：
? SimpleDateFormat ? Date ?日期显示
5、正则表达式：
? 验证字符串的组成
? 拆分、替换
6、使用正则验证email地址
public class RegDemo{
public static void main(String args[]){
String str = "a@aa.com.cn" ;
// com com.cn cn net net.cn org edu
System.out.println(str.matches("//w+@//w+.((com)|(com.cn)|(cn)|(net)|(net.cn)|(org)|(edu))")) ;
}
};
2.2、本次预计讲解的知识点
1、 File类的作用及使用
2、字节输入流/字节输出流、字符输入流/字符输出流
3、内存操作流
4、打印流
5、对象序列化
3、具体内容
在整个JAVA中所有的文件操作都是使用java.io包完成的，此包中包含了各种操作的类及接口。
IO包中有以下几个主要部分组成：
? 表示与文件本身的操作：File
? IO的输入、输出类
? 对象序列化
3.1、File类（重点）
在整个IO包中，File类是唯一表示文件本身的，即：文件的创建、删除、存在与否的判断。
File类在使用的时候需要指定操作的文件路径，构造方法：
? public File(String pathname)
例如：现在使用File类在硬盘上创建一个新的文件（e:/abc.txt）
? 创建文件的方法：public boolean createNewFile() throws IOException
import java.io.* ;
public class IODemo01{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://abc.txt") ;
try{
   System.out.println(f.createNewFile()) ;
}catch(Exception e){}
}
};
例如：删除在硬盘上建立好的文件
? 删除文件的方法：public boolean delete()
import java.io.* ;
public class IODemo02{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://abc.txt") ;
// 删除文件
f.delete() ;
}
};
但是以上有一个问题，至少文件存在之后才可以删除。证明，在删除之前需要先判断此文件是否存在，判断语法：public boolean exists()：
import java.io.* ;
public class IODemo03{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://abc.txt") ;
if(f.exists()){
   // 删除文件
   f.delete() ;
}
}
};
例如：要求完成以下的功能
? 如果文件存在则删除，如果文件不存在则创建
import java.io.* ;
public class IODemo04{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://abc.txt") ;
if(f.exists()){
   // 删除文件
   f.delete() ;
}else{
   try{
    f.createNewFile() ;
   }catch(Exception e){}
}
}
};
发现此种操作并不是立刻生效的，有一定时间的延迟。
注意：
如果在程序中直接输出File类的对象，则会打印路径名称。
import java.io.* ;
public class IODemo05{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://abc.txt") ;
System.out.println(f) ;
}
};
输出结果：
e:/abc.txt
例如：要求列出一个目录下的所有内容
方法名称如下：
? public String[] list()：只列出了所有的文件夹或文件的名称，不是绝对路径
? public File[] listFiles()：取得的是绝对路径
A、使用list()方法操作：
import java.io.* ;
public class IODemo06{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://") ;
String s[] = f.list() ;
for(int i=0;i<s.length;i++){
   System.out.println(s[i]) ;
}
}
};
B、使用listFiles()方法操作
import java.io.* ;
public class IODemo07{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://") ;
File fs[] = f.listFiles() ;
for(int i=0;i<fs.length;i++){
   System.out.println(fs[i]) ;
}
}
};
例如：区分一个给定的路径是文件还是文件夹
? 方法名称：public boolean isDirectory()
import java.io.* ;
public class IODemo08{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://") ;
System.out.println(f.isDirectory()) ;
}
};
思考：
任意给定一个路径，要求把此路径下的所有文件包括各个子文件夹的文件全部列出。
? 思路：
|- 通过给定的路径判断是否是一个文件夹
|- 如果是一个文件夹，则继续列出里面的内容
|- 之后再将此文件夹里面的内容继续判断，观察是否是目录
import java.io.* ;
public class IODemo09{
public static void main(String args[]){
// 告诉系统准备操作这样的一个文件
File f = new File("e://") ;
print(f) ;
}
public static void print(File f){
if(f.isDirectory()){
   File files[] = f.listFiles() ;
   try{
    for(int i=0;i<files.length;i++){
     // 如果还有子文件夹，则肯定继续列出
     print(files[i]) ;
    }
   }catch(Exception e){}
}else{
   System.out.println(f) ;
}
}
};
3.2、RandomAccessFile类（了解）
RandomAccessFile：实现随机访问，可以在文件之中跳转。
在保存内容的时候，必须指定内容的长度。
现在向文件之中写入如下数据：
? zhangsan 30
? lisi 31
? wangwu 32
例如：通过RandomAccessFile类向文件中保存内容
? 构造方法：public RandomAccessFile(File file,String mode) throws FileNotFoundException
|- String mode：表示的是文件的打开模式：
   |- 只读：r，但是使用此种方式的时候必须保证文件存在。
|- 读写：rw，使用此种方式的时候，向文件中写入数据，如果文件不存在，则会自动创建一个新的文件出来
? 向文件中写数据：
? 向文件中写入字符串：public final void writeBytes(String s) throws IOException
? 向文件中写入数字：public final void writeInt(int v) throws IOException
? 文件操作之后必须关闭：
? 关闭：public void close() throws IOException
利用以上方法完成文件的写入，可是写的时候，必须注意，所有的内容长度必须固定。
import java.io.* ;
public class IODemo10{
public static void main(String args[]) throws Exception{
File f = new File("e:"+File.separator+"hello.txt") ;
RandomAccessFile raf = null ;
// 如果文件不存在，则会自动创建一个
raf = new RandomAccessFile(f,"rw") ;
String name = null ;
int age = 0 ;
name = "zhangsan" ;
age = 30 ;
raf.writeBytes(name) ;
raf.writeInt(age) ;
name = "lisi    " ;
age = 31 ;
raf.writeBytes(name) ;
raf.writeInt(age) ;
name = "wangwu " ;
age = 32 ;
raf.writeBytes(name) ;
raf.writeInt(age) ;
raf.close() ;
}
};
例如：通过RandomAccessFile取出里面的内容
? 因为是读，所以可以使用只读的方式打开文件：r
? 读字符串：public final byte readByte() throws IOException
|- 使用byte的方式读取进来
? 读数字：public final int readInt() throws IOException
? 跳过指定长度的内容：public int skipBytes(int n) throws IOException
? 跳回位置：public void seek(long pos) throws IOException
import java.io.* ;
public class IODemo11{
public static void main(String args[]) throws Exception{
File f = new File("e:"+File.separator+"hello.txt") ;
RandomAccessFile raf = null ;
// 如果文件不存在，则会自动创建一个
raf = new RandomAccessFile(f,"r") ;
String name = null ;
int age = 0 ;
byte b[] = new byte[8] ;
// 跳过第一个人的信息
raf.skipBytes(12) ;
for(int i=0;i<b.length;i++){
   b[i] = raf.readByte() ;
}
age = raf.readInt() ;
name = new String(b) ;
System.out.println("姓名：" + name) ;
System.out.println("年龄：" + age) ;
raf.seek(0) ;
for(int i=0;i<b.length;i++){
   b[i] = raf.readByte() ;
}
age = raf.readInt() ;
name = new String(b) ;
System.out.println("姓名：" + name) ;
System.out.println("年龄：" + age) ;
raf.close() ;
}
};
3.3、字节流、字符流操作类（重点）
文件操作的基本流程：
1、通过File类找到一个文件
2、通过File类去实例化字节流、字符流操作类
3、进行读或写的操作，在写的时候如果文件不存在则会自动创建
4、关闭文件
3.3.1、字节流
在字节流中分为两种：
? 输出流：OutputStream
? 输入流：InputStream
例如：向文件之中打印一个“Hello World!!!”。
? 肯定使用输出流。
|- 定义：public abstract class OutputStream extends Objec timplements Closeable, Flushable
? OutputStream子类：FileOutputStream
|- 构造方法：public FileOutputStream(File file) throws FileNotFoundException
? 输出方法：public void write(byte[] b) throws IOException
|- 可以发现只能写出一个byte数组，那么现在是一个字符串，如果要想使用此种方式，需要将一个字符串变为一个byte数组，String中的方法：public byte[] getBytes() 。
? 关闭：public void close() throws IOException
import java.io.* ;
public class IODemo12{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
OutputStream out = null ;
try{
   // 通过子类实例化
   out = new FileOutputStream(f) ;
}catch(Exception e){}
String str = "Hello World!!!" ;
byte b[] = str.getBytes() ;
try{
   out.write(b) ;
}catch(Exception e){}
try{
   out.close() ;
}catch(Exception e){}
}
}
例如：既然可以通过OutputStream向文件中写入内容，那么就一定可以从文件中读取内容，使用InputStream读取内容。
? InputStream也是一个抽象类，所以必须使用其子类：FileInputStream
? 读的方式：
? public int read(byte[] b) throws IOException
   |- 传入一个byte数组，将所有的内容保存在byte数组之中。
   |- 此方法返回向数组中写入数据的个数
? 将byte数组变为字符串：public String(byte b[])、public String(byte b[],int be,int len)
import java.io.* ;
public class IODemo13{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
InputStream input = null ;
try{
   // 通过子类实例化
   input = new FileInputStream(f) ;
}catch(Exception e){}
byte b[] = null ;
int len = 0 ;
try{
   b = new byte[1024] ;
   // 把所有的内容读到数组b中
   // 返回读取的个数
   len = input.read(b) ;
}catch(Exception e){}
try{
   input.close() ;
}catch(Exception e){}
System.out.println(new String(b,0,len)) ;
}
}
? 但是读取的时候发现程序中开辟了一个很大的byte数组，不用的空间有些浪费，那能否根据文件的大小开辟呢？
? File类中有取得文件长度的方法。
import java.io.* ;
public class IODemo14{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
InputStream input = null ;
try{
   // 通过子类实例化
   input = new FileInputStream(f) ;
}catch(Exception e){}
byte b[] = null ;
try{
   b = new byte[(int)f.length()] ;
   // 把所有的内容读到数组b中
   // 返回读取的个数
   input.read(b) ;
}catch(Exception e){}
try{
   input.close() ;
}catch(Exception e){}
System.out.println(new String(b)) ;
}
}
? 如果现在不知道文件大小，该怎么读呢？
? 读取方法：
|- public abstract int read() throws IOException
|- 如果读取的内容不是“-1”，就表示还有文件，可以继续读
import java.io.* ;
public class IODemo15{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
InputStream input = null ;
try{
   // 通过子类实例化
   input = new FileInputStream(f) ;
}catch(Exception e){}
byte b[] = null ;
try{
   b = new byte[(int)f.length()] ;
   int x = 0 ;
   int foot = 0 ;
   while((x=input.read())!=-1){
    b[foot] = (byte)x ;
    foot++ ;
   }
}catch(Exception e){
   System.out.println(e) ;
}
try{
   input.close() ;
}catch(Exception e){}
System.out.println(new String(b)) ;
}
}
3.3.2、字符流
一个字符 = 两个字节。
在字符流操作中，主要使用以下两个类：
? 字符输出流：Writer
? 字符输入流：Reader
例如：向文件中保存一个数据
写内容的方法：public void write(String str) throws IOException
import java.io.* ;
public class IODemo16{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
Writer out = null ;
try{
   // 通过子类实例化
   out = new FileWriter(f) ;
}catch(Exception e){}
String str = "Hello World!!!" ;
try{
   out.write(str) ;
}catch(Exception e){}
try{
   out.close() ;
}catch(Exception e){}
}
}
例如：从文件中把内容读取进来
读的方法：
|- public int read(char[] cbuf) throws IOException
|- public int read() throws IOException
import java.io.* ;
public class IODemo17{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
Reader input = null ;
try{
   // 通过子类实例化
   input = new FileReader(f) ;
}catch(Exception e){}
char c[] = null ;
int len = 0 ;
try{
   c = new char[(int)f.length()] ;
   len = input.read(c) ;
}catch(Exception e){
   System.out.println(e) ;
}
try{
   input.close() ;
}catch(Exception e){}
System.out.println(new String(c,0,len)) ;
}
}
当然，也可以使用read()方法读取内容，代码如下：
import java.io.* ;
public class IODemo18{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
Reader input = null ;
try{
   // 通过子类实例化
   input = new FileReader(f) ;
}catch(Exception e){}
char c[] = null ;
try{
   c = new char[(int)f.length()] ;
   int x = 0 ;
   int foot = 0 ;
   while((x=input.read())!=-1){
    c[foot] = (char)x ;
    foot++ ;
   }
}catch(Exception e){
   System.out.println(e) ;
}
try{
   input.close() ;
}catch(Exception e){}
System.out.println(new String(c)) ;
}
}
3.3.3、字节流和字符流的区别
? 字节与字符的不同在于：
? 所有的文件不管是使用Output、Writer实际上最终保存在文件上的都是字节。
? 字符是在内存中形成的。
例如：观察以下代码
使用字节流输出，但是并没有关闭
import java.io.* ;
public class IODemo19{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
OutputStream out = null ;
try{
   // 通过子类实例化
   out = new FileOutputStream(f) ;
}catch(Exception e){}
String str = "Hello World!!!" ;
byte b[] = str.getBytes() ;
try{
   out.write(b) ;
}catch(Exception e){}
}
}
以上代码是使用字节流进行操作，但是文件本身并没有关闭，证明字节流是直接操作文件本身的。
那么，同样，将以上的字节流输出换为字符流输出：
import java.io.* ;
public class IODemo20{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
Writer out = null ;
try{
   // 通过子类实例化
   out = new FileWriter(f) ;
}catch(Exception e){}
String str = "Hello World!!!" ;
try{
   out.write(str) ;
}catch(Exception e){}
}
}
运行之后，发现文件虽然已经创建，但是所有的内容并没有写进去，这是因为对于字符流在关闭操作的时候，会强制性的将缓存清空，那么以上代码并没有关闭，所以现在的内容还在缓存里，并没有直接到文件之中。那么面对上面的情况，如果不关闭文件该如何解决呢？
在Writer类中提供了一个强制性清空缓存的操作：public abstract void flush() throws IOException
例如：修改之前的操作，清空缓存
import java.io.* ;
public class IODemo21{
public static void main(String[] args){
// 通过File找到一个文件
File f = new File("e://hello.txt") ;
// 输出流操作类
Writer out = null ;
try{
   // 通过子类实例化
   out = new FileWriter(f) ;
}catch(Exception e){}
String str = "Hello World!!!" ;
try{
   out.write(str) ;
   out.flush() ;
}catch(Exception e){}
}
}
但是：
一般程序对于字节流的使用相对较多，例如：图片、多媒体文件。
3.3.4、COPY功能的实现
命令格式：copy e:/hello.txt e:/abc.ini
此命令中有相关的错误提示。
那么现在要求使用JAVA编写这样的一个命令，例如：Java的类为Copy.class，则可以通过初始化参数的方式输入两个路径，例如：java Copy 路径1 路径2。
? 数据应该边读边写
? 要确定源路径是否存在及语法格式是否正确。
import java.io.* ;
public class Copy{
public static void main(String args[]) throws Exception{
// 判断参数
if(args.length!=2){
   System.out.println("命令语法不正确。") ;
   System.exit(1) ;
}
// 再判断源文件是否存在
File f1 = new File(args[0]) ;
if(!f1.exists()){
   System.out.println("系统找不到指定的文件。") ;
   System.exit(1) ;
}
File f2 = new File(args[1]) ;
InputStream input = new FileInputStream(f1) ;
OutputStream out = new FileOutputStream(f2) ;
int x = 0 ;
while((x=input.read())!=-1){
   out.write(x) ;
}
System.out.println("拷贝完成。") ;
input.close() ;
out.close() ;
}
};

3.3、内存流（掌握）
一个子类决定父类的具体操作行为，那么对于整个IO操作来说，具体的输入、输出会根据子类的不同而有所不同。
内存流：指的是所有的输入、输出都是以内存为目的地。
内存的输出流：ByteArrayOutputStream，以内存为源目的地
内存输入流：ByteArrayInputStream，是指把内容向内存中输入。
ByteArrayInputStream方法：
? 构造：public ByteArrayInputStream(byte[] buf)，表示把内容输入到内存里去
ByteArrayOutputstream方法：
? 构造：public ByteArrayOutputStream()
例如：以下代码完成了一个大-小写的转换功能
import java.io.* ;
public class IODemo22{
public static void main(String args[]) throws Exception{
ByteArrayInputStream bis = null ;
ByteArrayOutputStream bos = null ;
bos = new ByteArrayOutputStream() ;
String str = "helloworld" ;
// 把内容输入到内存里去
bis = new ByteArrayInputStream(str.getBytes()) ;
// 通过bos可以把内容读取出来
int c = 0 ;
while((c=bis.read())!=-1){
   char x = Character.toUpperCase((char)c) ;
   bos.write(x) ;
}
System.out.println(bos) ;
bis.close() ;
bos.close() ;
}
};
3.4、打印流（重点）
思考：
之前如果想向一个文件中保存一些内容，需要把内容变为byte数组，很麻烦，那么对于OutptuStream本身而言，只是具备了保存的功能，但是其功能并不完善。所以后来人们为了操作IO方便（输出方便）为OutptuStream增加了一个子类 —— PrintStream。
PrintStram之中提供了比OutputStram中更好的输出方法。
打印流实际上也分为两种：PrintStream、PrintWriter
PrintStream的使用：
? 构造：public PrintStream(OutputStream out)
|- 根据传入的OutputStream来决定输出的位置。
? 使用：print()、println()
例如：观察PrintStream使用
import java.io.* ;
public class IODemo23{
public static void main(String args[]) throws Exception{
PrintStream ps = null ;
ps = new PrintStream(new FileOutputStream(new File("e://h.txt"))) ;
ps.print("hello ") ;
ps.print("world") ;
ps.println("/r/nHELLO") ;
ps.close() ;
}
};
如果需要在文件之后对内容进行追加的话，则直接编写以下代码即可：
import java.io.* ;
public class IODemo23{
public static void main(String args[]) throws Exception{
PrintStream ps = null ;
ps = new PrintStream(new FileOutputStream(new File("e://h.txt"),true)) ;
ps.print("hello ") ;
ps.print("world") ;
ps.println("/r/nHELLO") ;
ps.println("/r/nABC") ;
ps.close() ;
}
};
可以发现，使用打印流很方便的完成数据的输出。
3.5、System对IO的支持
回顾：System.out.println() ;
System中有以下两个静态属性：
? System.out：对应的是标准输出，为显示器
? System.in：对应的是标准输入，为键盘
3.6.1、System.out
System.out是PrintStream的类型，问：能否通过此对象为OutputStream实例化？
import java.io.* ;
public class IODemo24{
public static void main(String args[]) throws Exception{
OutputStream out = System.out ;
out.write("HELLO WORLD".getBytes()) ;
out.close() ;
}
};
以上代码进一步验证了面向对象的多态性，那个子类为父类实例化，那么父类就具备那个子类的功能。所有的目的地由子类决定。父类只是规定出了标准。
3.6.2、System.in
System.in对应着键盘的输入，是InputStream类型的对象。
那么既然是InputStream类型的对象，那么下面的代码实验了由键盘输入数据：
import java.io.* ;
public class IODemo25{
public static void main(String args[]) throws Exception{
// 现在代码从键盘中读取信息
InputStream input = System.in ;
byte b[] = new byte[1024] ;
System.out.print("请输入内容：") ;
int len = input.read(b) ;
System.out.println("输入的内容为：" + new String(b,0,len)) ;
}
};
以上确实完成了键盘的输入信息功能，但是否存在问题？
? 开辟的空间问题。
之前学过一种方式，不开辟一个空间，有多少读多少？
那么如果现在使用此种方式呢？
import java.io.* ;
public class IODemo27{
public static void main(String args[]) throws Exception{
// 现在代码从键盘中读取信息
InputStream input = System.in ;
StringBuffer buf = new StringBuffer() ;
System.out.print("请输入内容：") ;
int c = 0 ;
while((c=input.read())!=-1){
   buf.append((char)c) ;
}
System.out.println("输入的内容为：" + buf) ;
}
};
以下代码没有指定出具体的空间大小，而是输入多少就保存多少，如果现在输入的是英文字母可以正确保存，如果是中文呢，因为是半个半个字保存的，所以是乱码。
3.6、BufferedReader（缓冲读取，重点）
之前出现乱码的根本原因在于是分着读的。
BufferedReader是一个字符流的子类，构造方法：
? public BufferedReader(Reader in)
System.in是一个字节流的对象。
字节流-字符流的转换类：
? InputStreamReader：把输入的字节流变为字符流
? OutputStreamWriter：把输出的字符流变为字节流
观察InputStreamReader，是Reader的子类，构造方法：
? public InputStreamReader(InputStream in)
BufferedReader中读取：public String readLine() throws IOException
键盘输入数据的标准格式：
import java.io.* ;
public class IODemo28{
public static void main(String args[]) throws Exception{
BufferedReader buf = null ;
buf = new BufferedReader(new InputStreamReader(System.in)) ;
System.out.print("请输入内容：") ;
String str = null ;
str = buf.readLine() ;
System.out.println("输入的内容为：" + str) ;
}
};
如果现在要想输入多个数据的话，则直接重复readLine()即可。
import java.io.* ;
public class IODemo29{
public static void main(String args[]) throws Exception{
BufferedReader buf = null ;
buf = new BufferedReader(new InputStreamReader(System.in)) ;
System.out.print("请输入内容1：") ;
String str = null ;
str = buf.readLine() ;
System.out.println("输入的内容1为：" + str) ;
System.out.print("请输入内容2：") ;
str = buf.readLine() ;
System.out.println("输入的内容2为：" + str) ;
}
};
3.6.1、练习一
完成以下功能
通过程序输入两个数字，之后进行两个数字的相加操作，并把结果打印输出。
要求：如果用户输入的不是数字，则应该提示用户输入错误，之后要求用户重新输入。
? 字符串 ? 整型：Integer.parseInt(String str)
A、基础模型
import java.io.* ;
public class IODemo30{
public static void main(String args[]) throws Exception{
BufferedReader buf = null ;
buf = new BufferedReader(new InputStreamReader(System.in)) ;
int x = 0 ;
int y = 0 ;
System.out.print("输入第一个数字：") ;
String str = null ;
str = buf.readLine() ;
x = Integer.parseInt(str) ;
System.out.print("输入第二个数字：") ;
str = buf.readLine() ;
y = Integer.parseInt(str) ;
System.out.println("计算结果：" + x + " + " + y + " = " + (x+y)) ;
}
};
B、为程序中加入判断
因为数据是由用户输入的，所以必须对输入的内容进行验证。使用正则表达式。
import java.io.* ;
public class IODemo31{
public static void main(String args[]) throws Exception{
BufferedReader buf = null ;
buf = new BufferedReader(new InputStreamReader(System.in)) ;
int x = 0 ;
int y = 0 ;
boolean flag = true ;
System.out.print("输入第一个数字：") ;
String str = null ;
while(flag){
   str = buf.readLine() ;
   if(str.matches("//d+")){
    x = Integer.parseInt(str) ;
    flag = false ;
   }else{
    System.out.print("输入的不是数字，请重新输入：") ;
   }
}
System.out.print("输入第二个数字：") ;
flag = true ;
while(flag){
   str = buf.readLine() ;
   if(str.matches("//d+")){
    y = Integer.parseInt(str) ;
    flag = false ;
   }else{
    System.out.print("输入的不是数字，请重新输入：") ;
   }
}
System.out.println("计算结果：" + x + " + " + y + " = " + (x+y)) ;
}
};
如果现在要求连续输入10个数字，则以上代码要重复10遍，下面设计一个输入数据的类，要求可以通过此类得到正确的整数、小数、日期（yyyy-mm-dd），和字符串，问此类如何设计，并将此类应用与之前的程序之上。
import java.io.* ;
import java.util.* ;
import java.text.* ;
class InputData{
private BufferedReader buf = null ;
public InputData(){
this.buf = new BufferedReader(new InputStreamReader(System.in)) ;
}
public String getString(String info){
String str = null ;
System.out.print(info) ;
try{
   str = this.buf.readLine() ;
}catch(Exception e){}
return str ;
}
public int getInt(String info){
int temp = 0 ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d+")){
     temp = Integer.parseInt(str) ;
     flag = false ;
    }else{
     System.out.print("输入的不是数字，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是数字，请重新输入,") ;
   }
}
return temp ;
}
public float getFloat(String info){
float temp = 0 ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d+.?//d{1,2}")){
     temp = Float.parseFloat(str);
     flag = false ;
    }else{
     System.out.print("输入的不是数字，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是数字，请重新输入,") ;
   }
}
return temp ;
}
public Date getDate(String info){
Date temp = null ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d{4}-//d{2}-//d{2}")){
     // 把一个字符传变为Date类型
     temp = new SimpleDateFormat("yyyy-MM-dd").parse(str) ;
     flag = false ;
    }else{
     System.out.print("输入的不是日期，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是日期，请重新输入,") ;
   }
}
return temp ;
}
};
public class IODemo32{
public static void main(String args[]) throws Exception{
InputData input = new InputData() ;
int x = input.getInt("输入第一个数字：") ;
int y = input.getInt("输入第二个数字：") ;
System.out.println("计算结果：" + x + " + " + y + " = " + (x+y)) ;
System.out.println(input.getFloat("输入小数：")) ;
System.out.println(input.getDate("输入日期：")) ;
}
};
3.6.2、练习二
设计一个菜单程序
用户运行程序之后，可以显示一个菜单：
[1]、输入数据
[2]、查看数据
[3]、修改数据
[4]、退出系统

请选择：
提示：可以通过switch完成
import java.io.* ;
import java.util.* ;
import java.text.* ;
class InputData{
private BufferedReader buf = null ;
public InputData(){
this.buf = new BufferedReader(new InputStreamReader(System.in)) ;
}
public String getString(String info){
String str = null ;
System.out.print(info) ;
try{
   str = this.buf.readLine() ;
}catch(Exception e){}
return str ;
}
public int getInt(String info){
int temp = 0 ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d+")){
     temp = Integer.parseInt(str) ;
     flag = false ;
    }else{
     System.out.print("输入的不是数字，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是数字，请重新输入,") ;
   }
}
return temp ;
}
public float getFloat(String info){
float temp = 0 ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d+.?//d{1,2}")){
     temp = Float.parseFloat(str);
     flag = false ;
    }else{
     System.out.print("输入的不是数字，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是数字，请重新输入,") ;
   }
}
return temp ;
}
public Date getDate(String info){
Date temp = null ;
boolean flag = true ;
String str = null ;
while(flag){
   try{
    str = this.getString(info) ;
    if(str.matches("//d{4}-//d{2}-//d{2}")){
     // 把一个字符传变为Date类型
     temp = new SimpleDateFormat("yyyy-MM-dd").parse(str) ;
     flag = false ;
    }else{
     System.out.print("输入的不是日期，请重新输入,") ;
    }
   }catch(Exception e){
    System.out.print("输入的不是日期，请重新输入,") ;
   }
}
return temp ;
}
};
class Operate{
public void add(){
System.out.println("选择的是输入操作！") ;
}
public void show(){
System.out.println("选择的是查看数据操作！") ;
}
public void update(){
System.out.println("选择的是修改操作！") ;
}
};
// 负责显示菜单
class Menu{
public Menu(){
while(true){
   this.showMenu() ;
}
}
public void showMenu(){
System.out.println(" ================== 菜单程序 ================== ") ;
System.out.println("[1]、输入数据") ;
System.out.println("[2]、查看数据") ;
System.out.println("[3]、修改数据") ;
System.out.println("[4]、退出系统") ;
InputData input = new InputData() ;
Operate o = new Operate() ;
switch(input.getInt("请选择：")){
   case 1:
    {
     o.add() ;
     break ;
    }
   case 2:
    {
     o.show() ;
     break ;
    }
   case 3:
    {
     o.update() ;
     break ;
    }
   case 4:
    {
     System.out.println("byebye!") ;
     System.exit(1) ;
     break ;
    }
   case 5:
    {
     System.out.println("无效的选项，请重新选择！") ;
     break ;
    }
}
}
};
public class IODemo33{
public static void main(String args[]) throws Exception{
new Menu() ;
}
};
3.7、字符编码（了解）
在各个平台上都是有语言的支持的，那么一般对于文字来说有以下几种常见的编码方式：
? GBK：包含了简体中文和繁体中文的编码集
? GB2312：只包含了简体中文
? ISO8859-1：是一个国际的通用编码
例如：取得本机的编码方式
public class IODemo34{
public static void main(String args[]) throws Exception{
System.getProperties().list(System.out) ;
}
};
显示结果：

任何编码都不写的情况下，肯定是GBK码，那么如果现在要保存一个文件的内容，但是文件的内容使用了ISO8859-1编码，问能正确解码吗？不可以
例如：以下代码对输出的内容进行重新编码
import java.io.* ;
public class IODemo35{
public static void main(String args[]) throws Exception{
OutputStream out = new FileOutputStream(new File("e://test.txt")) ;
out.write("世界，你好".getBytes("ISO8859-1")) ;
out.close() ;
}
};
因为程序本身与本地环境中的编码方式不一样，所以无法正确的进行解码。
程序造成乱码的根本原因：
? 编码不一致所造成
3.8、对象序列化（重点）
对象序列化：将一个对象进行IO操作，输入/输出。
如果要想实现对象序列化，则对象所在的类必须实现一个序列化接口 —— Serializable，但是此接口中没有任何的定义，所以此接口只是一个标识接口。
常见的标识接口：
? Cloneable，表示可以被克隆
? Serializable：标识可以被序列化
那么下面的代码以向文件中保存为例。
如果现在要想实现对象的输出和输入，则必须使用以下两个类：
? ObjectOutputStream：对象输出流
|- 构造方法：public ObjectOutputStream(OutputStream out) throws IOException
|- 写对象：public final void writeObject(Object obj) throws IOException
? ObjectInputStream：对象输入流，反序列化
|- 构造方法：public ObjectInputStream(InputStream in) throws IOException
|- 读对象：public final Object readObject() throws IOException,ClassNotFoundException
说明：
? 对象可以向任何地方保存。
例如：向文件之中写入一个对象
import java.io.* ;
class Person implements Serializable{
private String name;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class IODemo36{
public static void main(String args[]) throws Exception{
Person per = new Person("zhangsan",30) ;
ser(per) ;
}
public static void ser(Person per) throws Exception{
ObjectOutputStream oos = null ;
oos = new ObjectOutputStream(new FileOutputStream(new File("e://person.ser"))) ;
// 写对象
oos.writeObject(per) ;
oos.close() ;
}
};
例如：从文件之中读取出对象
import java.io.* ;
class Person implements Serializable{
private String name;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class IODemo37{
public static void main(String args[]) throws Exception{
Person per = new Person("zhangsan",30) ;
// ser(per) ;
System.out.println(dser()) ;
}
public static void ser(Person per) throws Exception{
ObjectOutputStream oos = null ;
oos = new ObjectOutputStream(new FileOutputStream(new File("e://person.ser"))) ;
// 写对象
oos.writeObject(per) ;
oos.close() ;
}
public static Person dser() throws Exception{
Person per = null ;
ObjectInputStream ois = null ;
ois = new ObjectInputStream(new FileInputStream(new File("e://person.ser"))) ;
per = (Person)ois.readObject() ;
ois.close() ;
return per ;
}
};
例如：现在不希望Person类中的name属性被序列化，那么次时对于不希望被序列化的属性就可以使用transient关键字声明。
import java.io.* ;
class Person implements Serializable{
private transient String name;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class IODemo37{
public static void main(String args[]) throws Exception{
Person per = new Person("zhangsan",30) ;
ser(per) ;
System.out.println(dser()) ;
}
public static void ser(Person per) throws Exception{
ObjectOutputStream oos = null ;
oos = new ObjectOutputStream(new FileOutputStream(new File("e://person.ser"))) ;
// 写对象
oos.writeObject(per) ;
oos.close() ;
}
public static Person dser() throws Exception{
Person per = null ;
ObjectInputStream ois = null ;
ois = new ObjectInputStream(new FileInputStream(new File("e://person.ser"))) ;
per = (Person)ois.readObject() ;
ois.close() ;
return per ;
}
};
4、总结
整个IO包中，实际上就五个类，一个接口、一个关键字
? 五个类：File、OutputStream、InputStream、Reader、Writer
? 一个接口：Serializable
? 一个关键字：transient
一切的操作以父类为准，但是里面有若干个子类很有用处：
? OutputStream：
|- FileOutputStream：文件操作类
|- ByteArrayOutputStream：内存操作类
|- ObjectOutputStream：对象输出流
|- PrintStream：打印流
? InputStream：
|- FileInputStream
|- ObjectInputStream
|- ByteArrayInputStream
? Writer：
|- OutputStreamWriter：字符-字节的转换类
|- FileWriter
|- PrintWriter
? Reader：
|- InputStreamReader
|- FileReader
|- BufferedReader
用户输入数据的标准格式
字符编码：GBK、GB2312、ISO8859-1
对象序列化