io 学习

最新推荐文章于 2024-01-09 12:06:09 发布

RPCH

最新推荐文章于 2024-01-09 12:06:09 发布

阅读量406

点赞数

分类专栏： java基础文章标签： io流

本文链接：https://blog.csdn.net/u012003703/article/details/24671811

版权

java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

//将数据刷到目的地中。

//fw.flush();

//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

FileWriterfw = new FileWriter("demo.txt",true);

Read()

//read():一次读一个字符。而且会自动往下读。

//定义一个字符数组。用于存储读到字符。

//该read(char[])返回的是读到字符个数。

import java.io.*;

源：键盘录入。

目的：控制台。

2，需求：想把键盘录入的数据存储到一个文件中。

源：键盘。

目的：文件。

3，需求：想要将一个文件的数据打印在控制台上。

源：文件。

目的：控制台。

流操作的基本规律：

最痛苦的就是流对象有很多，不知道该用哪一个。

通过三个明确来完成。

1，明确源和目的。

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer。

2，操作的数据是否是纯文本。

是：字符流。

不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：

源设备：内存，硬盘。键盘

目的设备：内存，硬盘，控制台。

1，将一个文本文件中数据存储到另一个文件中。复制文件。

源：因为是源，所以使用读取流。InputStream Reader

是不是操作文本文件。

是！这时就可以选择Reader

这样体系就明确了。

接下来明确要使用该体系中的哪个对象。

明确设备：硬盘。上一个文件。

Reader体系中可以操作文件的对象是 FileReader

是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

FileReader fr = newFileReader("a.txt");

BufferedReader bufr = newBufferedReader(fr);

目的：OutputStream Writer

是否是纯文本。

是！Writer。

设备：硬盘，一个文件。

Writer体系中可以操作文件的对象FileWriter。

是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = newFileWriter("b.txt");

BufferedWriter bufw = newBufferedWriter(fw);

练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。

---------------------------------------

2，需求：将键盘录入的数据保存到一个文件中。

这个需求中有源和目的都存在。

那么分别分析

源：InputStream Reader

是不是纯文本？是！Reader

设备：键盘。对应的对象是System.in.

不是选择Reader吗？System.in对应的不是字节流吗？

为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。

所以既然明确了Reader，那么就将System.in转换成Reader。

用了Reader体系中转换流,InputStreamReader

InputStreamReader isr = newInputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader

BufferedReader bufr = newBufferedReader(isr);

目的：OutputStream Writer

是否是存文本？是！Writer。

设备：硬盘。一个文件。使用 FileWriter。

FileWriter fw = newFileWriter("c.txt");

需要提高效率吗？需要。

BufferedWriter bufw = newBufferedWriter(fw);

**************

扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

目的：OutputStream Writer

是否是存文本？是！Writer。

设备：硬盘。一个文件。使用 FileWriter。

但是FileWriter是使用的默认编码表。GBK.

但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。

所以要使用的对象是OutputStreamWriter。

而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

OutputStreamWriter osw = newOutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要高效吗？需要。

BufferedWriter bufw = newBufferedWriter(osw);

所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，

需要用到转换流。

练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。

class TransStreamDemo2

