Java IO流操作
Java IO流操作
1：字节流是对二进制文件操作的（图片，音乐，影视文件的操作）
InputStream是一个抽象类，一般都使用它的两个实现的子类（FileInputStream 对二进制文件操作）（ObjectInputStream 对对象进行序列化反序列化操作）。如何想看这些类，JavaAPI自己去查看。
1：FileInpuitStream类 （操作文本文件乱码也已解决）
package com.fileinputstream;
import java.io.*;
import java.util.Scanner;
public class Demm {
public static void main(String[] args) throws IOException {
Scanner input=new Scanner(System.in);
File file=new File("F:/helloworld/jiahang.txt");
System.out.println("请输入要写的内容：");
String str=input.nextLine();
FileOutputStream fos=new FileOutputStream(file);
fos.write(str.getBytes());
System.out.println("写入完毕！");
fos.close();
FileInputStream fis=new FileInputStream(file);
int temp=0;// 解决方案：byte bytes[]=new byte[1024]; 充当缓存区
byte bytes[]=new byte[1024];
/*while((temp=fis.read())!=-1){//一个字节一个字节的读取文件 解决方案：(temp=fis.read(bytes))!=-1
System.out.print((char) temp); //将字节转成char输出 解决方案：new String(bytes,0,temp) 输出结果 从 0-temp
}*/
while((temp=fis.read(bytes))!=-1){
System.out.print(new String(bytes,0,temp) );
}
fis.close();
}
}
2ObjectInputStream(FileInputStream对象)，创建ObjectInputStream对象时，造方法中传入一个FileInputStream对象。创建FileInputStream对象时，构造方法传入一个File对象，就是一个文本地址路径。
package test816;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.*;
/**
* 为了方便测试，现将代码都写到一个类中了。以下是需要注意的两点：
* 1、对象中的transient和static类型成员变量不会被读取和写入
* 2、实现Serializable接口
* @author mengfeiyang
*
*/
public class hell {
public static void main(String[] args) {
// TODO Auto-generated method stub
String path = "F:/helloworld/d.txt";
ObjectInputStream ois = null;
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
Person p1 = new Person("张三", 12, true);
Person p2 = new Person("李四", 33, false);
oos.writeObject(p1);
oos.writeObject(p2);
oos.writeObject(null);
//如果不写入一个null对象 ，则读取的时候会报异常EOFException ,则需要try catch 捕获异常 （已经注释）
oos.flush();
System.out.println("写入完毕");
ois = new ObjectInputStream(new FileInputStream(path));
Object object = ois.readObject();
while( object !=null){
System.out.println(object.toString());
object = ois.readObject();
}
}
// catch(EOFException e){
// System.out.println("end");
// }
catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(oos!= null){
try {
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(ois!= null){
try {
ois.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
class Person implements Serializable{
private String name ;
private int age;
private boolean sex;
private void Perosn() {
// TODO Auto-generated method stub
}
public Person(String name, int age, boolean sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
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 boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", sex=" + (sex?"男":"女") + "]";
}
}
2：IO字符流的操作（对文本文件的操作，对字符串进行编码转换，字节流一个一个读取文本文件太慢啦！！！字符流操作出现，拯救一切！！！嘿嘿嘿）
1：InputStreamReader(InputStream is,charset c).创建InputStreamReader对象时，构造方法传入一个字节流对象，还可以进行编码转化。（只是InputStreamReader和B|ufferedInputStreamReader）的读取操作。
package com.reader;
import java.io.*;
/**
* @Title：${贾天一}
* @Description: [娱乐]
*/
//不管多大的文本，都可以读取。本人已经调试过啦！！！
public class demo {
public static void main(String[] args) {
demo a = new demo();
try {
a.transReadNoBuf();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("--------");
try {
a.transReadByBuf();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void transReadNoBuf() throws IOException {
/**
* 没有缓冲区，只能使用read()方法。
*/
//读取字节流
InputStream in = new FileInputStream("F:\\helloworld\\reader.txt");//读取文件的数据。
//将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.
//charsetname可以改写字符的编码问题
InputStreamReader isr = new InputStreamReader(in,"utf-8" );//读取
// 跟上面创建一样的效果
//InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"),"gbk");
char []cha = new char[1024];
int len = isr.read(cha);
System.out.println(new String(cha,0,len));
isr.close();
}
public static void transReadByBuf() throws IOException {
/**
* 使用缓冲区 可以使用缓冲区对象的 read() 和 readLine()方法。
*/
//读取字节流
InputStream in = new FileInputStream("F:\\helloworld\\reader.txt");//读取文件上的数据。
//将字节流向字符流的转换。
InputStreamReader isr = new InputStreamReader(in,"utf-8");//读取
//创建字符流缓冲区，BufferedReader 自带缓存区域，不用你自己再去定义（一个像上面那种）【1024】的字节数组进行缓存啦！！！
BufferedReader bufr = new BufferedReader(isr);//缓冲
//跟上面一样的创建效果
//BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\demo.txt")));
//带有缓存区域的可以分开读取文本文件，比如下面三行读取文本文件的一个字，再进行按行读取。
int ch =0;
ch = bufr.read();
System.out.println((char)ch);
String line = null;
while((line = bufr.readLine())!=null){
System.out.println(line);
}
isr.close();
}
}
这里是写入操作
package com.reader;
import java.io.*;
/**
* @Title：${贾天一}
* @Description: [娱乐]
*/
public class demo1 {
public static void main(String[] args) {
demo1 a = new demo1();
try {
a.transWriteNoBuf();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("用OnputStreamWriter输入到F:\\helloworld\\reader1.txt成功");
System.out.println("------------");
try {
a.transWriteByBuf();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("用BufferWriter输入到F:\\helloworld\\reader.txt成功");
}
public static void transWriteNoBuf() throws IOException {
//OutputStream out = System.out;//打印到控制台
OutputStream out = new FileOutputStream("F:\\helloworld\\reader1.txt");//打印到文件
OutputStreamWriter osr = new OutputStreamWriter(out);//输出
//OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//两句可以综合到一句。
// int ch = 97;//a
// int ch = 20320;//你
// osr.write(ch);
String str = "你好吗？";//你好吗？
osr.write(str);
osr.flush();
osr.close();
}
public static void transWriteByBuf() throws IOException {
//OutputStream out = System.out;//打印到控制台。
OutputStream out = new FileOutputStream("F:\\helloworld\\reader.txt");//打印到文件。
OutputStreamWriter osr = new OutputStreamWriter(out);//输出
//OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//综合到一句。
BufferedWriter bufw = new BufferedWriter(osr);//缓冲
// int ch = 97;//a
// int ch = 20320;//你
// osr.write(ch);
String str = "你好吗？\r\n我很好！";//你好吗？
bufw.write(str);
bufw.flush();
bufw.close();
}
}
3：FileReader是InputStreamReader的子类，简化InputStreamReader类的复杂操作。创建InputStreamReader对象时需要传入一个InputStream对象。FileReader不用，直接传入一个文本地址路径就可以啦！，但是FileReade类没有编码转化操作。
package com.filereader;
/*
* 文件读取的这种方式：通过字符数组进行读取。比一个一个字符读取快，但是也可以一个一个字符的读取。
* 步骤和一个字符一个字符读取的基本相似，但其中就是多创建一个字符数组
* 犹如不能进行编码转化，中文会出现乱码行为。
*/
import java.io.*;
public class demo1 {
public static void main(String[] args)
{
FileReader fr=null;
try
{
fr=new FileReader("F:\\helloworld\\filereader.txt");
char[] buf=new char[1024];
//read(char [])返回读到的字符个数
int num=0;
while((num=fr.read(buf))!=-1) //读取文件并把它存入buf中，用num返回读到字符的个数，一直读到结尾
{
System.out.print((new String(buf,0,num)));//字符数组里仍有空白没有读入的位置，所以不要了
//new String(字符串，开始位置，结尾位置)
}
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(fr!=null)
{
fr.close();
}
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
FileWriter输入操作
package com.filereader;
import java.io.*;
public class hell {
public static void main(String[] args) throws IOException {
File file = new File("F:\\helloworld\\test.txt");
FileWriter fw = new FileWriter(file);
fw.write(97); //会转化为字符，97是ASCALL值，输入小写字符a
fw.write("this is 我们"); //把字符串输入指定文本中
fw.close();
System.out.println("字符串输入到F:\\helloworld\\test.txt成功！！！");
}
}