JAVA IO

最新推荐文章于 2024-04-19 15:34:48 发布
最新推荐文章于 2024-04-19 15:34:48 发布
阅读量1.1k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA理解&总结 文章标签： java IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/SetO2/article/details/42494245
本文详细介绍了Java IO流的概念，包括输入流、输出流、字符流和字节流的划分，以及File类的常用操作，如获取路径、判断属性、创建、删除等。此外，还讨论了字符缓冲流、文本文件复制、转换流、打印流、SequenceInputStream、对象持久化和数据流的使用。最后，总结了不同类型的流在内存操作中的应用。

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

一、关于Java IO的概述

  • IO流用来处理设备之间的数据传输
  • Java对数据的操作是通过流的方式
  • Java用于操作流的对象都在IO包中
  • IO流按照流向划分为输入流、输出流
  • IO流按照操作数据划分为字符流（专门处理文字）、字节流
我理解的程序处理数据过程大致如下：

二、File相关操作

一个File类的实例代表一个文件或文件夹，File.pathSeparator指的是分隔连续多个路径字符串的分隔符，File.separator才是用来分隔同一个路径字符串中的目录的。由于java可跨平台，所以当new一个File时，路径中的“;"和"/"要用File.pathSeparator和File.separator代替。

File常用的构造方法

import java.io.File;

public class IOTest {
	public static void main(String[] args) {
		File file1=new File("D:"+File.separator+"IOTest.Java");//文件绝对路径
		File file2=new File("D:"+File.separator+"IO");//目录的绝对路径
		File file3=new File(file2, "IOTest.java");//第一个参数File实例代表一个目录file2，第二个参数为file2目录内的文件名
		File file4=new File("D:"+File.separator+"IO", "IOTest.java");//目录和文件的字符串类型
		
	}
}
File的常用方法 

	file1.createNewFile();
		System.out.println("file1.isFile():  " + file1.isFile());
		System.out.println("file1.isDirectory():  " + file1.isDirectory());
		System.out.println("file1.getName():  " + file1.getName());
		System.out.println("file1.getAbsolutePath  " + file1.getAbsolutePath());
		file2.mkdir();
		System.out.println("file2.isDirectory():  " + file1.isDirectory());
		String[] list = file2.list();//返回String[]类型的文件 只含文件名
		File[] listFile=file2.listFiles();//返回File[]类型的文件 包含完整的文件对象


其他相关方法的总结如下：

  • String getName():返回文件名或路径名（若是路径，返回最后一级子路径名）
  • String getPath():返回对象对应的路径名
  • File  getAbsoluteFile():返回绝对路径
  • String getAbsolutePath():返回对象对应的绝对路径
  • String getParent():返回文件目录的上一级目录名
  • boolean renameTo(File newName):重命名此File对象对应的文件或目录，若重命名成功返回true;
  • boolean exists():判断对象对应的文件或目录是否存在；
  • boolean canWrite():判断对象对应文件或目录是否可写；
  • boolean canRead():判断对象对应文件或目录是否可读；
  • boolean isFile():判断对象是文件，不是目录；
  • boolean isDirectory()  判断对象的文件是否是一个目录； 
  • boolean isAbsolute() 判断对象对应文件或目录是否为绝对路径名； 
  • boolean createNewFile() 当且仅当不存在，该方法创建一个该File对象所指定的新文件，创建成功返回true。 
  • boolean delete():删除File对象所对应的文件或路径；
  • boolean mkdir() 创建File对象所对应的目录，调用该方法的File对象必须对应路径，而不是文件。
  • String[] list():列出File对象的所有子文件名和路径名。
  • File[] listFiles():列出File对象的所有子文件和路径。
  • static File[] listRoots():列出系统所有的根路径；
对文件的操作前要判断文件是否存在，再做进一步io操作。


练习列出一个目录下所有文件及目录(利用递归)：

public class IOTest {
	public static void main(String[] args) throws Exception {
	
		File file = new File("C:\\Users\\Mr\\Desktop\\源码");
		scan(file);

	}

	private static void scan(File file) {
		// TODO Auto-generated method stub
		File[] files = file.listFiles();
		for (int i = 0; i < files.length; i++) {
			File newfile = files[i];
			if (newfile.isFile()) {
				System.out.println("文件：" + newfile.getName());
			} else {
				System.out.println("目录：" + newfile.getName());
				scan(newfile);
			}
		}
	}
}

