• java---IO流：字节流

    字节流写数据
    1. package IO流.字节流.字节流写数据;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. /*
    8.         字节流抽象基类
    9.             inputStream: 这个抽象类是表示字节输入流的所有类的超类
    10.             outputStream: 这个抽象类表示字节输出流的所有类的超类
    11.             子类名特点: 子类名称都是以其父类名作为子类名的后缀
    13.         FileOutputStream:文件输出流  用于将数据写入File
    14.             FileOutputStream(String name): 创建文件输出流以指定的名写入文件
    16.         使用字节输出流写数据的步骤：
    17.             创建字节输出流对象
    18.             调用字节输出流对象的写数据方法
    19.             释放资源
    21.  */
    22. public class 字节流写数据 {
    23.     public static void main(String[] args) throws IOException {
    24.         //创建字节输出流对象
    25.         FileOutputStream fos=new FileOutputStream("idea_text\\fos.txt");
    26.         /*
    27.             做了三件事情：
    28.                 1，调用系统功能创建了文件
    29.                 2，创建了字节输出流对象
    30.                 3，让字节输出流对象指向创建好的文件
    31.          */
    32.  
    33.         //void write​(int b) 将指定的字节写入此文件输出流。
    34.         fos.write(97);
    35. //        fos.write(57);
    36. //        fos.write(55);
    37.  
    38.         //最后都要释放资源
    39.         //void close​() 关闭此文件输出流并释放与此流相关联的任何系统资源
    40.         fos.close();
    41.  
    42.  
    43.     }
    44. }
    字节流写数据的3种方式
    1. package IO流.字节流.字节流写数据;
    2. /*
    3.         void write​(int b)
    4.             将指定的字节写入此文件输出流。
    5.             一次写一个字节数据
    6.         void write​(byte[] b)
    7.             将 b.length字节从指定的字节数组写入此文件输出流。
    8.             一次写一个字节数组数据
    9.         void write​(byte[] b, int off, int len)
    10.             将 len字节从指定的字节数组开始，从偏移量 off开始写入此文件输出流。
    11.             一次写一个字节数组的部分数据
    12.  */
    13.  
    14. import java.io.File;
    15. import java.io.FileNotFoundException;
    16. import java.io.FileOutputStream;
    17. import java.io.IOException;
    18.  
    19. public class 字节流写数据的3种方式 {
    20.     public static void main(String[] args) throws IOException {
    21.         //创建文件输出流以指定的名称写入文件
    22.         FileOutputStream fos = new FileOutputStream("idea_text\\fos.txt");
    23.         //new File(name)
    24. //        FileOutputStream fos = new FileOutputStream(new File("idea_text\\fos.txt"));
    25.  
    26.         //创建文件输出流以写入由指定的File对象表示的文件
    27. //        FileOutputStream(File file)
    28. //        File file=new File("idea_text\\fos.txt");
    29. //        FileOutputStream fos2 = new FileOutputStream(file);
    30. //        FileOutputStream fos2 = new FileOutputStream(new File("idea_text\\fos.txt"));
    31.  
    32. /*        //void write​(int b)
    33.         fos.write(97);
    34.         fos.write(98);
    35.         fos.write(99);
    36.         fos.write(100);
    37.         fos.write(101);*/
    38.  
    39.         //void write​(byte[] b)
    40. //        byte[] bys={97,98,99,100,101};
    41.         //byte[] getBytes() :返回字符串对应的字节数组
    42.         byte[] bys ="abcde".getBytes();
    43. //        fos.write(bys);
    44.  
    45.         //void write​(byte[] b, int off, int len)
    46.         fos.write(bys,1,3);
    47.  
    48.         //释放资源
    49.         fos.close();
    50.  
    51.  
    52.  
    53.  
    54.  
    55.  
    56.     }
    57. }

    字节流写数据的两个小问题
    1. package IO流.字节流.字节流写数据;
    2. /*
    3.         1，字节流写数据如何实现换行呢？
    4.             window：\r\n
    5.             linux:  \n
    6.             mac:   \r
    8.         2,字节流如何实现追加写入呢？
    9.             public FileOutputStream (String name,boolean append)
    10.                 创建文件输出流以指定的名称写入文件
    11.                 如果第二个参数为ture，则字节将写入文件的末尾而不是开头
    13.  */
    14.  
    15. import java.io.FileNotFoundException;
    16. import java.io.FileOutputStream;
    17. import java.io.IOException;
    18.  
    19. public class 字节流写数据的两个小问题 {
    20.     public static void main(String[] args) throws IOException {
    21.         //创建字节输出流对象
    22.         //追加写入
    23.         FileOutputStream fos=new FileOutputStream("idea_text\\fos.txt",true);
    24.  
    25.         //写数据
    26.         for (int i=0;i<10;i++){
    27.             fos.write("hello".getBytes());
    28.             fos.write("\r\n".getBytes());//换行
    29.         }
    30.  
    31.         //释放资源
    32.         fos.close();
    33.     }
    34. }
    字节流写数据加异常处理
    1. package IO流.字节流.字节流写数据;
    2. /*
    3.         finally：
    4.             在异常处理时提供finally块来执行所有的清除操作。
    5.           特点：
    6.                 被finally控制的语句一定会执行，除非JVM退出
    8.  */
    9.  
    10. import java.io.FileNotFoundException;
    11. import java.io.FileOutputStream;
    12. import java.io.IOException;
    13.  
    14. public class 字节流写数据加异常处理 {
    15.     public static void main(String[] args){
    16.  
    17.         //加finally来释放资源
    18.         FileOutputStream fos = null;
    19.         try{
    20.             fos=new FileOutputStream("idea_text\\fos.txt");
    21.             fos.write("hello".getBytes());
    22.         }catch(IOException e){
    23.             e.printStackTrace();
    24.         }
    25.         finally{
    26.             if (fos!=null){
    27.                 try{
    28.                     fos.close();
    29.                 }catch(IOException e){
    30.                     e.printStackTrace();
    31.                 }
    32.             }
    33.  
    34.         }
    35.     }
    36. }
     

     

    字节流读数据：
     

    一次读一个字节数据
     

    1. package IO流.字节流.字节流读数据.一次读一个字节数据;
    2. /*
    3.     字节流读数据：
    4.         需求：
    5.             把文件fos.txt中的内容读取出来在控制台输出
    7.             FileInputStream从文件系统中的文件获取输入字节。
    8.                 FileInputStream​(String name)
    9.                     通过打开与实际文件的连接来创建一个 FileInputStream ，
    10.                     该文件由文件系统中的路径名 name命名。
    12.             使用字节输入流读数据的步骤：
    13.                 1，创建字节输入流对象
    14.                 2，调用字节输入流对象的读取数据方法
    15.                 3，释放资源
    17.  */
    18.  
    19. import java.io.FileInputStream;
    20.  
    21. import java.io.IOException;
    22.  
    23. public class 一次读一个字节数据 {
    24.     public static void main(String[] args) throws IOException {
    25.         //创建字节输入流对象
    26.         //FileInputStream​(String name)
    27.         FileInputStream fis=new FileInputStream("idea_text\\fos.txt");
    28.  
    29.         //调用字节输入流对象的读取数据
    30.         int by;
    31.         /*
    32.             fis.read():读数据
    33.             by=fis.read():把读取的数据赋值给by
    34.             by ！=-1 ：判断读取的数据是否为-1
    35.          */
    36.         while ((by = fis.read()) != -1){
    37.             System.out.println((char)by);
    38.         }
    39.  
    40.         //释放资源
    41.         fis.close();
    42.     }
    43.  
    44. }
     

     
     

     
     

    复制文本文件
     

    1. package IO流.字节流.字节流读数据.一次读一个字节数据;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileNotFoundException;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    7.  
    8. /*
    9.         需求：
    10.             把“D:\\1\\java\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
    12.         分析：
    13.             1，复制文本文件，其实就把文本文件的内容从一个文件中读取出来（数据源）
    14.                 然后写入另一个文件中（目的地）
    15.             2，数据源：
    16.                 D:\\1\\java\\窗里窗外.txt---读数据---InputSteam---FileInputStream
    17.             3，目的地
    18.                 idea_text\\窗里窗外.txt---写数据---OutputStream---FileOutputStream
    20.  */
    21. public class 复制文本文件 {
    22.     public static void main(String[] args) throws IOException {
    23.         //根据数据源创建字节输入流对象
    24.         FileInputStream fis=new FileInputStream("D:\\1\\java\\窗里窗外.txt");
    25.  
    26.         //根据目的地创建字节输出流对象
    27.         FileOutputStream fos=new FileOutputStream("idea_text\\窗里窗外.txt");
    28.  
    29.         //读取数据（一次读取一个字节）
    30.         int by;
    31.         while ((by=fis.read())!=-1){
    32.             fos.write(by);
    33.         }
    34.  
    35.  
    36.         //释放资源
    37.         fis.close();
    38.         fos.close();
    39.  
    40.     }
    41. }
     

    一次读一个字节数组数据
     

    1. package IO流.字节流.字节流读数据.一次读一个字节数组数据;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileNotFoundException;
    5. import java.io.IOException;
    6.  
    7. /*
    8.     字节流读数据：
    9.         需求：
    10.             把文件fos.txt中的内容读取出来在控制台输出
    12.             使用字节输入流读数据的步骤：
    13.                 1，创建字节输入流对象
    14.                 2，调用字节输入流对象的读取数据方法
    15.                 3，释放资源
    17.  */
    18. public class Demo {
    19.     public static void main(String[] args) throws IOException {
    20.         //创建字节输入流对象
    21.         FileInputStream fis=new FileInputStream("idea_text\\fos.txt");
    22.  
    23.         //调用字节输入流对象的读取数据方法
    24.         //int read​(byte[] b) 从该输入流读取最多 b.length个字节的数据到一个字节数组。
    25. /*
    26.         byte[] bys=new byte[5];
    28.         //第一次读数据
    29.         int len = fis.read(bys);
    30.         System.out.println(len);
    31.         //String (byte[] bytes)
    32.         System.out.println(new String(bys));
    34.         //第二次读数据
    35.         len = fis.read(bys);
    36.         System.out.println(len);
    37.         //String (byte[] bytes)
    38.         System.out.println(new String(bys));
    40.         //第三次读数据
    41.         len = fis.read(bys);
    42.         System.out.println(len);
    43.         //String (byte[] bytes)
    44.         System.out.println(new String(bys));
    45.         */
    46. /*
    47.         hello\r\n
    48.         world\r\n
    49.          *//*
    52.         */
    53. /*
    54.         第一次：hello
    55.         第二次：\r\nwor
    56.         第三次：ld\r\nr
    57.          *//*
    60. */
    61.  
    62.         //代码优化：
    63.         byte[] bys =new byte[1024];
    64.         int len;
    65.         while ((len = fis.read(bys)) != -1){
    66.             System.out.println(new String(bys,0,len));
    67.         }
    68.  
    69.         //释放资源
    70.         fis.close();
    71.  
    72.  
    73.     }
    74. }
     

     
     

     
     

    复制图片
     

    1. package IO流.字节流.字节流读数据.一次读一个字节数组数据;
    2.  
    3.  
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.FileOutputStream;
    7. import java.io.IOException;
    8.  
    9.  
    10. /*
    11.         需求：
    12.             把“D:\\1\\1.jpg”复制到模块目录下的“1.jpg”
    14.         思路：
    15.             1，根据数据源创建字节输入流对象
    16.             2，根据目的地创建字节输出流对象
    17.             3，读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
    18.             4，释放资源
    20.  */
    21. public class 复制图片 {
    22.     public static void main(String[] args) throws IOException {
    23.         //根据数据源创建字节输入流对象
    24.         FileInputStream fis = new FileInputStream("D:\\1\\1.jpg");
    25.         //根据目的地创建字节输出流对象
    26.         FileOutputStream fos=new FileOutputStream("idea_text\\1.jpg");
    27.  
    28.         //读写数据
    29.         byte[] bys=new byte[1024];
    30.         int len;
    31.         while((len=fis.read(bys))!=-1){
    32.             fos.write(bys,0,len);
    33.         }
    34.  
    35.         //释放资源
    36.         fis.close();
    37.         fos.close();
    38.  
    39.     }
    40. }
     

    字节缓冲流
     

    1. package IO流.字节流.字节缓冲流;
    2. /*
    4. 1,  BufferOutputStream:该类实现缓冲输出流。
    5.     通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
    6. 2,  BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。
    7.     当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
    9.     构造方法:
    10.     字节缓冲输出流:BufferedOutputStream(OutputStreamout)
    11.     字节缓冲输入流:BufferedInputStream(InputStreamin)
    13.     为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?
    14.     ●字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
    16.  */
    17.  
    18. import java.io.*;
    19.  
    20. public class Demo {
    21.     public static void main(String[] args) throws IOException {
    22. /*
    23.         //字节缓冲输出流:BufferedOutputStream(OutputStreamout)
    24.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("idea_text\\bos.txt"));
    25.         //写数据
    26.         bos.write("hello\r\n".getBytes());
    27.         bos.write("world\r\n".getBytes());
    28.         //释放资源
    29.         bos.close();
    31.         */
    32.  
    33.         //字节缓冲输入流:BufferedInputStream(InputStreamin)
    34.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("idea_text\\bos.txt"));
    35.  
    36.         //一次读取一个字节数据
    37. //        int by;
    38. //        while((by=bos.read())!=-1){
    39. //            System.out.println((char)by);
    40. //        }
    41.  
    42.         //一次读取一个字节数组数据
    43.         byte[] bys=new byte[1024];
    44.         int len;
    45.         while((len=bis.read())!=-1){
    46.             System.out.println(new String(bys,0,len));
    47.         }
    48.  
    49.         //释放资源
    50.         bis.close();
    51.     }
    52. }
     

    复制视频
     

    1. package IO流.字节流.字节缓冲流;
    2. /*
    3.         需求：
    4.             把“D:\\1\\字节流复制视频.avi”复制到模块目录下的“idea_text\\字节流复制视频.avi”
    6.         思路：
    7.             1，根据数据源创建字节输入流对象
    8.             2，根据目的地创建字节输出流对象
    9.             3，读写数据，复制视频
    10.             4，释放资源
    11.  */
    12.  
    13. import java.io.*;
    14.  
    15. public class 复制视频 {
    16.     public static void main(String[] args) throws IOException{
    17.         //记录开始时间
    18.         long startTime = System.currentTimeMillis();
    19.  
    20.         //复制视频
    21.         method1();
    22.  
    23.         //记录结束时间
    24.         long endTime = System.currentTimeMillis();
    25.         System.out.println("共耗时："+(endTime-startTime)+"毫秒");
    26.  
    27.     }
    28.     public static void method1() throws IOException {
    29.         //根据数据源创建字节输入流对象
    30.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\1\\字节流复制视频.avi"));
    31.         //根据目的地创建字节输出流对象
    32.         BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("idea_text\\字节流复制视频.avi"));
    33.  
    34.         //读写数据，复制视频
    35.  
    36.         //一次读写一个字节
    37.         int by;
    38.         while ((by = bis.read()) != -1){
    39.             bos.write(by);
    40.         }
    41.  
    42.         //一次读写以个字节数组数据
    43.         //耗时更少，推荐使用
    44.         byte[] bys=new byte[1024];
    45.         int len;
    46.         while ((len = bis.read())!=-1){
    47.             bos.write(bys,0,len);
    48.         }
    49.  
    50.         //释放资源
    51.         bis.close();
    52.         bos.close();
    53.     }
    54. }
     

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
商品价格区间筛选                            
    
Java~JUC包                            
    
随机化在计算机中的应用:查找和搜索以及信息加密                            
    
python 小案例76                            
    
筑牢安全生产防线，工厂人员定位报警系统护航企业发展                            
    
ChartDirector 7.1.0 for VB Crack                            
    
python--列表应用                            
    
可解释的图像分类，提高组织表征的可信度论文速读                            
    
UDP通信                            
    
小学生C++趣味编程 视频集                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/z2021_000000/article/details/125525145
                
    •