java输入输出

package com.srsc;

import java.io.*;

 

public class Demo1 {

 

/**

 * @param args

 */

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File file=new File("D:\\test.txt");

if(!file.exists())

{

file.createNewFile();

}

System.out.println("文本路径"+file.getAbsolutePath());

System.out.println("文件是否可写："+file.canWrite());

File dir=new File("D:\\test");

 

if(!dir.exists())

{

dir.mkdir();

}

System.out.println("是否为目录："+dir.isDirectory());

}

 

}

 

File类中定义了一些方法，允许对文件和目录进行创建，修改与删除操作的方法

 

创建文件：File.createNewFile()方法

创建成功：true。已存在：false。错误，如路径找不到：IOException异常

 

Fipackage com.srsc;

import java.io.*;

import java.io.File;

public class Demo2 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("D:\\file.txt");

try

{

boolean b=file.createNewFile();

if(b)

{

System.out.println("已建立文件："+file.getAbsolutePath());

}

else

{

System.out.println("文件已存在："+file.getAbsolutePath());

}

} catch(IOException e)

{

System.out.println("创建文件失败");

}

}

 

}

le类中获取文件本身信息包括获取文件名字，文件的长度，文件的路径，判断文件是否可读，可写，是否存在

File类只能对文件进行简单操作，并不支持文件内容的读写。要想对文件进行读写操作，就必须通过输入输出流来完成。

package com.srsc;

import java.io.*;

import java.io.File;

public class FileUpdate {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("C:\\test.txt");

try

{

if(file.createNewFile())

{

System.out.println("已创建文件："+file.getAbsolutePath());

}

}

catch(IOException e)

{

e.printStackTrace();

}

File source=new File("C:\\test.txt");

File target=new File("C:\\rename_test.txt");

try{

source.createNewFile();

}

catch(IOException e)

{

e.printStackTrace();

}

source.renameTo(target);

System.out.println(source.getName()+"已经更名为："+target.getName());

}

 

}****************************************************************

 

package com.srsc;

import java.io.*;

public class FileDelete {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("C:\\delete_test.txt");

try

{

if(file.createNewFile())

{

System.out.println("已创建文件："+file.getAbsolutePath());

}

}

catch(IOException e)

{

e.printStackTrace();

}

boolean b=file.delete();

if(b)

{

System.out.println("删除文件成功："+file.getAbsolutePath());

}

else

{

System.out.println("删除文件失败："+file.getAbsolutePath());

}

if(!file.exists())

{

System.out.println("文件不存在："+file.getAbsolutePath());

}

b=file.delete();

if(b)

{

System.out.println("删除文件成功："+file.getAbsolutePath());

}

else

{

System.out.println("删除文件失败："+file.getAbsolutePath());

}

 

}

 

}

除了File类之外，Java还提供了用来专门处理文件的类，并称为随机访问文件RandomAccessFile类。该类提供了更加完善的，对文件输入输出操作的功能。RandomAccessFile可以在任意位置进行读写操作，处理文件更加灵活。

 

RandomAccessFile(File file,String node):创建随机存取文件流，文件名由File参数指定

RandomAccessFile(String name,String node):创建随机存取文件流，文件具有指定名称

Mode参数指定用以打开文件的访问模式（-r –rw –rws –rwd）

package com.srsc;

import java.io.*;

 

public class MyRandomAccessFile {

 

/**

 * @param args

 */

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File file=new File("C:\\test.txt");

if(file.exists())

{

file.delete();

file.createNewFile();

}

RandomAccessFile rafile=new RandomAccessFile(file,"rw");

 

rafile.writeBytes("I love you");

System.out.println(rafile.getFilePointer());

 

for(int i=0;i<rafile.length();i+=2)

{

rafile.seek(i);

System.out.println((char)rafile.readByte());

}

}

 

}

 

字节输入流：

字节输入流用于以二进制形式从数据源中读取数据。InputStream类是字节输入流的基类，该类包括FileInputStream,FilterInputStream,BufferedInputStream,DataInputStram等子类

InputStream：

InputStream类中拥有很多字节输入流都需要的方法，可以通过使用InputStream类提供的方法实现从输入流读取字节或者字节数组数据的功能。

FileInputStream:

package com.srsc;

import java.io.*;

 