文件过滤器，根据文件名或路径获得想要的文件对象

	private static void scan(File file) {
		// TODO Auto-generated method stub
		File[] files = file.listFiles(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				return name.contains(".java");
			}
			
		});
		System.out.println(Arrays.toString(files));

	}
通过listfile方法传入一个FilenameFilter接口的实例，复写accept方法，控制想要得到的文件。

三、流

  • 字符流

FileReader(直接读取)

import java.io.File;
import java.io.FileReader;

public class FileReaderTest   {
	public static void main(String[] args) throws Exception{
		File file=new File("d:"+File.separator+"test4.txt");
		FileReader reader=new FileReader(file);
		int ch=0;
		while((ch=reader.read())!=-1){
			System.out.print((char)ch);
		}
		reader.close();
	}
}

利用字符数组读取以提高效率 

import java.io.File;
import java.io.FileReader;

public class FileReaderTest {
	public static void main(String[] args) throws Exception {
		File file = new File("d:" + File.separator + "test4.txt");
		FileReader reader = new FileReader(file);
		char[] buf = new char[1024];
		int len = 0;
		while ((len = reader.read(buf)) != -1) {
			System.out.print(new String(buf, 0, len));
		}
		reader.close();
	}
}

FileWriter(现有文件追加一行)

import java.io.File;
import java.io.FileWriter;

public class FileWriterTest {
	public static void main(String[] args) throws Exception{
		File file = new File("d:" + File.separator + "test4.txt");
		if(!file.exists())file.createNewFile();
		FileWriter writer=new FileWriter(file,true);//可追加设为true
		writer.write("\r\n-------新追加一行--------");
		writer.close();
	}
}

文本文件复制 

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

public class Copy {
	public static void main(String[] args) throws Exception {
		File source = new File("d:" + File.separator + "test4.txt");
		File target = new File("d:" + File.separator + "test5.txt");
		if (!target.exists())
			target.createNewFile();
		FileReader reader = new FileReader(source);
		FileWriter writer = new FileWriter(target, true);
		char[] buf = new char[1024];
		int len = 0;
		while ((len = reader.read(buf)) != -1) {
			writer.write(buf, 0, len);
			writer.flush();
		}
		writer.close();
		reader.close();
	}
}

  • 字符缓冲流
BufferedReader 

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class BufferedReaderTest {
	public static void main(String[] args) throws Exception {
		BufferedReader reader=new BufferedReader(new FileReader("d:" + File.separator + "test4.txt"));
		String line;
		while((line=reader.readLine())!=null){
			System.out.println(line);
		}
	}
}

BufferedWriter 

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class BufferedWriterTest {
	public static void main(String[] args) throws Exception {
		BufferedWriter writer=new BufferedWriter(new FileWriter("d:" + File.separator + "test5.txt",true));
		writer.newLine();
		writer.write("新追加一行");
		writer.flush();
		writer.close();
	}
}


文本文件复制(字符缓冲流)

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

public class CopyByBuf {
	public static void main(String[] args) throws Exception {

		File source = new File("d:" + File.separator + "test4.txt");
		File target = new File("d:" + File.separator + "test6.txt");
		if (!target.exists())
			target.createNewFile();
		BufferedReader reader = new BufferedReader(new FileReader(source));
		BufferedWriter writer = new BufferedWriter(new FileWriter(target));
		String line;
		while ((line = reader.readLine()) != null) {
			writer.write(line);
			writer.newLine();
			writer.flush();
		}
		writer.close();
		reader.close();
	}
}

BufferedReader的子类LineNumberReader.setLineNumber(0)来设置初始行，默认0，getLineNumber()返回行号。

public class BufferedReaderTest {
	public static void main(String[] args) throws Exception {
		LineNumberReader reader=new LineNumberReader(new FileReader("d:" + File.separator + "test4.txt"));
		String line;
		//reader.setLineNumber(0);
		while((line=reader.readLine())!=null){
			System.out.println(reader.getLineNumber()+line);
		}
	}
}

  • 字节流
FileInputStream直接读取 

public class FileInputStreamTest {
	 public static void main(String[] args) throws Exception {
	 FileInputStream in = new FileInputStream("d:" + File.separator + "test4.txt");
		int ch = 0;
		while ((ch = in.read()) != -1) {
			System.out.print((char) ch);
		}
		in.close();
	}
}
FileInputStream通过byte[]读取 
public class FileInputStreamTest {
	
