黑马程序员_JAVA_IO流1

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

按数据分：字节流，字符流

按流向分：输入流，输出流

字节流抽象基类

InputStream，OutputStream

字符流的抽象基类

Reader，Writer

FileWriter fw = new FileWriter("demo.txt");
//创建一个filewriter对象，该对象一被初始化就必须要明确被操作的文件,而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
fw.write("abvfg");
//调用write方法，将字符串写到流中
fw.flush();
//刷新流对象中的缓冲数据,将数据刷到目的地中
fw.close();//关闭流资源，关闭之前flush一次数据

IO异常的处理方式

 FileWriter fw = null;
try
{
     fw = new FileWriter("k:\\demo.txt");\转义
     fw.write("akhf");
}
catch
{
     System.out.println(e.toString());
}
finally
{
     try
     {    
          if(fw!=null)
               fw.close();
     }
     catch(IOException e)
     {
          System.out.println(e.toString());
     }
}

对已有文件的数据续写

FileWriter fw = new FileWriter("demo.txt"，true);
//传递一个true参数，代表不覆盖已有文件，并在已有的文件末尾处进行数据续写。
fw.write("nihao\r\nlkj");

FileReader fr = new FileReader("demo.txt");
//创建一个文件读取流对象，和指定名称的文件对象相关联
//要保证文件是已经存在的，如果不存在，会发生FileNotFoundException异常
read()一次读一个字符，而且会自动往下读，读到末尾返回-1
int ch = 0;
while((ch=fr.read())!=-1)
{
     System.out.println("ch="+(char)ch);
}


fr.close();

第二种方法：通过字符数组进行读取

FileReader fr = new FileReader("demo.txt");
char[] buf = new char[3];
//定义一个字符数组，用于存储读到的字符
//该read(char[])返回的是读到的字符个数

int num = fr.read(buf);
System.out.println("num="+num+"..."+new String(buf));

int num = 0;
while((num=fr.read(buf))!=-1)
{
     System.out.println(new String(buf,0,num));
}

fr.close();

对于超大文件缓冲区一般取1024

copy_1

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

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

int ch = 0;

while((ch=fr.read())!=-1)
{
     fw.write(ch);
}
fw.close();
fr.close();

copy_2

FileWriter fr = null;
FileReader fr = null;
try
{
     fw = new FileWriter("SystemDemo_copy.txt");
     fr = new FileReader("SystemDemo.java");

     char[] buf = new char[1024];

     int len = 0;
     while((len=fr.read(buf))!=-1)
     {
          fw.write(buf,0,len);
     }
}
catch(IOException e)
{
     throw new RuntimeException("读写失败");
}
finally
{
     if(fr!=null)
          try(fr.close();)catch(IOException e){}
     if(fw!=null)
          try(fw.close();)catch(IOException e){}

}

缓冲区

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

BufferedWriter bufw = new BufferedWriter(fw);

//只要将需要被提高效率的流对象作为参数提供给Buffer对象的构造函数即可

bufw.write("dsgfsg");

bufw.flush();

//只要用到缓冲区，就必须刷新

fw.close();

//关闭缓冲区就是在关闭缓冲区对应的流对象

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

BufferedReader bufr = new BufferedReader(fr);

String s1 = bufr.readLine();

System.out.println("s1:"+s1);

String line = null;
while((line=bufr.readLine())!=null)
{
     System.out.println(line);
}

readLine()方法只返回回车之前的数据，并不返回回车符。

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

BufferedReader bufr = null;
bufferedWriter bufw = null;
try
{
     bufr = new BufferedReader(new FileReader("Buffered.java"));
     bufw = new BufferedWriter(new FileWriter("buffer_copy.txt"));

     String line = null;

     while((line=bufr.readLine())!=null)
     {
          bufw.write(line);
          bufw.newLine();
          bufw.flush();
     }
}
catch(IOException e)
{
     throw new RuntimeException("读写失败")；
}
finally
{
     try
     {
          if(bufr!=null)
               bufr.close();
     }
     catch(IOException e)
     {
          throw new RuntimeException("读取关闭失败")；
     }
     try
     {
          if(bufw!=null)
               bufw.close();
     }
     catch(IOException e)
     {
          throw new RuntimeException("写入关闭失败")；
     }
}

