Java之IO流

最新推荐文章于 2024-05-08 20:00:46 发布
最新推荐文章于 2024-05-08 20:00:46 发布
阅读量606 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43896141/article/details/108516295
版权

目录

IO流

FILE类

FILE类的一个对象代表一个文件或者一个文件目录

路径分隔符

  • 路径中的每级目录之间用一个路径分隔符隔开
  • 路径分隔符和系统有关：
    • windows和DOS系统默认使用’\’
    • UNIX和URL使用’/’
  • Java支持跨平台运行，因此路径分隔符要慎用
  • 为了解决这个隐患，File类提供了一个常量File.seperator

构造器

@Test
public void test1()
{
    // 构造器1
    File file = new File("Hello.txt");
    File file2 = new File("e:\\STUDY\\java");
    // which equals to
    File file3 = new File("e:"+File.separator+"STUDY"+File.separator+"java");
    
    File file4 = new File("e:\\STUDY\\java","day01.md");
    System.out.println(file4);
	
    File file5 = new File(file3,"day01.md");
    System.out.println(file5);
	
    //e:\STUDY\java\day01.md
    //e:\STUDY\java\day01.md
}

常用功能

获取相关信息
@Test
public void test2()
{
    File file = new File("hello.txt");
    System.out.println(file.getAbsoluteFile());
    System.out.println(file.getPath());
    System.out.println(file.getName());
    System.out.println(file.getParent());
    System.out.println(file.length());
    System.out.println(new Date(file.lastModified()));
//E:\Java\code\JavaSE\senior_java\hello.txt
//hello.txt
//hello.txt
//null 		-- 	只有构造器中是绝对路径的才能看到父目录
//11 		-- 	文件中的字节长度
//Wed Sep 09 15:30:11 CST 2020	--	返回时间戳
}
对文件夹的操作
@Test
public void test3()
{
    File file = new File("E:\\BUPT\\java");
    String[] list = file.list();
    for(String str : list)
    {
        System.out.println(str);
    }
    File[] files = file.listFiles();
    for (File f : files)
    {
        System.out.println(f);
    }
//        day1.md
//        day2.md
//        ...
//        E:\BUPT\java\day1.md
//        E:\BUPT\java\day2.md
//        ...
}
重命名

boolean file1.ranameTo(file2)

注意：file1必须在硬盘中存在，file2必须在硬盘中不存在，否则操作失败，返回false

@Test
public void test4()
{
    File file1 = new File("hello.txt");
    File file2 = new File("hi.txt");
    boolean b = file2.renameTo(file1);
    System.out.println(b);
    // true if hello.txt exists and hi.txt not
}
判断相关信息
  • public boolean isDirectory()：判断是否是目录
  • public boolean isFile()：判断是否是文件
  • public boolean exists()：判断是否存在
  • public boolean canRead()：判断是否可读
  • public boolean canWrite()：判断是否可写
创建、删除功能
  • public boolean createNewFile()：创建新的文件，如果文件存在则不创建，返回false
  • public boolean mkdir()：创建文件目录，如果目录存在则不创建，如果上层目录不存在也不创建
  • public boolean mkdirs()：创建文件目录，如果上层文件不存在一并创建
  • public boolean delete()：删除文件或文件夹。注意：Java删除不走回收站！

IO流原理及流的分类

IO是Input/Output的缩写，用于处理设备之间的数据传输。Java中数据的输入输出以流的方式进行。java.io包下提供了各种 流类和接口，并通过标准的方法输入或输出数据。

流的分类

  • 操作数据单位不同分为：字节流(8bit)，字符流(16bit)
  • 数据量的流向不同分为：输入流、输出流
  • 按流的角色的不同分为：节点流、处理流
抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

在这里插入图片描述

深色是比较重要的。主要学习访问文件的四个流，具体的操作方法每个流都差不多，剩下的学习功能即可。

文件流

FileReader

首先注意的几点：

  • IO流这些物理上的流JVM无法自行关闭，必须手动关闭！
  • read()的理解：返回读入的一个字符，如果达到文件末尾返回-1
  • 异常的处理：如果使用throws，发现错误就会理解创建异常对象然后结束，此时有可能IO流对象还未被关闭，所以需要使用try-catch-finally来关闭IO流而非使用throws
  • 打开的文件一定要存在，不然会报错