	public static void main(String[] args) throws Exception {
		FileInputStream in = new FileInputStream("d:" + File.separator + "test4.txt");
		byte[] buf = new byte[1024];
		int len = 0;
		while ((len = in.read(buf)) != -1) {
			System.out.print(new String(buf, 0, len));
		}
 		in.close();
	}
}
FileOutputStream直接写入数据 
public class FileInputStreamTest {
	public static void main(String[] args) throws Exception {
	FileOutputStream out=new FileOutputStream("d:" + File.separator + "test.txt");
	out.write("黑马你好".getBytes("UTF-8"));
	out.close();
 }
}
FileOutputStream和FileInputStream通过byte[]图片 
public class FileInputStreamTest {
	public static void main(String[] args) throws Exception {
	FileInputStream in = new FileInputStream("d:" + File.separator + "heima.jpg");
	FileOutputStream out=new FileOutputStream("d:" + File.separator + "heima_copy.jpg");
	byte[] buf = new byte[1024];
	int len = 0;
	while ((len = in.read(buf)) != -1) {
		out.write(buf, 0, len);
	}
	in.close();
	out.close();
}
}
FileOutputStream和FileInputStream通过BufferedOutputStream和BufferedInputStream复制图片 
public class FileInputStreamTest {
	public static void main(String[] args) throws Exception {
		BufferedInputStream in=new BufferedInputStream(new FileInputStream("d:" + File.separator + "heima.jpg"));
		BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream("d:" + File.separator + "heima_copy1.jpg"));
		int data = 0;
		while ((data = in.read()) != -1) {
			out.write(data);
		}
		in.close();
		out.close();
	}
}

  • 转换流
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。
而它们都是属于字节流，现在要实现对控制台输入的字符串打印或其他操作，由于是对文本进行操作，FileReader和FileWriter更为方便，怎样将要操作的字节流转换为字符流然后进行操作呢？这里可以用转换流InputStreamReader和OutputStreamReader： 
package Blog;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ConsoleTest {
	public static void main(String[] args) throws Exception {
		BufferedReader reader = new BufferedReader(new InputStreamReader(
				System.in));
		BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
				System.out));
		String line = null;
		while (!"stop".equals(line) && (line = reader.readLine()) != null) {
			writer.write(line);
			writer.newLine();
			writer.flush();
		}
		writer.close();
		reader.close();
	}
}
  • 字符流与字节流的总结
字节流和字符流在处理数据时代码和流程大致相同，字符流其根本也是用的字节流，但是为了处理文字方便加入了类似缓冲块的概念，使其字符流可以对文字的编码进行操作，避免乱码的出现，正因为有了缓冲，所以每次写入后需要flush操作将其刷进目标中，而字节流则不需要。并且字符流读取后close方法时也会对缓冲区进行刷新操作。字符流和字节流两者相比，字节流通用可以处理任何类型数据，但处理处理文本时，由于字符流的编码特性是最为合适的，并且字符流提供了专门处理文本的方便方法，而处理非文本时，一定要使用字节流，如果使用字符流可能复制成功后文件仍无法读取。
  • 用流对目录复制
将C盘下目录复制到D盘 
package Blog;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyDir {
	public static void main(String[] args) throws Exception {
		File dir_s = new File("c:" + File.separator + "heima");//源目录
		File dir_d = new File("d:" + File.separator + dir_s.getName());//目标目录
		dir_d.mkdir();//创建目录
		DoCopy(dir_s, dir_d);
	}

	private static void DoCopy(File dir_s, File dir_d) throws Exception {
		// TODO Auto-generated method stub

		File[] files = dir_s.listFiles();
		for (File file : files) {
			if (file.isFile()) {//如果是文件 复制
				BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
				File file_new=new File(dir_d, file.getName());
				file_new.createNewFile();
				BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file_new));
				int data = 0;
				while ((data = in.read()) != -1) {
					out.write(data);
				}
				in.close();
				out.close();
			} else {//如果是目录 递归
				File dir_new=new File(dir_d,file.getName());
				dir_new.mkdir();
				DoCopy(file,dir_new);//
			}
		}
	}

}
输入两个目录，作为源和目的，将源目录中所有.java文件复制到目的目录中同时将扩展名修改为txt
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;



public class Copy {
	
