java_IO

　流的分类：

按数据流的方向分为输入流和输出流

按处理数据单位不同分为字符流和字节流（一个字符为两个字节）

按照功能不同分为节点流和处理流

节点流为从一个特定的数据源读写数据

处理流是连接在已存在的流上，通过对数据的处理为程序提供更强大的读写功能

InputStream

基本方法：（具体可见ＡＰＩ）

　　int read() throws IOException
　　//从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。
　　//如果到达流的末尾，则返回 -1。
　　int read(byte[] b) throws IOException
　　//从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
　　//读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回 -1。
　　int read(byte[] b, int off, int len) throws IOException
　　//将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。将读取的第一个字节存储在元素 b[off] 中。
　　//读入缓冲区的总字节数；如果因为已到达流末尾而不再有数据可用，则返回 -1。
　　void close() throws IOException
　　//关闭此输入流并释放与该流关联的所有系统资源。
　　//InputStream 的 close 方法不执行任何操作。

OutputStream

　　void write(int b) throws IOException
　　//将指定的字节写入此输出流。
　　void write(byte[] b) throws IOException
　　//将 b.length 个字节从指定的 byte 数组写入此输出流
　　void write(byte[] b, int off, int len) throws IOException
　　//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
　　//如果 b 为 null，则抛出 NullPointerException。如果 off 为负，或 len 为负，或者 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。
　　void flush() throws IOException
　　//将输出流中缓冲的数据全部写出到目的地
　　void close() throws IOException
　　//关闭此输出流并释放与此流有关的所有系统资源。

　　//close之前用flush清空缓存

Reader 基本方法：

　　同上（不同以字符为单位）

Writer基本方法：

　　public void write(String str) throws IOException
　　//将字符串写入输出流。
　　//因为String有toCharArray方法将String转换为字符数组
　　void write(String str, int off, int len) throws IOException
　　//写入字符串的某一部分。
　　// str - 字符串；off - 相对初始写入字符的偏移量；len - 要写入的字符数

节点流类型：

处理流类型：

1、缓冲流：套接在相应字节流之上，对数据的读写提供缓冲的功能。

　　BufferedWriter、BufferedReader、BufferedInputStream、BufferedOutputStream

　　注意：

  • 　缓冲输入流支持其父类的mark和reset方法
  • 　BufferedReader提供了readLine方法用于读取一行字符串
  • 　BufferedWriter提供newLine方法，写入一个换行
  • 　对于输出缓冲流，写出的数据选在内存中缓存，使用flush方法将内存中的数据写出

2、转换流： 将字节流转换成字符流

　　InputStreamReader、OutputStreamWriter

　　注意：

  • 　InputStreamReader与InputStream套接
  • 　OutStreamWriter与OutputStream套接
  • 　转换流在构造时可以指定其编码集合（gbk 国标；ISO8859-1 西欧语言）

3、数据流：可以存取JAVA原始类型数据（int，float等）

　　DataInputStream、 DataOutputStream

4、Print流（打印流）

　　PrintWriter和PrintStream都属于输出流，分别对应字节和字符

　　PrintWriter和PrintStream提供了重载的Print

　　Println可以用于多种数据类型的输出

　　PrintWriter和PrintStream输出不会抛出异常

　　PrintWriter和PrintStream有自动flush功能

例 1：InputStream

import java.io.*;
public class TestFileInputStream {
  public static void main(String[] args) {
    int b = 0;
    FileInputStream in = null;
    try {
      in = new FileInputStream("d:\\share\\java\\io\\TestFileInputStream.java");
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件");
      System.exit(-1);
    }

    try {
      long num = 0;
      while((b=in.read())!=-1){
        System.out.print((char)b);
        num++;
      }
      in.close();
      System.out.println();
      System.out.println("共读取了 "+num+" 个字节");
    } catch (IOException e1) {
      System.out.println("文件读取错误"); System.exit(-1);
    }
  }
}

例2:OutputStream

import java.io.*;
public class TestFileOutputStream {
  public static void main(String[] args) {
      int b = 0;
      FileInputStream in = null;
      FileOutputStream out = null;
      try {
        in = new FileInputStream("d:/share/java/HelloWorld.java");
        out = new FileOutputStream("d:/share/java/io/HW.java");
        while((b=in.read())!=-1){
          out.write(b);
        }
        in.close();
        out.close();
      } catch (FileNotFoundException e2) {
        System.out.println("找不到指定文件"); System.exit(-1);
      } catch (IOException e1) {
        System.out.println("文件复制错误"); System.exit(-1);
      }
      System.out.println("文件已复制");
  }
}

