Java 基本IO操做
1.基本IO操做 java
有时候咱们编写的程序除了自身会定义一些数据信息外，还须要引用外界的数据，或是将自身的数据发送到外界，这时咱们须要使用输入与输出。数组
1）输入与输出 缓存
- 输入：是一个从外界进入到程序的方向，一般咱们须要“读取”外界的数据时，使用输入。因此输入是用来读取数据的
- 输出：是一个从程序发送到外界的方向，一般咱们须要“写出”数据到外界时，使用输出。因此输出是用来写出数据的
2）节点流与处理流app
按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。ide
- 节点流：能够从一个特定的地方（节点）读写数据，一般也称为低级流
- 处理流：是对一个已存在的流的链接和封装，经过所封装的流的功能调用实现数据读写，一般也称为高级流或过滤流
处理流的构造方法老是要带一个其余的流对象作参数，一个流对象通过其余流的屡次包装，称为流的连接。this
3）IS和OS经常使用方法编码
InputStream是全部字节输入流的父类，其定义了基础的读取方法，以下：spa
- int read()：读取一个字节，以int形式返回，该int值的“低8位”有效，若返回值为-1则表示EOF
- int read(byte[] d)：尝试最多读取给定数组length个字节并存入该数组，返回值为实际读取到的字节量
OutputStream是全部字节输出流的父类，其定义了基础的写出方法，以下：code
- void write(int d)：写出一个字节，写的是给定的int的“低8位”
- void write(byte[] d)：将给定的字节数组中的全部字节所有写出
4）建立FOS对象（重写模式）对象
FileOutputStream是文件的字节输出流，使用该流能够以字节为单位将数据写入文件。
- FileOutputStream(File file)：建立一个指定File对象表示的文件中写出数据的文件输出流
- FileOutputStream(String filename)：建立一个向具备指定名称的文件中写出数据的文件输出流
注意点：若指定的文件已经包含内容，那么当使用FOS对其写入数据时，会将该文件中原有的数据所有清楚。
案例1：FOS覆盖方式写文件
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt");
String str = "Hello,World";
byte[] date = str.getBytes();
fos.write(date);
System.out.println("写出完毕");
fos.close();
}
}
5）建立FOS对象（追加模式）
若想在文件的原有数据以后追加新数据，则须要如下构造方法建立FOS：
- FileOutputStream(File file,boolean append)：建立一个向指定File对象表示的文件中写出数据的文件输出流
- FileOutputStream(String filename,boolean append)：建立一个向具备指定名称的文件中写出数据的文件输出流
以上两个构造方法中，第二个参数若为true，那么经过该FOS写出的数据都是在文件末尾追加的。
案例2：FOS追加模式写文件
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt",true);
String str = "Hello,World";
byte[] date = str.getBytes();
fos.write(date);
System.out.println("写出完毕");
fos.close();
}
}
6）建立FIS对象
FileInputStream是文件的字节输入流，咱们使用该流能够以字节为单位从文件中读取数据。FileInputStream有两个经常使用的构造方法，以下：
- FileInputStream(File file)：建立一个从指定file对象表示的文件中读取数据的文件输入流
- FileInputStream(String name)：建立用于读取给定的文件系统中的路径名name所指定的文件的文件输入流
案例3：FIS读取文件数据
import java.io.FileInputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("fos.txt");
int d = -1;
while((d=fis.read())!=-1){
System.out.print((char)d);
}
fis.close();
}
}
/*
* 运行结果：
* Hello,WorldHello,World
*/
7）read()和write(int d)方法
FileInputStream继承自InputStream，其提供了以字节为单位读取文件数据的方法read。
- int read():今后输入流中读取一个数据字节，若返回-1则表示EOF（End Of File）
FileOutputStream继承自OutputStream，其提供了以字节为单位向文件写数据的方法write。
- void write(int d):将指定字节写入此文件输出流，这里只写给定int值的“低8位”
8）read(byte[] d)和write(byte[] d)方法
FileInputStream也支持批量读取字节数据的方法：
- int read(byte[] d)：今后输入流中将最多的d.length个字节的数据读入到字节数组d中
FileOutputStream也支持批量写出字节数据的方法：
- void write(byte[] d)：将d.length个字节从指定byte数组写入此文件输出流中
- void write(byte[] d,int offset,int len)：将指定byte数组中从偏移量off开始的len个字节写入此文件输出流
2.缓冲流
1）BOS基本工做原理
在向硬件设备作写出操做时，增大写出次数无疑会下降写出效率，为此咱们可使用缓冲输出流来一次性批量写出若干数据减小写出次数来提升写出效率。BufferedOutputStream缓冲输出流内部维护着一个缓冲区，每当咱们向该流写数据时，都会先将数据存入缓冲区，当缓冲区已满时，缓冲流会将数据一次性所有写出。
案例4：BOS演示
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//建立缓冲字节输出流
FileOutputStream fos = new FileOutputStream("fos.txt");
//全部字节被存入缓冲区，等待一次性写出
BufferedOutputStream bos = new BufferedOutputStream(fos);
String str = "Hello Java";
byte[] date = str.getBytes();
bos.write(date);
//关闭流以前，缓冲输出流会将缓冲区内容一次性写出
bos.close();
System.out.println("写出完毕");
}
}
2）BOS的flush方法
使用缓冲输出流能够提升写出效率，可是这也存在一个问题，就是写出数据缺少即时性。有时须要在执行完某些写出操做后，就但愿将这些数据确实写出，而不是在缓冲区中保存知道缓冲区满后才写出。这就须要flush方法了。
- void flush():清空缓冲区，将缓冲区中的数据强制写出
案例5：flush演示
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
String str = "Hello Java";
byte[] date = str.getBytes();
bos.write(date);
bos.flush(); //强制将缓冲区已缓存数据一次性写出
System.out.println("写出完毕");
bos.close();
}
}
3）BIS基本工做原理
在读取数据时若以字节为单位读取数据，会致使读取次数过于频繁从而大大下降读取效率。为此咱们能够经过提升一次读取的字节数量减小读写次数来提升读取的效率。BufferedInputStream是缓冲字节输入流。其内部维护着一个缓冲区（字节数组），使用该流在读取一个字节时，该流会尽量多的一次性读取若干字节并存入缓冲区，而后逐一的将字节返回，直到缓冲区中的数据被所有读取完毕，会再次读取若干字节从而反复，这样就减小了读取的次数，提升了读取效率。
BIS是一个处理流，该流为咱们提供了缓冲功能。
案例6：BIS演示
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//建立缓冲字节输入流
FileInputStream fis = new FileInputStream("fos.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
int d = -1;
//缓冲读入，实际上并不是是一个字节一个字节从文件读取
while((d=bis.read())!=-1){
System.out.println(d);
}
bis.close();
}
}
3.对象流
1）对象序列化
对象是存在于内存中的。有时候咱们须要将对象保存到硬盘上或者将对象传输到另外一台计算机上等，这时须要将对象转换为一个字节序列，而这个过程就成为对象序列化。相反，这样一个字节序列须要将其转换为对应的对象，这个过程成为对象的反序列化。
2）OOS实现对象序列化
ObjectOutputStream是用来对对象进行序列化的输出流，方法以下：
- void writeObject(Object b)：将给定的对象转换为一个字节序列后写出
3）OIS实现对象反序列化
ObjectInputStream是用来对对象进行反序列化的输入流，方法以下：
- Object readObject()：从流中读取字节并转换为对应的对象
4）Serializable接口
ObjectOutputStream在对对象进行序列化时有一个要求，就是须要序列化的对象所属的类必须实现Serializable接口。实现该接口不须要重写任何方法，其只是做为可序列化的标志。一般实现该接口的类须要提供一个常量serialVersionUID，代表该类的版本。若不显示的声明，在对象序列化时也会根据当前类的各个方面计算该类的默认serialVersionUID，但不一样平台编译器实现有所不一样，因此若想跨平台，都应显示的声明版本号。
若是声明的类的对象序列化存到硬盘上面，以后随着需求的变化更改了类的属性（增长或减小或更名），那么当反序列化时，就会出现InvalidClassException，这样会形成不兼容的问题。但当serialVersionUID相同时，它就会将不同的field以type的预设值反序列化，可避开不兼容性问题。
案例7：OOS序列化演示
//建立类Person
import java.io.Serializable;
import java.util.List;
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
private char gender;
private double salary;
private List<String> otherInfo;
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", salary=" + salary + ", otherInfo="
+ otherInfo + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public List<String> getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(List<String> otherInfo) {
this.otherInfo = otherInfo;
}
}
进行序列化
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/*
* 对象流是一组高级流,做用是方便读写java中任何对象.
* 对象输出流,能够写出java对象
* 工做原理:将给定java对象按照其结构转化为一组字节而后写出.
*/
public class OOSDemo {
public static void main(String[] args) throws IOException {
Person p = new Person(); //引用对象并设置相关信息
p.setName("暮");
p.setAge(20);
p.setGender('男');
p.setSalary(5000);
List<String> otherInfo = new ArrayList<String>();
otherInfo.add("是一位诗人");
otherInfo.add("也是一位程序猿");
p.setOtherInfo(otherInfo);
System.out.println(p.toString());
//开始写出对象
FileOutputStream fos = new FileOutputStream("mu.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//当调用oos.writeObject时,实际上作了两件事:将p对象按照结果转换为了一组字节(对象序列化)
//而后再将这组字节经过FOS写入到文件中,将数据写入硬盘的过程成为：持久化
oos.writeObject(p); //对象序列化
//可能会报错: java.io.NotSerializableException,这是由于对象所属的类没有继承Serializable接口,须要继承接口并生成serialVersionUID
System.out.println("序列化完成");
oos.close();
}
}
/*
* 运行结果：
* 反序列化完成
* Person [name=暮, age=20, gender=男, salary=5000.0, otherInfo=[是一位诗人, 也是一位程序猿]]
*/
案例8：反序列化演示
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class OISDemo {
public static void main(String[] args) throws ClassNotFoundException, IOException {
FileInputStream fis = new FileInputStream("mu.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);
System.out.println("反序列化完成");
ois.close();
}
}
/*
* 运行结果：
* Person [name=暮, age=20, gender=男, salary=5000.0, otherInfo=[是一位诗人, 也是一位程序猿]]
* 反序列化完成
*/
5）transient关键字
对象在序列化后获得的字节序列每每比较大，有时咱们在对一个对象进行序列化时能够忽略某些没必要要的属性，从而对序列化后获得的字节序列“瘦身”。
- transient：被该关键字修饰的属性在序列化时其值将被忽略。
案例9：transient演示
//修改类Person
import java.io.Serializable;
import java.util.List;
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
private char gender;
transient private double salary; //修改部分
transient private List<String> otherInfo; //修改部分
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", salary=" + salary + ", otherInfo="
+ otherInfo + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public List<String> getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(List<String> otherInfo) {
this.otherInfo = otherInfo;
}
}
序列化操做
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/*
* 对象流是一组高级流,做用是方便读写java中任何对象.
* 对象输出流,能够写出java对象
* 工做原理:将给定java对象按照其结构转化为一组字节而后写出.
*/
public class OOSDemo {
public static void main(String[] args) throws IOException {
Person p = new Person(); //引用对象并设置相关信息
p.setName("暮");
p.setAge(20);
p.setGender('男');
p.setSalary(5000);
List<String> otherInfo = new ArrayList<String>();
otherInfo.add("是一位诗人");
otherInfo.add("也是一位程序猿");
p.setOtherInfo(otherInfo);
System.out.println(p.toString());
//开始写出对象
FileOutputStream fos = new FileOutputStream("mu1.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//当调用oos.writeObject时,实际上作了两件事:将p对象按照结果转换为了一组字节(对象序列化)
//而后再将这组字节经过FOS写入到文件中,将数据写入硬盘的过程成为：持久化
oos.writeObject(p); //对象序列化
//可能会报错: java.io.NotSerializableException,这是由于对象所属的类没有继承Serializable接口,须要继承接口并生成serialVersionUID
System.out.println("序列化完成");
oos.close();
}
}
/*
* 运行结果：
* 反序列化完成
* Person [name=暮, age=20, gender=男, salary=5000.0, otherInfo=[是一位诗人, 也是一位程序猿]]
*/
反序列化，会发现加上transient关键字的部分输出变成了默认值输出。
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class OISDemo {
public static void main(String[] args) throws ClassNotFoundException, IOException {
FileInputStream fis = new FileInputStream("mu1.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);
System.out.println("反序列化完成");
ois.close();
}
}
/*
* 运行结果：
* Person [name=暮, age=20, gender=男, salary=0.0, otherInfo=null]
* 反序列化完成
*/
4.字符转换流
1）Reader和Writer
字符流原理：
- Reader是字符输入流的父类
- Writer是字符输出流的父类
- 字符流是以字符（char）为单位读写数据的，一次处理一个unicode
- 字符流的底层仍然是基本的字节流
Reader经常使用方法：
- int read()：读取一个字符，返回的int值“低16位”有效
- int read(char[] chs):从该流中读取一个字符数组的length个字符并存入该数组，返回值为实际读取到的字符量
Writer的经常使用方法：
- void write(int c):写出一个字符，写出给定int值“低16位”表示的字符
- void write(char[] chs)：将给定字符数组中全部字符写出
- void write(String str):将给定的字符串写出
- void write(char[] chs,int offset,int len):将给定的字符数组中从offset处开始连续的len个字符写出
2）字符转换流原理
- InputStreamReader：字符输入流，使用该流能够设置字符集，并按照指定的字符集从流中按照该编码将字节数据转换为字符并读取
- OutputStreamWriter：字符输出流，使用该流能够设置字符集，并按照指定的字符集将字符转换为对应字节后经过该流写出
3）指定字符编码
IntputStreamReader的构造方法容许咱们设置字符集：
- InputStreamReader(InputStream in,String charsetName)：基于给定的字节输入流以及字符编码建立ISR
- InputStreamReader(InputStream in):该构造方法会根据系统默认字符集建立ISR
OutputStreamWriter的构造方法：
- OutputStreamWriter(OutputStream out,String charsetName)：基于给定的字节输出流以及字符编码建立OSW
- OutputStreamWriter(OutputStream out)：该构造方法会根据系统默认字符集建立OSW
4）OSW
案例10：OSW演示
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Test {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("demo.txt");
OutputStreamWriter writer = new OutputStreamWriter(fos,"UTF-8");
String str = "Java,你好!";
writer.write(str);
writer.close();
}
}
5）ISR
案例11：ISR演示
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("demo.txt");
InputStreamReader reader = new InputStreamReader(fis,"utf-8");
int c = -1;
while((c=reader.read())!=-1){
System.out.print((char)c);
}
reader.close();
}
}
/*
运行结果：
Java,你好!
*/
5.缓冲字符流
1）PrintWriter
PrintWriter是具备自动行刷新的缓冲字符输出流，提供了丰富的构造方法：
PrintWriter(File file) PrintWriter(String fileName) PrintWriter(OutputStream out) PrintWriter(OutputStream out,boolean autoFlush) PrintWriter(Writer writer) PrintWriter(Writer writer,boolean autoFlush)
其中OutputStream与Writer的构造方法提供了一个可传入boolean值参数，该参数用于表示PrintWriter是否具备自动行刷新。
2）PrintWriter的重载print和println方法
使用PrintWriter写出字符串时咱们一般不使用Writer提供的writer()相关方法，而是使用print和println等方法，PrintWriter提供了若干重载的print和println方法，其中println方法是在写出数据后自动追加一个系统支持的换行符。
重载方法：
void print(int i) //打印整数 void print(char c) //打印字符 void print(boolean b) //打印boolean值 void print(char[] c) //打印字符数组 void print(double d) //打印double值 void print(float t) //打印float值 void print(long l) //打印long值 void print(String str) //打印字符串
println的方法参数与上面相同。
3）使用PW输出字符数据
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
public class PW {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
FileOutputStream fos = new FileOutputStream("pw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
//建立带有自动行刷新的PW
PrintWriter pw = new PrintWriter(osw,true);
pw.println("或许青春根本就没有明天");
pw.println("青春只有如今");
System.out.println("写出完毕");
pw.close();
}
}
4）BufferedReader
BufferedReader是缓冲字符输入流，其内部提供了缓冲区，能够提升读取效率。
经常使用构造方法：
BufferedReader(Reader reader)
建立一个BufferedRader缓冲字符输入流:
FileInputStream fis = new FileInputStream("pw.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
由于BufferedReader在构造实例时须要传入一个字符流，因此当咱们想基于一个字节流进行读取时，要先将字节流转换为字符流后猜能够建立缓冲字符输入流BufferedReader。
5）BR读取字符串
BufferedReader读取一行字符串：
String readLine()
该方法连续读取一行字符串，直到读取到换行符为止，返回的字符串中不包含该换行符，若EOF则返回null。
6）使用BR读取一行字符串
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class BR {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("pw.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String str = null;
while((str=br.readLine())!=null){
System.out.println(str);
}
br.close();
}
}
6.案例演示
案例1：FileOutputStream写操做演示
import java.io.FileOutputStream;
import java.io.IOException;
public class FOS {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt");
String str = "若是这注定是座荒芜的坟墓,那么我将硬生生的变成一座美丽的花园!";
byte[] date = str.getBytes("GBK");
fos.write(date);
System.out.println("写出完毕");
fos.close();
}
}
案例2：FileInputStream读操做演示
import java.io.FileInputStream;
import java.io.IOException;
public class FIS {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("fos.txt");
byte[] date = new byte[100];
int len = fis.read(date);
String str = new String(date,0,len,"GBK");
System.out.println(str);
fis.close();
}
}
//运行结果：若是这注定是座荒芜的坟墓,那么我将硬生生的变成一座美丽的花园!
案例3：缓冲输出流写操做演示
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BOSDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
String str = "东风吹落花满路，一片相思却似无.";
byte[] date = str.getBytes("GBK");
bos.write(date);
bos.flush();
System.out.println("写出完毕");
bos.close();
}
}
案例4：缓冲输入流读操做演示
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BOSDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("bos.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
byte[] date = new byte[100];
int len = bis.read(date);
String str = new String(date,0,len,"GBK");
System.out.println(str);
bis.close();
}
}
/*
运行结果:
东风吹落花满路，一片相思却似无.
*/
案例5：使用文件流复制文件
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("src.mp3");
FileOutputStream fos = new FileOutputStream("desc.mp3");
byte[] date = new byte[1024*10];
int len = -1;
while((len = fis.read(date))!=-1){
fos.write(date,0,len);
}
System.out.println("复制完毕");
fis.close();
fos.close();
}
}
案例6：缓冲流复制文件
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 缓冲流 缓冲流是一对高级流,做用是提升读写效率
*/
public class CopyDemo02 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("music.mp3");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("musiccopy.mp3");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d = -1;
while((d=bis.read())!=-1){
bos.write(d);
}
System.out.println("复制完毕");
bis.close();
bos.close();
}
}
案例7：OSW转换流写出演示
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OSW {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
osw.write("我从远方来,带着笔墨纸砚");
osw.write("我打江南走过,留下一纸旧约");
System.out.println("写出完毕");
osw.close();
}
}
案例8：ISR转换流读取演示
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class ISR {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("osw.txt");
InputStreamReader isr = new InputStreamReader(fis,"GBK");
int d = -1;
while((d=isr.read())!=-1){
System.out.print((char)d);
}
isr.close();
}
}
/*
运行结果：
我从远方来,带着笔墨纸砚我打江南走过,留下一纸旧约
*/
案例9：PW缓冲字符输入流直接对文件写操做
import java.io.FileNotFoundException;
import java.io.PrintWriter;
/*
* PW提供了直接针对文件写操做的构造方法：
* PrintWriter(String path)
* PrintWriter(File file)
* 按照指定字符集对文件写操做：
* PrintWriter(String path,String csn)
* PrintWriter(File file,String csn)
*/
public class PWDemo {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter pw = new PrintWriter("PW.txt");
pw.println("青春是一座坟墓");
pw.println("流年走过");
pw.println("留下不一样的墓志铭");
System.out.println("写出完毕");
pw.close();
}
}
案例10：简易记事本
要求：程序启动后要求用户输入文件名，而后针对该文件写入数据，每输入一行字符串就按行写入文件中，输入"exit"时退出程序，最后将用户写出的数据读取到控制台上。
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
System.out.println("请输入文件名:");
String fileName = scan.nextLine();
PrintWriter pw = new PrintWriter(fileName,"GBK");
System.out.println("请输入内容:");
while(true){
String line = scan.nextLine();
if(line.equals("exit")){
break;
}
pw.println(line);
}
System.out.println("写出完毕,程序退出");
pw.close();
System.out.println("=====输入内容展现=====");
FileInputStream fis = new FileInputStream(fileName);
InputStreamReader isr = new InputStreamReader(fis,"GBK");
BufferedReader br = new BufferedReader(isr);
String line = null;
while((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
/*
运行结果:
请输入文件名:
note.txt
请输入内容:
青春是一场盛宴
不繁华不罢休
exit
写出完毕,程序退出
=====输入内容展现=====
青春是一场盛宴
不繁华不罢休
*/
相关文章
- 1. java基础之IO操做
- 2. [Java IO]06_JSON操做
- 3. Java的IO操做
- 4. java的io操做
- 5. java IO流操做
- 6. Java基础梳理之-IO操做
- 7. java基础（一）IO流操做
- 8. Java IO系列之二：NIO基本操做
- 9. java学习之 io流的基本操做(1)
- 10. java学习之 io流的基本操做(2)
- 更多相关文章...
- • Git 基本操作 - Git 教程
- • Java 中操作 R - R 语言教程
- • Kotlin学习（一）基本语法
- • Kotlin学习（二）基本类型
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解决方法
- 2. Qt5.7以上调用虚拟键盘(支持中文)，以及源码修改(可拖动，水平缩放)
- 3. 软件测试面试- 购物车功能测试用例设计
- 4. ElasticSearch（概念篇）：你知道的, 为了搜索…
- 5. redux理解
- 6. gitee创建第一个项目
- 7. 支持向量机之硬间隔（一步步推导，通俗易懂）
- 8. Mysql 异步复制延迟的原因及解决方案
- 9. 如何在运行SEPM配置向导时将不可认的复杂数据库密码改为简单密码
- 10. windows系统下tftp服务器使用
欢迎关注本站公众号,获取更多信息
相关文章
- 1. java基础之IO操做
- 2. [Java IO]06_JSON操做
- 3. Java的IO操做
- 4. java的io操做
- 5. java IO流操做
- 6. Java基础梳理之-IO操做
- 7. java基础（一）IO流操做
- 8. Java IO系列之二：NIO基本操做
- 9. java学习之 io流的基本操做(1)
- 10. java学习之 io流的基本操做(2)