黑马Java学习笔记之-----输入输出流IO

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

1、File类

（1）用来将文件或者文件夹封装成对象

（2）方便对文件和文件夹的属性信息进行操作

（3）File对象可以作为参数传递给流的构造函数

 

File类常用方法：

 

No.	方法或常量	类型	描述
1	public static final String pathSeparator	常量	表示路径的分隔符（windows是“;”）
2	public static final String separator	常量	表示路径的分隔符（windows是“\”）
3	public File(String pathname)	构造	创建File类对象，传入完整路径
4	public boolean createNewFile()throws IOException	普通	创建新文件
5	public boolean delete()	普通	删除文件
6	public boolean exists()	普通	判断文件是否存在
7	public boolean isDirectory()	普通	判断给定的路径是否在一个目录
8	public long length()	普通	返回文件的大小
9	public String[] list()	普通	列出指定目录的全部内容，只是名称
10	public File[] listFiles()	普通	列出指定目录的全部内容，有路径
11	Public Boolean mkdir()	普通	创建一个目录
12	Public Boolean renameTo(File dest)	普通	为已有的文件重命名

 

 

 1 /*
 2     练习：
 3         列出一个文件夹下所有的子文件夹以及子文件
 4 */
 5 
 6 import java.io.File;
 7 public class Practice
 8 {
 9     public static void main(String[] args) 
10     {
11         String path = "e:"+File.separator+"xiao";
12         File f = new File(path);
13         showDir(f);
14     }
15 
16     public static void showDir(File file) 
17     {
18         File[] f = file.listFiles();
19         for (File f2: f )
20         {
21             System.out.println(f2);
22             if (f2.isDirectory())
23             {
24                 showDir(f2);  //递归调用
25             }
26         }
27     }
28 }

 

总结：

1 File类是在java.io包中唯一与文件本身有关的

2 可以使用File类创建、删除等常见的文件操作

3 在使用File类指定路径的时候一定要注意操作系统间的差异，尽量使用separator 进行分割

 

2、IO流概述

(1)用来处理设备(硬盘，控制台，内存)间的数据。

(2)java中对数据的操作都是通过流的方式。

(3)java用于操作流的类都在io包中。

 

 

按流向分为：输出流、输入流

操作数据分：字节流与字符流

 

字节流（原始数据），需要用户读入后进行相应的编码转换。 由InputStream和OutputStream处理

字符流基于自动转换而实现，读取数据时会把数据按照JVM的默认编码自动转换成字符。 由Reader和Writer处理。

 

InputStream：继承自InputStream的流都是用于向程序中输入数据的，且数据单位都是字节（8位）。　　

OutputSteam：继承自OutputStream的流都是程序用于向外输出数据的，且数据单位都是字节（8位）。　　

Reader：继承自Reader的流都是用于向程序中输入数据的，且数据单位都是字符（16位）。　　

Writer：继承自Writer的流都是程序用于向外输出数据的，且数据单位都是字符（16位）。

 

 1 /*
 2     练习：
 3         使用FileInputStream执行输入，FileOutputStream执行输出，
 4         用以实现复制InputStreamTest.java文件的功能。
 5 */
 6 import java.io.*;
 7 public class StreamTest
 8 {
 9     public static void main(String[] args)
10     {
11         FileInputStream is = null;
12         FileOutputStream os = null;
13         try
14         {
15             is = new FileInputStream("InputStreamTest.java");
16             os = new FileOutputStream("newFile.txt");
17             byte[] bbuf = new byte[1024];
18             int hasRead = 0;
19             //从输入流中循环取出数据
20             while ((hasRead=is.read(bbuf))>0)
21             {
22                 //每读取一次，即写入文件输出流，读了多少，就写多少
23                 os.write(bbuf,0,hasRead);
24             }
25         }
26         catch (IOException ioe)
27         {
28             ioe.printStackTrace();
29         }
30         finally 
31         {
32             if(is!=null)
33             {
34                 try
35                 {
36                     is.close(); //关闭输入流
37                 }
38                 catch (IOException ioe)
39                 {
40                     ioe.printStackTrace();
41                 }
42                 
43             }
44             if (os!=null)
45             {
46                 try
47                 {
48                     os.close();  //关闭输出流
49                 }
50                 catch (IOException ioe)
51                 {
52                     ioe.printStackTrace();
53                 }
54                 
55             }
56         }
57     }
58 }

 

