IO流

最新推荐文章于 2025-08-15 22:56:20 发布
最新推荐文章于 2025-08-15 22:56:20 发布
阅读量134 收藏
点赞数
分类专栏： IO流 文章标签： java IO流
本文深入讲解Java中的IO流概念，包括File类的功能与使用方法，FileInputStream与FileOutputStream的读写操作，以及字符流和字节流的区别。通过实例演示了文件的读取、写入、复制和数据包装流的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/*

  • File类是java.io包下代表与平台无关的文件和目录
  • */
    package com.imti.day0428;

import java.io.File;
import java.io.IOException;

/*

  • File类是java.io包下代表与平台无关的文件和目录

  • */
    public class FileDemo
    {
    public static void main(String[] args) {

     // 创建一个File对象
 String filePath = "D:/IO流/课件/输入与输出.doc";
 File mFile = new File(filePath);

 // 读取文件的信息
 System.out.println("可读：" + mFile.canRead());
 System.out.println("可写：" + mFile.canWrite());
 System.out.println("文件名称：" + mFile.getName());
 System.out.println("文件路径：" + mFile.getPath());
 System.out.println("文件绝对路径：" + mFile.getAbsolutePath());
 System.out.println("文件的父路径：" + mFile.getParent());
 System.out.println("文件大小：" + mFile.length());
 System.out.println("文件的修改日期：" + mFile.lastModified());
 System.out.println("文件是否存在：" + mFile.exists());

 System.out.println("=================================");

 /*
  * 1.创建一个文件对象， 判断此文件是否存在 2.如果存在，则判断此文件是文件还是目录，然后输出文件的名称和路径， 3.如果不存在则创建一个文件或目录
  */

 // 1.创建一个文件对象，
 File myFile = new File("D:/mytest");

 // 2.判断此文件是否存在
 if (myFile.exists()) {
 	// 则判断此文件是文件还是目录
 	if (myFile.isFile()) {
 		System.out.println("是一个文件!");
 		System.out.println("文件名称：" + myFile.getName());
 		System.out.println("文件路径：" + myFile.getPath());
 	} else {
 		System.out.println("是一个目录!");
 		System.out.println("文件名称：" + myFile.getName());
 		System.out.println("文件路径：" + myFile.getPath());
 	}
 } else {

 	try {
 		// 如果是文件，则创建文件
 		if (myFile.isFile()) {
 			myFile.createNewFile();
 			System.out.println("文件创建成功!");
 		} else {
 			// 如果是目录，则创建目录
 			// 创建一级目录
 			// myFile.mkdir();
 			// 创建多级目录
 			myFile.mkdirs();
 			System.out.println("目录创建成功!");
 		}
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

 System.out.println("==========================");

 // 1.创建一个指定名称和后缀的文件
 // createTempFile(String prefix, String suffix) ：
 // 在默认临时文件目录中创建一个空文件，使用给定的前缀和后缀生成其名称。

 try {
 	File file = File.createTempFile("Car", ".java");
 	System.out.println("文件路径：" + file.getPath());

 	// static File createTempFile(String prefix, String suffix, File directory) :
 	// 在指定的目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。

 	File file2 = File.createTempFile("myfile", null, new File("D:/"));
 	System.out.println("file2:" + file2.getPath());

 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 }

 System.out.println("=====================");
 File file3 = new File("D:/");

 // 列出File对象的所有子文件名和目录名
 String[] fileNames = file3.list();

 for (String fileName : fileNames) {
 	System.out.println(fileName);
 }

 System.out.println("=================");
 //  File[] listFiles()：列出File对象的所有子文件和目录对象。

 File file4 = new File("D:/JDBC");
 /*
  * File[] files = file4.listFiles(); for (File file : files) { if
  * (file.isFile()) System.out.println("文件：" + file.getName()); else {
  * System.out.println("一级目录："); System.out.println("目录：" + file.getName());
  * 
  * // 获取目录下的所有文件 files = file.listFiles(); for (File file2 : files) { if
  * (file2.isFile()) System.out.println("文件：" + file2.getName()); else {
  * System.out.println("二级目录："); System.out.println("目录：" + file2.getName()); } }
  * } }
  */
 showFileList(file4);

    }

    // 显示指定目录下所有的文件和目录
    public static void showFileList(File myFile) {
    if (myFile == null)
    return;

     if (myFile.isFile()) {
 	System.out.println("是一个文件:" + myFile.getName());
 	return;
 }

 // 列出File对象的所有子文件和目录对象。
 File[] files = myFile.listFiles();

 // 循环遍历
 for (File file : files) {
 	if (file.isFile()) {
 		System.out.println("文件：" + file.getName());
 	} else {
 		System.out.println("目录：" + file.getName());
 		// 递归
 		showFileList(file);
 	}
 }

    }
    }

1.读取一个.txt的文件
package com.imti.day0428;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*

  • FileInputStream:文件字节流，常用于读取二进制文件，如图片，声音，影像等

  • 1.读取一个.txt的文件

  • */
    public class FileInputStreamDemo
    {

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    FileInputStreamDemo isd = new FileInputStreamDemo();

     File mFile = new File("D:/test.txt");
 isd.readOneByOne(mFile);

 System.out.println("\n==========一次读取多个字节======");
 isd.readMultiple(mFile);

    }

    /**

    • 一次读取一个字节

    • @param file
      */
      public void readOneByOne(File file) {
      FileInputStream inputStream = null;
      try {
      // 创建FileInputStream对象
      inputStream = new FileInputStream(file);

       /**
  * 1.一次读取一个字节 该返回值是一个 0 到 255 范围内的 int
  * 字节值（将字节值转换为int值，低8位为有效值，高24位补0）。如果因已到达流末尾而没有可用的字节，则返回值 -1。
  */
 int num = 0;

 // 循环读取
 while ((num = inputStream.read()) != -1) {
 	System.out.print((char) num);
 }

      } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      } finally {
      // 关闭流，释放资源
      try {
      if (inputStream != null)
      inputStream.close();
      } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      }
      }
      }

    /**

    • 一次读取1024个字节

    • @param file
      */
      public void readMultiple(File file) {
      FileInputStream fis = null;

      try {
      // 创建对象
      fis = new FileInputStream(file);

       // 定一个缓冲的字节数组
 byte[] b = new byte[1024];

 int num = 0;

 // 循环读取文件的数据，直到文件末尾
 // while ((num = fis.read(b)) != -1) {
 // System.out.write(b);
 // }

 while ((num = fis.read(b, 0, b.length)) != -1) {
 	System.out.write(b, 0, b.length);
 }

      } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      } finally {
      try {
      if (fis != null)
      fis.close();
      } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      }
      }
      }
      }

