java 输入输出流学习

首先，需要声明File类（File类只涉及获取文件本身的一些信息，而不涉及对文件的操作）

    创建一个File对象的构造方法有3个：

    File(String filename);

   File(String directoryPath,String filename);

   File(File f, String filename);

File类的下列方法获取文件本身的一些信息。

public String getName() 获取文件的名字。

public boolean canRead() 判断文件是否是可读的。

public boolean canWrite() 判断文件是否可被写入。

public boolean exits() 判断文件是否存在。

public long length() 获取文件的长度（单位是字节）。

public String getAbsolutePath() 获取文件的绝对路径。

public String getParent() 获取文件的父目录。

public boolean isFile() 判断文件是否是一个普通文件，而不是目录。

public boolean isDirectroy() 判断文件是否是一个目录。

public boolean isHidden() 判断文件是否是隐藏文件。

public long lastModified() 获取文件最后修改的时间。

 

 

   public String[] list() 用字符串形式返回目录下的全部文件。

    public File [] listFiles() 用File对象形式返回目录下的全部文件。

    public String[] list(FilenameFilter obj) 用字符串形式返回目录下的指定类型的所有文件。

    public File [] listFiles(FilenameFilter obj) 用File对象形式返回目录下的指定类型所有文件。

   上述两方法的参数FilenameFilter是一个接口，该接口有一个方法：

public boolean accept(File dir,String name);

例子：

package exam;

import java.io.*;

class Cfile implements FilenameFilter{
    private String extendname=".";
    void SetEXtendName(String s)
    {
        extendname+=s;
    }
    public boolean accept(File dir, String name) {
        // TODO Auto-generated method stub
        return name.endsWith(extendname);
    }
}
public class 文件 {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File file=new File("G:\\Java");
        File f2=new File("G:\\Java","123.txt");
        Cfile cfile=new Cfile();
        cfile.SetEXtendName("ppt");
        File f[]=file.listFiles();
        for(File n:f)
        {
            System.out.println(n);
        }
        if(!f2.exists())
            f2.createNewFile();
        File f1[]=file.listFiles();
        System.out.println();
        for(File n:f1)
        {
            System.out.println(n);
        }
        f2.delete();
        String f3[]=file.list();
        System.out.println();
        for(String n:f3)
        {
            System.out.println(n);
        }
//        File s[]=file.listFiles();
//        for(File str:s)
//        {
//            System.out.println(str.toString());
//        }
//        
        
    }

}

用Runtime 类声明一个对象( Runtime类在java.lang包)

       Runtime ec;

  ◆ 然后使用该类的getRuntime()静态方法创建这个对象：

         ec=Runtime.getRuntime();

  ◆ ec可以调用

       exec(String command)

   方法打开本地机的可执行文件或执行一个操作。

例子:

public static void main(String[] args) throws IOException {
        File file=new File("E:\\幕布思维导图\\mubu\\幕布.exe");
        Runtime cc=Runtime.getRuntime();
        cc.exec(file.getAbsolutePath());

InputStream抽象类的子类创建的流对象称作字节输入流、OutputStream抽象类的子类创建的流对象称作字节输出流，Java把Reader抽象类的子类创建的流对象称作字符输入流、Writer抽象类的子类创建的流对象称作字符输出流。

使用FileInputStream类的下列构造方法创建指向文件的输入流。

       FileInputStream(String name);

       FileInputStream(File file);

int read() 读取单个字节的数据，返回字节值（0~255整数），如果未读出字节就返回-1。

◆ int read(byte b[]) 读取b.length个字节到字节数组b中，返回实际读取的字节数。如果到达文件的末尾，则返回-1。

◆ int read(byte b[], int off, int len) 读取len个字节到字节数组b中，并返回实际读取的字节数目。如果到达文件的末尾，则返回-1，参数off指定从字节数组的某个位置开始存放读取的数据。

 使用FileOutputStream类的下列具有刷新功能的构造方法创建指向文件的输出流。

FileOutputStream(String name);

FileOutputStream(File file);

输出流的wirie方法以字节单位向目的地写数据。

   void write(int n) 向目的地写入单个字节。

   void write(byte b[]) 向目的地写入一个字节数组。

   void write(byte b[],int off,int len) 从字节数组中偏移量off处取len个字节写到目的地。

public static void main(String[] args) {
        // TODO Auto-generated method stub
//        byte [] a="Happy New Year!".getBytes();
//        byte [] b="新年快乐！".getBytes();
//        File file=new File("G:\\Java\\java2实用教程（第4版） 耿祥义","1.txt");
//        try {
//            OutputStream out=new FileOutputStream(file);
//            out.write(a);
//            out.close();
//            System.out.println(file.getName()+":"+file.length());
//            OutputStream out=new FileOutputStream(file,true);   持续写入文件（也就是输出到文件）
//            out.write(b);
//            out.close();
//            System.out.println("success!");
//        }
//        catch(Exception e)
//        {
//            System.out.println(e.getMessage());
//        }
        File f1=new File("G:\\Java\\java2实用教程（第4版） 耿祥义","1.txt");
        byte [] a=new byte[100];    这个InputStream 是字节输入流，所以这里用byte数组
        int n;
        try {
            InputStream in=new FileInputStream(f1);
            while((n=in.read(a,0,100))!=-1)    这个地方：将文件里的东西读到a里，但a每次只能存100字节的东西，读完之后从新读，
            {
                String s=new String(a,0,100);
                System.out.println("1236  "+s);   1236是个小测试
            }
        
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }
    }

字符输入输出流：

Reader类提供的read方法以字符为单位顺序地读取源中的数据。

  int read()：

  int read(char b[])：

  int read(char b[], int off, int len)：

  void close():

  long skip(long numBytes):

2． Writer流以字符为单位顺序地写文件，每次调用write方法就顺序地向目的地写入内容。 Writer类有如下常用的方法。

   void write(int n):  向输出流写入一个字符。

   void write(byte b[]):  向输出流写入一个字符数组。

   void write(byte b[],int off,int length):  从给定字符数组中起始于偏移量off处取len个字符写到输出流。

    void close():  关闭输出流。

  import java.io.*;
public class Example10_6 {
   public static void main(String args[]) {
      File sourceFile = new File("a.txt");  //读取的文件
      File targetFile = new File("b.txt");  //写入的文件
      char c[] =new char[19];               //char型数组 
      try{  
         Writer out = new FileWriter(targetFile,true); //指向目的地的输出流
         Reader in  = new FileReader(sourceFile);   //指向源的输入流  
         int n = -1;
         while((n=in.read(c))!=-1) {
             out.write(c,0,n);
         }
         out.flush();
         out.close();
      }
      catch(IOException e) {
          System.out.println("Error "+e);
      }
  }
}
 

缓冲输入、输出流：

1．BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。 

   构造方法：

     BufferedReader(Reader in);

      BufferedWriter (Writer out);

   2.BufferedReader和BufferedWriter类读写文件的方法：

     readLine() 读取文本行

     write(String s,int off,int len) 把字符串s写到文件中

     newLine(); 向文件写入一个回行符

public static void main(String[] args) {
        // TODO Auto-generated method stub
        File source=new File("G:\\Java","1.txt");
        File target=new File("G:\\Java","2.txt");
        try {
            Reader read=new FileReader(source);
            Writer write=new FileWriter(target);
            BufferedReader out=new BufferedReader(read);       缓冲输入·、输出流必须以字符输入、输出流为源、目的地

            BufferedWriter in=new BufferedWriter(write);
            String str;
            
            double sum=0;
            double aver=0;
            ArrayList<Double> d=new ArrayList<Double>();
            while((str=out.readLine())!=null)
            {
                d.add(Double.parseDouble(str));
                sum+=Double.parseDouble(str);
                
            }
            aver=sum/d.size();
            in.write("aver:"+aver);
            in.write("sum:"+sum);
            in.close();
            out.close();
            write.close();
            read.close();
        }
        catch(Exception e)
        {
            System.out.println("error:"+e);
        }
    }

先写这么多吧，本人小白，如有错误，请各位前辈指出，不剩感激！