A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© LOVE你的ME 中级黑马   /  2014-12-12 15:54  /  1606 人查看  /  14 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

定义一个文件输入流,调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)。
老是感觉这道题不对劲啊,感觉考的是数组限制为5的这点,但是代码好像没有体现(其实本人理解题的能力很差0.0)求指导
  1.         File file = new File("exercise.txt");
  2.                 FileInputStream fis = null;
  3.                 BufferedOutputStream bos = null;
  4.                         fis = new FileInputStream(file);
  5.                         bos = new BufferedOutputStream(System.out);
  6.                         byte[] by = new byte[5];//---------------
  7.                         int len = 0;
  8.                         while ((len = fis.read(by)) != -1) {
  9.                                 bos.write(by, 0, len);
  10.                         }
复制代码



14 个回复

倒序浏览
怎么说呢,因为限制为5位,而中文是4位,所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输出一行,应该全部写完再输出,可以用ByteArrayWriter
回复 使用道具 举报
冥夜 发表于 2014-12-12 16:14
怎么说呢,因为限制为5位,而中文是4位,所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输 ...

我是想到了乱码的问题,但是我这个方法读出来的字符中文英文都有,没有乱码现象啊。
回复 使用道具 举报
所以说是可能- -有各种情况的吧。。。我是这么理解的
回复 使用道具 举报
冥夜 发表于 2014-12-12 16:14
怎么说呢,因为限制为5位,而中文是4位,所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输 ...

字节流怎么会有乱码呢
回复 使用道具 举报
不懂中。。。。。。。。
回复 使用道具 举报
  1. package com.gotoheima;

  2. import java.io.FileInputStream;
  3. import java.io.IOException;

  4. /**
  5. *
  6. * 定义一个文件输入流,调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5,不考虑中文编码问题)
  7. *
  8. */
  9. public class Test7
  10. {
  11.         public static void main(String[] args)
  12.         {
  13.                 FileInputStream fis = null;
  14.                 try
  15.                 {
  16.                         fis = new FileInputStream("exercise.txt");
  17.                        
  18.                         byte[] b = new byte[5];
  19.                         int num = 0;
  20.                         while ((num = fis.read(b)) != -1)
  21.                         {
  22.                                 System.out.print(new String(b,0,num));                               
  23.                         }
  24.                 }
  25.                 catch(IOException e)
  26.                 {
  27.                         throw new RuntimeException("读写出错!");
  28.                 }
  29.                 finally
  30.                 {
  31.                         try
  32.                         {
  33.                                 if (fis != null)
  34.                                         fis.close();
  35.                         }
  36.                         catch(IOException e)
  37.                         {
  38.                                 throw new RuntimeException("关闭出错!");
  39.                         }
  40.                 }
  41.                        
  42.                
  43.                
  44.        
  45.         }
  46. }
复制代码
回复 使用道具 举报
冥夜 中级黑马 2014-12-12 18:20:02
8#
聪明叉 发表于 2014-12-12 16:28
字节流怎么会有乱码呢

哦哦- -没注意。。。的确不会。。。主要我的理解就是他让你用5位的字节数组存储数据目的就是让你考虑乱码问题。
回复 使用道具 举报
冥夜 发表于 2014-12-12 18:20
哦哦- -没注意。。。的确不会。。。主要我的理解就是他让你用5位的字节数组存储数据目的就是让你考虑乱码 ...