public class MyFileInputStream {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileInputStream in=new FileInputStream("E:\\test.txt");

int data;

while((data=in.read())!=-1)

{

System.out.println(data);

}

 

in.close();

 

}

 

}

 

FilterInputStream:

过滤流提供了在读写数据的同时可以对数据进行处理的功能，同时还提供了同步机制，使得某一时刻只能有一个线程可以访问一个数据流，以防止多个线程同时对一个数据流进行操作所带来意想不到的结果。

为了使用一个过滤流，必须先把过滤流连接在某个输入输出流上，通常通过在构造方法的参数中指定所要连接的输入输出流来实现。

输入流过滤器FilterInputStream的构造方法：

FilterInputStream(InputStream  in)：指定InputStream输入流

 

BuffferedInputStream:

BufferedInputStream类是InputStream类的间接子类，其直接子类是FilterInputStream,该类采用缓冲区机制进行字节流输入。

BufferedInputStream类的构造方法:

BufferedInputStream(InputStream in):以InputStream对象in为参数创建类

BufferedInputStream(InputStream in,in size):以InputStream对象in为参数创建类，并且通过参数size指定缓冲区大小。

以缓冲区的机制进行流的输入，输出具有更高的执行效率。而且，在字节流方式下，通过调用mark（）和reset（）方法，可以从指定位置操作，而不仅仅是只能按顺序操作。

DataInputStream:

DataInputStream(数据输入流)允许应用程序从基础输入流中读取基本Java数据类型，如byte，int，float，boolean等。

DataInputStream类的构造方法:

DataInputStream(InputStream in):使用指定的InputStream输入流创建一个DataInputStream对象.

DataInputStream类定义了许多以read开头后面跟数据类型的方法，这些方法用于读取指定数据类型的数据。

 

字节输出流：

字节输出流用于以二进制的形式将数据写入目标设备。OutputStream类是字节输出流的基类，该类包括:FileOutputStream,BufferedOutputStream,DataOutputStream,PrintStream等子类。

OutputStream:

实现向输出流写入字节写入字节或者字节数组数据的功能

FileOutputStream:

用于将字节流数据写入文件。

构造方法：

FileOutputStream(File file):通过file对象创建FileOutputStream

FileOutputStream(File file,boolean append):通过File对象创建类，append为true或false表示是否在文件末尾追加。

FileOutputStream(FileDescriptor fdobj):参数fdobj为文件描述符，通过文件描述符创建FileOutputStream

FileOutputStream(String name）：参数name为文件路径名，通过文件路径创建FileOutputStream。

FileOutputStream(String name,boolean append):参数name为文件路径名，通过文件路径创建FileOutputStream.append为true或false表示是否在文件末尾追加。

package com.srsc;

import java.io.*;

 

public class MyFileOutputStream {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileOutputStream out=new FileOutputStream("E:\\test.txt");

out.write('l');

out.write('o');

out.write('v');

out.write('e');

out.close();

}

 

}

 

字节缓冲区输出流：BufferedOutputStream

BufferedOutputStream类是OutputStream类的间接子类，其直接父类是FilterOutputStream。该类采用缓冲区机制进行字节流输出，通过设置这种输出流，应用程序就可以将各个字节写入基础输出流中，而不必为每次字节写入调用基础系统。

BufferedOutputStream(OutputStream out):以OutputStream对象out为参数创建类

BufferedOutputStream(OutputStream out,int size):以OutputStream对象out为参数创建类，并且通过size指定缓冲区大小

flush（）方法用于强制将缓冲区的内容立即写入输出流，在使用缓冲区机制的输出流时，调用write（）方法后数据并没有立即写入输出流，调用write（）方法后数据并没有立即写入输出流，而是先放在缓冲区中。所以，在必要的地方可以调用flush()方法强制刷新缓冲区。

package com.srsc;

import java.io.*;

 

public class MyBufferedOutputStream {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileOutputStream out=new FileOutputStream("E:\\test.txt");

BufferedOutputStream bos=new BufferedOutputStream(out);

String s="I Love U java";

bos.write(s.getBytes());

bos.flush();

bos.close();

}

 

}

DataOutputStream:

数据输出流，允许应用程序以适当方式将基本java数据类型写入输出流中，如byte，int，float，boolean等类型，然后，应用程序可以使用数据输入流将数据读入。

构造函数：

DataOutputStream(OutputStream out):创建一个新的数据输出流，将数据写入指定基础输出流。