{

public static voidmain(String[] args) throws IOException

{

System.setIn(newFileInputStream("PersonDemo.java"));

System.setOut(newPrintStream("zzz.txt"));

//键盘的最常见写法。

BufferedReader bufr=

newBufferedReader(new InputStreamReader(System.in));

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

String line = null;

while((line=bufr.readLine())!=null)

{

if("over".equals(line))

break;

bufw.write(line.toUpperCase());

bufw.newLine();

bufw.flush();

}

bufr.close();

}

//----------------------------------------------------------------------------字符流和字节流：

字符流和字节流：

字节流两个基类：

InputStream OutputStream

字符流两个基类：

Reader Writer

先学习一下字符流的特点。

既然IO流是用于操作数据的，

那么数据的最常见体现形式是：文件。

那么先以操作文件为主来演示。

需求:在硬盘上，创建一个文件并写入一些文字数据。

找到一个专门用于操作文件的Writer子类对象。FileWriter。后缀名是父类名。前缀名是该流对象的功能。

import java.io.*;

class FileWriterDemo

{

publicstatic void main(String[] args) throws IOException

{

//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。

//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。

//其实该步就是在明确数据要存放的目的地。

FileWriterfw = new FileWriter("demo.txt");

//调用write方法，将字符串写入到流中。

fw.write("abcde");

//刷新流对象中的缓冲中的数据。

//将数据刷到目的地中。

//fw.flush();

//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。

//将数据刷到目的地中。

//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。

fw.close();

}

//------------------------------------------------------------------------IO异常的处理方式。-------------

IO异常的处理方式。

import java.io.*;

class FileWriterDemo2

{

publicstatic void main(String[] args)

{

FileWriterfw = null;

try

{

//FileWriterfw = new FileWriter;会出现错误

fw= new FileWriter("demo.txt");

fw.write("abcdefg");

}

catch(IOException e)

{

System.out.println("catch:"+e.toString());

}

finally

{

try

{

if(fw!=null)

fw.close();

}

catch(IOException e)

{

System.out.println(e.toString());

}

//------------------------------------------------------------//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。-----------------

演示对已有文件的数据续写。

import java.io.*;

class FileWriterDemo3

{

publicstatic void main(String[] args) throws IOException

{

//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

FileWriterfw = new FileWriter("demo.txt",true);

fw.write("nihao\r\nxiexie");//\r\换行

fw.close();

}

//---------------------------------------------------------------------------

//----------------------------------------------------------------------------FileReader文件读取

import java.io.*;

class FileReaderDemo

{

publicstatic void main(String[] args) throws IOException

{

//创建一个文件读取流对象，和指定名称的文件相关联。

//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException

FileReaderfr = new FileReader("demo.txt");

//调用读取流对象的read方法。

//read():一次读一个字符。而且会自动往下读。

intch = 0;

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

{

System.out.println(

}

while(true)

{

intch = fr.read();

if(ch==-1)

break;

System.out.println("ch="+(char)ch);

}

fr.close();

//读原理

}

//----------------------------------------------------------------------------read(char [])----------

class FileReaderDemo2

{

publicstatic void main(String[] args) throws IOException

{

FileReaderfr = new FileReader("demo.txt");

//定义一个字符数组。用于存储读到字符。

//该read(char[])返回的是读到字符个数。

char[]buf = new char[1024];

/*char[]buf = new char[3];

intnum=fr.read(buf);

System.out.prinltn("num"+num+"..."mewString(buf));

intnum1=fr.read(buf);

System.out.prinltn("num1"+num1+"..."mewString(buf));

intnum2=fr.read(buf);

System.out.prinltn("num2"+num2+"..."mewString(buf,0,num2));

intnum = 0;

while((num=fr.read(buf))!=-1)

{

System.out.println(newString(buf,0,num));

}

fr.close();

}

//总结:read(char[]) ,每一次重新读取char[]

Intread(char[]) 返回,char[] 数组个数.最后返回-1,以判断

String (char[],0,num);打印每一个char[]字符,从char[0]位开始到char[num]结束

while(int i=read(char[])){}

//----------------------------------------------------------------------------

//将C盘一个文本文件复制到D盘。

复制的原理：

其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：

1，在D盘创建一个文件。用于存储C盘文件中的数据。

2，定义读取流和C盘文件关联。

3，通过不断的读写完成数据存储。

4，关闭资源。

import java.io.*;

class CopyText

{

publicstatic void main(String[] args) throws IOException

{

copy_2();

}

publicstatic void copy_2()

{

FileWriterfw = null;

FileReaderfr = null;

try

{

fw= new FileWriter("SystemDemo_copy.txt");

fr= new FileReader("SystemDemo.java");

char[]buf = new char[1024];

intlen = 0;

while((len=fr.read(buf))!=-1)

{

fw.write(buf,0,len);

}

catch(IOException e)

{

thrownew RuntimeException("读写失败");

}

finally

{

if(fr!=null)

try

{

fr.close();

}

catch(IOException e)

{

}

if(fw!=null)

try

{

fw.close();

}

catch(IOException e)

{

}

//从C盘读一个字符，就往D盘写一个字符。

publicstatic void copy_1()throws IOException

{

//创建目的地。

FileWriterfw = new FileWriter("RuntimeDemo_copy.txt");

//与已有文件关联。

FileReaderfr = new FileReader("RuntimeDemo.java");

intch = 0;

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

{

fw.write(ch);

}

fw.close();

fr.close();

}

//---------------------------------

缓冲区的出现是为了提高流的操作效率而出现的。

所以在创建缓冲区之前，必须要先有流对象。

该缓冲区中提供了一个跨平台的换行符。

newLine();

import java.io.*;

class BufferedWriterDemo{

publicstatic void main(String[] args) throws IOException{

//创建一个字符写入流对象。

FileWriterfw = new FileWriter("buf.txt");

//为了提高字符写入流效率。加入了缓冲技术。

//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

BufferedWriterbufw = new BufferedWriter(fw);

for(intx=1; x<5; x++){

bufw.write("abcd"+x);

bufw.newLine();

bufw.flush();

}

//记住，只要用到缓冲区，就要记得刷新。

//bufw.flush();

//其实关闭缓冲区，就是在关闭缓冲区中的流对象。

bufw.close();

}

//---------------------------------------------

缓冲区的出现是为了提高流的操作效率而出现的。

所以在创建缓冲区之前，必须要先有流对象。

该缓冲区中提供了一个跨平台的换行符。

//记住，只要用到缓冲区，就要记得刷新。

newLine();

import java.io.*;

class BufferedWriterDemo{

publicstatic void main(String[] args) throws IOException{

//创建一个字符写入流对象。

FileWriterfw = new FileWriter("buf.txt");

//为了提高字符写入流效率。加入了缓冲技术。

//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

BufferedWriterbufw = new BufferedWriter(fw);

for(intx=1; x<5; x++){

bufw.write("abcd"+x);

bufw.newLine();

bufw.flush();

}

//记住，只要用到缓冲区，就要记得刷新。

//bufw.flush();

//其实关闭缓冲区，就是在关闭缓冲区中的流对象。

bufw.close();

}

//----------------------------------------------------------------------------

/*字符读取流缓冲区：

该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。

当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

import java.io.*;

class BufferedReaderDemo{

publicstatic void main(String[] args) throws IOException{

//创建一个读取流对象和文件相关联。

FileReaderfr = new FileReader("buf.txt");

//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。

BufferedReaderbufr = new BufferedReader(fr);

Stringline = null;

while((line=bufr.readLine())!=null)

{

System.out.print(line);

}

bufr.close();

}

//-----------------------------------------------------------------------------

通过缓冲区复制一个.java文件。

import java.io.*;

class CopyTextByBuf{

publicstatic void main(String[] args) {

BufferedReaderbufr = null;

BufferedWriterbufw = null;

try{

bufr= new BufferedReader(new FileReader("BufferedWriterDemo.java"));

bufw= new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

Stringline = null;

while((line=bufr.readLine())!=null){

bufw.write(line);

bufw.newLine();

bufw.flush();

}

}catch(IOException e){

thrownew RuntimeException("读写失败");

}finally{

try{if(bufr!=null)

bufr.close();

} catch (IOException e){

thrownew RuntimeException("读取关闭失败"); }

try{ if(bufw!=null)

bufw.close();

}

catch(IOException e){

thrownew RuntimeException("写入关闭失败");

}

//----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

明白了BufferedReader类中特有方法readLine的原理后，

可以自定义一个类中包含一个功能和readLine一致的方法。

来模拟一下BufferedReader

import java.io.*;

class MyBufferedReader extends Reader

{

privateReader r;

MyBufferedReader(Readerr)

{

this.r= r;

}

//可以一次读一行数据的方法。

publicString myReadLine()throws IOException

{

//定义一个临时容器。原BufferReader封装的是字符数组。

//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。

StringBuildersb = new StringBuilder();

intch = 0;

while((ch=r.read())!=-1)

{

if(ch=='\r')

continue;

if(ch=='\n')

returnsb.toString();

else

sb.append((char)ch);

}

if(sb.length()!=0)

returnsb.toString();

returnnull;

}

覆盖Reader类中的抽象方法。

publicint read(char[] cbuf, int off, int len) throws IOException

{

returnr.read(cbuf,off,len) ;

}

publicvoid close()throws IOException

{

r.close();

}

publicvoid myClose()throws IOException

{

r.close();

}

//-----------------------------------------------------------------------------装饰模式--------------------------------------

MyReader//专门用于读取数据的类。

|--MyTextReader

|--MyBufferTextReader

|--MyMediaReader

|--MyBufferMediaReader

|--MyDataReader

|--MyBufferDataReader

class MyBufferReader

{

MyBufferReader(MyTextReadertext)

{}

MyBufferReader(MyMediaReadermedia)

{}

}

上面这个类扩展性很差。

找到其参数的共同类型。通过多态的形式。可以提高扩展性。

class MyBufferReader extends MyReader

{

privateMyReader r;

MyBufferReader(MyReaderr)

{}

}

MyReader//专门用于读取数据的类。

|--MyTextReader

|--MyMediaReader

|--MyDataReader

|--MyBufferReader

以前是通过继承将每一个子类都具备缓冲功能。

那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。

将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。

这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。

而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

所以装饰类和被装饰类通常是都属于一个体系中的。

总结: 装饰类是增强对象,比继承灵活.

复制一个图片

思路：

1，用字节读取流对象和图片关联。

2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。

3，通过循环读写，完成数据的存储。

4，关闭资源。

//---------------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;

class CopyPic

{

publicstatic void main(String[] args)

{

FileOutputStreamfos = null;

FileInputStreamfis = null;

try

{

fos= new FileOutputStream("c:\\2.bmp");

fis= new FileInputStream("c:\\1.bmp");

byte[]buf = new byte[1024];

intlen = 0;

while((len=fis.read(buf))!=-1)

{

fos.write(buf,0,len);

}

catch(IOException e)

{

thrownew RuntimeException("复制文件失败");

}

finally

{

try

{

if(fis!=null)

fis.close();

}

catch(IOException e)

{

thrownew RuntimeException("读取关闭失败");

}

try

{

if(fos!=null)

fos.close();

}

catch(IOException e)

{

thrownew RuntimeException("写入关闭失败");

}

//------------------------------------------------------

import java.io.*;

class MyBufferedInputStream

{

privateInputStream in;

privatebyte[] buf = new byte[1024*4];

privateint pos = 0,count = 0;

MyBufferedInputStream(InputStreamin)

{

this.in= in;

}

//一次读一个字节，从缓冲区(字节数组)获取。

publicint myRead()throws IOException

{

//通过in对象读取硬盘上数据，并存储buf中。

if(count==0)

{

count= in.read(buf);

if(count<0)

return-1;

pos= 0;

byteb = buf[pos];

count--;

pos++;

returnb&255;

}

elseif(count>0)

{

byteb = buf[pos];

count--;

pos++;

returnb&0xff;

}

return-1;

}

publicvoid myClose()throws IOException

{

in.close();

}

11111111-111111110000000000101001001010100101010010101001010

byte: -1 ---> int : -1;

00000000 00000000 00000000 11111111 255

11111111 11111111 11111111 11111111

11111111 -->提升了一个int类型那不还是-1吗？是-1的原因是因为在8个1前面补的是1导致的。

那么我只要在前面补0，即可以保留原字节数据不变，又可以避免-1的出现。

怎么补0呢？

11111111 11111111 11111111 11111111

&00000000 00000000 00000000 11111111

------------------------------------

00000000 00000000 00000000 11111111

0000-0001

1111-1110

000000001

1111-1111 -1

结论：

字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。

因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.

那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。

所以，为了避免这种情况将读到的字节进行int类型的提升。

并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。

而在写入数据时，只写该int类型数据的最低8位。

*//

///---------------------------------------

字符读取流缓冲区：

该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。

当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

//-------------------------------------------------------

import java.io.*;

import java.util.*;

import java.text.*;

class ExceptionInfo

{

publicstatic void main(String[] args)throws IOException

{

try

{

int[]arr = new int[2];

System.out.println(arr[3]);

}

catch(Exception e)

{

try

{

Dated = new Date();

SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Strings = sdf.format(d);

PrintStreamps = new PrintStream("exeception.log");

ps.println(s);

System.setOut(ps);

}

catch(IOException ex)

{

thrownew RuntimeException("日志文件创建失败");

}

e.printStackTrace(System.out);

}

//log4j

RPCH

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
io 学习

//将数据刷到目的地中。 //fw.flush(); //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。 FileWriterfw = new FileWriter("demo.txt",true); Rea
复制链接

扫一扫

专栏目录