精华内容
下载资源
问答
  • 关于java中文件输入输出流问题我写了个文件分割的小程序 以下是分割部分的代码/*文件分割方法参数file表示要分割的源文件dir表示分割完成后要保存的路径size表示要分割的大小*/private void cutFile(File file,File ...

    关于java中文件输入输出流问题

    我写了个文件分割的小程序 以下是分割部分的代码

    /*文件分割方法

    参数file表示要分割的源文件

    dir表示分割完成后要保存的路径

    size表示要分割的大小*/

    private void cutFile(File file,File dir,long size) {

    // TODO Auto-generated method stub

    FileInputStream fis=null; //创建文件输入和输出流

    FileOutputStream fos=null;

    long fileSize=file.length(); //取得源文件大小

    String fileName=file.getName(); //取得原文件名字

    long fileNum=0; //附加在分割好后文件名后面的文件编号

    try {

    fis=new FileInputStream(file);

    fileNum=0;

    if(fileSize<=1024){

    JOptionPane.showMessageDialog(null,"文件不需要分割");

    return;

    }

    int readByte=0;

    byte[]date=new byte[1024]; //缓存数组

    int singleFileSize=0; //分割文件大小临时变量

    File nextFile=null;

    //读取源文件直到文件末尾

    while((readByte=fis.read(date))!=-1){

    if(nextFile==null)

    nextFile=new File(dir,fileName+"."+"cut"+fileNum); //创建分割后的单个文件

    if(fos==null){

    fos=new FileOutputStream(nextFile); //创建分割后单个文件的输出流

    }

    /*

    if(singleFile

    fos.write(date,0,readByte);

    singleFileSize+=readByte;

    }

    else{

    info.append(nextFile.getName()+"\n");

    fos.close();

    singleFileSize=0;

    fileNum++;

    nextFile=new File(dir,fileName+"."+"cut"+fileNum);

    fos=new FileOutputStream(nextFile);

    }

    */

    if(singleFileSize>=size){ //如果分割的文件大小等于或大于指定的分割大小重新创建一个文件

    info.append(nextFile.getName()+"\n"); //在信息拦添加文件名

    fos.close();

    singleFileSize=0;

    fileNum++;

    nextFile=new File(dir,fileName+"."+"cut"+fileNum);

    fos=new FileOutputStream(nextFile);

    }

    fos.write(date,0,readByte);

    singleFileSize+=readByte;

    }

    if(fos!=null){

    fos.close();

    }

    if(fis!=null){

    fis.close();

    }

    info.append(nextFile.getName()+"\n");

    } catch (FileNotFoundException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    以上代码不考虑中间那段加粗的注释部分 分割出来的文件是正常的

    但如果我把注释部分代码替换掉以下代码 分割出来的文件总数大小比原文件小了30多KB这是为什么按理来说2种if语句完成的功能能应该是一样的

    if(singleFileSize>=size){ //如果分割的文件大小等于或大于指定的分割大小重新创建一个文件

    info.append(nextFile.getName()+"\n"); //在信息拦添加文件名

    fos.close();

    singleFileSize=0;

    fileNum++;

    nextFile=new File(dir,fileName+"."+"cut"+fileNum);

    fos=new FileOutputStream(nextFile);

    }

    fos.write(date,0,readByte);

    singleFileSize+=readByte;

    ------解决方案--------------------

    Java code当然不一样了

    if(singleFile

    fos.write(date,0,readByte); //这里的代码是有条件执行的,满足else的时候就不会执行这里

    singleFileSize+=readByte;

    }

    else{

    info.append(nextFile.getName()+"\n");

    fos.close();

    singleFileSize=0;

    fileNum++;

    nextFile=new File(dir,fileName+"."+"cut"+fileNum);

    fos=new FileOutputStream(nextFile);

    }

    if(singleFileSize>=size){ //如果分割的文件大小等于或大于指定的分割大小重新创建一个文件

    info.append(nextFile.getName()+"\n"); //在信息拦添加文件名

    fos.close();

    singleFileSize=0;

    fileNum++;

    nextFile=new File(dir,fileName+"."+"cut"+fileNum);

    fos=new FileOutputStream(nextFile);

    }

    fos.write(date,0,readByte); //这里的代码是无条件执行的,不管满足不满足上面的if,都会执行

    singleFileSize+=readByte;

    所以,第一种方法,当满足else时,就不会执fos.write(date,0,readByte); 而丢失信息

    而第二种是,即使满足了if,也还是会执行fos.write(date,0,readByte); 不会丢失信息

    展开全文
  • 关于文件输入流遇到问题和部分解决思路关于输出InputFileStream read()方法问题what? 关于输出InputFileStream read()方法问题 首次学习IO流简直不要哭死,根本不知道在干嘛。硬着头皮死记硬背不是...

    关于文件输入流遇到的问题和部分解决思路

    关于输出InputFileStream 的read()方法的问题

    首次学习IO流简直不要哭死,根本不知道在干嘛。硬着头皮死记硬背不是学习编程的必修之路。对代码的增删改查才是进阶之路。话不多说上正菜

    //文件输入输出流
    	@Test
    	public void FileIn() {
    		FileInputStream a = null;
    		try {
    			a = new FileInputStream("Test/demo1.txt");
    			// 此处定义一个整形变量是用来接收read方法返回的ascll码,由于整数并非在任何时候都可以用to string方法。所以需要用强制类型转换。
    			int b;
    			while (true) {
    				b = a.read();
    				if (b == -1)
    					break;
    				System.out.print((char) b);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				if (a != null) {
    					a.close();
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    
    //这个是demo1.txt的文本
    Hello FileInputStream123123
    

    运行结果如下:

    Hello FileInputStream123123
    

    以上是一个简单的循环输出文本文件的代码
    当时我想优化代码就这么写了一下

    @Test
    	public void FileIn1() {
    		FileInputStream a = null;
    		try {
    			a = new FileInputStream("Test/demo1.txt");
    			// 此处定义一个整形变量是用来接收read方法返回的ascll码,由于整数并非在任何时候都可以用to string方法。所以需要用强制类型转换
    			while (true) {
    				if (a.read() == -1)
    					break;
    				System.out.print((char) a.read());
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				if (a != null) {
    					a.close();
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    

    编译无错。运行结果如下:

    el ienuSra132?
    

    这样不太直观的话,那我接着告诉你
    我只是int b 删除,所有输出都采用 a.read();大家 可以亲自测试。在不循环遍历的情况下。

    int b=a.read();
    System.out.println((char)b);
    

    System.out.println((char)a.read());
    
    

    输出的结果都是一样

    what?

    对你没有看错
    是一样的都会输出H
    我大胆猜测问题出现在print方法上
    我查看了他的源码

     public void print(char c) {
            write(String.valueOf(c));
        }
    

    可以直接写代码

    @Test
    	public void intToString() {
    		int a = 5;
    		char b = 'w';
    		System.out.println(a);
    		System.out.println(b);
    		System.out.println((char) a);
    		System.out.println();
    	}
    

    输出结果如下:

    5
    w
    
    

    得出一个大学时期得出的基础理论
    由此可见某些情况int强制类型转化成char的时候是会出错的
    但是!
    但是!
    但是!
    file存储方式的是列表
    我们采用索引(下标)(地址)来指向内存区(堆)中存放给的数据(堆栈的知识,不会请百度谢谢)
    所以是获取地址中的参数进行输出,输出出现误差,应该是地址转换出了错,所以我们采用一个整型数来存放地址


    奈何我的基础太差,理解不够深入不够透彻,下面都是我自己的猜测和理解,看个笑话吧。谢谢
    我大胆分析一下:
    发现传入参数必须是char c输出的类型是String.valueOf(c)
    对于底层我不太懂,我大胆猜测。强制类型转换后值没有改变。类型变了。总所周知,机器用二进制存储,机器本省不识别01以外的任何数字和字母。所以在int转变成char 的时候。int是二进制数字所以输入参数端口没有问题!
    我们来看输出端口String.valueOf(c)
    在用来输出的时候我感觉应该是获取堆中数据出了问题。出了什么问题;哪块出了问题问题,我也不知道
    我的思路是就是这样谢谢

    展开全文
  • 今天学习C++输入输出流的时候,遇到一个问题,先贴代码: void foutput (ofstream &fout, int m) { for (int i=1;i;i++) { fout *i+0.5; } } 上面这个函数的参数中用了一个ofstream类的变量,在下面...
  • 输入流输出流到底是怎么来分辨,在写代码的时候经常会遇到问题,或者经常混淆找两个流的关系。通过今天的学习做个笔记,也提供给大家来学习,同时提出我的问题。 书上说 输入流:只能从中读取数据,不能向其写入...
    输入流,输出流到底是怎么来分辨,在写代码的时候经常会遇到问题,或者经常混淆找两个流的关系。通过今天的学习做个笔记,也提供给大家来学习,同时提出我的问题。
    

    书上说
    输入流:只能从中读取数据,不能向其写入数据。
    输出流:只能向其写入数据,不能从中读取数据。

     所以我有个疑问,这个流到底是个什么玩意???
    

    书上给流的定义是:Java中把不同的输入/输出源(键盘、文件、网络连接等)抽象的标书为“流”。所以,流就是键盘、文件、网络连接等只不过被抽象了而已。

    那么就以FileInputStream和FileOutputStream为例,来分辨什么是流?什么是输入流?什么是输出流?
    
     public static void Test1() throws Exception{
            FileInputStream fileInputStream = new FileInputStream("F:\\Demo\\1.txt");
            //创建输出流
            FileOutputStream fos = new FileOutputStream("F:\\Demo\\2.txt");
    
            //定义字符用来接收文件中读取的数据
            byte[] bbuf = new byte[100];
            //定义一个hasRead来确定读到数据的个数
            int hasRead = 0;
            String line = "";
            while ((hasRead = fileInputStream.read(bbuf)) > 0){
                System.out.println(new String(bbuf , 0 , hasRead));
                //将流中读到的数据写入到fos流中去
                fos.write(bbuf);
            }
            //关闭输入流
            fileInputStream.close();
            fos.close();
        }
    这段代码的作用很简单,就是从输入流中读取数据,然后写入到输出流中去。
    那么这个 输入流 就是1.txt。输出流 就是2.txt
    正如前面输入流和输出流定义一样,输入流(1.txt)从中读取数据。输出流(2.txt)向其中写入数据。
    这样的话抽象的流也就容易理解了。
    

    希望有更好见解的在下面写出自己的简介,供大家学习。

    这篇文章写得有些不明确,我又写了一篇文章,大家看而已去看一下,就能清晰地理解什么是输入输出流了。

    关于FileInputStream和FileOutputStream输入流与输出流问题二

    展开全文
  • 下面的代码关于输入输出流的复制,以及发散思维切割文件合并文件。 public static void main(String[] args) { //通过输入输出流控制文件 inputOutputCopy(); //使用tryResource的方式通过输入输出流控制...

    输入输出流&Files操作代码:复制 切割 合并


    通过jdk1.7的文件操作工具类,可以使用少量的代码完成 复制,移动,读取字节,写文件,生成流等等,好用。
    下面的代码是关于输入输出流的复制,以及发散思维切割文件合并文件。

    
         public static void main(String[] args) {
    
            //通过输入输出流控制文件
            inputOutputCopy();
            //使用tryResource的方式通过输入输出流控制文件
            tryResourceInputOutputCopy();
            //通过 jdk1.7 Files工具类 控制文件(内部做好了输入输出流操作)
            filesWriteCopy();
            //Files 加 输入流 切割文件
            toPart();
            //通过Files合并文件 通过输入输出流合并文件
            merge();
        }
    
        public static void inputOutputCopy(){
    
            FileInputStream fileInputStream =null;
            BufferedInputStream bufferedInputStream= null;
            DataInputStream dataInputStream = null;
    
            FileOutputStream fileOutputStream =null;
            BufferedOutputStream bufferedOutputStream= null;
            DataOutputStream dataOutputStream = null;
            try {
                fileInputStream = new FileInputStream("C:\\Users\\k1326\\Desktop\\1.jpg");//节点类 我把它当作入口
                bufferedInputStream = new BufferedInputStream(fileInputStream);//缓冲类  我把它当作缓存
                dataInputStream = new DataInputStream(bufferedInputStream);//装饰类  据说是 与字节字符有关,最后是用字节的方式来读入java
    
    
                fileOutputStream = new FileOutputStream("D:\\2222.jpg");
                bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
                dataOutputStream = new DataOutputStream(bufferedOutputStream);
    
                byte[] change = new byte[1024];
                int len=-1;
                // 这种方式来写呢   最后一次 write 会多出来 一部分字节
                //所以要通过 read 的 数量 来控制最后一次的 write
    //            while(true){
    //                int read = dataInputStream.read(change);
    //                if (read==-1){
    //                    break;
    //                }
    //                dataOutputStream.write(change,0,read);
    //            }
                //终极模式   jdk
                while((len=dataInputStream.read(change))!=-1){
                    dataOutputStream.write(change,0,len);
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    dataInputStream.close();
                    dataOutputStream.flush();
                    dataOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    
        //主体代码11行  nice  上面都是28行
        public static  void tryResourceInputOutputCopy(){
            //try  resource  格式   不用去管理  资源的释放   觉得不错
            try(
                    DataInputStream dataInputStream =new DataInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\k1326\\Desktop\\1.jpg")));
                    DataOutputStream dataOutputStream =new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\k1326\\Desktop\\1.jpg")));
            ){
                byte[] change = new byte[1024];
                int len=-1;
                while((len=dataInputStream.read(change))!=-1){
                    dataOutputStream.write(change,0,len);
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    
        // jdk1.7  6行
        public static  void filesWriteCopy(){
            //通过这种方式呢,我可以把  每一个部分文件按照顺序读取出字节数组,然后通过 追加变量  把每一个字节写到文件追加到文件字节的最后面,从而达到文件的合并效果
            //Files.write(new File("").toPath(),new byte[0],StandardOpenOption.APPEND);
            //那么自然而然的 可以通过 读取一个文件的字节来进行 拆分操作  比如 每 10240个字节 作为一个部分(part)  然后通过   //Files.write(new File(i+".part").toPath(),new byte[0],StandardOpenOption.CREATE_NEW);
            //try  resource  格式   不用去管理  资源的释放   觉得不错
            try {
                InputStream inputStream = Files.newInputStream(Paths.get("C:\\Users\\k1326\\Desktop\\1.jpg"), StandardOpenOption.READ);
                // deleteIfExists(target);  再底层 就需要 稍微深入一些了    FileSystemProvider
                long copy = Files.copy(inputStream, new File("C:\\Users\\k1326\\Desktop\\2.jpg").toPath(), StandardCopyOption.REPLACE_EXISTING);
                System.out.println(copy);
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        //切割文件  最近简单的看了一下流,结合着之前的代码经历,就思考自己进行文件切割,果然基础的重要性,感觉得到了一些收获
        public static void toPart(){
            try {
                InputStream inputStream = Files.newInputStream(Paths.get("C:\\Users\\k1326\\Desktop\\202-8-3.rar"), StandardOpenOption.READ);
                //FileOutputStream fileOutputStream = null;  //此处对象不需要接收
                BufferedOutputStream bufferedOutputStream = null;
                //DataOutputStream dataOutputStream = null;//已经是字节,不是用这个类装饰了
                //10M
                byte[] b = new byte[10240000];
                int len=-1;
                int i=0;
                while((len=inputStream.read(b))!=-1){
                    i++;
                    //String.format("%04d",i) 通过它就可以不进行 排序操作了
                    bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\Users\\k1326\\Desktop\\part\\"+String.format("%04d",i)+".part"));
                    bufferedOutputStream.write(b,0,len);
                    bufferedOutputStream.close();
                    // Files.write(Paths.get("C:\\Users\\k1326\\Desktop\\part\\"+String.format("%04d",i)+".part"),b,StandardOpenOption.CREATE_NEW);
                }
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public static void merge(){
            File file = new File("C:\\Users\\k1326\\Desktop\\part");
            Path path = file.toPath();
            //茴香豆 的 茴
            //JDK1.0
            File[] files = file.listFiles((dir,name)->name.endsWith(".part"));
            try {
                //1.8
                Stream<Path> list = Files.list(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                //1.7
                DirectoryStream<Path> paths = Files.newDirectoryStream(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
            //Files.walkFileTree()
    
            try {
                new File("C:\\Users\\k1326\\Desktop\\1.rar").createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            //8行 merge
            Path path1 = Paths.get("C:\\Users\\k1326\\Desktop\\1.rar");
            for (File file1 : files) {
                try {
                    Files.write(path1,Files.readAllBytes(file1.toPath()),StandardOpenOption.APPEND);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //21行 merge
            BufferedOutputStream bufferedOutputStream= null;
            FileInputStream fileInputStream = null;
            byte[] b = new byte[1024];
            int len=-1;
            try {
                bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\Users\\k1326\\Desktop\\2.rar"));
                for (File file1 : files) {
                        fileInputStream = new FileInputStream(file1);
                        while((len=fileInputStream.read(b))!=-1){
                            bufferedOutputStream.write(b,0,len);
                        }
                        fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    展开全文
  • 这是我的代码:  int n;  while (cin >> n)  {<!-- -->  if (cin.eof())  cout << "到达文件末尾" << endl;  if (cin.fail())  cout ...
  • 内存和硬盘就好比两个储水容器,所以要实现里面内容互换,就必须要管道连接,这就是输入输出流对象作用。 以代码为例: package io0222mwj; import java.io.BufferedInputStream; import ...
  • 示例代码 以下主要展示了以下几种写法: 一次一个字节读取 一次一个字节数组读取 字符串写入文件 文件内容写入字符串 我相信新手对于第一种写法和第二种写法经常混淆,第一种int其实质就是读取字节内容,而第二...
  • 以文本读写为例,在字节输入流中(FileInputStream)作用是从文件系统中读入文件内容字节,并且做进一步操作,例如打印到Console命令台,关于此操作可以使用如下代码输入(此代码非本人原创): public static ...
  • IO以及缓冲可以帮我们实现文本文件的读写操作, 关于它们使用可以去参考这篇博客io/缓冲. 接下来我们直接来看复制文本文件的五种方法,直接看代码: package com.qibao.iostream; import java.io....
  • 今天我们总结一下java中关于输入流输出流的知识,博客的代码选自Thinking in java一书。我突然很想忘了你,就像从未遇见你。java中的输入流huhx.txt文件的内容如下: I love you, ch. 中文一、缓冲中输入文件...
  • 萌新最近搬砖遇到一个问题,上面让我做一个dump文件的...一开始写了一个demo放到测试机上面跑,最初代码如下(只保留转换相关的代码,所以不可以运行):import java.io.InputStreamReader; public class DumpAnaly...
  • C++文件输入/输出

    2020-03-25 00:51:10
    最近特别查阅了一下关于C++文件的输入/输出的资料,整理了一下就写一下笔记。 文章目录一、什么是二、什么是缓冲区三、代码实现文件IO3.1 使用文件流对象读取数据3.2重定向 一、什么是 当前计算机具有很多种...
  • 这是一段关于文件输入输出流的代码,首先弹出窗口输入要拷贝的文件名称,拷贝完成后会通过frame窗口告知拷贝信息,但是现在出了个问题,文件能够顺利拷贝,frame窗口能够打开,可是label却并不显示复制信息,给位...
  • 里面有我刚开始学习Java时,关于io输入输出流的总结及代码,还有线程的两种实现方法的总结及代码展示,文件的读写展示,还有Java中特殊for语句的展示!供初学者学习参考!
  • 这里是在网上找来的几个关于 IO流文件输入流具体实例代码,接下来试着将其解析得更清楚明白一些,希望初学者看完能有所收获,这篇这个例子的代码是把文件上的字符一个个连续输出 方法/步骤 ...
  • Io流按照分类 有两种分类流向方向: 有输入流输出流按照操作类型有:字节流和字符流按照流向方向字节流的一些操作//读文件FileInputStream fis = new FileInputStream("java.txt");int temp = fis.read(...
  • java 关于文件剪切操作代码方法一package Onenine;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import ...
  • File类:写在学习之前,在之前我们操作系统中的文件都是通过可视化界面,接下来关于IO学习中示例,是使用代码去针对文件进行操作File类构造函数APIFile(String pathname)根据一个路径得到File对象File(String ...
  • 关于异常概念: 一种程序控制机制,与...关于异常概念部分代码: #include using namespace std; int DDiv(int x, int y) { if (0 == y) { throw 0; } return x / y; } int Div(int x, int y...
  • 关于Java输入输出函数

    2011-04-13 09:22:55
    java输入输出功能十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出文件的操作...
  • 今天我们总结一下java中关于输入流输出流的知识,博客的代码选自Thinking in java一书。我突然很想忘了你,就像从未遇见你。 java中的输入流 huhx.txt文件的内容如下: I love you, ch. 中文 一、缓冲中输入...
  • =========关于JAVA输入输出流,BufferedReader.readLine()方法效率问题=======-珑琉璃 2009-03-29 11:31感觉readLine()是不是效率有点低?当我读入数据时候,如果这个数据中间没有换行,那不就等于整个文件就...
  • 解决关于java的IO进行文件...2.然后观察自己的代码,发现idea也没有飘红,自己的输入输出的路径也好像没什么问题,原本代码如下所示: fis = new FileInputStream(“E:\java 程序\出师表.txt”); fos = new FileO
  • 这是输出部分,我将一个数组大小以压缩形式输出到一个文件里。 [code="java"] import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io...
  • 关于JAVA IO文件数字乱码问题

    千次阅读 2016-04-07 20:52:54
    在完成JavaWeb作业时遇到一题是需要持久化保存登录人数,题主当时就在Listener里写了输入输出两个函数,但是检查一看发现写入数字变成了乱码(其实不能说是乱码)。 当时很疑惑就改用了如下代码: 写代码: ...
  • Awrite(int)方法向底层输出流输出int变量低八位,计数器增加1 BwriteByte(int)将int变量低八位写入,计数器增加1 CwriteDouble(double)将double变量的的低八位写入,计数器增加1 DwriteInt(int)将int变量写入...
  • 在完成JavaWeb作业时遇到一题是需要持久化保存登录人数,题主当时就在Listener里写了输入输出两个函数,但是检查一看发现写入数字变成了乱码(其实不能说是乱码)。当时很疑惑就改用了如下代码:写代码:File file...
  • 那么再问:当读取返回值len=-1,表示输入流读取数据已经读到文件结束了,那么这个时候fos.write(bytes,0,len)这段代码应该不会再执行了,那么最后一次读取数据还保存在数组bytes里面,而没有执行输出流操作 ...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 366
精华内容 146
关键字:

关于文件输入流输出流的代码