public void test() throws IOException {
    FileReader fr = null;
    try {
        File file = new File("hello.txt");
        fr = new FileReader(file);

        int data;
        while((data = fr.read())!=-1)
        {
            System.out.print((char)data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fr != null)
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}

重载read()方法——一次读多个字符

public void test2() {
    FileReader fr = null;
    try {
        // 1. File类的初始化
        File file = new File("hello.txt");
        // 2. io流类的初始化
        fr = new FileReader(file);
        // 3. 读文件操作
        // 这里使用重载的read(char[] buf)
        int len;
        char[] cbuf = new char[5];
        while ((len = fr.read(cbuf)) != -1) {
//            System.out.println("错误的写法1");
//            for (int i = 0; i < cbuf.length; i++)
//                System.out.print(cbuf[i]);
//            // helloworld123ld
//            
//            System.out.println("\n错误的写法2:");
//            String str = new String(cbuf);
//            System.out.print(cbuf);
//            // helloworld123ld
//            
//            System.out.println("\n正确的写法1");
//            for (int i = 0; i < len; i++)
//                System.out.print(cbuf[i]);
//            // helloworld

            System.out.println("\n正确的写法2");
            String str2 = new String(cbuf, 0, len);
            System.out.print(str2);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4. 关闭IO流
        if(fr != null)
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}

FileWriter

注意：

  • 若文件不存在，则创建该文件
  • 若文件存在，会覆盖该文件
  • FileWriter(File file,boolean append)，如果使用该构造器，append为false则覆盖，为true则添加
public void test3(){
    FileWriter fw = null;
    try {
        // 该文件不存在,则会创建文件
        File file = new File("hi.txt");
        fw = new FileWriter(file);

        fw.write("I hava a dream! ");
        fw.write("This is a Test");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileReader和FileWriter实现文件复制

注意：FileReader是字符流形式，不能用于图片、视频的复制，如果想实现后者的复制，必须换成FileOutputStream，FileWriter同理。

结论：对于文本文件(.txt.doc.c.java)用字符流处理，非文本文件用字节流(.jpg.mp4.mp3)处理

@Test
public void test5()
{
    FileReader fr = null;
    FileWriter fw = null;
    try {
        File srcfile = new File("hello.txt");
        File destfile = new File("hello2.txt");

        fr = new FileReader(srcfile);
        fw = new FileWriter(destfile);

        int len;
        char []cbuf = new char[5];
        while((len = fr.read(cbuf))!=-1)
        {
            String str = new String(cbuf,0,len);
            fw.write(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fr!=null)
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        if(fw !=null)
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }

缓冲流（处理流的一种）

缓冲流是为了提高读写效率

注意：

  • 新建缓冲流的前提是新建了一个节点流
  • 关闭处理流时，只用关闭外层流，内层流自动关闭
  • 使用缓冲流的速度远大于节点流（原因：内部提供缓冲区，大小为8092，等到缓冲区填满了再flush出去）
@Test
public void test6() {
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try {
        // 1.造文件
        File f1 = new File("UI1.png");
        File f2 = new File("UI2.png");

        // 2.造流
        // 2.1 造节点流
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);
        // 2.2 造处理流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);

        // 复制
        int len;
        byte[] bytes = new byte[10];
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bos != null) {
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bis != null) {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

转换流

分辨属于什么流看后缀，转换流属于字符流

  • InputStreamReader：将一个字节的输入流转换为字符的输入流
  • OutputStreamWriter：将一个字符的输出流转换为字节的输出流
  • 作用：提供字节流与字符流之间的转换
  • 解码：字节、字节数组 —>字符数组、字符串
  • 编码：字符数组、字符串 —>字节、字节数组

字符集

  • ASCII：美国标准信息交换码，用一个字节的7位可以表示

  • ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位可以表示

  • GB2312：中国的中文编码表，最多两个字节编码所有字符

  • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节

  • Unicode：国际校准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码，所有的文字字符都用两个字节表示

  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符

对象流

序列化机制

允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的Java对象。

对象的序列化

用于存储和读取基本数据类型数据或对象的处理流，可以把Java中的对象写入到数据源中也能还原回来。

  • ObjectInputStream和ObjectOutputStream
  • 序列化：用ObjectInputStream类保存基本类型数据或对象的机制
  • 反序列化：用ObjectOutputStream类读取基本类型数据或对象的机制

static和transient修饰的成员变量不能被序列化

IO流的框架都是一样的，对象流也差不多

自定义类序列化的注意事项：

  • 注意进行序列化的对象所在的类必须要实现Serializable接口，尤其是自定义类
  • 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量private static final long serialVersionUID
  • 如果不显式设置这个ID也可，但是系统会隐式给你一个ID，当你修改了类中的变量之后，ID会改变，可能会造成先前序列化后的文件反序列化回来的结果与原来不一致。所以一般自己显示定义一个常量。
  • 自定义类的所有内部属性必须可序列化。（默认情况下，基本数据类型可序列化）
public class ObjectStreamTest {
    // 序列化
    @Test
    public void test2()
    {
        ObjectOutputStream oos = null;
        try {
            File file = new File("object.dat");
            FileOutputStream fos = new FileOutputStream(file);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(new User(18,"Bill"));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null)
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    // 反序列化
    @Test
    public void test1()
    {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            User user = (User) obj;
            System.out.println(user);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null)
            {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

       System.out.println(user);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if(ois != null)
        {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

}
10_ADDTIPLY
关注
专栏目录
Python语言实现哈夫曼编码
EggWave的博客
12-02 1万+
汉语版：使用python实现huffman编码是一个能够很快地实现。所以我们选择使用python来实现我们这个程序。 l E-version: we will use python to realize this program called huffman encoding and decoding. why we use python, because in python we can fi
怎么用python实现哈夫曼树_Python数据结构之哈夫曼树定义与使用方法示例
weixin_39843431的博客
12-18 181
本文实例讲述了Python数据结构之哈夫曼树定义与使用方法。分享给大家供大家参考，具体如下：HaffMan.py#coding=utf-8#考虑权值的haff曼树查找效率并非最高,但可以用于编码等使用场景下class TreeNode:def __init__(self,data):self.data=dataself.left=Noneself.right=Noneself.parent=Non...
python实现哈夫曼编码生成器
06-08
本人运用Python编写对文本词频统计并生成哈夫曼树，进而进行哈夫曼编码。所生成的编码字典还可以对其他文本进行编码解码。
数据结构和算法——Huffman树和Huffman编码
热门推荐
null的专栏
02-04 5万+
Huffman树是一种特殊结构的二叉树，由Huffman树设计的二进制前缀编码，也称为Huffman编码在通信领域有着广泛的应用。在word2vec模型中，在构建层次Softmax的过程中，也使用到了Huffman树的知识。在通信中，需要将传输的文字转换成二进制的字符串，假设传输的报文为：“AFTERDATAEARAREARTAREA”，现在需要对该报文进行编码。一、Huffman树的基本概念在二叉
haffman树的python实现
bingbingxie1的博客
01-04 305
#节点类 class Node(object): def __init__(self,name=None,value=None): self._name=name self._value=value self._left=None self._right=None #哈夫曼树类 class HuffmanTree(obje...
Java之IO流学习总结.pdf
09-30
在这份《Java之IO流学习总结》文档中，我们可以了解到IO流的不同使用场景和基本的编程操作。 首先，我们来认识IO流中的基本类。在Java中，所有与IO相关的类都位于java.io包中。主要的抽象基类有InputStream、...
java之io流实例
09-28
Java中的IO流是Java语言处理输入输出操作的重要组成部分，它为数据传输提供了强大的支持。本文将深入探讨Java的IO流实例应用，旨在帮助开发者更好地理解和掌握这一关键概念。 IO流在Java中分为两大类：字符流...
Python算法设计 - 哈夫曼编码
小鸿的博客
04-22 1742
Python算法设计 - 哈夫曼编码
数据结构与算法--哈夫曼树/赫夫曼树 Python实现哈夫曼树 Python实现赫夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
storyfull
01-02 3250
哈夫曼树/赫夫曼树 Python实现赫夫曼树 Python实现哈夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
【贪心算法】哈夫曼编码Python实现
最新发布
丷从心·的博客
05-08 1920
【贪心算法】哈夫曼编码Python实现
哈夫曼编码python实现
04-26
使用python编写的一套代码，可以实现随机文本生成，字符串字符统计还有哈夫曼编码。可以转换哈夫曼编码到010101，然后解码生成字符串
Python 算法（2） 哈夫曼编码 Huffman Encoding
aini4568的博客
07-27 498
　　这个问题原始是用来实现一个可变长度的编码问题，但可以总结成这样一个问题，假设我们有很多的叶子节点，每个节点都有一个权值w(可以是任何有意义的数值，比如它出现的概率)，我们要用这些叶子节点构造一棵树，那么每个叶子节点就有一个深度d，我们的目标是使得所有叶子节点的权值与深度的乘积之和$$\Sigma w{i}d{i}$$最小。 　　很自然的一个想法就是，对于权值大的叶子节点我们让...
Python实现Huffman编码
tiankongtiankong01的博客
10-13 2165
基于Huffman编码的压缩软件的Python实现 个人分类： 算法 Python 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/xanxus46/article/details/41359841 哈夫曼编码是利用贪心算法进行文本压缩的算法，其算法思想是首先统计文件中各字符出现的次数，保存到数组中，然后将各字符按照次数升序排序，挑选次数最...
贪心算法之Huffman
lengyue815的博客
11-16 188
不断的循环，直到最后的树的集合只剩下一棵，则构建完成，最后输出Huffman编码即可。j++) {//合并一次增加一个节点，所以合并第i次增加i个节点。i++) {//初始化节点。cout
python实现霍夫曼树以及编码
dreaming__star的博客
11-29 4908
python实现霍夫曼树以及编码 再看移动通信的时候了解到了霍夫曼（Huffman）编码，花了一些时间进行了霍夫曼编码的python实现。文章内容包括霍夫曼树的生成，以及相应编码的生成，每一部分都会有完整的代码，个人python3测试无误，可以放心大胆地Ctrl+C哈哈哈 P1 节点的定义类 为节点定义名称，值，左右孩子，二进制编码数字 class Node(object): def __...
哈夫曼树（Python实现）
种花家的兔子
11-29 3560
哈夫曼树 """ 【问题描述】使用贪心算法求解Huffman编码问题，具体来说就是，根据每个字符的出现频率， 构造出字符的最优二进制表示，即前缀码。 在程序开始说明部分，简要描述使用贪心算法求解Huffman编码问题的算法过程。 【输入形式】在屏幕上输入字符个数和每个字符的频率。 【输出形式】每个字符的Huffman编码。 """ import nu...
huffman编码python的实现,[python]Huffman Encoding哈夫曼编码
weixin_31184715的博客
03-19 146
[python]Huffman Encoding哈夫曼编码#Huffman Encoding#Tree-Node Typeclass Node:def __init__(self,freq):self.left = Noneself.right = Noneself.father = Noneself.freq = freqdef isLeft(self):return self.father.l...
赫夫曼树---Java版
Daylight629博客
04-07 158
赫夫曼树 一、基本介绍 给定 n 个权值作为 n 个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为 最优二叉树，也称为哈夫曼树(HuffmanTree), 还有的书翻译为霍夫曼树。 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近 二、赫夫曼树几个重要概念和举例说明 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为 1，则从根结点到第 L 层结点的路径长度为 L-1
python哈夫曼编码注意_哈夫曼编码—贪心算法经典例子
weixin_39855658的博客
11-26 946
哈夫曼编码是一种变长的字符编码方式，常用于对指定的字符集进行数据压缩，压缩率在 20%～90%。1. 问题描述现在有一个包含 5 个字符的字符表 {A,B,C,D,E}，各字符出现的频率统计如表 1 所示。表 1：各字符出现的频率统计字符出现概率字符出现概率字符出现概率A0.35C0.2E0.15B0.1D0.2需要构造一种有效率的编码类型，使用该编码表达以上字符表内容时可以产生平均长度最短的位串...
Java使用IO流实现服务器文件下载
"本文将介绍如何使用Java的IO流实现从服务器下载文件，特别是针对HTTP协议的文件传输。我们将探讨如何设置HTTP连接、指定下载范围以及利用RandomAccessFile类进行文件写入，确保文件下载的正确性和完整性。" 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值