*有些输出结果会产生问号，是因为DataOutputStream类是按二进制输入的这些数据类型，而记事本文件对输出格式进行了转化，按字符输出。所以有些格式显示不出，变成问号。

package com.srsc;

import java.io.*;

import java.io.File;

public class MyDataOutputStream {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileOutputStream Out=new FileOutputStream("E:\\teat.txt");

DataOutputStream d=new DataOutputStream(Out);

 

d.writeBoolean(false);

d.writeByte(1);

d.writeChar('x');

d.writeDouble(1.0);

d.writeFloat(1.5f);

d.writeInt(200);

 

d.close();

}

 

}

 

字符输入流：

字符输入流用于以字符的形式从数据源中读取数据。Reader类的字符输入流旳基类，该类包括FileReader,BufferedReader等子类。

字符文件输入流：FileReader

FileReader和FileInputStream类似，所不同的是它是针对字符进行操作，而不是字节。它的间接父类是字符流Reader。FileReader类中未自定义方法，而是继承父类级间接父类的方法。

FileReader类的构造方法：

Public FileReader(File file):在给定从中读取数据的File的情况下创建一个新类

Public FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新类。

package com.srsc;

import java.io.*;

 

public class MyfileReader {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileReader fr=new FileReader("E:\\test.txt");

 

do

{

System.out.println((char)fr.read());

}

while(fr.read()!=-1);

fr.close();

}

 

}

 

字符缓冲区输入流：BufferedeReader

BufferedReader类从字符输入流中读取文本，缓冲各个字符，从而提供字符，数组和行的高效读取。Java中，控制台输入由从System.in读取数据完成。BufferedReader支持缓冲输入流。

字符缓冲区输入流BufferedReader的构造方法：

Public BufferdeReader(Reader in):创建一个默认大小输入缓冲区的输入流

Public BufferedReader(Reader in,int size):创建一个使用size指定大小输入缓冲区输入流

package com.srsc;

import java.io.*;

public class MyBufferedReader {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File f=new File("E:\\test.txt");

FileReader fr=new FileReader(f);

BufferedReader br=new BufferedReader(fr);

char[] chars=new char[(int)f.length()];

 

do

{

br.read(chars);

System.out.print(chars);

}

while(br.read()!=-1);

br.close();

}

 

}

 

字符输出流：Writer

Writer是字符输出流所有类的父类。

 

FileWriter类：

用于将字符数据写入文件

FileWriter类的构造方法：

FileWriter(File file):通过file对象创建FileWriter

FIleWriter(File file,boolean append):通过file对象创建类，append为true或false表示是否在末尾追加

FileWriter(FileDescriptor fd):参数fd为文件描述符，通过文件描述符创建FileWriter

FileWriter(String fileName):参数fileName为文件路径名，通过文件路径创建FileWriter

FileWriter(String fileName,boolean append):参数fileName为文件路径名，通过文件路径创建FileWriter,append为true或false表示是否在文件末尾追加

package com.srsc;

import java.io.*;

 

public class MyFileWriter {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileWriter fw=new FileWriter("E:\\test.txt");

 

fw.write('I');

fw.write("Love");

fw.write("java !");

fw.close();

 

}

 

}

BufferedWriter:

将文本写入字符输出流，缓冲各个字符，从而提供单个字符，数组和字符串的高效写入。可以指定缓冲区大小，或者接受默认的大小，在大多数情况下，默认值就够了。

BufferedWriter的构造函数：

Public BufferedWriter(Writer out):创建一个使用默认大小输出缓冲区的输出流

Public BufferedWriter(Writer out,int size):创建一个指定size大小输出缓冲区的输出流

package com.srsc;

import java.io.*;

 

public class MyBufferedWriter {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileWriter fw=new FileWriter("E:\\test.txt");

BufferedWriter bw=new BufferedWriter(fw);

String s="I love java!";

 

bw.write(s,0,s.length());

 

bw.flush();

bw.close();

}

 

}

 

字符打印流PrintWriter:

PrintWriter类用于将字符数据进行格式化输出。前面介绍的其他Writer类的子类在输出是均是保持原有字符数据的格式。而PrintWriter类在输出时会进行字符格式转换，默认使用操作系统的编码进行字符转换

package com.srsc;

import java.io.*;

 

