IO流相关练习

最新推荐文章于 2023-08-09 20:29:31 发布
最新推荐文章于 2023-08-09 20:29:31 发布
阅读量103 收藏
点赞数
分类专栏： JAVA基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35494622/article/details/104142613
版权

【文件切割】
public class SplitFileDemo {

    private static final int SIZE = 1024 * 1024;

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        File file = new File("c:\\aa.mp3");

        splitFile_2(file);
    }

    private static void splitFile_2(File file) throws IOException {

        // 用读取流关联源文件。
        FileInputStream fis = new FileInputStream(file);

        // 定义一个1M的缓冲区。
        byte[] buf = new byte[SIZE];

        // 创建目的。
        FileOutputStream fos = null;

        int len = 0;
        int count = 1;
        
        
        /*
         * 切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数。 以方便于合并。
         * 这个信息为了进行描述，使用键值对的方式。用到了properties对象
         * 
         */
        Properties prop  = new Properties();
        
    

        File dir = new File("c:\\partfiles");
        if (!dir.exists())
            dir.mkdirs();

        while ((len = fis.read(buf)) != -1) {

            fos = new FileOutputStream(new File(dir, (count++) + ".part"));
            fos.write(buf, 0, len);
            fos.close();
        }
        
        //将被切割文件的信息保存到prop集合中。
        prop.setProperty("partcount", count+"");
        prop.setProperty("filename", file.getName());
        
        
        
        fos = new FileOutputStream(new File(dir,count+".properties"));
        
        //将prop集合中的数据存储到文件中。 
        prop.store(fos, "save file info");

        fos.close();
        fis.close();

    }

    public static void splitFile(File file) throws IOException {

        // 用读取流关联源文件。
        FileInputStream fis = new FileInputStream(file);

        // 定义一个1M的缓冲区。
        byte[] buf = new byte[SIZE];

        // 创建目的。
        FileOutputStream fos = null;

        int len = 0;
        int count = 1;

        File dir = new File("c:\\partfiles");
        if (!dir.exists())
            dir.mkdirs();

        while ((len = fis.read(buf)) != -1) {

            fos = new FileOutputStream(new File(dir, (count++) + ".part"));
            fos.write(buf, 0, len);
        }

        fos.close();
        fis.close();

    }

}

【文件合并】

public class MergeFile {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {

        File dir = new File("c:\\partfiles");
        
        mergeFile_2(dir);
    }
    
    public static void mergeFile_2(File dir) throws IOException {
        
        /*
         * 获取指定目录下的配置文件对象。
         */
        File[] files = dir.listFiles(new SuffixFilter(".properties"));
        
        if(files.length!=1)
            throw new RuntimeException(dir+",该目录下没有properties扩展名的文件或者不唯一");
        //记录配置文件对象。
        File confile = files[0];
        
        
        
        //获取该文件中的信息================================================。
        
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream(confile);
        
        prop.load(fis);
        
        String filename = prop.getProperty("filename");        
        int count = Integer.parseInt(prop.getProperty("partcount"));
        
        
        
        
        //获取该目录下的所有碎片文件。 ==============================================
        File[] partFiles = dir.listFiles(new SuffixFilter(".part"));
        
        if(partFiles.length!=(count-1)){
            throw new RuntimeException(" 碎片文件不符合要求，个数不对!应该"+count+"个");
        }
        
        
        
        //将碎片文件和流对象关联 并存储到集合中。 
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=0; x<partFiles.length; x++){
            
            al.add(new FileInputStream(partFiles[x]));
        }
        
        
        
        //将多个流合并成一个序列流。 
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        SequenceInputStream sis = new SequenceInputStream(en);
        
        FileOutputStream fos = new FileOutputStream(new File(dir,filename));
        