例3：Reader

import java.io.*;
public class TestFileReader {
  public static void main(String[] args) {
    FileReader fr = null;
    int c = 0;
    try {
      fr = new FileReader("d:\\share\\java\\io\\TestFileReader.java");
      int ln = 0;
      while ((c = fr.read()) != -1) {
        //char ch = (char) fr.read();
        System.out.print((char)c);
        //if (++ln >= 100) { System.out.println(); ln = 0;}
      }
      fr.close();
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件");
    } catch (IOException e) {
      System.out.println("文件读取错误");
    }

  }
}

例4：Writer

import java.io.*;
public class TestFileWriter {
  public static void main(String[] args) {
    FileWriter fw = null;
    try {
      fw = new FileWriter("d:\\bak\\unicode.dat");
      for(int c=0;c<=50000;c++){
        fw.write(c);
      }
      fw.close();
    } catch (IOException e1) {
        e1.printStackTrace();
      System.out.println("文件写入错误");
      System.exit(-1);
    }
  }
}

例5：BufferedStream

import java.io.*;

public class TestBufferedStream1 {
    public static void main(String[] args) {
        try {
            int b = 0;
            FileInputStream fis = new FileInputStream("g:/JAVA基础/TestFileInputStream.java" );
            BufferedInputStream bis = new BufferedInputStream(fis);//注意BufferedInputStream的构造函数
            System.out.println(bis.read());
            System.out.println(bis.read());
            bis.mark(100);　　　　　　　　　　//标记第100个字节
            for(int i=0; i<10 && (b=bis.read())!=-1;i++){         // 从第100个字节开始
                System.out.print((char)b+" ");
            }
            System.out.println();
            bis.reset();　　　　　　　　　　　//回到第100个字节
            for(int i=0; i<10 && (b=bis.read())!=-1;i++){
                System.out.print((char)b+" ");
            }
            bis.close();
        }catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("未找到文件");
        } catch (IOException e) {
                e.printStackTrace();
                System.out.println("文件读取错误");
        }
    }
}

运行结果：

不是读到到显示屏上，读到b上，在内存中的一块区域，显示屏上是由于打印的结果

例6：BufferedWriter BufferedReader

import java.io.*;

public class TestBufferedStream2 {

