Java中IO流,输入输出流概述与总结

简介: 总结的很粗糙,以后时间富裕了好好修改一下。 1:Java语言定义了许多类专门负责各种方式的输入或者输出,这些类都被放在java.io包中。其中, 所有输入流类都是抽象类InputStream(字节输入流),或者抽象类Reader(字符输入流)的子类; 而所有输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。 【首先需要明白的是:流是干什么的??
总结的很粗糙,以后时间富裕了好好修改一下。

1:Java语言定义了许多类专门负责各种方式的输入或者输出,这些类都被放在java.io包中。其中,

所有输入流类都是抽象类InputStream(字节输入流),或者抽象类Reader(字符输入流)的子类

而所有输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。

【首先需要明白的是:流是干什么的???(为了永久性的保存数据)

  根据数据流向的不同分为输入流和输出流;

  根据处理数据类型的不同分为字符流和字节流;

【然后需要明白的是输入模式和输出模式是谁流向谁:

InputStream(字节输入流)和Reader(字符输入流)通俗的理解都是读(read)的。

OutputStream(字节输出流)和Writer(字符输出流)通俗的理解都是写(writer)的。

最后下面搞清楚各种流的类型的该怎么用,谁包含谁,理清思路。

2:InputStream类是字节输入流的抽象类,是所有字节输入流的父类,InputStream类具有层次结构如下图所示;

 

3:java中的字符是Unicode编码的,是双字节的。InputStream是用来处理字节的,在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类,所有字符输入流的实现都是它的子类。

4:输出流OutputStream类是字节输入流的抽象类,此抽象类表示输出字节流的所有类的超类。

5:Writer类是字符输出流的抽象类,所有字符输出类的实现都是它的子类。

6:File类是IO包中唯一代表磁盘文件本身的对象。通过File来创建,删除,重命名文件。File类对象的主要作用就是用来获取文本本身的一些信息。如文本的所在的目录,文件的长度,读写权限等等。(有的需要记忆,比如isFile(),isDirectory(),exits();有的了解即可。使用的时候查看API)

详细如下:
File类(File类的概述和构造方法)
A:File类的概述
  File更应该叫做一个路径
  文件路径或者文件夹路径
  路径分为绝对路径和相对路径
    绝对路径是一个固定的路径,从盘符开始
    相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下
  查看API指的是当前路径
  文件和目录路径名的抽象表示形式
B:构造方法
  File(String pathname):根据一个路径得到File对象
  File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
 
File类(File类的创建功能)
  A:创建功能
    public boolean createNewFile():创建文件 如果存在这样的文件,就不创建了
    public boolean mkdir():创建文件夹 如果存在这样的文件夹,就不创建了
    public boolean mkdirs():创建文件夹,如果父文件夹不存在,会帮你创建出来
(使用createNewFile()文件创建的时候不加.txt或者其他后缀也是文件,不是文件夹;使用mkdir()创建文件夹的时候,如果起的名字是比如aaa.txt也是文件夹不是文件;)
注意事项:
如果你创建文件或者文件夹忘了写盘符路径,那么,默认在项目路径下。
 
File类(File类的重命名和删除功能)
  A:重命名和删除功能
    public boolean renameTo(File dest):把文件重命名为指定的文件路径
    public boolean delete():删除文件或者文件夹
  B:重命名注意事项
    如果路径名相同,就是改名。
    如果路径名不同,就是改名并剪切。
  C:删除注意事项:
    Java中的删除不走回收站。
    要删除一个文件夹,请注意该文件夹内不能包含文件或者文件夹
 
File类(File类的判断功能)
  A:判断功能
    public boolean isDirectory():判断是否是目录
    public boolean isFile():判断是否是文件
    public boolean exists():判断是否存在
    public boolean canRead():判断是否可读
    public boolean canWrite():判断是否可写
    public boolean isHidden():判断是否隐藏

 

File类(File类的获取功能)
  A:获取功能
    public String getAbsolutePath():获取绝对路径
    public String getPath():获取路径
    public String getName():获取名称
    public long length():获取长度。字节数
    public long lastModified():获取最后一次的修改时间,毫秒值
    public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
    public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
 
