Java IO流之节点流与字符流的相关知识总结

一、file

file是文件和目录路径名的抽象表示

1.1 file的用法

用法：

file file = new file("路径名");

//如
file file = new file("l:\\filetestdemo\\aaa\\aaa.txt");

注意：在windows中，路径名不能使用单个的\，单个的\为转义字符，可以使用\\，//或/

1.2 file的常用方法

1.boolean createnewfile()

当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件。 注意： 不能创建文件夹，只能创建文件

 system.out.println(file.createnewfile());  //true or false表示是否创建成功

2.boolean delete()

删除此抽象路径名表示的文件或目录。

system.out.println(file.delete());

3.boolean exists()

测试此抽象路径名表示的文件或目录是否存在。

if(!file.exists()){
    system.out.println("文件不存在，创建"+ file.createnewfile());
}

4.string getname()

返回此抽象路径名表示的文件或目录的名称。

system.out.println(file.getname());

5.long lastmodified()

返回上次修改此抽象路径名表示的文件的时间。

system.out.println(new simpledateformat().format(new date(file.lastmodified())));

二、io流

file 类：

只能操作文件外部的内容,无法操作文件内部内容的读写

流：
数据以先入先出的顺序进行传输,流就是管道,就是用来 传输数据的

io 流：
java提供了一个io包,提供了很多类,提供了很多功能能够实现数据的读写

2.1 流的概念

数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。 流是一个抽象、动态的概念， 是一连串连续动态的数据集合

2.2 流的分类

按流向可分为输入流(inputstream和reader)和输出流(outputstream和writer)

按操作单元可分为字节流(inputstream 和 outputstream)和字符流(reader 和 writer)

按功能可分为节点流(可以直接从数据源或目的地读写数据)和功能流(是处理流的流。通过对其他流的处理提高程序的性能)

2.3 io操作步骤

在进行任何操作之前，首先要明确目的（读还是写），找准源头（读取），找准目的地（写出）

1.建立联系 ：这一步骤是为了获取流，如果此时是文件，则需要将文件抽象到内存形成对象。后期也 可以是其他的数据源

2.选择流：从读写、数据单元和功能方面考虑。输入|输出，字节|字符，结点流|处理流。

3.执行操作：该读就读，该写就写。考虑是一次性完成还行需要循环。

4.释放资源：程序中打开的文件 io 资源不属于内存中的资源，垃圾回收无法回收，需要显示关闭。

2.4 基本输入流(inputstream和reader)

int read() -> 返回值是这一次读取到的内容（一个字节的值， 一个字符的值）

int read(byte[] car) -> 将读取到的字节临时存储到car数组中， 返回实际读取到的字节数量

int reade(char[] car) -> 将读取到的字符临时存储到car数组中， 返回实际读取到的字符数量

无论以何种方式 read(), read([]) 读取文件， -1,就意味着读取到文件末尾

字符 -> 只能操作文本，直接读取到的就是字符

字节 -> 任意数据， 但是如果操作是字符的话，还需要我们转换（麻烦）

单个字节读取

以inputstream为例，reader同理

public class iotest {
    public static void main(string[] args) throws ioexception {
        //选择流，建立联系
        inputstream is = new fileinputstream("l:\\filetestdemo\\123.txt");

        //无论以何种方式 read(), read([]) 读取文件， -1,就意味着读取到文件末尾 
        //则当result的值为-1时结束
        int result = -1;
        while((result = is.read()) != -1){
            system.out.println((char)result);
        }

        //关闭
        is.close();

    }
}

多个字节读取

public class iotest {
    public static void main(string[] args) throws ioexception {
        //选择流，建立联系
        inputstream is = new fileinputstream("l:\\filetestdemo\\123.txt");

        //定义运输数组
        byte[] car = new byte[1024];
        int len = -1;
        //当result的值为-1时结束
        while ((len = is.read(car)) != -1){
            system.out.println(new string(car,0,len));
        }

        //关闭
        is.close();

    }
}