    public static void main(String[] args) {
            try {
                BufferedWriter bw = new BufferedWriter(new FileWriter("g:/JAVA基础/TestFileInputStream.java"));
                BufferedReader br = new BufferedReader(new FileReader("g:/JAVA基础/TestFileInputStream.java"));
                String c=null;
                for(int i=0; i<10; i++){
                    c=String.valueOf(Math.random());
                    bw.write(c);
                    bw.newLine();
                }
                bw.flush();
                String b=null;
                while((b=br.readLine())!=null){
                    System.out.println(b);
                }
                bw.close();
                br.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }

例7：OutputStreamWriter

import java.io.*;

public class TranseForm1 {
    public static void main(String[] args) {
            try {
                OutputStreamWriter osw = new OutputStreamWriter(
                        new FileOutputStream("g:/JAVA基础/TestFileInputStream.java"));
                osw.write("sdjfghgklhaksh");
                System.out.println(osw.getEncoding());//返回此流使用的字符编码的名称
                osw.flush();
                osw.close();
                osw = new OutputStreamWriter(
                        new  FileOutputStream("g:/JAVA基础/TestFileInputStream.java",true),"ISO8859-1");//true为续写即接着原来的写
                osw.write("sdjfghgklhaksh");
                System.out.println(osw.getEncoding());
                osw.flush();
                osw.close();
            }catch (FileNotFoundException e) {
                    e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}

运行结果：

　打开文件 ：

　　　　　　　　　　　　　　

例8：InputStreamWriter

import java.io.*;
public class TestTransForm2 {
  public static void main(String args[]) {
    InputStreamReader isr =
            new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    String s = null;
    try {
      s = br.readLine();
      while(s!=null){
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        s = br.readLine();
      }
      br.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
} //阻塞

例9：DataInputStream，DataOutputStream

import java.io.*;
public class TestDataStream {
    public static void main(String[] args) {
        ByteArrayOutputStream bao =  new ByteArrayOutputStream ();
        DataOutputStream dos = new DataOutputStream(bao);
        try {
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray());
            DataInputStream dis = new DataInputStream(bai);
            System.out.println(bai.available());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            dos.close();
            dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

　　　　

例10：PrintStream

import java.io.*;
public class TestPrintStream1 {

    public static void main(String[] args) {
        try {
            FileOutputStream fos =  new FileOutputStream("g:/JAVA基础/TestFileInputStream.java");
            PrintStream ps = new PrintStream(fos);
            if(ps!=null){
                System.setOut(ps);//将输出方向指向Ps
            }
            for(int i = 0 ; i < 100 ; i++){
                System.out.print((char)i + " ");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}
时间： 2024-10-12 01:51:43

java_IO的相关文章

Java_io体系之RandomAccessFile简介、走进源码及示例——20

Java_io体系之RandomAccessFile简介.走进源码及示例——20 RandomAccessFile 1.       类功能简介: 文件随机访问流.关心几个特点: 1.他实现的接口不再是InputStream.OutputStream中的任何一个.而是实现的DataInput.DataOutput.这也注定了他可以对java基础类型进行操作.而且是即可读取.也可以写入.关于这部分的方法大多数都是从DataInputStream.DataOutputStream那里荡来的. 2.如

java_io学习_编码

package io; public class encodingDemo{ public static void main(String[] args) throws Exception{ // TODO Auto-generated method stub String s="李雪涛ja";//转换成字节序列用的是项目默认编码 byte[] byte1=s.getBytes(); for(byte b:byte1) //把字节(转换成了int)以16进制显示 System.out.

java_io字节流操作

看代码: package wkl.file; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.InputStream; import java.io.OutputStream; import java.io.Writer; import javax.imageio.stream.FileIm

java_io文件类操作

Java对文件的操作主要包括创建文件,删除文件,列出指定目录下的所有文件,判断路径是目录还是文件等.详细代码如下所示: package wkl.file; import java.io.File; import java.io.IOException; public class FileTest { //创建一个文件 public static void creafile(){ String filename = "C:"+File.separator+"hello.txt&

java_IO总结（一）

所谓IO,也就是Input与Output的缩写.在java中,IO涉及的范围比较大,这里主要讨论针对文件内容的读写 其他知识点将放置后续章节(我想,文章太长了,谁都没耐心翻到最后) 对于文件内容的操作主要分为两大类 分别是: 字符流 字节流 其中,字符流有两个抽象类:Writer   Reader 其对应子类FileWriter和FileReader可实现文件的读写操作 BufferedWriter和BufferedReader能够提供缓冲区功能,用以提高效率 同样,字节流也有两个抽象类:Inp

24(java_io from keyboard)

public class ReadFromKB{ public static void main(String args[]) { try { byte bArray[]=new byte[128]; String str; System.out.println("Enter something Using Keyborad:"); System.in.read(bArray); str = new String(bArray, 0); System.out.print("Y

十、java_IO

目录: 一.java流式输入/输出原理 二.java流类的分类 三.输入/输出流类 四.常见的节点流和处理流 五.文件流 六.缓冲流 七.数据流 八.转换流 九.Print流 十.Ubject流 一.java流式输入/输出原理 java中,对于数据的输入/输出操作以”流”(Stream)方式进行:JDK提供了各种各样的”流”类,用以获取不同类型的数据:程序中通过标准的方法输入或输出数据 二.java流类的分类 按数据流的方向不同可以分为输入流和输出流 按处理数据单位不同可以分为字节流和字符流 按

Java_IO流_File类配合使用(其中用到了递归)

第一:Java File类的功能非常强大,利用Java基本上可以对文件进行所有的操作.以下对Java File文件操作以及常用方法进行简单介绍 案例1:遍历出指定目录下的文件夹,并输出文件名 1 static void findDirectory() { 2 //构建file对象,指定目录路径(separator 跨平台分隔符) 3 File root = new File("E://") ;//传的是String,因为是路径,所有按照格式写eg:"E://"与&q

Java_IO流——File类(2)

File类使用练习1 1.输出指定目录下面指定后缀的文件名称 判断E盘目录下面是否有后缀命名为.txt的文件,如果有,就输出此文件名称. 2.分析: (1).封装E盘目录 (2).获取该目录下面所有文件或者文件夹的File数组,用于判断是不是文件 (3).遍历该File数组,获取每一个File对象,然后判断 (4).是否是文件 是:继续判断是否是以.txt文件结尾 是:就输出该文件名称 否:就不管 否:就不管 3.改进: 使用文件名称过滤器改进 方法: public String[] list(