Java入门系列-22-IO流

简介:

File类的使用

Java程序如何访问文件?通过 java.io.File 类

使用File类需要先创建文件对象 File file=new File(String pathname);,创建时在构造函数中指定物理文件或目录,然后通过文件对象的方法操作文件或目录的属性。

\ 是特殊字符,要使用需要转义 \\

File 类常用方法

方法名称 说明
boolean exists() 判断文件或目录是否存在
boolean isFile() 判断是否是文件
boolean isDirectory() 判断是否是目录
String getPath() 返回此对象表示的文件的相对路径名
String getAbsolutePath() 返回此对象表示的文件的绝对路径
String getName() 返回此对象指定的文件或目录
boolean createNewFile() 创建名称的空文件,不创建文件夹
long length() 返回文件的长度,单位为字节,文件不存在则返回0L
File[] listFiles() 返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。
static File[] listRoots() 列出可用文件系统根
boolean mkdirs() 创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。

使用示例:

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

public class TestFile {

    public static void main(String[] args) {
        //创建File对象 传入文件的路径
        File file=new File("D:\\a.txt");
        //创建File对象 传入文件夹的路径
        File dir=new File("D:/word");
        //判断是否存在
        if(file.exists()) {
            if(file.isFile()) {
                //getName()获取名字
                System.out.println(file.getName()+" 是文件");
            }else if(file.isDirectory()){
                System.out.println(file.getName()+" 是目录");
            }            
        }else {
            System.out.println(file.getName()+" 不存在!");
            try {
                //创建文件
                file.createNewFile();
                System.out.println("文件大小:"+file.length()+" 字节");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(dir.exists()) {
            if(dir.isFile()) {
                System.out.println(dir.getName()+" 是文件");
            }else if(dir.isDirectory()) {
                System.out.println(dir.getName()+" 是文件夹");
                //绝对路径
                System.out.println(dir.getAbsolutePath());
            }            
        }else {
            System.out.println(dir.getName()+" 不存在!");
            //创建目录
            dir.mkdirs();
        }
        
    }
}

:指一连串流动的字符,是以先进先出方式发送信息的通道

输入流:源数据流向程序(读)

输入流:程序中的数据流向目标数据源(写)

Java流的分类

按流向

  • 输出流(OutputStream和Writer作为基类)
  • 输入流(InputStream和Reader作为基类)

输入输出流是相对于计算机内存来说的

按照处理数据单元划分

  • 字节流

    • 字节输入流(InputStream基类)
    • 字节输出流(OutputStream基类)
  • 字符流

    • 字符输入流(Reader基类)
    • 字符输出流(Writer基类)

字节流是8位(1B)通用字节流,字符流是16位(2B)Unicode字符流

字节流

FileInputStream 是 InputStream 的子类

InputStream 类常用方法

方法名称 说明
int read() 从输入流中读取数据的下一个字节。返回0到255的int值,如果到达流的末尾,则返回-1
int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。返回读入缓冲区的总字节数,如果达到末尾则返回-1
int read(byte[] b,int off,int len) 将输入流中最多 len 个数据字节读入 byte数组
void close() 关闭此输入流并释放与该流关联的所有系统资源
int available() 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取的估计字节数

FileInputStream 类常用构造方法

名称 说明
FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定。

使用 FileInputStream 读取文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestFileInputStream {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("D:\\a.txt");
            //读取结果存入StringBuffer
            StringBuffer sb=new StringBuffer();
            System.out.println("预计读取:"+fis.available()+"字节");
            //记录每次读取的长度
            int len=0;
            //缓冲区字节数组
            byte[] buff=new byte[1024];
            while((len=fis.read(buff))!=-1) {
                System.out.println("还剩余:"+fis.available()+"字节");
                sb.append(new String(buff,0,len));
            }
            System.out.println("结果:");
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream 是 OutputStream 的子类

OutputStream 类常用方法

方法名称 说明
void write(int c) 将制定的字节写入此输出流
void write(byte[] buf) 将 b.length 个字节从指定的 byte 数组写入此输入流
void write(byte[] b,int off,int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void close() 关闭此输出流并释放与此流有关的所有系统资源

FileOutputStream的构造方法

名称 说明
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name,boolean append) 第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处

使用 FileOutputStream 写文件

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileOutputStream {

    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            //创建输出流对象
            fos=new FileOutputStream("D:\\c.txt");
            //要输出的字符
            String str="hello world 你好";
            //将字符串转成字节数组并写入到流中
            fos.write(str.getBytes());
            //刷新流
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字符流

上面的内容我们看到,字节流不能直接操作字符,所以操作字符用字符流。

FileReader 是 Reader 的子类

Reader 类常用方法

方法名称 说明
int read() 读取单个字符
int read(char[] c) 将字符读入数组
read(char[] c,int off,int len) 将字符读入数组的某一部分
void close() 关闭该流并释放与之关联的所有资源

使用 FileReader 读取文本文件

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

public class TestReader {

    public static void main(String[] args) {
        Reader r=null;
        try {
            //创建FileReader对象
            r=new FileReader("D:\\a.txt");
            //字符缓冲数组
            char[] chrs=new char[512];
            //记录每次读取的个数
            int len=0;
            //循环读取
            while((len=r.read(chrs))!=-1) {
                String str=new String(chrs, 0, len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (r!=null) {
                try {
                    r.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter 是 Writer 的子类

Writer 类常用方法

方法名称 说明
write(String str) 写入字符串
write(String str,int off,int len) 写入字符串的某一部分
void close() 关闭此流,但要先刷新它
void flush 刷新该流的缓冲

使用 FileWriter 写入文本文件

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

public class TestWriter {

    public static void main(String[] args) {
        Writer w=null;
        try {
            //创建字符输出流
            w=new FileWriter("D:\\msg.txt");
            String msg="hello every bady 兄嘚";
            //将字符串写入到流中
            w.write(msg);
            w.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (w!=null) {
                try {
                    w.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

缓冲字符流

如果频繁的对字符进行读写操作,墙裂建议使用缓冲!

BufferedReader 类带有缓冲区,可以先把一批数据读到缓冲区,接下来的读操作都是从缓冲区内获取数据,避免每次都从数据源读取数据进行字符编码转换,从而提高读取操作的效率。

使用BufferedReader读取文本文件

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestBufferedReader {

    public static void main(String[] args) {
        FileReader reader=null;
        BufferedReader br=null;
        try {
            //创建字符读入流
            reader=new FileReader("D:\\a.txt");
            //将字符读入流包装成字符缓冲流
            br=new BufferedReader(reader);
            //记录每行读入的内容
            String line=null;
            //用于拼接保存每行读入的内容
            StringBuffer content=new StringBuffer();
            while ((line=br.readLine())!=null) {
                content.append(line+"\n");
            }
            System.out.println("所有内容:");
            System.out.println(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (reader!=null) {
                    reader.close();
                }
                if (br!=null) {
                    br.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedReader 是 Reader 的子类,带有缓冲区,特有方法 readLine() 按行读取内容

BufferedWriter 类带有缓冲区,与BufferedReader的方向正好相反,BufferedWriter 是把一批数据写到缓冲区,当缓冲区满的时候,再把缓冲区的数据写到字符输出流中。避免每次都执行物理写操作,提高写操作的效率。

使用 BufferedWriter 写文件

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

public class TestBufferedWriter {

    public static void main(String[] args) {
        FileWriter writer=null;
        BufferedWriter bw=null;
        try {
            writer=new FileWriter("D:\\out.txt");
            bw=new BufferedWriter(writer);
            bw.write("hello");
            //内容换行
            bw.newLine();
            bw.write("world");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bw!=null) {
                    bw.close();
                }
                if (writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关闭流的顺序与创建流的顺序相反

数据流

DataInputStream 类

  • FileInputStream 的子类
  • 与 FileInputStream 类结合使用读取二进制文件

DataOutputStream 类

  • FileOutputStream 的子类
  • 与 FileOutputStream 类结合使用写二进制文件

使用数据流复制图片

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy {

    public static void main(String[] args) {
        //文件输入流
        FileInputStream fis=null;
        //数据输入流(包装fis得到)
        DataInputStream dis=null;
        //文件输出流
        FileOutputStream fos=null;
        //数据输出流(包装fos得到)
        DataOutputStream dos=null;
        
        try {
            fis=new FileInputStream("D:\\a.jpg");
            dis=new DataInputStream(fis);
            fos=new FileOutputStream("F:\\b.jpg");
            dos=new DataOutputStream(fos);
            //缓冲数组
            byte[] buff=new byte[1024];
            //记录每次读取的字节个数
            int len=0;
            //循环读入
            while((len=dis.read(buff))!=-1) {
                //循环写入len个字节
                dos.write(buff,0,len);
            }
            System.out.println("完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (dis!=null) {
                    dis.close();
                }
                if (dos!=null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
相关文章
|
2月前
|
存储 安全 Java
从入门到精通:Java Map全攻略,一篇文章就够了!
【10月更文挑战第17天】本文详细介绍了Java编程中Map的使用,涵盖Map的基本概念、创建、访问与修改、遍历方法、常用实现类(如HashMap、TreeMap、LinkedHashMap)及其特点,以及Map在多线程环境下的并发处理和性能优化技巧,适合初学者和进阶者学习。
52 3
|
14天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
20天前
|
Java 大数据 API
14天Java基础学习——第1天:Java入门和环境搭建
本文介绍了Java的基础知识,包括Java的简介、历史和应用领域。详细讲解了如何安装JDK并配置环境变量,以及如何使用IntelliJ IDEA创建和运行Java项目。通过示例代码“HelloWorld.java”,展示了从编写到运行的全过程。适合初学者快速入门Java编程。
|
26天前
|
存储 安全 Java
🌟Java零基础-反序列化:从入门到精通
【10月更文挑战第21天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
66 5
|
23天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
32 1
|
1月前
|
Java 数据处理 开发者
Java多线程编程的艺术:从入门到精通####
【10月更文挑战第21天】 本文将深入探讨Java多线程编程的核心概念,通过生动实例和实用技巧,引导读者从基础认知迈向高效并发编程的殿堂。我们将一起揭开线程管理的神秘面纱,掌握同步机制的精髓,并学习如何在实际项目中灵活运用这些知识,以提升应用性能与响应速度。 ####
45 3
|
2月前
|
Java
Java中的多线程编程:从入门到精通
本文将带你深入了解Java中的多线程编程。我们将从基础概念开始,逐步深入探讨线程的创建、启动、同步和通信等关键知识点。通过阅读本文,你将能够掌握Java多线程编程的基本技能,为进一步学习和应用打下坚实的基础。
|
2月前
|
存储 安全 Java
从入门到精通:Java Map全攻略,一篇文章就够了!
【10月更文挑战第19天】本文介绍了Java编程中重要的数据结构——Map,通过问答形式讲解了Map的基本概念、创建、访问与修改、遍历方法、常用实现类(如HashMap、TreeMap、LinkedHashMap)及其特点,以及Map在多线程环境下的使用和性能优化技巧,适合初学者和进阶者学习。
49 4
|
2月前
|
Java
[Java]Socket套接字(网络编程入门)
本文介绍了基于Java Socket实现的一对一和多对多聊天模式。一对一模式通过Server和Client类实现简单的消息收发;多对多模式则通过Server类维护客户端集合,并使用多线程实现实时消息广播。文章旨在帮助读者理解Socket的基本原理和应用。
23 1
|
2月前
|
SQL IDE Java
入门Cloud Toolkit:简化你的Java应用开发与部署流程
【10月更文挑战第19天】作为一名长期从事Java开发的程序员,我一直致力于寻找能够简化日常开发工作的工具。在众多工具中,阿里巴巴推出的Cloud Toolkit引起了我的注意。这款免费的插件旨在帮助开发者更轻松地进行开发、测试及部署工作,尤其是在与云服务交互时表现尤为出色。本文将从个人的角度出发,介绍Cloud Toolkit的基本功能及其使用技巧,希望能帮助初学者快速上手这款实用工具。
24 1

热门文章

最新文章

下一篇
无影云桌面