public class Demo1 {

 

/**

 * @param args

 */

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File file=new File("D:\\test.txt");

if(!file.exists())

{

file.createNewFile();

}

System.out.println("文本路径"+file.getAbsolutePath());

System.out.println("文件是否可写："+file.canWrite());

File dir=new File("D:\\test");

 

if(!dir.exists())

{

dir.mkdir();

}

System.out.println("是否为目录："+dir.isDirectory());

}

 

}

 

File类中定义了一些方法，允许对文件和目录进行创建，修改与删除操作的方法

 

创建文件：File.createNewFile()方法

创建成功：true。已存在：false。错误，如路径找不到：IOException异常

 

Fipackage com.srsc;

import java.io.*;

import java.io.File;

public class Demo2 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("D:\\file.txt");

try

{

boolean b=file.createNewFile();

if(b)

{

System.out.println("已建立文件："+file.getAbsolutePath());

}

else

{

System.out.println("文件已存在："+file.getAbsolutePath());

}

} catch(IOException e)

{

System.out.println("创建文件失败");

}

}

 

}

le类中获取文件本身信息包括获取文件名字，文件的长度，文件的路径，判断文件是否可读，可写，是否存在

File类只能对文件进行简单操作，并不支持文件内容的读写。要想对文件进行读写操作，就必须通过输入输出流来完成。

package com.srsc;

import java.io.*;

import java.io.File;

public class FileUpdate {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("C:\\test.txt");

try

{

if(file.createNewFile())

{

System.out.println("已创建文件："+file.getAbsolutePath());

}

}

catch(IOException e)

{

e.printStackTrace();

}

File source=new File("C:\\test.txt");

File target=new File("C:\\rename_test.txt");

try{

source.createNewFile();

}

catch(IOException e)

{

e.printStackTrace();

}

source.renameTo(target);

System.out.println(source.getName()+"已经更名为："+target.getName());

}

 

}****************************************************************

 

package com.srsc;

import java.io.*;

public class FileDelete {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

File file=new File("C:\\delete_test.txt");

try

{

if(file.createNewFile())

{

System.out.println("已创建文件："+file.getAbsolutePath());

}

}

catch(IOException e)

{

e.printStackTrace();

}

boolean b=file.delete();

if(b)

{

System.out.println("删除文件成功："+file.getAbsolutePath());

}

else

{

System.out.println("删除文件失败："+file.getAbsolutePath());

}

if(!file.exists())

{

System.out.println("文件不存在："+file.getAbsolutePath());

}

b=file.delete();

if(b)

{

System.out.println("删除文件成功："+file.getAbsolutePath());

}

else

{

System.out.println("删除文件失败："+file.getAbsolutePath());

}

 

}

 

}

除了File类之外，Java还提供了用来专门处理文件的类，并称为随机访问文件RandomAccessFile类。该类提供了更加完善的，对文件输入输出操作的功能。RandomAccessFile可以在任意位置进行读写操作，处理文件更加灵活。

 

RandomAccessFile(File file,String node):创建随机存取文件流，文件名由File参数指定

RandomAccessFile(String name,String node):创建随机存取文件流，文件具有指定名称

Mode参数指定用以打开文件的访问模式（-r –rw –rws –rwd）

package com.srsc;

import java.io.*;

 

public class MyRandomAccessFile {

 

/**

 * @param args

 */

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File file=new File("C:\\test.txt");

if(file.exists())

{

file.delete();

file.createNewFile();

}

RandomAccessFile rafile=new RandomAccessFile(file,"rw");

 

rafile.writeBytes("I love you");

System.out.println(rafile.getFilePointer());

 

for(int i=0;i<rafile.length();i+=2)

{

rafile.seek(i);

System.out.println((char)rafile.readByte());

}

}

 

}

 

字节输入流：

字节输入流用于以二进制形式从数据源中读取数据。InputStream类是字节输入流的基类，该类包括FileInputStream,FilterInputStream,BufferedInputStream,DataInputStram等子类

InputStream：

InputStream类中拥有很多字节输入流都需要的方法，可以通过使用InputStream类提供的方法实现从输入流读取字节或者字节数组数据的功能。

FileInputStream:

package com.srsc;

import java.io.*;

 

public class MyFileInputStream {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileInputStream in=new FileInputStream("E:\\test.txt");

int data;

while((data=in.read())!=-1)

{

System.out.println(data);

}

 

in.close();

 

}

 

}

 