缓冲区

好处： 提高了对数据的读写效率

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

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

 

 1 class BufferedWriterDemo {    
 2     public static void main(String[] args) throws IOException    {        
 3         FileWriter fw=new FileWriter("buf.txt");        //为了提高字符写入流效率，加入了缓冲技术        
 4         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可        
 5         BufferedWriter bufw=new BufferedWriter(fw);        
 6         for (int x=0;x<6 ;x++ )        {            
 7             bufw.write("wjkerwhrw"+x);            
 8             bufw.newLine();            
 9             bufw.flush();        
10         }    
11         
12         //只要用到缓冲区，就要记得刷新        
13         //bufw.flush();        
14 
15         //其实关闭缓冲区，就是关闭缓冲区中的流对象        
16         bufw.close();    
17     }
18 }

 

3、转换流

 

InputStreamReader将字节输入流抓换成字符输入流，OutputStreamWriter将字节输出流转换成字符输出流。

 

 1 　　/*
 2 　　    练习：
 3 　　        打印键盘输入，“exit”时退出
 4 　　*/
 5 　　
 6 　　import java.io.*;
 7 　　
 8 　　public class Practice1
 9 　　{
10 　　    public static void main(String[] args) throws Exception
11 　　    {
12 　　        //将System.in对象转换成Reader对象
13 　　        InputStreamReader isr = new InputStreamReader(System.in);
14 　　        //将普通Reader包装成BufferedReader
15 　　        BufferedReader br = new BufferedReader(isr);
16 　　        String buf = null;
17 　　        while ((buf=br.readLine())!=null)
18 　　        {
19 　　            if (buf.equals("exit"))
20 　　            {
21 　　                break;
22 　　            }
23 　　            //打印读取的内容
24 　　            System.out.println("输入内容为："+buf);
25 　　        }
26 　　        //关闭输入流
27 　　        br.close();
28 　　    }
29 　　}

 

总结：

由于BufferedReader具有一个readLine方法，可以非常方便的一次读入一行内容，所以经常把读取文本内容的输入流包装成BufferedReader，用以方便的读取输入流的文本内容。

 

System.out:对应的是标准输出设备，控制台
System.in:对应的标准输入设备:键盘

 

 

5、RandomAccessFile

 

 

 

该类不是IO体系中的子类，而是直接继承自Object
但是它是IO包中成员，因为它具备读和写功能
内部封装了一个数组，而且可以通过指针对数组的元素进行操作
可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置
其实完成读写的原理就是内部封装了字节输入流和输出流

 

构造函数：

 

public RandomAccessFile(File file,String mode)throws FileNotFoundException

 

实例化此类的时候需要传递File类。告诉程序应该操作的是哪个文件，之后有个模式，文件的打开模式，常用的两种模式：

 

• • r：读
  • w：写
  • rw：读写，如果使用此模式，如果文件不存在，则会自动创建

 

 

6、装饰设计模式:
装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰对象的功能，提供更强的功能。

 

 1 interface Person{
 2      public void eat();
 3  }
 4  class Man implements Person{
 5      public void eat() {
 6          System.out.println("吃饭");
 7      }
 8  }
 9 class Decorator implements Person{
10      private Man man;
11      public void setMan(Man man) {
12          this.man = man;
13      }
14      public void eat() {
15          man.eat();
16      }
17  }
18   class ManDecorator extends Decorator{
19      public void eat() {
20          super.eat();
21          soup();//增加的功能
22      }
23      private void soup(){
24          System.out.println("喝汤");
25      }
26  }
27   public class Test {
28      public static void main(String[] args) {
29          Man man=new Man();
30          ManDecorator p=new ManDecorator();
31          p.setMan(man);
32          p.eat();
33      }
34  }

 

 

---------------------- android培训、java培训、期待与您交流！ ----------------------

---

 

转载于:https://www.cnblogs.com/MercyK/archive/2013/04/29/3043561.html