Java——IO输入/输出

在学习输入/输出流的前提下先了解一下File类。

使用 File 类操作文件

import java.io.File;
import java.io.IOException;

public class FIleTest {

    public static void main(String[] args) {
        //创建File 类对象
        File file = new File("files/file");

        //创建文件夹，并且只能创建一级文件夹
        //System.out.println(file.mkdir());  //返回 false
        //可以同时创建多层目录
        //System.out.println(file.mkdirs());

        //访问文件名相关的方法
        System.out.println("获取文件的名称："+file.getName());
        System.out.println("返回路径名："+file.getPath());
        System.out.println("返回绝对路径："+file.getAbsolutePath());
        System.out.println("返回最后一级子目录对应的父目录名："+file.getParent());

        //文件检测相关的方法
        System.out.println(file.exists());  //判断文件或者目录是否存在
        System.out.println(file.canWrite());  //判断此 file对象所对应的文件或目录是否可写
        System.out.println(file.canRead());    //是否可读
        System.out.println(file.isFile());   //判断是不是文件
        System.out.println(file.isDirectory());   //判断是不是目录
        System.out.println(file.isAbsolute());   //判断 File 对象所对应的文件或目录是否是绝对路径

        //在指定路径下创建新的文件
        file = new File("files/file/hello.txt");
        //判断这个文件是否存在
        if (!file.isFile()){
            try {
                file.createNewFile();   //不存在就创建一个
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

流的分类:

1.输入流和输出流

按照流的流向来分类，可以分为输入流和输出流。

》输入流：只能从中读取数据，而不能向其写入数据。

》输出流：只能向其写入数据，而不能从中读取数据。

　　Java中的输入流主要用 InputStream 和 Reader 作为基类，而输出流则主要由OutputStream 和 Writer 作为基类。他们都是一些抽象基类，不能直接创建实例。

2.字节流和字符流

　　字节流和字符流的用法几乎完全一致，区别在于字节流和字符流所操作的数据单元不同——字节流操作的数据单元是 8 位的字节，而字符流操作的数据单元是 16 为的字符。

　　字节流主要由 InputStream 和 OutputStream 作为基类，而字符流则主要由 Reader 和 Writer 作为基类。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

Java 输入/输出流体系中常用的流分类
分类 字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 　　InputStream OutPutStream Reader Writer
访问文件 FileInputStream FileOuputStream FileReader FileWiter
访问数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReaader CharArrayWriter
访问管道 PipedInputStream PipedOutputStream PipedReader PipedWriter
访问字符流     StringReader StringWriter
缓存流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流     InputStreamReader OutputStreamWriter
对象流 ObjectInputStream ObjectInputStream    
抽象基流 FilterInputStream FilterOutputStream FilterReader FilterWriter
打印流   PrintStream   PrintWritrt
推回输入流 PushbackInputStream   PushbackReader  
特殊流 DataInputStream DataOutputStream    

输入流：

　　输出流又分为两种 字节输入流（InputStream）和字符输入流(Reader)

》》字节流
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamTest {

    public static void main(String[] args) throws IOException {
        //创建字节输入流
        InputStream fis = new FileInputStream(new File("files/file/hello.txt"));
        //创建输入流，可以看成一个“竹筒”
        byte[] bbuf = new byte[1024];
        //用于保存实际读取的字节数
        int hasRead = 0;
        //使用循环重复“取水”的过程
        while((hasRead = fis.read(bbuf)) >0 ){
            //取出 “竹筒”中的水滴（字节），将字节数组转换成字符串输入
            System.out.println(new String(bbuf,0,hasRead));
        }
        //关闭文件输入流
        fis.close();
    }
}

》》字符流

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class ReaderTest {

    public static void main(String[] args) {
        //创建字符流并且自动关闭流，这样保证输入流一定会关闭
        try (Reader fr = new FileReader(new File("files/fils/hello.txt"))){
            //创建一个长度为32的“竹筒”
            char[] cbuf =new char[32];
            //用于保存实际读取的字符数
            int hasRead = 0;
            //使用循环来重复“取水”的过程
            while((hasRead = fr.read(cbuf)) > 0){
                //取出“竹筒”中的水滴（字符），将字符数组转换成字符串输入
                System.out.println(new String(cbuf,0,hasRead));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

》》使用Reader 和 BufferedReader 读取文本文件

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BufferedReaderTest {

    public static void main(String[] args) {
        /**
         * BufferedReader类是 Reader 类的一个子类，它与FileReader 类的区别在于，BufferedReader 类带有缓存区，
         * 它可以先把一批数据读到缓存区，接下来的读取操作都是从缓存中获取数据，避免每次都从数据源读取数据进行字符
         * 编码转换，从而提高读取操作的效率。
         *
         */
        //创建字符流 Reader对象
        try(Reader fr = new FileReader(new File("files/file/hello.txt"))) {
            //创建一个 BufferedReader 对象
            BufferedReader br =new BufferedReader(fr);
            //接受读取出的数据
            String line = null;
            //采用循环方式来逐行地读取数据
            while((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出流：

　　输出也是分为两种 字节流（OutputStream） 和 字符流（Writer）

》》字节输出流（OutputStream）
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStreamTest {

    public static void main(String[] args) {

        //创建输入流，以追加方式写入文件
        try (OutputStream fos = new FileOutputStream(new File("files/file/hello.txt"),true)){
            String str ="\n好好学习Java";  //加\n可以自动换行
            //字节数组
            byte[] words = str.getBytes();
            //写入文件
            fos.write(words, 0, words.length);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

》》字符输入流（Writer）

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class WriterTest {

    public static void main(String[] args) {

        //创建字符输出流，并且以追加方式写入文件
        try(Writer fw = new FileWriter(new File("files/file/hello.txt"),true)) {
            //写入文件
            fw.write("Hello Java!");
            fw.flush();  //刷新缓存区
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

》》使用BufferedWriter 和 FileWriter 写入文本文件

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class BufferedWrierTest {

    public static void main(String[] args) {

        try(
                //创建输出流，并且以追加方式写入文本
                Writer fw = new FileWriter(new File("files/file/hello.txt"),true);
                //创建一个 BufferedWriter 缓存对象
                BufferedWriter bw = new BufferedWriter(fw)) {
            bw.newLine();   //换行
            bw.write("我正在学习BufferedWriter");//写入文本

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

二进制文件的读写：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class MyTest {

    public static void main(String[] args) {
        try (
                //创建字节输入流
                InputStream fis = new FileInputStream(new File("F://MyEclipse/MyIO/bin/cn/bdqn/file/FileTest.class"));
                DataInputStream dis =new DataInputStream(fis);

                //创建字节输出流
                OutputStream fos = new FileOutputStream(new File("files/file/file.class"));
                DataOutputStream dos = new DataOutputStream(fos);

                ){

            int temp;
            //读取并写入文件
            while((temp = dis.read())!=-1){
                dos.write(temp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

序列化和反序列化：

序列化概述：

　　简单的说，序列化就是将对象的状态存储到特定存储介质中的过程，也就是将对象转换为可保持或传输格式的过程中，会将对象的公有成员、私有成员（包括类名），转换为字节流，然后再把字节流写入数据流，存储到存储到文件中

用序列化保存对象信息

　　序列化机制允许将实现序列化的Java对象转换为字节序列，这个需要借助于I/O流来实现。Java 中，只有实现了 java.io.Serializable 接口的类的对象才能被序列化，Serializable 表示串行的、可序列化的，所以对象序列化在某些文献上也称为串行化。

》》创建Student类
import java.io.Serializable;

public class Student implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private String sex;
    private String address;

    public Student() {

    }

    public Student(String name, int age, String sex, String address) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

》》序列化

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializaleTest {

    public static void main(String[] args) {
        //创建字节输出流
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("files/file/student.txt")))) {
            Student stu = new Student("张三",22,"男","北京海定区五道口");
            oos.writeObject(stu);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

》》反序列化

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeSerializableTest {

    public static void main(String[] args) {

        //创建字节输入流
        try (ObjectInputStream ois =new ObjectInputStream(new FileInputStream(new File("files/file/student.txt")))) {
            //强制转换成Student 对象
            Student stu = (Student)ois.readObject();
            System.out.println("姓名："+stu.getName());
            System.out.println("年龄："+stu.getAge());
            System.out.println("性别：" + stu.getSex());
            System.out.println("地址：" + stu.getAddress());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
时间： 2024-10-17 23:32:52

Java——IO输入/输出的相关文章

Java的输入/输出操作

Java的输入\输出机制 计算机的基本功能就是通过输入输出设备与外部其他设备尽心数据的交互,从其他设备读入数据叫做输入操作,将计算机内的数据写入到其他设备叫做输出操作.可以向计算机发送数据.又可以接受计算机数据的设备叫做输入/输出(I/O)设备,例如磁盘.网络等. Java中主要按照一种方式进行数据交换——流(Stream)的方式.流方式就好比是建立在数据交换源与目的地之间的一条通信路径.但是数据在作为流在该路径中进行传输.数据流的走向是有方向的,相对于计算机而言,传向计算机的数据流叫做输入流(

java 的输入/输出

java 的输入/输出java的 I/O是通过java.io包下的类和接口支持,其中最重要的是5个类,分别是 File,OutputStream,InputStream, Write,Reader及一个接口Serializable.File类:可以对文件进行操作字节流:(OutputStream/InputStream),可以使用字节流读取文件内容字符流:(Writer/Reader)转换流:(InputStreamReader/OutputStreamWriter)将字节流转换为字符流缓冲流:

Java基础——输入/输出（一）

概述 Java的IO通过java.io包下是类和接口来支持,在java.io包下主要包括输入,输出两种IO流,每种输入.输出流又可分为字节流和字符流两大类.其中字节流以字节为单位来处理输入.输出操作,而字符流以字符来处理来处理输入.输出操作. 一.File类 File类可以使用文件路径字符串来创建File实例,该文件字符串可以是绝对路径,也可以是相对路径.在默认情况下,系统总是依据用户的工作路径来解释相对路径,这个路径由系统属性“userdir”指定. 一旦创建了File对象后,就可以调用Fil

java.IO输入输出流：过滤流：buffer流和data流

java.io使用了适配器模式装饰模式等设计模式来解决字符流的套接和输入输出问题. 字节流只能一次处理一个字节,为了更方便的操作数据,便加入了套接流. 问题引入:缓冲流为什么比普通的文件字节流效率高? 不带缓冲的操作,每读一个字节就要写入一个字节. 由于涉及磁盘的IO操作相比内存的操作要慢很多,所以不带缓冲的流效率很低. 带缓冲的流,可以一次读很多字节,但不向磁盘中写入,只是先放到内存里. 等凑够了缓冲区大小的时候一次性写入磁盘,这种方式可以减少磁盘操作次数,速度就会提高很多! 这就是两者的区别

Java IO输入输出流 笔记

String s = "慕课ABC"; byte[] bytes1 = s.getBytes();//转换成字节序列用的是项目默认的编码 ,编码GBK for(byte b : bytes1) { //把字节(转换成)int以16进制的方式显示, 只显示后8位 System.out.println(Integer.toHexString(b & 0xff) + " "); } //gbk编码中文占用两个字节,英文占用1个字节 //utf-8编码中文占用3个字

Java基础——输入/输出（二）

一.字节流与字符流 1.1 InputStream和Reader InputStream是抽象类,本身并不能创建实例来执行输入,它里面包含如下几个方法: 1.Int read():从输入流中读取单个字节,返回所读取的字节数据. 2.int read(byte[] b):从输入流中最多读取b.length个字节的数据,并将其存储在字节数组b中,返回实际读取的字节数. 3.int read(byte[] b,int off,int len):从输入流中最多读取len个字节的数据,并将其存储在数组b中

Java IO输入/输出流的套接

缓冲字符流BufferedInputStream / BufferedOutputStream 文件操作流 InputStream / OutputStream java 输入输出流的套接,测试一下流链的速度 因为节点流在程序中并不是很常用,一般常通过过滤流将多个流套接在一起,利用各流的特性共同处理数据,套接的多个流构成了一个流链: 我们来分析他们的运行时间.(因为在不同的系统(maxOX,Linux,WIN(32/64))上运行的时间可能都不相同)我截取了几段时间来进行对比. 1.缓冲字符流B

java io 输入输出流

数据流分类:流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据.因此Java中的流分为两种: 1) 字节流:数据流中最小的数据单元是字节 2) 字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节. http://blog.csdn.net/hguisu/article/details/7418161

Java IO输入输出流 FileWriter 字符流

字节缓冲流 //为什么要使用包装流,使用包装流是为了提高读写操作的性能. public class Packing_flowDemo { public static void main(String[] args) throws Exception { File file = new File("file/packing_flow.txt"); //包装流的写法,缓冲区内存大小.1024*8=8192 (byte) // BufferedOutputStream packing = n