FilterInputStream:

过滤流提供了在读写数据的同时可以对数据进行处理的功能，同时还提供了同步机制，使得某一时刻只能有一个线程可以访问一个数据流，以防止多个线程同时对一个数据流进行操作所带来意想不到的结果。

为了使用一个过滤流，必须先把过滤流连接在某个输入输出流上，通常通过在构造方法的参数中指定所要连接的输入输出流来实现。

输入流过滤器FilterInputStream的构造方法：

FilterInputStream(InputStream  in)：指定InputStream输入流

 

BuffferedInputStream:

BufferedInputStream类是InputStream类的间接子类，其直接子类是FilterInputStream,该类采用缓冲区机制进行字节流输入。

BufferedInputStream类的构造方法:

BufferedInputStream(InputStream in):以InputStream对象in为参数创建类

BufferedInputStream(InputStream in,in size):以InputStream对象in为参数创建类，并且通过参数size指定缓冲区大小。

以缓冲区的机制进行流的输入，输出具有更高的执行效率。而且，在字节流方式下，通过调用mark（）和reset（）方法，可以从指定位置操作，而不仅仅是只能按顺序操作。

DataInputStream:

DataInputStream(数据输入流)允许应用程序从基础输入流中读取基本Java数据类型，如byte，int，float，boolean等。

DataInputStream类的构造方法:

DataInputStream(InputStream in):使用指定的InputStream输入流创建一个DataInputStream对象.

DataInputStream类定义了许多以read开头后面跟数据类型的方法，这些方法用于读取指定数据类型的数据。

 

字节输出流：

字节输出流用于以二进制的形式将数据写入目标设备。OutputStream类是字节输出流的基类，该类包括:FileOutputStream,BufferedOutputStream,DataOutputStream,PrintStream等子类。

OutputStream:

实现向输出流写入字节写入字节或者字节数组数据的功能

FileOutputStream:

用于将字节流数据写入文件。

构造方法：

FileOutputStream(File file):通过file对象创建FileOutputStream

FileOutputStream(File file,boolean append):通过File对象创建类，append为true或false表示是否在文件末尾追加。

FileOutputStream(FileDescriptor fdobj):参数fdobj为文件描述符，通过文件描述符创建FileOutputStream

FileOutputStream(String name）：参数name为文件路径名，通过文件路径创建FileOutputStream。

FileOutputStream(String name,boolean append):参数name为文件路径名，通过文件路径创建FileOutputStream.append为true或false表示是否在文件末尾追加。

package com.srsc;

import java.io.*;

 

public class MyFileOutputStream {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileOutputStream out=new FileOutputStream("E:\\test.txt");

out.write('l');

out.write('o');

out.write('v');

out.write('e');

out.close();

}

 

}

 

字节缓冲区输出流：BufferedOutputStream

BufferedOutputStream类是OutputStream类的间接子类，其直接父类是FilterOutputStream。该类采用缓冲区机制进行字节流输出，通过设置这种输出流，应用程序就可以将各个字节写入基础输出流中，而不必为每次字节写入调用基础系统。

BufferedOutputStream(OutputStream out):以OutputStream对象out为参数创建类

BufferedOutputStream(OutputStream out,int size):以OutputStream对象out为参数创建类，并且通过size指定缓冲区大小

flush（）方法用于强制将缓冲区的内容立即写入输出流，在使用缓冲区机制的输出流时，调用write（）方法后数据并没有立即写入输出流，调用write（）方法后数据并没有立即写入输出流，而是先放在缓冲区中。所以，在必要的地方可以调用flush()方法强制刷新缓冲区。

package com.srsc;

import java.io.*;

 

public class MyBufferedOutputStream {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileOutputStream out=new FileOutputStream("E:\\test.txt");

BufferedOutputStream bos=new BufferedOutputStream(out);

String s="I Love U java";

bos.write(s.getBytes());

bos.flush();

bos.close();

}

 

}

DataOutputStream:

数据输出流，允许应用程序以适当方式将基本java数据类型写入输出流中，如byte，int，float，boolean等类型，然后，应用程序可以使用数据输入流将数据读入。

构造函数：

DataOutputStream(OutputStream out):创建一个新的数据输出流，将数据写入指定基础输出流。

