• Java筑基31-IO流01-文件&流分类

    目录

    一、文件基础知识

    二、常用的文件操作

    1.创建文件

    2.获取文件信息

    3.目录操作

    三、IO流原理及流的分类

    1. I/O流原理与分类

    2. I/O流体系图

    3.字节流

    4.字符流

    一、文件基础知识

    什么是文件？

    什么是文件流？

    二、常用的文件操作

    1.创建文件

    1. package com.feiyang.basic15_file;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description:创建文件
    10.  */
    11. public class FileCreate {
    12.     public static void main(String[] args) throws IOException {
    13.  
    14.         //方式一：根据路径
    15.         File file1 = new File("d:\\new1.txt");
    16.         if(file1.createNewFile()){
    17.             System.out.println("创建ok~");
    18.         }else{
    19.             System.out.println("创建失败~");
    20.         }
    21.  
    22.         //方式二：根据父目录文件+子路径
    23.         File file2 = new File(new File("d:\\"), "new2.txt");
    24.         if(file2.createNewFile()){
    25.             System.out.println("创建ok~");
    26.         }else{
    27.             System.out.println("创建失败~");
    28.         }
    29.  
    30.         //方式三：根据父目录+子路径
    31.         File file3 = new File("d:\\", "new3.txt");
    32.         if(file3.createNewFile()){
    33.             System.out.println("创建ok~");
    34.         }else{
    35.             System.out.println("创建失败~");
    36.         }
    37.  
    38.     }
    39. }

    2.获取文件信息

    1. package com.feiyang.basic15_file;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5. import java.text.SimpleDateFormat;
    6. import java.time.format.DateTimeFormatter;
    7. import java.util.Date;
    8.  
    9. /**
    10.  * @author：飞扬
    11.  * @公众hao：程序员飞扬
    12.  * @description:获取文件信息
    13.  */
    14. public class FileInformation {
    15.     public static void main(String[] args) throws IOException {
    16.  
    17.         File file = new File("d:\\hello.txt");
    18.         //file.createNewFile();//真正的创建文件
    19.  
    20.         System.out.println("文件名==" + file.getName());
    21.         System.out.println("文件大小（字节数）==" + file.length()); //只针对文件有效
    22.  
    23.         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyyMMdd HHmmss");
    24.         System.out.println("文件最后一次修改时间：" + file.lastModified());
    25.         Date date = new Date();
    26.         date.setTime(file.lastModified());
    27.         String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
    28.         System.out.println("文件最后一次修改时间：" + format);
    29.  
    30.         System.out.println("文件绝对路径：" + file.getAbsolutePath());
    31.         System.out.println("文件父路径：" + file.getParent());
    32.  
    33.         //判断
    34.         System.out.println(file.exists());//是否存在
    35.         System.out.println(file.isFile());//是否是文件
    36.         System.out.println(file.isDirectory());//是否是目录
    37.  
    38.  
    39.     }
    40. }

    3.目录操作

    1. package com.feiyang.basic15_file;
    2.  
    3. import org.junit.jupiter.api.Test;
    4. import java.io.File;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description:目录操作
    10.  */
    11. public class Directory_ {
    12.     public static void main(String[] args) {
    13.  
    14.     }
    15.  
    16.     //判断文件是否存在，存在就删除，否则提示不存在
    17.     @Test
    18.     public void m1(){
    19.         File file = new File("d:\\new1.txt");
    20.         if(file.exists()){
    21.             if(file.delete()){
    22.                 System.out.println("文件删除成功~");
    23.             }else{
    24.                 System.out.println("文件删除失败~");
    25.             }
    26.         }else{
    27.             System.out.println("文件不存在~");
    28.         }
    29.     }
    30.  
    31.     //判断目录d:\demo1是否存在，存在就删除，不存在就提示
    32.     //java中，目录也被当作文件
    33.     @Test
    34.     public void m2(){
    35.         File file = new File("d:\\demo1");
    36.         if(file.exists()){
    37.             if(file.delete()){
    38.                 System.out.println("删除成功~");
    39.             }else{
    40.                 System.out.println("删除失败~");
    41.             }
    42.         }else{
    43.             System.out.println("该目录不存在~");
    44.         }
    45.     }
    46.  
    47.     //判断目录是否存在d:\demo\a\b\c，不存在就创建
    48.     @Test
    49.     public void m3(){
    50.         File file = new File("d:\\demo\\a\\b\\c");
    51.         if(file.exists()){
    52.             System.out.println("该文件已存在");
    53.         }else{
    54.             boolean mkdirs = file.mkdirs();
    55.             if(mkdirs){
    56.                 System.out.println("多级目录创建成功");
    57.             }else{
    58.                 System.out.println("多级目录创建失败");
    59.             }
    60.         }
    61.     }
    62.  
    63. }

    三、IO流原理及流的分类

    1. I/O流原理与分类

    2. I/O流体系图

    3.字节流

    1.FileInputStream

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description:字节输入流（文件 → 程序）
    5.  */
    6.  
    7. public class FileInputStream_ {
    8.     public static void main(String[] args){
    9.     }
    10.  
    11.     @Test
    12.     public void read01(){
    13.         FileInputStream fis = null;
    14.         try {
    15.             fis = new FileInputStream(new File("d:\\new2.txt"));
    16.             //从该输入流读取一个字节的数据，如果没有输入可用该方法将阻止
    17.             //如果返回-1，表示读取完毕
    18.             int read;
    19.             while((read = fis.read()) != -1){
    20.                 System.out.print((char)read);
    21.             }
    22.             System.out.println("========================");
    23.  
    24.             //
    25.             byte[] b = new byte[1024 * 2];
    26.             int len;
    27.             while((len = fis.read(b)) != -1){
    28.                 System.out.print(new String(b,0,len));
    29.             }
    30.         } catch (IOException e) {
    31.             e.printStackTrace();
    32.         }finally {
    33.             try {
    34.                 fis.close();
    35.             } catch (IOException e) {
    36.                 e.printStackTrace();
    37.             }
    38.         }
    39.     }
    40.  
    41.  
    42.     @Test
    43.     public void read02() {
    44.         FileInputStream fis = null;
    45.         try {
    46.             fis = new FileInputStream(new File("d:\\new2.txt"));
    47.             byte[] b = new byte[1024]; //一次读取1024个字节
    48.             int len;
    49.             //从输入流读取最多b.length个字节的数据到字节数组
    50.             while((len = fis.read(b)) != -1){
    51.                 System.out.print(new String(b,0,len));
    52.             }
    53.         } catch (IOException e) {
    54.             e.printStackTrace();
    55.         }finally {
    56.             try {
    57.                 fis.close();
    58.             } catch (IOException e) {
    59.                 e.printStackTrace();
    60.             }
    61.         }
    62.     }
    63. }

    2.FileOutPutStream

    1. import org.junit.jupiter.api.Test;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description: 字节输出流
    9.  */
    10. public class FileOutPutStream_ {
    11.  
    12.  
    13.     @Test
    14.     public void method1() throws IOException {
    15.         String file = "d:\\a.txt";
    16.         FileOutputStream ost = null;
    17.         try {
    18.             //ost = new FileOutputStream(file);//会覆盖
    19.             ost = new FileOutputStream(file,true);//不会会覆盖
    20.             //写入一个字节
    21.             //ost.write('E');
    22.  
    23.             //写入多个字符
    24.             String s = "Hello World!";
    25.             byte[] bytes = s.getBytes();
    26.             //ost.write(bytes);
    27.  
    28.             //写入指定范围的字符串
    29.             ost.write(bytes,0,5);
    30.  
    31.         } catch (IOException e) {
    32.             e.printStackTrace();
    33.         }finally {
    34.             try{
    35.                 ost.close();
    36.             }catch (Exception ex){
    37.                 ex.printStackTrace();
    38.             }
    39.  
    40.         }
    41.     }
    42. }

    3.文件拷贝

    1. import java.io.FileInputStream;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description: 文件拷贝
    9.  */
    10. public class FileCopy {
    11.     public static void main(String[] args) {
    12.  
    13.         //完成思路：先读再写
    14.         
    15.         FileInputStream fis;
    16.         FileOutputStream fos;
    17.  
    18.         String srcFile = "d:\\aaa.jpg";
    19.         String destFile = "d:\\aaa2.jpg";
    20.  
    21.         byte[] bytes = new byte[1024];
    22.         try {
    23.             fis = new FileInputStream(srcFile);
    24.             fos = new FileOutputStream(destFile);
    25.             int readLen = 0;
    26.             while((readLen = fis.read(bytes)) != -1){
    27.                 fos.write(bytes,0,readLen);
    28.             }
    29.             System.out.println("拷贝ok~");
    30.  
    31.         } catch (IOException e) {
    32.             e.printStackTrace();
    33.         }
    34.     }
    35. }

    4.字符流

    1.FileReader

    1. package com.feiyang.basic15_file;
    2.  
    3. import java.io.FileReader;
    4. import java.io.IOException;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description: 字符输入流
    10.  */
    11. public class FileReader_ {
    12.     public static void main(String[] args) {
    13.         String filePath = "d:\\hello.txt";
    14.         FileReader fileReader = null;
    15.         int data = 0;
    16.  
    17.         try {
    18.             //创建流对象
    19.             fileReader = new FileReader(filePath);
    20.             //读取，每次读取单个字符，如果文件到末尾返回-1
    21.             /*while((data=fileReader.read()) != -1){
    22.                 System.out.print((char)data);
    23.             }*/
    24.  
    25.             //批量读取多个字符到char[],返回读到的实际字符个数
    26.             char[] chars = new char[5];
    27.             while((data=fileReader.read(chars)) != -1){
    28.                 System.out.print(new String(chars,0,data));
    29.             }
    30.         }catch (IOException e){
    31.             e.printStackTrace();
    32.         }finally {
    33.             if(fileReader != null){
    34.                 try {
    35.                     fileReader.close();
    36.                 } catch (IOException e) {
    37.                     e.printStackTrace();
    38.                 }
    39.             }
    40.         }
    41.     }
    42. }

    2.FileWriter

    1. package com.feiyang.basic15_file;
    2.  
    3. import java.io.FileWriter;
    4. import java.io.IOException;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description: 字符输出流
    10.  */
    11. public class FileWriter_ {
    12.     public static void main(String[] args) {
    13.         String filePath = "d:\\note.txt";
    14.         FileWriter fileWriter = null;
    15.  
    16.         try {
    17.             fileWriter = new FileWriter(filePath,true);//追加模式
    18.             fileWriter.write('H'); //写入单个字符
    19.  
    20.             char[] chars = {'飞','扬'};
    21.             fileWriter.write(chars); //写入字符数组
    22.             fileWriter.write("公众号：".toCharArray(),0,4); //写入指定长度的字符数组
    23.             fileWriter.write("程序员飞扬"); //写入整个字符串
    24.             fileWriter.write("java全栈知识体系公众号",0,13); //写入指定长度的字符串
    25.         } catch (IOException e) {
    26.             e.printStackTrace();
    27.         }finally {
    28.             try {
    29.                 if(fileWriter != null){
    30.                     //fileWriter.flush();
    31.                     fileWriter.close(); //切记一定要刷新或关闭流，否则无法写入文件
    32.                 }
    33.             } catch (IOException e) {
    34.                 e.printStackTrace();
    35.             }
    36.         }
    37.     }
    38. }

  • 相关阅读:
    java中json转list和map的嵌套
    一种曲线递增策略的自适应粒子群算法研究-附代码
    C#使用OpenCv（OpenCVSharp）图像轮廓凸包检测与绘制
    设计模式-备忘录模式（Memento Pattern）
    运维监控背景信息
    事件捕获和时间冒泡，event.stopPropagation()；event.preventDefault()；和js jquery取消事件
    python argparse 库
    计算机毕业设计Java瀚绅睿茨二人二轮车租赁管理(源码+系统+mysql数据库+lw文档)
    linux 学习笔记
    Maven项目的目录结构
  • 原文地址：https://blog.csdn.net/lu_xin5056/article/details/126833817