	public static void main(String[] args) throws Exception {
		System.out.println("请输入一个源目录");
		String SourceDir = getDir();
		System.out.println("请输入一个目的目录");
		String dtDir = getDir();
		mainJob(SourceDir, dtDir);
		System.out.println("-------------已完成-------------");
	}

	static String getDir() throws Exception {
		BufferedReader reader = new BufferedReader(new InputStreamReader(
				System.in));
		String str = reader.readLine();
		//reader.close();
		return str;
	}

	static void mainJob(String S, String D) throws Exception {
		File source = new File(S);
		File dest = new File(D);
		dest.mkdir();
		List<File> javaList = new ArrayList<File>();
		javaList = scanDir(source, javaList);
		for (File file : javaList) {
			File newFile = new File(dest,FileUtil.getHeadName(file)+".txt");
			int n = 0;
			String head=FileUtil.getHeadName(newFile);
			String tail=FileUtil.getExtendName(newFile);
			while (newFile.exists()) {
				//判断 若有同名文件出现时 防止覆盖
				newFile=new File(dest,head+"("+(++n)+")."+tail);
			}
			newFile.createNewFile();
			copy2dest(file, newFile);

		}

	}

	/**
	 * @param source
	 * @param javaList
	 * @return
	 * @throws Exception
	 * 扫描目录筛选java文件   返回File集合
	 */
	static List<File> scanDir(File source, List<File> javaList)
			throws Exception {
		File[] javas = source.listFiles();
		for (File file : javas) {
			if (file.isDirectory()) {
				scanDir(file, javaList);
			} else {
				if (file.getName().endsWith(".java"))
					javaList.add(file);
			}
		}
		return javaList;

	}

	/**
	 * @param file
	 * @param dest
	 * @throws Exception
	 * 主要复制动作
	 */
	static void copy2dest(File file, File dest) throws Exception {
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(
				file));
		BufferedOutputStream out = new BufferedOutputStream(
				new FileOutputStream(dest));
		int data = 0;
		System.out.println("正在复制  "+dest.getName());
		while ((data = in.read()) != -1) {
			out.write(data);
		}
		in.close();
		out.close();

		 
	}
	
	
 
}
/**
 * @author Mr
 *	自定义文件工具类
 */
class FileUtil{
	/**
	 * @param file
	 * @return
	 * 获取文件名不带扩展名
	 */
	public static String getHeadName(File file){
		return file.getName().substring(0,file.getName().lastIndexOf("."));
	}
	/**
	 * @param file
	 * @return
	 * 获取扩展名
	 */
	public static String getExtendName(File file){
		
		return file.getName().substring(file.getName().lastIndexOf(".")+1);
	}
	/**
	 * @param file
	 * @param extendName
	 * @return
	 * 修改扩展名
	 */
	public static File trExtendName(File file,String extendName){
		return new File(file.getParent(),getHeadName(file)+"."+extendName);
	}
}

四、其它重要IO相关

1.可接收字符输出流和字节输出流的打印流PrintWriter，PrintWriter功能十分强大也比较常用，同时可直接接受File类型文件或String文件路径，具有自动flush的特点。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;

public class PrintWriterTest  {
	public static void main(String[] args) throws Exception{
		BufferedReader reader=new BufferedReader(new FileReader("d:" + File.separator + "test4.txt"));
		PrintWriter printer=new PrintWriter(System.out,true);//true 自动刷新， system.out是输出流 也可以是文件File或文件路径
		String data=null;
		while((data=reader.readLine())!=null){
			printer.println(data);
		}
		printer.close();
		reader.close();
	}
}

2.通过InputStream下的SequenceInputStream类实现合并多个字节输入流

该类有两个构造方法，也就是两种不同的实现方式：

通过传入Enumeration<? extends InputStream>对多个流的封装

public class SequenceInputStreamTest {
	public static void main(String[] args) throws Exception {
		FileInputStream in1 = new FileInputStream("d:" + File.separator
				+ "test4.txt");
		FileInputStream in2 = new FileInputStream("d:" + File.separator
				+ "test5.txt");
		FileInputStream in3 = new FileInputStream("d:" + File.separator
				+ "test6.txt");
		Vector<InputStream> vector = new Vector<InputStream>();
		vector.add(in1);
		vector.add(in2);
		vector.add(in3);//将三个inputStream添加进Vector集合
		Enumeration<InputStream> enumeration = vector.elements();//获取Enumeration对象
		SequenceInputStream in_all = new SequenceInputStream(enumeration);
		PrintWriter printer = new PrintWriter(System.out, true);
		BufferedReader reader = new BufferedReader(
				new InputStreamReader(in_all));
		String data = null;
		while ((data = reader.readLine()) != null) {
			printer.println(data);
		}
		reader.close();
		in1.close();
		in2.close();
		in2.close();
		in_all.close();
		printer.close();
	}
}