*有些输出结果会产生问号，是因为DataOutputStream类是按二进制输入的这些数据类型，而记事本文件对输出格式进行了转化，按字符输出。所以有些格式显示不出，变成问号。

package com.srsc;

import java.io.*;

import java.io.File;

public class MyDataOutputStream {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileOutputStream Out=new FileOutputStream("E:\\teat.txt");

DataOutputStream d=new DataOutputStream(Out);

 

d.writeBoolean(false);

d.writeByte(1);

d.writeChar('x');

d.writeDouble(1.0);

d.writeFloat(1.5f);

d.writeInt(200);

 

d.close();

}

 

}

 

字符输入流：

字符输入流用于以字符的形式从数据源中读取数据。Reader类的字符输入流旳基类，该类包括FileReader,BufferedReader等子类。

字符文件输入流：FileReader

FileReader和FileInputStream类似，所不同的是它是针对字符进行操作，而不是字节。它的间接父类是字符流Reader。FileReader类中未自定义方法，而是继承父类级间接父类的方法。

FileReader类的构造方法：

Public FileReader(File file):在给定从中读取数据的File的情况下创建一个新类

Public FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新类。

package com.srsc;

import java.io.*;

 

public class MyfileReader {

 

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

FileReader fr=new FileReader("E:\\test.txt");

 

do

{

System.out.println((char)fr.read());

}

while(fr.read()!=-1);

fr.close();

}

 

}

 

字符缓冲区输入流：BufferedeReader

BufferedReader类从字符输入流中读取文本，缓冲各个字符，从而提供字符，数组和行的高效读取。Java中，控制台输入由从System.in读取数据完成。BufferedReader支持缓冲输入流。

字符缓冲区输入流BufferedReader的构造方法：

Public BufferdeReader(Reader in):创建一个默认大小输入缓冲区的输入流

Public BufferedReader(Reader in,int size):创建一个使用size指定大小输入缓冲区输入流

package com.srsc;

import java.io.*;

public class MyBufferedReader {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

File f=new File("E:\\test.txt");

FileReader fr=new FileReader(f);

BufferedReader br=new BufferedReader(fr);

char[] chars=new char[(int)f.length()];

 

do

{

br.read(chars);

System.out.print(chars);

}

while(br.read()!=-1);

br.close();

}

 

}

 

字符输出流：Writer

Writer是字符输出流所有类的父类。

 

FileWriter类：

用于将字符数据写入文件

FileWriter类的构造方法：

FileWriter(File file):通过file对象创建FileWriter

FIleWriter(File file,boolean append):通过file对象创建类，append为true或false表示是否在末尾追加

FileWriter(FileDescriptor fd):参数fd为文件描述符，通过文件描述符创建FileWriter

FileWriter(String fileName):参数fileName为文件路径名，通过文件路径创建FileWriter

FileWriter(String fileName,boolean append):参数fileName为文件路径名，通过文件路径创建FileWriter,append为true或false表示是否在文件末尾追加

package com.srsc;

import java.io.*;

 

public class MyFileWriter {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileWriter fw=new FileWriter("E:\\test.txt");

 

fw.write('I');

fw.write("Love");

fw.write("java !");

fw.close();

 

}

 

}

BufferedWriter:

将文本写入字符输出流，缓冲各个字符，从而提供单个字符，数组和字符串的高效写入。可以指定缓冲区大小，或者接受默认的大小，在大多数情况下，默认值就够了。

BufferedWriter的构造函数：

Public BufferedWriter(Writer out):创建一个使用默认大小输出缓冲区的输出流

Public BufferedWriter(Writer out,int size):创建一个指定size大小输出缓冲区的输出流

package com.srsc;

import java.io.*;

 

public class MyBufferedWriter {

 

public static void main(String[] args) throws IOException{

// TODO Auto-generated method stub

FileWriter fw=new FileWriter("E:\\test.txt");

BufferedWriter bw=new BufferedWriter(fw);

String s="I love java!";

 

bw.write(s,0,s.length());

 

bw.flush();

bw.close();

}

 

}

 

字符打印流PrintWriter:

PrintWriter类用于将字符数据进行格式化输出。前面介绍的其他Writer类的子类在输出是均是保持原有字符数据的格式。而PrintWriter类在输出时会进行字符格式转换，默认使用操作系统的编码进行字符转换