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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© jekyll 中级黑马   /  2015-9-27 00:38  /  560 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

  1. package com.cnstrong.study;

  2. import java.io.*;

  3. public class T01 {

  4.         public static void main(String[] args) throws IOException, ClassNotFoundException {
  5.                
  6.                 /*
  7.                 1. 流的分类
  8.                 按照方向分:输入流,输出流
  9.                         以程序运行起来那一段内存而言,他的流向。
  10.                        
  11.                 按照传输单位分:字节流(1字节),字符流(2字节)
  12.                        
  13.                 按照目的地分:文件流,网络流,内存流等等
  14.                
  15.                 按照处理能力分:节点流,处理流(包装在另外一个流之上,提供了更强大的对流的处理功能的流)
  16.                
  17.                 2. IO的框架
  18.                 2.1 4个顶层抽象类
  19.                                   输入                          输出
  20.                 字节       InputStream   OutputStream
  21.                 字符       Reader        Writer
  22.                
  23.                 2.2 InputStream | ByteArrayInputStream ==> 节点流
  24.                                                   FileInputStream ==> 节点流,文件流
  25.                                                   ObjectInputStream ==> 处理流( 传输对象 )
  26.                                                   BufferedInputStream ==> 处理流
  27.                                                   DataInputStream ==> 处理流,数据输入流允许应用程序以与
  28.                                                                   机器无关方式从底层输入流中读取基本 Java 数据类型。
  29.                
  30.                 3. available():预估字节数,一般情况下读取本地文件都比较准确,网络之间不太准确,因为有可能网络阻塞。
  31.                
  32.                 4. 练习写文件("gahsgdfgadf563534653")
  33.                
  34.                 5. Reader | CharArrayReader
  35.                                         FileReader
  36.                                         BufferedReader
  37.                                        
  38.                                         InputStreamReader:字节流通向字符流的桥梁
  39.                                        
  40.                    Writer | .....
  41.                                            OutputStreamWriter:字符流通向字节流的桥梁
  42.                
  43.                 作业题目1:遍历某一个目录下面的所有文件和目录(明天交)
  44.                 作业题目2:将C盘下的一个图片(1.jpg)Copy到D盘下(明天交)
  45.                 作业题目3:实现学生管理系统( 学生新增【 编号,姓名,年龄 】,删除,查询(按照姓名进行模糊查询) )(端午节后交)                       
  46.                                  实现文件存储,存储的是ArrayList
  47.                  * */
  48.                
  49.                 testFile2();
  50.         }
  51.        
  52.         public static void testFile2()
  53.         {
  54.                 File f = new File("C:\\");
  55.                 String[] str1 = f.list();
  56.                
  57.                 for (String string : str1) {
  58.                         System.out.println(string);
  59.                 }
  60.         }
  61.        
  62.         public static void testFile1()
  63.         {
  64.                 File f = new File("C:\\11.txt");
  65.                 boolean bln = f.exists();
  66.                 System.out.println(bln);
  67.                 bln = f.isDirectory();
  68.                 System.out.println(bln);
  69.         }
  70.        
  71.         public static void testAppendFile()throws IOException
  72.         {
  73.                 //第二个参数代表追加
  74.                 Writer w = new FileWriter("C:\\11.txt" ,true);
  75.                 BufferedWriter bw = new BufferedWriter(w);
  76.                
  77.                 bw.newLine();
  78.                 bw.write("我是朱元璋!");
  79.                 bw.newLine();
  80.                 bw.write("我是鲁智深!");
  81.                
  82.                 bw.flush();
  83.                 w.flush();
  84.                 bw.close();
  85.                 w.close();
  86.         }
  87.        
  88.         //从字节流到字符流
  89.         public static void testByteToChar()throws IOException
  90.         {
  91.                 InputStream is = new FileInputStream("C:\\11.txt");
  92.                
  93.                 //将字节流处理成字符流
  94.                 InputStreamReader isr = new InputStreamReader(is);
  95.                
  96.                 BufferedReader br = new BufferedReader(isr);
  97.                
  98.                 String str = null;
  99.                 while( (str = br.readLine()) != null )
  100.                 {
  101.                         System.out.println(str);
  102.                 }
  103.                
  104.                 br.close();
  105.                 isr.close();
  106.                 is.close();
  107.         }
  108.        
  109.         public static void testReader1()throws IOException
  110.         {
  111.                 Reader r = new FileReader("C:\\11.txt");
  112.                 BufferedReader br = new BufferedReader(r);
  113.                
  114.                 String str = null;
  115.                 while( (str = br.readLine()) != null )
  116.                 {
  117.                         System.out.println(str);
  118.                 }
  119.                
  120.                 br.close();
  121.                 r.close();
  122.         }
  123.        
  124.         public static void testWriter1()throws IOException
  125.         {
  126.                 Writer w = new FileWriter("C:\\11.txt");
  127.                 BufferedWriter bw = new BufferedWriter(w);
  128.                
  129.                 bw.write("我是张三丰!");
  130.                 bw.newLine();
  131.                 bw.write("我是杨广!");
  132.                
  133.                 bw.flush();
  134.                 w.flush();
  135.                 bw.close();
  136.                 w.close();
  137.         }
  138.        
  139.         public static void testDataInputStream1()throws IOException
  140.         {
  141.                 InputStream is = new FileInputStream("C:\\11.txt");
  142.                 DataInputStream dis = new DataInputStream(is);
  143.                
  144.                 int i = dis.readInt();
  145.                 double dbl =  dis.readDouble();
  146.                
  147.                 dis.close();
  148.                 is.close();
  149.                
  150.                 System.out.println(i + "  " + dbl);
  151.         }
  152.        
  153.         public static void testDataOutputStream1() throws IOException
  154.         {
  155.                 OutputStream os = new FileOutputStream("C:\\11.txt");
  156.                 DataOutputStream dos = new DataOutputStream(os);
  157.                
  158.                 dos.writeInt(1);
  159.                 dos.writeDouble(2.3);
  160.                
  161.                 dos.flush();
  162.                 os.flush();
  163.                
  164.                 dos.close();
  165.                 os.close();
  166.         }
  167.        
  168.         public static void testObjectInputStream1()throws IOException, ClassNotFoundException
  169.         {
  170.                 InputStream is = new FileInputStream("C:\\11.txt");
  171.                 ObjectInputStream ois = new ObjectInputStream(is);
  172.                
  173.                 /*
  174.                 Student stu1 = (Student)ois.readObject();
  175.                 System.out.println(stu1.id + "  " + stu1.name);
  176.                
  177.                 Student stu2 = (Student)ois.readObject();
  178.                 System.out.println(stu2.id + "  " + stu2.name);
  179.                 */
  180.                
  181.                 Object object = null;
  182.                 while( (object = ois.readObject())!=null )
  183.                 {
  184.                         Student stu = (Student)object;
  185.                         System.out.println( stu.id + "  " + stu.name );
  186.                 }
  187.                
  188.                 ois.close();
  189.                 is.close();
  190.         }
  191.        
  192.         public static void testObjectOutputStream1()throws IOException
  193.         {
  194.                 Student student = new Student();
  195.                 student.id = 1;
  196.                 student.name = "刘德华";
  197.                
  198.                 OutputStream os = new FileOutputStream("C:\\11.txt");
  199.                 ObjectOutputStream oos = new ObjectOutputStream(os);
  200.                
  201.                 oos.writeObject(student);
  202.                
  203.                 student = new Student();
  204.                 student.id = 2;
  205.                 student.name = "马德华";
  206.                 oos.writeObject(student);
  207.                
  208.                 oos.flush();
  209.                 os.flush();
  210.                
  211.                 oos.close();
  212.                 os.close();
  213.         }
  214.        
  215.         public static void testFileInputStream1() throws IOException
  216.         {
  217.                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
  218.                
  219.                 InputStream is = new FileInputStream("C:\\11.txt");
  220.                 byte[] bytes = new byte[8];
  221.                 int length = -1;
  222.                 while(   (length = is.read(bytes)) != -1   )
  223.                 {
  224.                         baos.write(bytes, 0, length);
  225.                 }
  226.                
  227.                 is.close();
  228.                
  229.                 String str = new String(baos.toByteArray());
  230.                 System.out.println(str);
  231.         }
  232.        
  233.         public static void testFileInputStream2() throws IOException
  234.         {
  235.                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
  236.                
  237.                 InputStream is = new FileInputStream("C:\\11.txt");
  238.                 BufferedInputStream bis = new BufferedInputStream(is);
  239.                
  240.                 byte[] bytes = new byte[8];
  241.                 int length = -1;
  242.                 while(   (length = bis.read(bytes)) != -1   )
  243.                 {
  244.                         baos.write(bytes, 0, length);
  245.                 }
  246.                
  247.                 bis.close();
  248.                 is.close();
  249.                
  250.                 String str = new String(baos.toByteArray());
  251.                 System.out.println(str);
  252.         }       
  253. }

  254. class Student implements Serializable
  255. {
  256.         public int id;
  257.         public String name ;
  258. }
复制代码

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马