        byte[] buf = new byte[1024];
        
        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        
        fos.close();
        sis.close();
        
        
        
        
        
        
    }

    public static void mergeFile(File dir) throws IOException{
        
        
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        
        for(int x=1; x<=3 ;x++){
            al.add(new FileInputStream(new File(dir,x+".part")));
        }
        
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        SequenceInputStream sis = new SequenceInputStream(en);
        
        FileOutputStream fos = new FileOutputStream(new File(dir,"1.bmp"));
        
        byte[] buf = new byte[1024];
        
        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        
        fos.close();
        sis.close();
        
    }

package cn.itcast.io.p1.splitfile;

import java.io.File;
import java.io.FilenameFilter;

public class SuffixFilter implements FilenameFilter {

    private String suffix;
    
    public SuffixFilter(String suffix) {
        super();
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File dir, String name) {

        return name.endsWith(suffix);
    }

}

【对象序列流】

    public static void readObj() throws IOException, ClassNotFoundException {
        //这个是对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化
        ObjectInputStream ois = new ObjectInputStream(newFileInputStream("obj.object"));
        //对象的反序列化。 
        Person p = (Person)ois.readObject();
        
        System.out.println(p.getName()+":"+p.getAge());
        
        ois.close();
        
    }

    public static void writeObj() throws IOException, IOException {
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));
        //对象序列化。  被序列化的对象必须实现Serializable接口。 
        oos.writeObject(new Person("小强",30));
        
        oos.close();
        
        
        
    }

/*
 * Serializable:用于给被序列化的类加入ID号。
 * 用于判断类和对象是否是同一个版本。 
 */
public class Person implements Serializable/*标记接口*/ {

    /**
     * transient:非静态数据不想被序列化可以使用这个关键字修饰。 
     */
    private static final long serialVersionUID = 9527l;
    private transient String name;
    private static int age;
    
    
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    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;
    }
    
}

序列化的作用：用于给序列化的类加入ID号，用于判断类和对象是否是同一版本，如果不是同一个版本会抛出InvalidClassException
比如说，将上个列子的一个成员变量public 给成private  那么在反序列化的时候就会报异常


序列化运行时使用一个称为serialVersionUid的版本号与每个序列化类相关连。
该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化
兼容的类。

serialVersionUid是根据类的特征和数字签名来算的。数字签名：比如说成员的修饰符public是1,private 是2

如果可序列化类未显示式声明serialVersionUID,则可序列时基于该类的各个方面
计算该类的默认serialVersionUID值。不过，强烈建议都显示声明serialVersionUid
原因是在计算默认的serialVersionUid对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，
这样在反序列化过程中可能会导致意外的InvalidClassException。此外，还强烈建议使用private修饰符显示声明serialVersionUID


public class Person implements Serializable/*标记接口*/ {

    /**
     * transient:非静态数据不想被序列化可以使用这个关键字修饰。 
     */
    private static final long serialVersionUID = 9527l;
    private transient String name;
    private static int age;
    
    
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    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;
    }
    
}


transient:非静态数据不想被序列化可以使用这个关键字修饰。


 

