Java I/O

package FileStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

//使用FileInputStream类来读取数据源中的数据

public class FileInputStreamTest {

public static void main(String[] args) {

FileInputStream fin=null;

try {

//step1：创建一个连接到指定文件的FileInputStream对象

fin=new FileInputStream("D:\\IOTest\\source.txt");

System.out.println("可读取的字节数："+fin.available()+"字节");

//step2:读数据：一次读取一个字节的数据，返回的是读到的字节

int i=fin.read();

while (i!=-1) {  //若遇到流的末尾，会返回-1

System.out.print((char)i);

i=fin.read(); //再读

}

} catch (FileNotFoundException e) {

e.printStackTrace();

}catch (IOException e) {  //捕获I/O异常

e.printStackTrace();

}finally{

try {//关闭输入流

if (null!=fin) {

fin.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

/*使用FileOutputStream类往指定文件中写入数据*/

public class FileOutputStreamTest {

public static void main(String[] args) {

FileOutputStream out=null;

try {

//Step1：创建一个向指定名的文件中写入数据的FileOutputStream

//第二个参数设置为true表示：使用追加模式添加字节

out=new FileOutputStream("D:\\IOTest\\shenxiaolin.txt",true);

//Step2:写数据

out.write(‘#‘);

out.write("105032013120_沈晓麟".getBytes());

out.write("Hello World 你好".getBytes());

//Step3:刷新输出流

out.flush();

} catch (FileNotFoundException e) {

e.printStackTrace();

}catch (IOException e) { //捕获IO异常

e.printStackTrace();

}finally{

if (out!=null) {

try {

out.close(); //Step:4：关闭输出流

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

}

package FileStream;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReaderAndFileWriterTest {

//用 FileReaderAndFileWriter实现复制字符文本文件复制的功能

/**  * @param arg */

public static void main(String[] args) {

FileReader fr=null;

FileWriter fw=null;

int c=0;

try {

//创建I/O流对象

fr=new FileReader("D:\\IOTest\\shenxiaolin.txt");

fw=new FileWriter("D:\\IOTest\\shenxiaolin2.txt");

while ((c=fr.read())!=-1) {//从源文件中读取字符

fw.write(c);

}

fw.flush();//刷新输出流

} catch (FileNotFoundException e) {

  e.printStackTrace();

}catch (IOException e) {

e.printStackTrace();

}finally{

//关闭所有的I/O流对象

try {

if (null!=fw) {

fw.close();

}

} catch (IOException e) {

e.printStackTrace();

}

try {

if (null!=fr) {

fr.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedInputStreamAndBufferedOutputStreamTest {

public static void main(String[] args) {

BufferedInputStream bfiStream=null;

BufferedOutputStream bfoStream=null;

try {

bfiStream=new BufferedInputStream(new FileInputStream("D:\\IOTest\\source.txt"));

bfoStream=new BufferedOutputStream(new FileOutputStream("D:\\IOTest\\shenxiaolinbuffOutStream.txt"));

int i;

while ((i=bfiStream.read())!=-1) {

bfoStream.write((char)i);

}

bfoStream.flush();

} catch (IOException e) {

e.printStackTrace();

}finally{

try {

if (bfoStream!=null) {

bfoStream.close();

}

} catch (IOException e) {

e.printStackTrace();

}

try {

if(null!=bfiStream){

bfiStream.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

//用BufferedReader和BufferedWriter实现字符文本文件复制的功能：

public class BufferedReaderAndBufferedWriterTest {

public static void main(String[] args) {

BufferedReader br=null;

BufferedWriter bw=null;

try {

  //创建缓冲流对象：它是过滤流，是对节点流的包装

br=new BufferedReader(new FileReader("D:\\IOTest\\source.txt"));

bw=new BufferedWriter(new FileWriter("D:\\IOTest\\shenxiaolinBF.txt"));

String str=null;

while ((str=br.readLine())!=null) {

//一次性读取字符文本文件的一行字符

bw.write(str);//一次写入一行字符串

bw.newLine();//写入行分隔符

}

bw.flush();//刷新缓冲区

} catch (IOException e) {

e.printStackTrace();

}finally{

//关闭I/O流对象

try {

if (null!=bw) {

bw.close();//关闭过滤流时，会自动关闭它所包装的底层节点流

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class InputStreamReaderByteToCharTest {

public static void main(String[] args) {

System.out.println("请输入信息（退出请输入e或者exit）：");

//把“标准”输入流（键盘输入）这个字节流包装成字符流，再包装成缓冲流

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String s=null;

try {

while ((s=br.readLine())!=null) {

//读取用户输入的一行数据-->阻塞程序

if (s.equalsIgnoreCase("e")||s.equalsIgnoreCase("exit")) {

System.out.println("安全退出！");

break;

}

//将读取到的整行字符串转成大写输出

System.out.println("-->:"+s.toUpperCase());

System.out.println("继续输入信息");

}

} catch (IOException e) {

e.printStackTrace();

}finally{

try {

if (null!=br) {

br.close();//关闭过滤流时，会自动关闭它包装的底层节点流

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

public class OutputStreamWriterCharToByteTest {

public static void main(String[] args) {

System.out.println("请输入信息：");

BufferedReader bufr1=new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw1=new BufferedWriter(new OutputStreamWriter(System.out));

String line1=null;

try {

while ((line1=bufr1.readLine())!=null) {

if ("over".equals(line1))   break;

bufw1.write(line1.toUpperCase());

bufw1.newLine();

bufw1.flush();

}

} catch (IOException e) {

e.printStackTrace();

}finally{

try {

if (null!=bufw1) {

bufw1.close();

}

} catch (Exception e2) {

e2.printStackTrace();

}

   try {

    if (null!=bufr1) {

   bufr1.close();

   }

   } catch (Exception e2) {

  e2.printStackTrace();

    }

    }

    }

}

package FileStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.IOException;

//数据流在内存中的使用示例

import java.io.DataOutputStream;

public class DataInputStreamAndDataOutputStreamTest {

public static void main(String[] args) {

ByteArrayOutputStream baos=new ByteArrayOutputStream();

DataOutputStream dos=new DataOutputStream(baos);

try {

dos.writeDouble(Math.random());

dos.writeBoolean(true);

dos.writeChars("shenxiaolin|Java|\t");

dos.writeUTF("沈晓麟");

ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());

System.out.println("可读取的字节数是："+bais.available());

DataInputStream dis=new DataInputStream(bais);

System.out.println(dis.readDouble());

System.out.println(dis.readBoolean());

char[] temp=new char[200];

//开辟空间200

int len=0;

char c=0;

while ((c=dis.readChar())!=‘\t‘) {

//读取字符

temp[len] = c;

len++;

}

String name=new String(temp,0,len);

System.out.println(name);

System.out.println(dis.readUTF());

dos.close();

dis.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

package FileStream;

import java.io.DataOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class DataOutputStreamTest {

public static void main(String[] args) {

DataOutputStream dos=null;

try {

//创建连接到指定文件的数据输出流对象

dos=new DataOutputStream(new  FileOutputStream("D:\\IOTest\\testData.dat"));

dos.writeUTF("china中国"); //写入UTF字符串

dos.writeBoolean(false); //写入布尔值

dos.writeLong(123456789L);//写入长整数

System.out.println("写文件成功！");

} catch (IOException e) {

e.printStackTrace();

}finally{

try {

if (null!=dos) {

dos.close(); //关闭过滤流时，会自动关闭它包装的底层节点流

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.PrintStream;

//把标准的输出改成指定的文件输出

public class PrintStreamTest {

public static void main(String[] args) {

FileOutputStream fos=null;

try {

fos=new FileOutputStream(new File("D:\\IOTest\\text.txt"));

} catch (FileNotFoundException e) {

e.printStackTrace();

}

//创建打印输出流，设置为自动刷新模式（写入换行符或字节‘\n‘时都会刷新输出缓冲区）

PrintStream ps=new PrintStream(fos,true);

if (ps!=null) {

//把标准输出流（控制台输出）改成文件

System.out.println(ps);

}

for (int i = 0; i <= 255; i++) { //输出ASCII字符

System.out.print((char)i);

if (i%50==0) {

System.out.println(); //换行

}

}

ps.close();

}

}

  package FileStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.PrintStream;

import java.io.PrintWriter;

public class PrintWriterTest {

public static void main(String[] args) {

String str="Hello ! PrintWriter!";

try {

PrintWriter pw=new PrintWriter(new FileOutputStream("D:\\IOTest\\textPrintWriter.txt"));

pw.println(str);

pw.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}                                                     

package FileStream;

//可序列化的Student类

public class Student  implements java.io.Serializable{

private int id;

private String name;

private transient int age; //不需要序列化的属性

public int getId() {  return id;  }

public String getName() { return name; }

public int getAge() { return age; }

public Student(int id, String name, int age) {

super();

this.id = id;

this.name = name;

this.age = age;

}

public String toString() {

return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";

}

}

package FileStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

//创建一个学生对象，并把它序列化到一个文件(objectSeri.dat)中：

public class SerializationTest {

public static void main(String[] args) {

ObjectOutputStream oos=null;

try {

//创建连接到指定文件的对象输出流实例

oos=new ObjectOutputStream(new FileOutputStream("D:\\IOTest\\objectSeri.dat"));

oos.writeObject(new Student(120, "沈晓麟", 20));

//把stu对象序列化到文件中

oos.flush();//刷新输出流

System.out.println("序列化成功！！！");

} catch (IOException e) {

e.printStackTrace();

} finally{

     try {

if(null!=oos){

oos.close();

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

package FileStream;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

//把指定文件中的数据反序列化回来，打印输出它的信息。

public class DeserializationTest {

public static void main(String[] args) {

ObjectInputStream ois=null;

try {

//创建连接到指定文件的对象输入流实例

ois=new ObjectInputStream(new FileInputStream("D:\\IOTest\\objectSeri.dat"));

Student stu=(Student)ois.readObject();//读取对象

System.out.println(stu);

} catch (ClassNotFoundException e) {

e.printStackTrace();

}catch (IOException e) {

e.printStackTrace();

}finally{

   try {

if (null!=ois) {

ois.close();//关闭

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}