File类(文件名称过滤器的概述及使用)
  A:文件名称过滤器的概述
    public String[] list(FilenameFilter filter)
    public File[] listFiles(FileFilter filter)
 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 
 5 public class Test {
 6 
 7     public static void main(String[] args) throws Exception{
 8         // TODO Auto-generated method stub
 9         File file=new File("aa.txt");//文件默认就创建在你创建的项目下面,刷新即可看到
10         System.out.println(file.exists());//判断文件是否存在
11         file.createNewFile();//创建文件,不是文件夹
12         System.out.println(file.exists());//再次判断是否存在
13         System.out.println(file.getName());//获取文件的名字
14         System.out.println(file.getAbsolutePath());//获取文件的绝对路径
15         System.out.println(file.getPath());//获取文件的相对路径
16         System.out.println(file.getParent());//获取文件的父路径
17         System.out.println(file.canRead());//文件是否可读
18         System.out.println(file.canWrite());//文件是否可写
19         System.out.println(file.length());//文件的长度
20         System.out.println(file.lastModified());//文件最后一次修改的时间
21         System.out.println(file.isDirectory());//判断文件是否是一个目录
22         System.out.println(file.isHidden());//文件是否隐藏
23         System.out.println(file.isFile());//判断文件是否存在
24     }
25 
26 }

  public String[] list():获取指定目录下的所有文件或者文件夹的名称数组

  public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

 

list()获取某个目录下所有的文件或者文件夹:

 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 
 5 public class FileTest {
 6 
 7     public static void main(String[] args){
 8         File file=new File("D:/");//指定文件目录
 9         String[] str=file.list();//获取指定目录下的所有文件或者文件夹的名称数组
10         for(String s : str){//加强for循环遍历输出
11             System.out.println(s);
12         }
13         
14     }
15 }
 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 
 5 public class FileTest {
 6 
 7     public static void main(String[] args){
 8         File file=new File("D:/");//指定文件路径
 9         File[] f=file.listFiles();//获取指定目录下的所有文件或者文件夹的File数组
10         for(File fi : f){//加强for循环遍历输出
11             System.out.println(fi);
12         }
13         
14     }
15 }

案例演示:

获取某种格式的文件比如获取某种后缀的图片,并输出文件名:

 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 
 5 public class FileTest {
 6 
 7     public static void main(String[] args){
 8         File file=new File("C:\\Users\\biehongli\\Pictures\\xuniji");
 9         String[] str=file.list();
10         
11         for(String s : str){
12             if(s.endsWith(".jpg") || s.endsWith(".png")){//如果后缀是这种格式的就输出
13                 System.out.println(s);
14             }
15         }
16         
17         
18     }
19 }

下面演示获取文件夹下面子目录里面的文件获取(并没有完全获取子目录的子目录等等,仅仅获取了子一级目录):

 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 
 5 public class FileTest {
 6 
 7     public static void main(String[] args){
 8         File file=new File("C:\\Users\\biehongli\\Pictures\\Camera Roll");
 9         
10         File[] f=file.listFiles();
11         
12         for(File fi : f){
13             if(fi.isDirectory()){//判断如果是一个目录
14                 String[] s=fi.list();
15                 for(String str : s){
16                     if(str.endsWith(".jpg")){
17                         System.out.println(str);
18                     }
19                 }
20             }
21         }
22     }
23 }

A:文件名称过滤器的概述

    public String[] list(FilenameFilter filter)
    public File[] listFiles(FileFilter filter)
 1 package com.ningmeng;
 2 
 3 import java.io.File;
 4 import java.io.FilenameFilter;
 5 
 6 public class FileTest {
 7 
 8     public static void main(String[] args){
 9         File file=new File("C:\\Users\\biehongli\\Pictures\\Camera Roll");
10         
11         String[] str=file.list(new FilenameFilter() {//过滤器,匿名内部类
12             
13             @Override
14             public boolean accept(File dir, String name) {
15                 // TODO Auto-generated method stub
16                 //System.out.println(dir);//获取文件的路径
17                 //System.out.println(name);//获取文件的名字
18                 File f=new File(dir,name);
19                 return f.isFile() && f.getName().endsWith(".jpg");
20             }
21         });
22         for(String s : str){
23             System.out.println(s);
24         }
25         
26     }
27 }

7:下面以一些字节输入输出流具体的案例操作(操作的时候认清自己使用的是字节流还是字符流):

注意:read()方法读取的是一个字节,为什么返回是int,而不是byte
字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111;那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上;24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型

FileInputStream的单个字节读取:

FileOutputStream的单个字节写入:

 1 package com.ningmeng;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 
 6 public class FileTest {
 7 
 8     public static void main(String[] args) throws Exception{
 9         FileInputStream fis=new FileInputStream("aaa.txt");
10         FileOutputStream fos=new FileOutputStream("bbb.txt",true);
11         //FileOutputStream()后面加true指文件后面可追加
12         
13         int a=fis.read();//read()一次读取一个字节
14         System.out.println(a);//读取的一个字节输出
15         
16         fos.write(101);//write()一次写一个字节
17         fis.close();//一定记得关闭流,养成好习惯
18         fos.close();
19     }
20 }

FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲:

 1 package com.ningmeng;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 
 6 public class FileTest {
 7 
 8     public static void main(String[] args) throws Exception{
 9         FileInputStream fis=new FileInputStream("aaa.txt");
10         FileOutputStream fos=new FileOutputStream("bbb.txt");
11         //如果没有bbb.txt,会创建出一个
12         
13         int b;
14         while((b=fis.read())!=-1){
15             fos.write(b);
16         }
17         fis.close();
18         fos.close();
19     }
20 }

FileInputStream和FileOutputStream定义小数组进行读写操作:

 1 package com.ningmeng;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 
 6 public class FileTest {
 7 
 8     public static void main(String[] args) throws Exception{
 9         FileInputStream fis = new FileInputStream("aaa.txt");
10         FileOutputStream fos = new FileOutputStream("bbb.txt");
11         int len;
12         byte[] arr = new byte[1024 * 8];//自定义字节数组
13         
14         while((len = fis.read(arr)) != -1) {
15             //fos.write(arr);
16             fos.write(arr, 0, len);//写出字节数组写出有效个字节个数
17         }
18         //IO流(定义小数组)
19         //write(byte[] b)
20         //write(byte[] b, int off, int len)写出有效的字节个数
21 
22         fis.close();
23         fos.close();
24     }
25 }

 IO流(BufferedInputStream和BufferOutputStream拷贝)

* A:缓冲思想
  * 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多,
  * 这是加入了数组这样的缓冲区效果,java本身在设计的时候,
  * 也考虑到了这样的设计思想,所以提供了字节缓冲区流
* B.BufferedInputStream
  * BufferedInputStream内置了一个缓冲区(数组)
  * 从BufferedInputStream中读取一个字节时
  * BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
  * 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
  * 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
* C.BufferedOutputStream
  * BufferedOutputStream也内置了一个缓冲区(数组)
  * 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
  * 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里
 1 package com.ningmeng;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileOutputStream;
 7 
 8 public class FileTest {
 9 
10     public static void main(String[] args) throws Exception{
11         FileInputStream fis = new FileInputStream("aaa.txt");
12         FileOutputStream fos = new FileOutputStream("bbb.txt");
13         
14         BufferedInputStream bis=new BufferedInputStream(fis);
15         //使用装饰模式,把fis装饰进去bis中。使用缓冲读取速度变快
16         BufferedOutputStream bos=new BufferedOutputStream(fos);
17         
18         int b;
19         while((b=bis.read())!=-1){
20             bos.write(b);
21         }
22         bis.close();
23         bos.close();
24     }
25 }

 面试题小数组的读写和带Buffered的读取哪个更快?

  * 定义小数组如果是8192个字节大小和Buffered比较的话
  * 定义小数组会略胜一筹,因为读和写操作的是同一个数组
  * 而Buffered操作的是两个数组
IO流(flush和close方法的区别)
flush()方法: 用来刷新缓冲区的,刷新后可以再次写出(字节缓冲流内置缓冲区,如果没有读取出来,可以使用flush()刷新来)
close()方法:用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
8:字符流FileReader和FileWriter
字符流是什么
  * 字符流是可以直接读写字符的IO流
  * 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.    
IO流(什么情况下使用字符流)
* 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
* 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
* 读取的时候是按照字符的大小读取的,不会出现半个中文
* 写出的时候可以直接将字符串写出,不用转换为字节数组
 