传入两个inputStream实例对象，并且只能是两个，不常用

public class SequenceInputStreamTest {
	public static void main(String[] args) throws Exception {
		FileInputStream in1 = new FileInputStream("d:" + File.separator
				+ "test4.txt");
		FileInputStream in2 = new FileInputStream("d:" + File.separator
				+ "test5.txt");
		SequenceInputStream in_all = new SequenceInputStream(in1, in2);
		PrintWriter printer = new PrintWriter(System.out, true);
		BufferedReader reader = new BufferedReader(
				new InputStreamReader(in_all));
		String data = null;
		while ((data = reader.readLine()) != null) {
			printer.println(data);
		}
		reader.close();
		in1.close();
		in2.close();
		in_all.close();
		printer.close();
	}
}

3.切割流

public class SplitFile {
	public static void main(String[] args) throws Exception{
		BufferedInputStream in=new BufferedInputStream(new FileInputStream("d:" + File.separator + "梁心颐 - 小树.mp3"));
		BufferedOutputStream out=null;
		byte[] data=new byte[1024*1024];
		int len=0;
		int count=0;
		while((len=in.read(data))!=-1){
			out=new BufferedOutputStream(new FileOutputStream("d:" + File.separator + "梁心颐 - 小树"+(++count)+".part"));
			out.write(data, 0, len);
			out.close();
		}
		in.close();
	}
}

4.ObjectInputStream和ObjectOutStream实现对象持久化

要想通过该方法持久化的实例对象，该类必须实现Serializable接口

import java.io.Serializable;

public class Person implements Serializable{
	
	private static final long serialVersionUID = -4102534291757583600L;
	private String name;
	private Integer age;
	public String add;
	public Person(String name, Integer age, String add) {
		super();
		this.name = name;
		this.age = age;
		this.add = add;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
}
并声明UID，如果不实现该接口则在ObjectOutputStream写出对象时会报“未序列化的对象”异常

下面开始对一个Person对象进行持久化即写入一个文件中，随后读出该文件

public class ObjectStream {
	public static void main(String[] args) throws Exception, IOException {
		Person p1=new Person("liuli", 25, "china");
		//写
		ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:"+File.separator+"test.obj"));
		out.writeObject(p1);
		out.close();
		//读
		ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:"+File.separator+"test.obj"));
		Person p2=(Person)in.readObject();
		System.out.println(p2.getName()+p2.getAdd()+p2.getAge());
	}
}


5.管道流 

public class PipeTest {
	public static void main(String[] args) throws Exception {
		PipedInputStream pipeIn = new PipedInputStream();
		PipedOutputStream pipeOut = new PipedOutputStream();
		pipeIn.connect(pipeOut);//连接两个流
		In in = new In(pipeIn);
		Out out = new Out(pipeOut);
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		t1.start();
		t2.start();
	}
}

class In implements Runnable {
	private PipedInputStream in;

	public In(PipedInputStream in) {
		// TODO Auto-generated constructor stub
		this.in = in;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub

		BufferedReader reader = new BufferedReader(new InputStreamReader(in));
		String line = null;
		try {
			while ((line = reader.readLine()) != null) {
				System.out.println(line);
			}
			reader.close();
			in.close();

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

		}
	}
}

class Out implements Runnable {
	private PipedOutputStream out;