自定义一个类中包含一个功能和readline一样的功能

class  MyBufferedReader
{
     private FileReader r;
     MyBufferedReader(FileReader r)
     {
          this.r = r;
     }

     public String myReadLine() throw IOException
     {

          StringBuilder sb = new StringBuilder();
          int ch = 0;
          while()
          {
               if(ch=='\r')
                    continue;
               if(ch=='\n')
                    return sb.toString();
               else
                    sb.append((char)ch);
          }
          if(sb.length()!=0)
               return sb.toString();
          return null;
     }
     public void myClose()
     {
          r.close();
     }
}

装饰设计模式

当想要对已有对象进行功能增强时，可以定义类，对已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

装饰类对通过构造方法接收被装饰对象并基于装饰对象的功能提供更强的功能，装饰模式比继承灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。装饰类和被装饰对象继承同一对象实现同一接口，两者通常属于同一体系。

class MyBufferedReader
{
     private FileReader r;
     MyBufferedReader(FileReader r)
     {
              this.r = r;
     }
}

LineNumberReader
FileReader fr = new FileReader("PersonDemo.java");
LineNumberReader lnr = new LineNumber(fr);
String line = null;
lnr.setLineNumber(100);
while((line=lnr.readLine())!=null)
{
     System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close;

字节流

InputStream读

OutputStream写

	FileInputStream fis = new FileInputStream("fos.txt");
	byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环
	fis.read(buf);
	System.out.println(new String(buf));
	fis.close();

拷贝一个图片文件

          FileOutputStream fos = null;
          FileInputStream fis = null;
          try
          {
               fos = new FileOutputStream("c:\\2.bmp");
               fis = new FileInputStream("c:\\1.bmp");

               byte[] buf = new byte[1024];
              
               int len = 0;

               while((len=fis.read(buf))!=-1)
               {
                    fos.write(buf,0,len);
               }
          }
          catch (IOException e)
          {
               throw new RuntimeException("复制文件失败")；
          }
          finally
          {
               try
               {
                    if(fis!=null)
                         fis.close();
               }
               catch (IOException e)
               {
                    throw new RuntimeException("读取关闭失败")；

               }
               try
               {
                    if(fos!=null)
                         fos.close();
               }
               catch (IOException e)
               {
                    throw new RuntimeException("写入关闭失败")；

               }
          }

Properties是hashtable的子类，具备Map集合的特点，里面存储的键值对都是字符串,Properties是集合和IO技术相结合的容器；可以用于键值对形式的配置文件;加载数据需要有固定格式，即键=值；#后是注释说明文字。

Properties  prop = new Properties();

prop.setProperty("wo","12");

prop.setProperty("ni","83");

String value = prop.getProperty("wo");//value = 12

Set<String> names = prop.stringPropertyName();//获取集合中所有键名

将流中的数据存到集合中

Properties的处理方法

Properties  prop = new Properties();

FileInputStream fis = new FileInputStream("info.txt");

prop.load(fis);//将流中的数据加载进集合

prop.list(System.out);//列出集合目录

prop.setProperty("","");

FileOutputStream fos = new FileOutputStream("info.txt");

prop.store(fos,"zhushi");//将修改后的集合保存

打印流

PrintWriter该流提供了打印方法，可以将各种数据原样打印

1.文件对象,File

2.字符串路径

3.字节输出流，OutputStream

4.字符输出流，Writer

PrintWriter out = new PrintWriter(System.out,true);

PrintWriter out = new PrintWriter("a.txt");

PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

//自带刷新，刷新是针对流而言，文件路径要封装成流对象才能刷新

//只有println,printf,format方法可以自动刷新

out.println();//可换行

PrintStream可以直接接收:

1.文件对象File

2.字符串路径

3.字节输出流OutputStream

IO流合并

	Vector<FileInputStream> v = new Vector<FileInputStream>();
	v.add(new FileInputStream(file1));
	v.add(new FileInputStream(file2));
	v.add(new FileInputStream(file3));

	Enumeration<FileInputStream> en = v.elements();//迭代器出现之前的取出元素方法

	SequenceInputStream sis = new SequenceInputStream(en);

切割

用流对象将文件输出到若干小文件中