文件过滤器
package com.imti.day0428;

import java.io.File;
import java.io.FilenameFilter;

/*

  • 文件过滤器

  • FileNameFilter

  • */
    public class FileNameFilterDemo
    {
    public static void main(String[] args) {

     FileNameFilterDemo ffd = new FileNameFilterDemo();

 File myFile = new File("D:/");
 ffd.filterFile(myFile);

    }

    // 过滤指定目录下的图片
    public void filterFile(File myFile) {
    if (myFile == null)
    return;

     // 过滤
 File[] files = myFile.listFiles(new FilenameFilter() {

 	@Override
 	public boolean accept(File dir, String name) {
 		// TODO Auto-generated method stub
 		return isPNG(name) || isJPG(name) || isGIF(name);
 	}

 	// 图片：.jpg(.JPG) .png(.PNG) .gif(.GIF)
 	public boolean isPNG(String name) {
 		return name.toLowerCase().endsWith(".png");
 	}

 	public boolean isJPG(String name) {
 		return name.toLowerCase().endsWith(".jpg");
 	}

 	public boolean isGIF(String name) {
 		return name.toLowerCase().endsWith(".gif");
 	}
 });

 // 输出：
 for (File file : files) {
 	System.out.println("文件：" + file.getName());
 }

    }

    // 显示指定目录下所有的文件和目录
    public static void showFileList(File myFile) {
    if (myFile == null)
    return;

     if (myFile.isFile()) {
 	System.out.println("是一个文件:" + myFile.getName());
 	return;
 }

 // 列出File对象的所有子文件和目录对象。
 File[] files = myFile.listFiles();

 // 循环遍历
 for (File file : files) {
 	if (file.isFile()) {
 		System.out.println("文件：" + file.getName());
 	} else {
 		System.out.println("目录：" + file.getName());
 		// 递归
 		showFileList(file);
 	}
 }

    }
    }

