Java4Android(第32~34集) Java当中的I/O

第32集  Java当中的IO(一)

本集主要内容.
1.  I/O操作的目标.

  从数据源当中读取数据,以及将数据写入到数据目的地当中.

        


 这个源和目的不局限于文件。  流可以理解为一个管道，池子里的水一点点的流入目的，而不是一下子就到另一个地方的。
2.  I/O的分类方法.

 输入流，输出流；   字节流，字符流；  节点流，处理流。

3.  读取文件和写入文件的方法.

  在java的世界里面,所有的东西都是对象.   输入,输出流也都是对象.

  要生成对象，就先要有类。 下面来看看I/O当中的核心类：

                            


InputStream和OutputStream 是所以字节流的父类。

FileInputStream: 从文件当中读数据。    FileOutputStream：把数据写到文件当中。

 核心类的核心方法

         InputStream

            int  read(byte[ ] b, int off , int len);

         OutputStream  

            void write(byte[ ] b ,int off ,in len);   

 程序示例：

//第一步骤:导入类;
import java.io.*;
class Test{
public static void main(String args[]){
//声明输入流引用
FileInputStream fis = null;
//声明输出流引用
FileOutputStream fos = null;
try{
//生成代表输入流的对象.
fis = new FileInputStream("g:/srclxm/from.txt");
//生成代表输出流的对象
fos = new FileOutputStream("g:/srclxm/to.txt");
//生成一个字节数组
byte [] buffer  = new byte[100];
//调用输入流对象的read方法,读取数据
//fis.read(buffer,0,buffer.length);
int temp =fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
//for(int i = 0; i < buffer.length; i++){
//	System.out.println(buffer[i]);
String s = new String(buffer);
//调用一个String对象的 trim方法,将会去除掉这个字符串的首尾空格和空字符.
s = s.trim();
System.out.println(s);
//}
}
catch(Exception e){
System.out.println(e);
}
}
}

总结:
          1. I/O系统的主要目标是为了对数据进行读写操作.
          2.数据的流向以java程序为参照物
          3.I/O流可以有三种分类方法.
          4.read方法和writer方法. 
第33集  Java当中的IO(二)

本集主要内容

   1.大文件的读写方法

   2.字符流的使用方法

程序1：

import java.io.*;
class Test{
public static void main(String argsp[]){
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("E:/marschen/fileop/form.txt");
fos = new FileOutputStream("E:/marschen/fileop/to.txt");
byte [] buffer = new byte[1024];
while(true){
int temp = fis.read(buffer,0,buffer.length);
if(-1 == temp){   //读到文件末尾就返回-1
break;   //跳出当前循环
}
fos.write(buffer,0,temp);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fis.close();  //用完之后要关闭I/O流
fos.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}

总结,大文件读写,创建一个数组,用一个循环,每次从文件中读取一部分放入数组

        这个循环当读写到文件尾部的时候,停止.

     最后,要记得调用        file.close();

程序2：字符流

字符流:读写文件时,以字符为基础  

字符输入流:Reader  <----FileReader             int read(char [ ] c,int off,int len);  

字符输出流:Writer  <----FileWriter                   int write(char [ ] c,int off,int len);  

import java.io.*;

public class TestChar{
public static void main(String args[]){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("E:/marschen/fileop/form.txt");
fw = new FileWriter("E:/marschen/fileop/to.txt");
char [] buffer = new char[100];
int temp = fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
/*for(int i = 0; i < buffer.length; i++)
{
System.out.println(buffer[i]);
}*/
}
catch(Exception e){
System.out.println(e);

}
finally{
try{
fr.close();
fw.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}

第34集  Java当中的IO(三)

 主要内容

  1.处理流使用实例.

  2. 装饰者模式(Decorator)

  3. 节点流与处理流之间的关系
 BufferdReader介绍
   
public String raadLine()
   
        throwsIOException
  Reads
a line of text. A line is condsidered to be berminated by any on e of a line 
处理流使用示例：

import java.io.*;

class Test{
public static void main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader = null;
try{
fileReader = new FileReader("E:/marschen/fileop/form.txt");
bufferedReader = new BufferedReader(fileReader);  //它的参数是fileReader
//String line = bufferedReader.readLine();
//System.out.println(line);
String line = null;
while(true){
line = bufferedReader.readLine();
if(line == null){
break;
}
System.out.println(line);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
bufferedReader.close();
fileReader.close();
}
catch(Exception e ){
System.out.println(e);
}
}
}
}

下面一个例子是建立一个工人体系：

                              


如果每个部分用一个类来表示，那将非常复杂，下面就是介绍一种简单的模式。
装饰者模式(Decorator) 

下面通过5个类来说明 Worker类, Carpenter类,Plumber类, AWorker类,TestWorker类。

//*******************************Worker接口***************************************//
interface Worker{
public void doSomeWork();
}
//*******************************Carpenter类***************************************//
//木匠
class Carpenter implements Worker{
public void doSomeWork(){
System.out.println("修门窗");
}
}

//*******************************Plumber类,***************************************//
//水管工
class Plumber implements Worker{ //实现Worker
public void doSomeWork(){
System.out.println("修水管");
}
}

//*******************************AWorker类,***************************************//
//水管工
class AWorker implements Worker{ //实现Worker
private Worker worker;
public AWorker(Worker worker){
this.worker=worker;
}
public void doSomeWork(){
System.out.printle("AWorker");
worker.dosomeWork();
}
}
//*******************************TestWorker类***************************************//
class TestWorker{
public static void main(String args[]){
//生成一个A公司水管工对象
Plumber plumber = new Plumber();//先生成一个水管工
AWorker aWorker = new AWorker(plumber); //再生一个A公司员工,并且把水管工传入
aWorker.doSomeWork();
//生成一个A公司木匠对象
Carpenter carpenter = new Carpenter();//先生成一个木匠
AWorker aWorker2 = new AWorker(carpenter);//再生一个A公司员工,并且把木匠传入
aWorker2.doSomeWork();
}
}

总结

使用装饰者模式.

不使用继承.

处理流  BufferedReader     相当于工人     是装饰者

节点流  FileReader         相当于水管工   被装饰者.

被装饰者要作为对象传到装饰者里面去.

BufferedReader 可以装饰 读取文件,

                       还可以读取键盘

                       还可以读取网络.

                    

处理流是给节点流添加功能.......

处理流还有很多,比如压缩流,管道流,,,,,,都是在节点流基础上扩展的.在上面添加一些新功能.