	public Out(PipedOutputStream out) {
		// TODO Auto-generated constructor stub
		this.out = out;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		PrintWriter writer=new PrintWriter(out, true);
		try {
			writer.println("黑马程序员2015年1月9日18:51:42");
			writer.println("黑马程序员2015年1月9日18:51:45");
			writer.println("黑马程序员2015年1月9日18:51:47");
			writer.close();
			out.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
由此可见管道流建立了两个不同线程的沟通桥梁，可以实现线程间的通讯，可以实现生产者消费者模型。

6.DataInputStream和DataOutputStream存储基本数据类型数据

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class DataStream {
	public static void main(String[] args) throws Exception{
		DataOutputStream out=new DataOutputStream(new FileOutputStream("d:" + File.separator + "test.txt"));
		out.writeInt(2015);
		out.writeBoolean(true);
		out.writeDouble(2015.0109);
		out.close();
		
		DataInputStream in=new DataInputStream(new FileInputStream("d:" + File.separator + "test.txt"));
		System.out.println(in.readInt());
		System.out.println(in.readBoolean());
		System.out.println(in.readDouble());
		in.close();
	}
}

7.ByteArrayInputStream和ByteArrayOutputStream 
public class ByteArrayOutputStreamTest {
	public static void main(String[] args) throws Exception {
		File file = new File("d:" + File.separator + "test4.txt");
		if (!file.exists())
			throw new RuntimeException("文件不存在");
		FileInputStream in;
		ByteArrayOutputStream arr = new ByteArrayOutputStream();

		in = new FileInputStream(file);
		byte[] data = new byte[5];
		int len = 0;

		while ((len = in.read(data)) != -1) {
			arr.write(data, 0, len);

		}
		System.out.println(arr.toString());
		in.close();
	}	
}

8.StringReader和StringWriter 
public class StringReader {
	public static void main(String[] args) throws Exception {
		
		BufferedReader reader2=new BufferedReader(new StringReader("黑马程序员"));
		StringWriter writer2=new StringWriter();
		writer2.append(reader2.readLine());
		writer2.append("------追加新文字");
		System.out.println(writer2.toString());
		
		BufferedReader reader3=new BufferedReader(new CharArrayReader("黑马程序员".toCharArray()));
		CharArrayWriter writer3=new CharArrayWriter();
		writer3.write(reader3.readLine().toCharArray());
		System.out.println(writer3.toString());
	}	
}

9.CharArrayReader和CharArrayWriter 

public class CharArray {
	public static void main(String[] args) throws Exception {
		BufferedReader reader3=new BufferedReader(new CharArrayReader("黑马程序员".toCharArray()));
		CharArrayWriter writer3=new CharArrayWriter();
		writer3.write(reader3.readLine().toCharArray());
		System.out.println(writer3.toString());
	}	
}

总结：ByteArrayInputStream和ByteArrayOutputStream、CharArrayReader和CharArrayWriter、StringReader和StringWriter都是用流的思想操作内存中的数据。








javautil File文件，文件夹的创建，删除 以及文件_工具方法
zona_wzq的博客
11-15 955
java删除文件夹，文件夹下的文件
FileUtils 基本文件操作
方逸涛的专栏
08-17 1万+
FileUtils.cd( dir, *options ) FileUtils.cd( dir, *options ) {|dir| .... } Options: noop verbose移动到dir目录。若被用作迭代器的
java.util.File 中，mkdir()方法和mkdirs()方法的区别
wer的博客
09-20 3926
首先我们看一下这两个方法在API中的解释： mkdir():创建此抽象路径名指定的目录。 mkdirs():创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。注意，此操作失败时也可能已经成功地创建了一部分必需的。 也就是说，mkdir（）只能创建一级的目录，且需要存在父目录;mkdirs（）可以创建多级目录，无论是否存在父目录 可以用代码简单测试一下 //当我们在D盘根目录下
Java后端如何进行文件上传和下载 —— 本地版（文末配绝对能用的源码，超详细，超好用，一看就懂，博主在线解答） 文件如何预览和下载？（超简单教程）
dream_ready的博客
04-19 3846
response.addHeader 等会再讲，先简单讲述下作用，使用第一个 response.addHeader 时，访问url文件直接下载，无法预览，使用第二个 response.addHeader 时，访问url文件如果可以预览，则先预览，不可以，会进行下载。还记得我们开始定义的保存文件的父级目录么，也就是 ROOT_PATH，现在我们要保存文件了，既然要保存，我们需要判断这个父级目录是否存在，如果不存在，我们要先创建这个 “父级目录”它会自动识别当前项目所在的根路径，每个人的可能都不一样。
File文件类操作
凌峰的博客
03-26 1090
File(String pathname)    java.io.File用于表示文件(目录),也就是说程序员可以通过File类在程序中操作硬盘上的文件和目录.    File类只用于表示文件(目录)的信息(名称、大小等)，不能对文件的内容进行访问.    构造方法:    -File(String pathname)    通过将给定路径名字字符串转化成抽象路径名来创建一个新File实例    ...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
java-io-guide:Java中的Java IO（输入和输出流）指南
04-29
这是Java中文件处理的完整指南。 本指南的源代码在我们的本地开发环境中经过了很好的测试，并使用了静态代码分析器工具SonatLint ， PMD等对代码进行了分析。本指南的源代码无缺陷，并使用JDK 8进行编译和执行。 ...
JavaIO总结
05-08
有关Java输入输出流的总结有关Java输入输出流的总结有关Java输入输出流的总结
java IO教程，java IO教程，java IO教程
04-07
java IO教程，java IO教程，java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程，java IO教程，java IO教程，java IO...
JavaIO文件复制优化-JavaIO优化详解（下载可用）
05-30
JavaIO文件复制优化——JavaIO优化详解（下载可用）。个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。...
FileUtil（文件操作工具类）
01-05
FileUtil（文件操作工具类）
FIle类和递归方法的使用
黑某人
03-14 268
File类 概述：文件和目录【文件夹和盘符】路径名的抽象表示形式；文件和目录在内存中的另外一种表现形式 路径：文件或目录在磁盘中的位置的地址 绝对路径： 概述：从根目录开始一直到文件本省的位置的地址 根路径： windows系统：根路径就是盘符路径 mac、linux系统：根路径就是【/】 相对路径： 概述：相对于某个路径而言的路径【有一个参考的路径】 在eclipse当中相对路径相对于工程路径 ...
字节流与字符流
qq_43711904的博客
07-19 246
1、输入与输出操作传递的是一种数据流，即字节数据，这种流的处理形式在java.io包中提供了两类支持： 字节处理流(abstract)：OutputStream（输出字节流）、InputStream（输入字节流） 字符处理流(abstract)：Writer（输出字符流）、Reader（输入字符流） 2、OutputStream类定义：public abstract class Output...
绝对路径和相对路径、cd、mkdir+mrdir、rm命令
rain_yunlx的博客
12-19 7178
一.绝对路径和相对路径 pwd   #查看当前所在的目录 cd    #change directory的意思 1.绝对路径：路径的写法一定是从根目录/开始， [root@lx02 ~]# cd /root/.ssh/         #这就是一个绝对路径 [root@lx02 .ssh]#                      
java上传文件(图片),并把文件地址返回给前端
XU_RI_DONG_SHENG的博客
11-03 4182
import java.io.File; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.Random; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import
IO文件File练习
computer408的博客
02-08 513
一、 练习：判断com.test.filedemo目录下是否有后缀名为.java的文件 如果有，统计该类型文件的个数并输出文件名称 二、 已知文件的路径为：C:\mygames.txt 要求得到 是否存在 取得文件名 取得文件路径 得到绝对路径 得到文件夹名 判断文件是否存在 判断文件是否可读，可写 判断是...
FileUtil文件工具简单应用
飞翔的心
07-31 3395
该file文件操作工具类实现功能包括：文件的增删改查，移动文件，文件内容的读取，较大的特点是通过反射获取包下所有类。后面做了简单测试验证以及一些反射相关知识补充。
java中的File类中的mkdir()和mkdirs()
winnieFighting
09-12 5805
前言 小编今天做文件上传的功能，发现了一个bug,那就是系统找不到相应的路径，于是经过一步步调试发现，是找不到要保存的路径，然后就在相应的文件夹下创建了相应的路径，可以成功上传！ 但是还有一个更加方便的方式，就是用到了java中的File类汇总的mkdir()和mkdirs()方法。在代码中让他自己生成相应的文件夹。那么这两个方法有什么区别又怎么使用呢？ 正文 实例：我的代码↓ 我的代码中之前是没...
Java File的mkdir()和mkdirs()使用区别
热门推荐
菜鸟程序员成长路
06-13 2万+
import java.io.*;    public class TestFile {        public static void main(String[] args) throws Exception {          File f1 = new File("E://aaa//bbb");          if (!f1.exists()) {              f1....
JavaIO
最新发布
03-21
好的，我现在需要处理用户关于Java IO的问题。用户希望了解Java IO的概念或者解决相关问题，特别是询问教程和故障排除的方法。首先，我得回顾一下Java IO的基础知识，确保自己理解正确，然后组织回答的结构。 首先...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值