2.5 基本输出流(outputstream和writer)

以outputstream为例，writer同理

注意：在关闭(close)输出流前需要先清空(flush)缓存区的数据

flush()一般主要用在io中，即清空缓冲区数据，就是说你用读写流的时候，其实数据是先被读到了内存中，然后用数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了 close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()，先清空数据。

单字节写入

public class outputstream01 {

    public static void main(string[] args) throws ioexception {
        选择流，建立联系
        outputstream os = new fileoutputstream("l:\\filetestdemo\\abc.txt",true);
        //写入数据
        os.write('a');

        //刷出流
        os.flush();
        //关闭
        os.close();
    }
}

多字节输入

public class outputstream02 {

    public static void main(string[] args) throws ioexception {
        //构建输出流
        outputstream os = new fileoutputstream("l:\\filetestdemo\\abc.txt");

        //需要写入的数据
        string str = "我好菜啊\n" +
                "就这？\n" +
                "\t\t\t不是吧，阿sir";

        //转为字节数据存入数组
        byte[] arr = str.getbytes();

        //写入数据
        os.write(arr);

        //刷出数据
        os.flush();
        //关闭
        os.close();
    }
}

2.6 输入输出联合使用

以inputstream和outputstream为例

public class in_out {
    public static void main(string[] args){
		//提升作用域范围
        inputstream is = null;
        outputstream os = null;
        try {
            //创建输入流
            is = new fileinputstream("l:\\filetestdemo\\aaa.txt");
            os = new fileoutputstream("l:\\filetestdemo\\abc\\bbb.txt");

            //创建输入数组
            byte[] arr = new byte[1024];

            int len = -1;

            while ((len = is.read(arr)) != -1){
                //write(byte[] b, int off, int len) 将从偏移量 off开始的指定字节数组中的 len字节写入此输出流
                os.write(arr,0,len);
            }

            //刷出
            os.flush();
        } catch (filenotfoundexception e) {
            e.printstacktrace();
        } catch (ioexception e) {
            e.printstacktrace();
        }finally {
            //后打开，先关闭
            //先关闭输出流
            if(os != null){
                try {
                    os.close();
                } catch (ioexception e) {
                    e.printstacktrace();
                }
            }
            //再关闭输入流
            if(is != null){
                try {
                    is.close();
                } catch (ioexception e) {
                    e.printstacktrace();
                }
            }
        }
    }

}

2.7 异常的处理

在使用io流的时候会出现编译时异常，可以使用抛出异常或抓取异常来处理

抛出异常

public class iotest {
    
    public static void main(string[] args) throws ioexception {
        //建立联系可能会遇到找不到文件位置(filenotfoundexception)异常
        //这时候可以抛出(throw)异常
        inputstream is = new fileinputstream("l:\\filetestdemo\\123.txt");
    }
}

抓取异常

public class iotest {
    public static void main(string[] args){
    	//通过try...carch...来抓取异常
        try {
            inputstream is = new fileinputstream("l:\\filetestdemo\\123.txt");
        } catch (filenotfoundexception e) {
            e.printstacktrace();
        }

    }
}

2.8 字节流与字符流的区别

字节流和字符流的区别：

1.每次读写的字节数不同；

2.字符流是块读写，字节流是字节读写；

3.字符流带有缓存，字节流没有。

java流在处理上分为字符流和字节流。字符流处理的单元为2个字节的unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。

字符流和字节流，一个属性范围小，一个属性范围大，字符流只能是字符这一种类型，但是字节流中可以是字符，可以是二进制文件，可以是音频，可以是各种各样的类型，只要符合字节形式存储的都可以接字节流，而字符流只能接字符。

到此这篇关于java io流之节点流与字符流的相关知识总结的文章就介绍到这了,更多相关java节点流与字符流内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！