定义一个文件输入流，调用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.                         }

复制代码

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();

        }

}

聪明叉 发表于 2014-12-13 08:30
那就是说要在循环中加个判断条件，读两次再写出？

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

1. 
   
2. import java.io.FileReader;
   
3. import java.io.IOException;
   
4. import java.util.Map;
   
5. import java.util.TreeMap;
   
6. 
   
7. /*
   
8. * 把当前文件中的所有文本拷贝，存入一个txt文件，统计每个字符出现的次数并输出
   
9. *
   
10. * 思路：就是把这个文件的文本复制到一个txt文件中（鼠标操作），读取文本并统计字符出现的次数
    
11. */
    
12. public class Test13 {
    
13. 
    
14.         public static void main(String[] args) throws IOException {
    
15.                 // TODO Auto-generated method stub
    
16.                 FileReader fr = new FileReader("e:\\file.txt");
    
17.                 Map<Character,Integer> treeMap = new TreeMap<Character,Integer>();
    
18.                
    
19.                 int ch = fr.read();
    
20.                 while(ch!=-1){
    
21.                         Character character = (char)ch;
    
22.                         Integer value = treeMap.get(character);
    
23.                         if(!treeMap.containsKey(character))
    
24.                                 treeMap.put(character, 1);
    
25.                         treeMap.put(character, value+1);
    
26.                 }
    
27.                 for(Map.Entry<Character, Integer> me : treeMap.entrySet()){
    
28.                         System.out.println(me.getKey()+":"+me.getValue()+"次");
    
29.                 }
    
30.                
    
31.         }
    
32. 
    
33. }

复制代码

HelloWorld! 发表于 2014-12-12 18:48
当前系统默认GBK编码表，一个中文占2个字节，一次读5个字节，读一次就写一次，的确会乱码。原题应该有不 ...

那就是说要在循环中加个判断条件，读两次再写出？

顶一手~

我感觉考得应该是输出时用print还是println的知识点！

1. package com.itheima;
   
2. 
   
3. import java.io.ByteArrayOutputStream;
   
4. import java.io.FileInputStream;
   
5. import java.io.IOException;
   
6. 
   
7. /**
   
8. * 第5题： 定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)
   
9. *
   
10. *
    
11. * 分析：如果每一次读取到五个字节就打印，很明显会出现乱码，因为汉字是用两个字节表示。因此考虑使用字节数组输出流来暂时保存
    
12. *      每一次读取到的字节，并最终打印。
    
13. * */
    
14. public class Test5 {
    
15.         public static void main(String[] args) throws IOException
    
16.         {
    
17.                 //定义一个文件输入流
    
18.                 FileInputStream fin=new FileInputStream("exercise.txt");
    
19.                
    
20.                 //定义一个字节数组输出流，用来保存每次读取到的字节数组
    
21.                 ByteArrayOutputStream bos =new ByteArrayOutputStream();
    
22.                
    
23.                 //定义一个字节数组，大小为5
    
24.                 byte[] b=new byte[5];
    
25.                
    
26.                 //定义一个int类型的变量，用来保存实际读取到的字节数
    
27.                 int len;
    
28.                
    
29.                 //将文件输入流中的所有数据写入到字节数组输出流中
    
30.                 while((len=fin.read(b))!=-1)
    
31.                 {
    
32.                         bos.write(b,0,len);
    
33.                 }
    
34.                 System.out.println(bos.toString());
    
35.                
    
36.                 //关闭资源，ByteArrayOutputStream没必要关闭资源，只需关闭输入流资源就ok
    
37.                 fin.close();
    
38.         }
    
39. }
    

复制代码

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

当前系统默认GBK编码表，一个中文占2个字节，一次读5个字节，读一次就写一次，的确会乱码。原题应该有不考虑中文的提示

聪明叉 发表于 2014-12-12 16:28
字节流怎么会有乱码呢

哦哦- -没注意。。。的确不会。。。主要我的理解就是他让你用5位的字节数组存储数据目的就是让你考虑乱码问题。

1. package com.gotoheima;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /**
   
7. *
   
8. * 定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5，不考虑中文编码问题)
   
9. *
   
10. */
    
11. public class Test7
    
12. {
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 FileInputStream fis = null;
    
16.                 try
    
17.                 {
    
18.                         fis = new FileInputStream("exercise.txt");
    
19.                        
    
20.                         byte[] b = new byte[5];
    
21.                         int num = 0;
    
22.                         while ((num = fis.read(b)) != -1)
    
23.                         {
    
24.                                 System.out.print(new String(b,0,num));                               
    
25.                         }
    
26.                 }
    
27.                 catch(IOException e)
    
28.                 {
    
29.                         throw new RuntimeException("读写出错！");
    
30.                 }
    
31.                 finally
    
32.                 {
    
33.                         try
    
34.                         {
    
35.                                 if (fis != null)
    
36.                                         fis.close();
    
37.                         }
    
38.                         catch(IOException e)
    
39.                         {
    
40.                                 throw new RuntimeException("关闭出错！");
    
41.                         }
    
42.                 }
    
43.                        
    
44.                
    
45.                
    
46.        
    
47.         }
    
48. }
    

复制代码

不懂中。。。。。。。。

冥夜 发表于 2014-12-12 16:14
怎么说呢，因为限制为5位，而中文是4位，所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输 ...

字节流怎么会有乱码呢

所以说是可能- -有各种情况的吧。。。我是这么理解的

冥夜 发表于 2014-12-12 16:14
怎么说呢，因为限制为5位，而中文是4位，所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输 ...

我是想到了乱码的问题，但是我这个方法读出来的字符中文英文都有，没有乱码现象啊。

怎么说呢，因为限制为5位，而中文是4位，所以你用你这个去读中文很可能会读到乱码。所以不能读一行写一行输出一行，应该全部写完再输出，可以用ByteArrayWriter