当前系统默认GBK编码表,一个中文占2个字节,一次读5个字节,读一次就写一次,的确会乱码。原题应该有不考虑中文的提示
回复 使用道具 举报
Whero 中级黑马 2014-12-12 18:50:03
10#
  1. package com.itheima;

  2. import java.io.ByteArrayOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;

  5. /**
  6. * 第5题: 定义一个文件输入流,调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)
  7. *
  8. *
  9. * 分析:如果每一次读取到五个字节就打印,很明显会出现乱码,因为汉字是用两个字节表示。因此考虑使用字节数组输出流来暂时保存
  10. *      每一次读取到的字节,并最终打印。
  11. * */
  12. public class Test5 {
  13.         public static void main(String[] args) throws IOException
  14.         {
  15.                 //定义一个文件输入流
  16.                 FileInputStream fin=new FileInputStream("exercise.txt");
  17.                
  18.                 //定义一个字节数组输出流,用来保存每次读取到的字节数组
  19.                 ByteArrayOutputStream bos =new ByteArrayOutputStream();
  20.                
  21.                 //定义一个字节数组,大小为5
  22.                 byte[] b=new byte[5];
  23.                
  24.                 //定义一个int类型的变量,用来保存实际读取到的字节数
  25.                 int len;
  26.                
  27.                 //将文件输入流中的所有数据写入到字节数组输出流中
  28.                 while((len=fin.read(b))!=-1)
  29.                 {
  30.                         bos.write(b,0,len);
  31.                 }
  32.                 System.out.println(bos.toString());
  33.                
  34.                 //关闭资源,ByteArrayOutputStream没必要关闭资源,只需关闭输入流资源就ok
  35.                 fin.close();
  36.         }
  37. }
复制代码
回复 使用道具 举报
huoxy 中级黑马 2014-12-12 19:20:56
11#
我感觉考得应该是输出时用print还是println的知识点!
回复 使用道具 举报
顶一手~
回复 使用道具 举报
HelloWorld! 发表于 2014-12-12 18:48
当前系统默认GBK编码表,一个中文占2个字节,一次读5个字节,读一次就写一次,的确会乱码。原题应该有不 ...

那就是说要在循环中加个判断条件,读两次再写出?
回复 使用道具 举报
聪明叉 发表于 2014-12-13 08:30
那就是说要在循环中加个判断条件,读两次再写出?

才看到基础视频IO部分后面有讲到操作数组的类,ByteArrayOutputStream,封装了数组,可以将数组中的数据缓冲,循环结束后再将缓冲区数据一次性输出到控制台。因为操作内存中的数据,没调用系统底层资源,所以close方法不起作用。

  1. import java.io.FileReader;
  2. import java.io.IOException;
  3. import java.util.Map;
  4. import java.util.TreeMap;

  5. /*
  6. * 把当前文件中的所有文本拷贝,存入一个txt文件,统计每个字符出现的次数并输出
  7. *
  8. * 思路:就是把这个文件的文本复制到一个txt文件中(鼠标操作),读取文本并统计字符出现的次数
  9. */
  10. public class Test13 {

  11.         public static void main(String[] args) throws IOException {
  12.                 // TODO Auto-generated method stub
  13.                 FileReader fr = new FileReader("e:\\file.txt");
  14.                 Map<Character,Integer> treeMap = new TreeMap<Character,Integer>();
  15.                
  16.                 int ch = fr.read();
  17.                 while(ch!=-1){
  18.                         Character character = (char)ch;
  19.                         Integer value = treeMap.get(character);
  20.                         if(!treeMap.containsKey(character))
  21.                                 treeMap.put(character, 1);
  22.                         treeMap.put(character, value+1);
  23.                 }
  24.                 for(Map.Entry<Character, Integer> me : treeMap.entrySet()){
  25.                         System.out.println(me.getKey()+":"+me.getValue()+"次");
  26.                 }
  27.                
  28.         }

  29. }
复制代码
回复 使用道具 举报
HelloWorld! 发表于 2014-12-13 09:03
才看到基础视频IO部分后面有讲到操作数组的类,ByteArrayOutputStream,封装了数组,可以将数组中的数据 ...

不好意思代码贴错了
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
* 定义一个文件输入流,调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组
* 的大小限制为5)
*/
public class Test11 {

        public static void main(String[] args) throws IOException {
                // TODO Auto-generated method stub
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\exercise.txt"));
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                byte [] b = new byte[5];
                int len = 0;
                while(( len= bis.read(b))!=-1){
                        bos.write(b,0,len);//将数组中的数据缓冲
                }
                bos.writeTo(System.out);//循环结束后,将缓冲区数据写入输出流,即控制台
                bis.close();

        }

}
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马