IO流(字符流是否可以拷贝非纯文本的文件)
* 不可以拷贝非纯文本的文件
* 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
* 如果是?,直接写出,这样写出之后的文件就乱了,看不了了
 1 package com.ningmeng;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 
 6 public class FileTest {
 7 
 8     public static void main(String[] args) throws Exception{
 9         //FileReader类的read()方法可以按照字符大小读取
10         FileReader fr=new FileReader("aaa.txt");
11         int b;
12         while((b=fr.read())!=-1){
13             System.out.println((char)b);//int类型转为字符型
14         }
15         fr.close();
16         
17         //FileWriter类的write()方法可以自动把字符转为字节写出
18         FileWriter fw = new FileWriter("aaa.txt",true);
19         fw.write("aaa");
20         fw.close();
21         
22         //字符流的拷贝
23         FileReader fr2 = new FileReader("aaa.txt");
24         FileWriter fw2 = new FileWriter("bbb.txt");
25         
26         int ch;
27         while((ch = fr2.read()) != -1) {
28             fw2.write(ch);
29         }
30 
31         fr2.close();
32         fw2.close();
33     }
34 }
 1 package com.ningmeng;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 
 8 public class FileTest {
 9 
10     public static void main(String[] args) throws Exception{
11         BufferedReader br=new BufferedReader(new FileReader("aaa.txt"));
12         BufferedWriter bw=new BufferedWriter(new FileWriter("bbb.txt"));
13         //BufferedReader和BufferedWriter的使用:
14         int b;
15         while((b=br.read())!=-1){
16             bw.write((char)b);
17         }
18         br.close();
19         bw.close();
20     }
21 }

 先写到这里吧,内容比较多,以后有时间再总结,也方便自己脑补                                         

目录
相关文章
|
2月前
|
存储 缓存 Java
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
这篇文章详细介绍了Java中的IO流,包括字符与字节的概念、编码格式、File类的使用、IO流的分类和原理,以及通过代码示例展示了各种流的应用,如节点流、处理流、缓存流、转换流、对象流和随机访问文件流。同时,还探讨了IDEA中设置项目编码格式的方法,以及如何处理序列化和反序列化问题。
83 1
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
|
2月前
|
Java 数据处理 开发者
揭秘Java IO流:字节流与字符流的神秘面纱!
揭秘Java IO流:字节流与字符流的神秘面纱!
38 1
|
2月前
|
自然语言处理 Java 数据处理
Java IO流全解析:字节流和字符流的区别与联系!
Java IO流全解析:字节流和字符流的区别与联系!
89 1
|
2月前
|
Java
Java 中 IO 流的分类详解
【10月更文挑战第10天】不同类型的 IO 流具有不同的特点和适用场景,我们可以根据具体的需求选择合适的流来进行数据的输入和输出操作。在实际应用中,还可以通过组合使用多种流来实现更复杂的功能。
52 0
|
3月前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流(Stream)、文件(File)和输入/输出(I/O)是处理数据的关键概念。`File`类用于基本文件操作,如创建、删除和检查文件;流则提供了数据读写的抽象机制,适用于文件、内存和网络等多种数据源;I/O涵盖更广泛的输入输出操作,包括文件I/O、网络通信等,并支持异常处理和缓冲等功能。实际开发中,这三者常结合使用,以实现高效的数据处理。例如,`File`用于管理文件路径,`Stream`用于读写数据,I/O则处理复杂的输入输出需求。
|
2月前
|
存储 Java 程序员
【Java】文件IO
【Java】文件IO
38 0
|
3月前
|
安全 Java API
Java 18 概述:新特性一览
Java 18 作为 Java 平台的最新版本,引入了多项令人振奋的新特性和改进,包括模式匹配、记录类型、流库改进、外部函数与内存 API 以及并发处理增强。这些新功能不仅提升了开发者的生产力,还显著增强了 Java 的性能和安全性。本文将详细介绍 Java 18 的主要新特性,并通过代码示例帮助读者更好地理解和应用这些功能。
|
3月前
|
数据采集 Java 数据挖掘
Java IO异常处理:在Web爬虫开发中的实践
Java IO异常处理:在Web爬虫开发中的实践
|
4月前
|
NoSQL Java Redis
【Azure Spring Cloud】Java Spring Cloud 应用部署到Azure上后,发现大量的 java.lang.NullPointerException: null at io.lettuce.core.protocol.CommandHandler.writeSingleCommand(CommandHandler.java:426) at ... 异常
【Azure Spring Cloud】Java Spring Cloud 应用部署到Azure上后,发现大量的 java.lang.NullPointerException: null at io.lettuce.core.protocol.CommandHandler.writeSingleCommand(CommandHandler.java:426) at ... 异常