我是传奇丶丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java io流练习题_Java IO流经典练习题
weixin_30488835的博客
02-19 2309
本文对javaIO流的13道经典的练习题做解答，里面有详细的思路解析，做题时最好养成先写思路在编程的习惯。一．练习的题目(一)在电脑D盘下创建一个文件为HelloWorld.txt文件，判断他是文件还是目录，在创建一个目录IOTest,之后将HelloWorld.txt移动到IOTest目录下去；之后遍历IOTest这个目录下的文件(二)递归实现输入任意目录，列出文件以及文件夹，效果看图(三)递归...
IO流练习题
路人甲的博客
08-21 559
记录一下IO流的练习题 读进来(input)，写出去(output) 1.递归复制文件夹及文件 2.获取文本上字符出现的次数,把数据写入文件 3.列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推 4.求任意一个目录的总大小 public class FileTest { /** * 1.递归复制文件夹及文件 * <p> * <p> * 思路： * 1.判断源文件是目录还是文件 * 2.是
11 IO流总结及相关练习题
zhangxinxin1108的博客
05-15 246
一 IO流总结练习一package Stream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOEx...
io流总结和面试题
蓝色的猴子
06-21 1444
1）file类：主要是用于访问文件和目录，不能对文件内容进行访问(对于file能新建，删除，重命名文件和目录)。 2）Java的io类分类：有字节流和字符流。 有节点流和处理流。 3）字节流/字符流：字节流的输入 inputstream的方法read() , read(byte[] b), read(byte[] b,int off,int len)。 字符流的输入 reader的方法read(), read(char[] a),read(char[
ByteBuff常用方法，使用
热门推荐
一点光辉的博客
07-04 1万+
ByteBuff常用方法，使用
Java-Io流，练习
07-06
本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output Stream）。输入流用于从源（如文件、网络连接等）读取数据，而输出流则...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、...
IO流练习题1
01-08
根据提供的信息，我们可以总结出以下关于“IO流练习题1”的相关知识点： ### IO流基础知识 #### 1. IO流概念 在计算机科学中，**输入/输出流（Input/Output Stream，简称IO流）**是指数据从一个地方到另一个地方的...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许...在分析给定的压缩包文件“file-io-app”和“io-app2”，我们可以预期它们可能包含了一些示例代码或练习项目，用于演示和练习Java IO流的各种使用方法。
Netty（3）——ByteBuf最全最详细16个案例
醉花妍
11-20 1242
代码基本每行都有注释，还是比较好理解的 代码清单 5-1 支撑数组 代码清单 5-2 访问直接缓冲区的数据 代码清单 5-3 使用 ByteBuffer 的复合缓冲区模式 代码清单 5-4 使用 CompositeByteBuf 的复合缓冲区模式 代码清单 5-5 访问 CompositeByteBuf 中的数据 代码清单 5-6 访问数据 代码清单 5-7 读取所有数据 代码清单...
字节流（输入，输出）
m0_63988476的博客
04-22 810
输入 import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; public class InputStreamDemo3 { public static void main(String[] args) { InputStream inputStream = null;
byte[] buffer=new byte[1024]
niuzaiwenjie的专栏
03-26 1万+
byte[] buffer=new byte[4096] byte[]   buffer   =   new   byte[4096]       4096=1024*4=4K         只是在内存中开辟块缓冲区而已。大小随便写，只要不超过你实际可用内存大小就好。不过太大或者太小都会对性能有影响。所以通常采用   4   的倍数，或者 1K   的倍数作为
Java中关于I/O流一些考题
qq_57839826的博客
08-09 195
字节流是字节读写，可以对视频，音频，文本等进行读写操作。字符流是块读写，只能对纯文本内容进行读写操作。
用于存储byte[]的buf
qq_24266861的专栏
12-17 456
当多线程处理数据的时候,我们需要环形buf用于数据的缓存 public class MyRingBuf { private static final String TAG = MyRingBuf.class.getSimpleName(); private static final boolean DEBUG_SHOW_ADD = false && com.physi
Netty---ByteBuf实现
阿七
07-06 617
一，获取 1.ByteBuf实现分类 按底层实现分类 1.HeadByteBuf: 底层实现为java堆内的字节数组，byte[],可以有GC回收。特点是内涵的分配和回收速度块，缺点是如果进行socket的io读写，需要额外做一次内存复制，将堆内存的内容复制到内核内存中，性能会有一定程度的下降。 2.DirectByteBuf：直接内存字节缓冲区，非堆内存，它在堆外进行内存分配，相比于堆内存，它的分配和回收都相对较慢，但是读写操作，少了一次内存复制，速度比堆内存块。内核空间的字节数...
bytes=new Byte[1024]: 缓冲器的作用原理
tian5753的博客
11-30 3645
bytes=new Byte[1024]: 缓冲器的作用原理
给我几个JavaIO流的练习案例
最新发布
09-08
通过实际操作和练习，你可以更好地掌握JavaIO流的相关知识。 ### 回答3： 以下是几个Java IO流的练习案例： 1. 案例一：复制文件 编写一个Java程序，实现将一个文件的内容复制到另一个文件中。可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值