演示：将指定的内容，写入指定文件中
package com.imti.day0428;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*

  • FileOutputStream:文件字节输出流,以字节的方式向文件中写数据

  • 演示：将指定的内容，写入指定文件中

  • */
    public class FileOutputStreamDemo
    {
    public static void main(String[] args) {
    FileOutputStream fos = null;
    try {

     	// 创建文件字节输出流对象
 	/*
 	 * 注：1.指定的文件可以不存在，但是不能指定一个被其他程序打开的文件 2.如果指定的文件中有内容，则会覆盖内容
 	 */
 	fos = new FileOutputStream("D:/a.txt");

 	// 创建一个字节数组
 	// byte[] b = { 'I', 'L', 'O', 'V', 'E', 'C', 'H', 'I', 'N', 'A' };
 	// 写入数据
 	// fos.write(b);

 	// 定义一个字符串对象
 	String content = "I LOVE CHINA";
 	fos.write(content.getBytes());

 	System.out.println("写入成功!");
 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (fos != null)
 			fos.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

FileReader是用于读取字符流
package com.imti.day0428;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*

  • FileReader是用于读取字符流

  • */
    public class FileReaderDemo
    {
    public static void main(String[] args) {
    // TODO Auto-generated method stub

     // 创建一个FileReader对象
 FileReader fr = null;
 try {
 	fr = new FileReader("D:/a.txt");

 	int num = 0;
 	// 单个字符读取
 	// while ((num = fr.read()) != -1) {
 	// System.out.print((char) num);
 	// }

 	// 一次读取多个字符
 	char[] buff = new char[1024];
 	while ((num = fr.read(buff)) != -1) {

 		// 将字符数组转换成String对
 		String str = new String(buff, 0, buff.length);
 		System.out.print(str);
 	}

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (fr != null)
 			fr.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

演示：使用FileInputStream和FileOutputStream复制一张图片
package com.imti.day0428;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*

  • 演示：使用FileInputStream和FileOutputStream复制一张图片

  • 1.原图片

  • 2.字节输入和输出流对象

  • */
    public class FileCopyDemo
    {
    public static void main(String[] args) {
    // 创建需要复制的文件对象
    File imgFile = new File(“D:/one.jpg”);

     // 复制后的文件对象
 File copyFile = new File("D:/one_copy.jpg");

 FileInputStream fis = null;
 FileOutputStream fos = null;
 try {
 	// 创建输入流和输出对象
 	fis = new FileInputStream(imgFile);
 	fos = new FileOutputStream(copyFile);

 	// 创建字节数组，一次读取1024个字节
 	byte[] b = new byte[1024];
 	int num = 0;

 	// 循环读取文件，直到文件末尾
 	while ((num = fis.read(b)) != -1) {
 		// System.out.write(b);
 		// 向文件中写入数据
 		fos.write(b);
 	}

 	System.out.println("复制成功!");

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (fos != null)
 			fos.close();

 		if (fis != null)
 			fis.close();

 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

字节输入缓冲流：BufferedInputStream
package com.imti.day0429;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*

  • 字节输入缓冲流：BufferedInputStream

  • 1.skip():跳过指定的字节数

  • 2.mark():标记读取的输入流的点

  • a.读取过的字节，在将要读取下一个字节时，才能做标记，如11，标记值为10

  • b.在读的过程中，读取的次数要小于字节数

  • 3.reset():读取最后一次mark操作后读取的数据

  • */
    public class BufferedInputStreamDemo
    {
    public static void main(String[] args) {
    // TODO Auto-generated method stub

     // 定义一个字节输入流对象
 FileInputStream fis = null;
 // 定义输入缓冲流对象
 BufferedInputStream bis = null;

 try {
 	fis = new FileInputStream(new File("src/file/FileReaderAndWriterDemo.java"));
 	bis = new BufferedInputStream(fis);

 	// 获取输入流最大的字节数
 	int avacount = bis.available();
 	System.out.println("输入流中最大的字节数：" + avacount); // 1823

 	// 统计字节数
 	int num = 0;

 	// 读取600个
 	for (int i = 0; i < 600; i++) {
 		System.out.print((char) bis.read());
 		num++;
 	}

 	// 标记读取的输入流的点
 	bis.mark(100);
 	bis.mark(200);
 	bis.mark(300);

 	// 读取自最后一次 mark 操作后读取的所有字节
 	bis.reset();

 	// 跳过600字节
 	bis.skip(600);

 	for (int i = 0; i < avacount - 600; i++) {
 		System.out.print((char) bis.read());
 		num++;
 	}

 	System.out.println("一共读取了num=" + num);
 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (bis != null)
 			bis.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

BufferedOutputStream
package com.imti.day0429;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*

  • 字节缓冲输出流：BufferedOutputStream类先把数据写到缓冲区，在默认情况下，只有当缓冲区满的时候，才会把缓冲区的数据真正写到数据宿，这样能减少物理写数据的次数。

  • 为了保证BufferedOutputStream会把缓冲区的数据写到文件中，最好是在写操作完成后，调用flush()方法，该方法会立即执行一次把缓冲区中的数据写到文件的操作。

  • */
    public class BufferedOutputStreamDemo
    {

    public static void main(String[] args) {
    // TODO Auto-generated method stub

     // 创建BufferedOutputStream对象
 BufferedOutputStream bos = null;

 try {
 	bos = new BufferedOutputStream(new FileOutputStream(new File("D:/fr.txt")));

 	String str = "今天天气真好!";
 	bos.write(str.getBytes());

 	// 将缓冲区的数据一次写入到文件中
 	bos.flush();

 	System.out.println("写入成功!");

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (bos != null)
 			bos.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

使用字符缓冲流读写文件
package com.imti.day0429;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*

  • 使用字符缓冲流读写文件

  • 1.readLine()：一次读取一行的数据

  • 2.newLine()：写入一个行分隔符

  • */
    public class BufferedReaderAndWriterDemo
    {

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
    // 创建字符缓冲流输入和输出对象
    br = new BufferedReader(new FileReader(new File(“src/file/FileReaderAndWriterDemo.java”)));
    bw = new BufferedWriter(new FileWriter(new File(“D:/FileReaderAndWriterDemo.java”)));

     	// 读写文件
 	String info = null;
 	while ((info = br.readLine()) != null) {
 		System.out.println(info);

 		// 将数据写入文件中
 		bw.write(info);
 		// 开辟一个新行
 		bw.newLine();
 	}

 	// 调用flush()方法， 把缓冲区中的数据写到文件
 	bw.flush();

 	System.out.println("文件复制成功!");
 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (bw != null)
 			bw.close();

 		if (br != null)
 			br.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

.BufferedReader
package com.imti.day0429;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*

  • 1.BufferedReader可以先把一批数据读到缓冲区中，接下来的读操作都从缓冲区内获取数据，避免每次都从数据源读取数据并进行字符编码转换，从而提高读操作的效率。

  • 2.BufferedReader的readLine()方法可以一次读入一行字符，以字符串形式返回

  • */
    public class BufferedReaderDemo
    {
    public static void main(String[] args) {
    // TODO Auto-generated method stub

     // 创建BufferedReader对象
 FileReader in = null;
 BufferedReader br = null;
 try {
 	in = new FileReader("src/file/a.txt");
 	br = new BufferedReader(in);

 	/*
 	 * // 创建字符数组缓冲区 char[] cbuf = new char[1024]; // 读取数据 int num = -1; while ((num
 	 * = br.read(cbuf)) != -1) {
 	 * 
 	 * String str = new String(cbuf); System.out.println(str); }
 	 */

 	// 一行一行的读取数据:readLine(),如果已达到流的末尾，则为null
 	String str = null;
 	while ((str = br.readLine()) != null) {
 		System.out.println(str);
 	}

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (br != null)
 			br.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

BufferedWriter
package com.imti.day0429;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*

  • BufferedWriter也带有缓冲区，它可以先把一批数据写到缓冲区内，当缓冲区满的时候，再把缓冲区的数据写到字符输出流中。 这可以避免每次都执行物理写操作，从而提高IO操作的效率

  • */
    public class BufferedWriterDemo
    {
    public static void main(String[] args) {
    // 创建BufferedWriter对象
    BufferedWriter bw = null;

     try {
 	bw = new BufferedWriter(new FileWriter("src/file/w.txt"));

 	String info = "BufferedWriter也带有缓冲区，它可以先把一批数据写到缓冲区内，当缓冲区满的时候，再把缓冲区的数据写到字符输出流中";
 	bw.write(info);

 	System.out.println("数据写入成功!");
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (bw != null)
 			bw.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

数据包装流(DataInputStream,DataOutputStream)
package com.imti.day0429;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*

  • 数据包装流(DataInputStream,DataOutputStream)

  • DataInputStream和DataOutputStream可提供一些对Java基本数据类型读/写的方法，像读/写int、double和boolean等的方法。

  • 由于Java的数据类型大小是规定好的，在读/写这些基本数据类型时，就不用担心不同平台间数据大小不同的问题。
    DataInputStream应该和DataOutputStream配套使用，这样才能保证获得正确的

    演示：1.将数据写入文件中
    2.读取指定文件的数据

  • */
    public class DataInputAndOutputStreamDemo
    {
    public static void main(String[] args) {

     // 创建DataOutputStream对象
 FileOutputStream fos = null;
 BufferedOutputStream bos = null;
 DataOutputStream dos = null;

 // 创建数据包装流的输入流
 FileInputStream fis = null;
 BufferedInputStream bis = null;
 DataInputStream dis = null;

 try {
 	// 输出流
 	fos = new FileOutputStream(new File("src/file/dos.txt"));
 	bos = new BufferedOutputStream(fos);
 	dos = new DataOutputStream(bos);

 	// 输入流
 	fis = new FileInputStream(new File("src/file/dos.txt"));
 	bis = new BufferedInputStream(fis);
 	dis = new DataInputStream(bis);

 	// 向文件中写数据整型数据
 	dos.writeByte(5);
 	dos.writeShort(6);
 	dos.writeInt(15);
 	dos.writeLong(56);

 	// 浮点型数据
 	dos.writeDouble(4.5);
 	dos.writeFloat(2.3f);

 	// 布尔型数据
 	dos.writeBoolean(true);

 	// 字符型
 	dos.writeChar(97);

 	// 字符串
 	dos.writeUTF("hello");

 	// 调用flush
 	dos.flush();
 	System.out.println("数据写入成功!");

 	// 从指定文件中读取数据
 	System.out.println("读取的数据：");
 	System.out.println(dis.readByte());
 	System.out.println(dis.readShort());
 	System.out.println(dis.readInt());
 	System.out.println(dis.readLong());

 	System.out.println(dis.readDouble());
 	System.out.println(dis.readFloat());

 	System.out.println(dis.readBoolean());
 	System.out.println(dis.readChar());
 	System.out.println(dis.readUTF());

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	// 关闭资源
 	try {
 		if (dos != null)
 			dos.close();

 		if (dis != null)
 			dis.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

功能：读写一个文本文件
package com.imti.day0429;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*

  • 字符流：读写文本文件

  • FileReader，FileWriter

  • 功能：读写一个文本文件

  • 注：1.使用FileInputStream和FileOutputStream读写中文的字符会出现乱码，而且字节流只提供对字节或字节数组的读取方法

  • 2.java中汉字在文件中占2个字节

  • 3.使用字符流解决读取中文出现乱码的情况

  • */
    public class FileReaderAndWriterDemo
    {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    FileReader fr = null;
    FileWriter fw = null;

     try {
 	// 创建字符流的输入和输出对象
 	fr = new FileReader(new File("src/file/a.txt"));
 	// fw = new FileWriter(new File("D:/a_bak.txt"));

 	// boolean类型的参数，如果为true表示将内容追加到文件的末尾，如果为false，则表示覆盖原文件的内容
 	fw = new FileWriter(new File("D:/a_bak.txt"), false);

 	// 定义一个字符数组缓存区
 	char[] cbuf = new char[1024];

 	int num = fr.read(cbuf);

 	// 如果没有到达文件末尾
 	while (num != -1) {

 		// 更新变量值
 		num = fr.read(cbuf);

 		// 将字符数组转换成字符串
 		String info = new String(cbuf);

 		// 将数据写入指定文件中
 		fw.write(info);
 		System.out.println(info);
 	}

 	// 清空缓存区:把缓存区的内容输出到文件中
 	fw.flush();

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	try {
 		if (fw != null) {
 			fw.close();
 		}

 		if (fr != null) {
 			fr.close();
 		}
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

打印流
package com.imti.day0429;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/*

  • 打印流

  • 1.与其他输出流不同，PrintStream永远不会抛出IOException

  • 2.自带刷新功能，可以自动调用flush（）

  • 3.使用PrintStream可自动进行字符转换的动作，默认会使用操作系统的变量来处理对应的字符转换动作

  • 演示：将数据打印到指定的文件中

  • */
    public class PrintStreamDemo
    {
    public static void main(String[] args) {
    // TODO Auto-generated method stub

     // 创建打印流对象
 PrintStream ps = null;
 FileOutputStream fos = null;
 try {
 	ps = new PrintStream(new File("src/file/ps.txt"));
 	fos = new FileOutputStream(new File("src/file/ps2.txt"));

 	// 整型数据
 	ps.print(5);
 	ps.print('5');
 	ps.println(true);
 	ps.println(1.5f);
 	ps.println("test");

 	// 向指定文件中写入数据
 	fos.write(5);

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	if (ps != null)
 		ps.close();

 	try {
 		if (fos != null)
 			fos.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

字节流：读写二进制文件，如图片，视频，音频等
package com.imti.day0429;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*

  • 字节流：读写二进制文件，如图片，视频，音频等

  • FileInputStream 和FileOutputStream

  • 功能：复制一张图片

  • */
    public class TestFileStreamDemo
    {
    public static void main(String[] args) {

     FileInputStream fis = null;
 FileOutputStream fos = null;
 try {
 	// 创建输入流和输出流对象
 	fis = new FileInputStream(new File("src/img/k.jpg"));
 	fos = new FileOutputStream(new File("D:/k_bak.jpg"));
 	/*
 	// 创建一个byte字节数组的缓存区
 	byte[] b = new byte[1024];

 	int num = -1;
 	// 读文件
 	while ((num = fis.read(b)) != -1) {
 		// 将输入写入文件中
 		fos.write(b);
 	}
 	 */
 	
 	// 使用available()方法获取流的最大字节数
 	int count = fis.available();
 	byte[] b = new byte[count];
 	System.out.println("可读字节数：" + count);
 	fis.read(b);
 	fos.write(b);
 	
 	System.out.println("文件复制成功!");

 } catch (FileNotFoundException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } catch (IOException e) {
 	// TODO Auto-generated catch block
 	e.printStackTrace();
 } finally {
 	// 关闭输入和输出流，释放资源
 	try {
 		if (fos != null)
 			fos.close();

 		if (fis != null)
 			fis.close();
 	} catch (IOException e) {
 		// TODO Auto-generated catch block
 		e.printStackTrace();
 	}
 }

    }
    }

Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
Java中文件IO流.pdf
07-11
Java 中文件 IO 流 Java 中文件 IO 流是指 Java 语言中对文件的输入输出操作，通过定义文件流来实现文件的读写操作。文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream ...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 16万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java：IO流详解
游手好闲
01-06 1万+
Java：IO流详解
javaIO流详解
weixin_46676497的博客
01-27 3645
java常用io流介绍
io流
qq_40977337的博客
05-09 3207
IO流 java.io包 1.什么是流？ io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 字节流 byte 字符流 char ...
java基础：IO流
weixin_62944431的博客
11-04 1913
目录序一、IO流开篇1、概念2、流的分类3、IO流的作用4、IO流的使用场景二、字节流1、字节流抽象基类2、字节流写数据（1）基本步骤（2）三种方式（3）两个问题（4）异常处理3、字节缓冲流（1）基本分类&概述（2）构造方法（3）代码演示三、字符流1、概念2、分类（1）字符流体系图（2）字符输入流（Reader）（3）字符输出流（Writer）3、字符缓冲流（1）概念（2）构造方法（3）代码演示（4）字符缓冲流特有功能四、IO特殊操作流。
java中的IO流
炭烤玛卡巴卡的博客
07-23 1747
存储和读取数据的解决方案。
Java中的IO流-最全最基础的IO流概述和简介
是程序喵呀
08-23 4022
Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。
Java io流 详解
m0_68987535的博客
06-11 5144
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、...
Java——琐碎知识点2
2401_88065518的博客
08-15 390
Java基础知识点：Java官方帮助文档、Scanner扫描器、快捷键、“==”做比较、获取代码运行时间、打印对象名时不会出现内存地址的类型、Arrays类常用方法、循环标号的使用、Lambda表达式、异常处理、Java浮点数的精度问题（BigDecimal）、DecimalFormat格式化数字工具、printf格式化输出
JavaScript 核心基础：类型检测、DOM 操作与事件处理
最新发布
热爱音乐和二次元！
08-15 717
本文系统梳理 JavaScript 核心知识点，包括数据类型检测规则、遍历方式、DOM操作和事件处理。重点解析 typeof 运算符对不同数据类型的检测结果，数组与对象的遍历方法差异，以及使用 querySelector 获取元素的现代方案。同时详细讲解事件绑定的两种方式（onclick 覆盖 vs addEventListener 多播）和事件冒泡机制，帮助开发者构建扎实的 JS 基础，写出更健壮的代码。
cat本地部署
Chaser______的博客
08-15 358
CAT监控系统部署指南 环境准备：JDK1.8、Tomcat、MySQL 获取CAT包：通过Git克隆源码或下载官网war包 部署步骤： 创建/data目录结构并设置权限 配置client.xml、datasources.xml和server.xml 导入SQL文件创建数据库 将cat.war部署到Tomcat的webapps目录 启动服务：启动Tomcat后访问http://ip:8080/cat 注意事项：将配置文件中的127.0.0.1替换为实际IP地址 （98字）
Java 中 get 和 set 方法详解（更新版）
Toroto5的博客
08-14 833
get 方法（访问器）和 set 方法（修改器）是面向对象编程中实现封装的关键技术。它们提供了一种标准化的方式来访问和修改类的私有成员变量。在 Java 等面向对象语言中，为了实现良好的封装性，通常会将类的成员变量声明为 private，然后通过 public 的 get 和 set 方法来操作这些变量。示例：一个完整的 User 类实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值