JAVA 文件操作+流操作(第21天 )_java 报错getfilebyte-CSDN博客

本文链接：https://blog.csdn.net/qq_44102678/article/details/103206862

1.文件基本操作

package io;

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class TestFile {
	public static void main(String[] args) throws IOException {
		// 文件操作1
		File file1 = new File("d:/a.txt");
		System.out.println("文件名:" + file1.getName());
		System.out.println("文件路径:" + file1.getAbsolutePath());
		System.out.println("文件大小:" + file1.length());
		System.out.println("文件可读:" + file1.canRead());
		System.out.println("文件可写:" + file1.canWrite());
		System.out.println("文件存在:" + file1.exists());
		System.out.println("文件隐藏:" + file1.isHidden());
		System.out.println("文件最后更改时间:" + new Date(file1.lastModified()));
		System.out.println("文件是否目录:" + file1.isDirectory());
		System.out.println("是否文件:" + file1.isFile());
		System.out.println("文件父目录:"+file1.getParent());
		// 文件操作2: 创建文件夹
		File file2 = new File("d:/test.java");
		// 如果D盘下不存在该文件夹，则创建，否则删除
		if (file2.exists() == false) {
			// 创建文件夹
			try {
				file2.createNewFile();
				System.out.println("文件创建成功！");
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			// 删除文件和目录:2种方式
			/**
			 * 1:直接（立即）删除 file2.delete(); 2.程序结束时删除
			 */
			file2.deleteOnExit();// 程序结束时删除
			System.out.println("执行删除方法");
			// 存在改文件时，先线程运行5s
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		
		// 文件操作3
		// 创建以my_开头，以.tmp结尾的文件
		File file3 = File.createTempFile("my_", ".tmp");
		System.out.println(file3.getName());
		System.out.println(file3.getAbsolutePath());
		System.out.println("文件夹file3创建成功！");
		// 文件操作4
		test1();
		test2();
	}

	public static void test1() {
		// 列出可用的文件系统根。
		File[] files = File.listRoots();
		for (File file : files) {
			System.out.println(file.getAbsolutePath());
			System.out.println("磁盘总大小:" + file.getTotalSpace() / 1024 / 1024 / 1024 + "G");
			System.out.println("磁盘可用大小:" + file.getFreeSpace() / 1024 / 1024 / 1024 + "G");
		}
	}
	//文件操作5:创建目录
	public static void test2() {
		//注意：相对路径
		File file = new File("d:/1109/21");
		if(file.exists()==false) {
			//只能创建一级目录
//			boolean is = file.mkdir();
			//能够创建多级目录
			boolean is = file.mkdirs();
			System.out.println("创建结果:"+is);
		}
		//删除目录:只能删除空目录
//		boolean is = file.delete();
//		System.out.println("删除:"+is);
		System.out.println(file.getAbsolutePath());
	}
}

在这里插入图片描述

2文件夹遍历

package io;

import java.io.File;
/**
 * 文件夹遍历
 * @author 11327
 *
 */
public class TestFileDir {
	public static void main(String[] args) {
		File dir = new File("d:/");
		//listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
		/**
		 *列出目录中的文件
		 * 1.用字符串形式返回目录下的所有文件
		 * public String[] list();
		 * 2.用File对象形式返回目录下的所有文件
		 * public File[] listFiles();
		 */
		File [] files = dir.listFiles();
		for (File files1 : files) {
			System.out.println("文件路径:"+files1.getAbsolutePath());
			System.out.println("文件是否隐藏:"+files1.isHidden());
			//如果文件是目录，则继续遍历
			if(files1.isDirectory()) {
				File [] file2 = files1.listFiles();
				for (File files2 : files) {
					if(files2.isDirectory()) {
						File [] files3 = files2.listFiles();
					}
				}
			}
		}
	}
}

在这里插入图片描述

3.文件递归遍历

package io;

import java.io.File;
import java.io.FileFilter;

import javax.swing.JFileChooser;

/**
 * 文件递归
 * 递归思想：斐波拉契数列和阶乘
 * @author 11327
 *
 */
public class TestDiGui {
	public static void main(String[] args) {
		int result = jiecheng(4);
		System.out.println("阶乘为:"+result);
		int sum = feibo(9);
		System.out.println("斐波拉契数列和为:"+sum);
		//文件选择器
		JFileChooser jc = new JFileChooser("d:/");
		//设置可以选择文件夹
		jc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
		int op = jc.showOpenDialog(null);
		if(op == JFileChooser.APPROVE_OPTION) {
			//选择
			File dir = jc.getSelectedFile();
			find(dir);
		}
	}
	//递归遍历目录下的所有文件
	public static void find(File file) {
		//如果file是目录,则需要列出所有子文件夹
		if(file.isDirectory()) {
			//调用文件过滤器：列出指定类型的文件
			/**
			 * 1以字符串形式返回目录下指定类型的所有文件
			 * public String[] list(FilenameFilter obj)
			 * 2用File对象返回目录下指定类型的所有文件
			 * public File[] listFiles(FilenameFilter obj)
 			 */
			File[] files = file.listFiles(new MyFilter());
			//如果子文件夹不为空
			if(files!=null) {
				for (File file2 : files) {
					find(file2);
				}
			}
		}else {
			//则表示为 文件，直接打印即可
			System.out.println("文件路径:"+file.getAbsolutePath());
		}
	}
	
	//递归阶乘
	public static int jiecheng(int num) {
		if(num==1) {
			return 1;
		}
		return num*jiecheng(num-1);
	}
	//斐波拉契数列
	public static int feibo(int num){
		if(num==1||num==2) {
			return 1;
		}
		return feibo(num-1)+feibo(num-2);
	}
	//文件过滤器
	static class MyFilter implements FileFilter{

		@Override
		/**
		 * 如果返回true，则留下
		        如果返回false，则舍弃
		 */
		public boolean accept(File pathname) {
			String name = pathname.getName();
			return pathname.isDirectory()||name.endsWith(".java");
		}
		
	}
}

在这里插入图片描述

流

1文件拷贝-字节流

package demo2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TestCopy {
	public static void main(String[] args) {
		String src = "d:/CPU_Z_1_87.zip";
		String dest = "d:/xxxxx.zip";
		copy(src, dest);
	}
	/**
	 * 
	 * 文件复制
	 * @param src 源文件
	 * @param dest 目标文件
	 */
	public static void copy(String src,String dest) {
		try {
			InputStream in = new FileInputStream(src);
			OutputStream out = new FileOutputStream(dest);
			//每次读取的是1024个字节，可以根据要复制的文件大小，任意更改。
			byte []b = new byte[1024];
			int len = 0;
			while((len=in.read(b))!=-1) {
				out.write(b,0,len);
			}
			out.close();
			in.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("文件复制成功！");

	}
}

在这里插入图片描述
复制成功的压缩包:

2字符流

package demo3;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符流：Reader和Writer
 * 常见的编码格式
 * gbk  gb2312
 * iso-8859-1  美国编码
 * utf-8  2个字节
 * ASCII  1个字节
 * unicode 国际编码
 * @author 11327
 * 文件常见后缀名:.txt .xml .sql .java .html .properties
 *
 */
public class TestReaderWriter {
	public static void main(String[] args) {
//		writer();
		reader();
	}
	//写出
	/**
	 * 注意：流用完务必关闭，否则文件中没有内容
	 * 
	 */
	public static void writer() {
		//true 追加  false 覆盖
		try {
			Writer w = new FileWriter("a.txt",true);
			w.write("aqeogeorgeog多啦大V熬过哦");
			//清空缓冲区
			//强制把字符写到缓冲区中
//			w.flush();
			w.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("写出成功！");
	}
	//读入
	public static void reader() {
		try {
			Reader r = new FileReader("d:/a.txt");
			char []c = new char[1024];
			int len = 0;
			String sbf = "";
			while((len=r.read(c))!=-1) {
				sbf += new String(c,0,len);
			}
			sbf = new String(sbf.getBytes("utf-8"),"unicode");
			r.close();
			System.out.println(sbf);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("读入成功！");
	}
}

在这里插入图片描述
注意:不管是字符流还是字节流，在写出读入过程中都会出现乱码的问题。

3转换流

package demo3;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

/**
 * 转换流
 * 字节流转换为字符流
 * @author 11327
 *
 */
public class TestStreamReaderWriter {
	public static void main(String[] args) {
//		writer();
		reader();
	}
	public static void reader() {
		
		try {
			//基本流
			InputStream in = new FileInputStream("b.txt");
			//功能流
			InputStreamReader isr = new InputStreamReader(in,"utf-8");
			
			char []c = new char[1024];
			int len = 0;
			String str = "";
			while((len=isr.read(c))!=-1) {
				str += new String(c,0,len);
			}
			isr.close();
			in.close();
			System.out.println("读入成功！");
			System.out.println(str);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static void writer() {
		
		try {
			//基本流:字节流
			OutputStream out = new FileOutputStream("b.txt");
			//功能流
			OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
			
			osw.write("sifgo让给欧文人认购为奇偶认识儿子jz");
			osw.close();
			out.close();
			System.out.println("写出成功！");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在这里插入图片描述
转换流就避免出现了乱码的问题

4字节缓冲流

package demo3;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import javax.imageio.stream.FileImageInputStream;

/**
 * 字节缓冲流
 * @author 11327
 *
 */
public class TestBufferedStream {
	public static void main(String[] args) {
//		writer();
		reader();
	}
	public static void reader() {
		try {
			InputStream in = new FileInputStream("b.txt");
			BufferedInputStream bis = new BufferedInputStream(in);
			byte []b = new byte[1024];
			int len = 0;
			String str = "";
			while((len=bis.read(b))!=-1) {
				str +=new String(b,0,len);
			}
			bis.close();
			in.close();
			System.out.println("读入成功");
			System.out.println(str);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	/**
	 * 缓冲流写出时一定要关闭
	 * 否则不会写出到磁盘
	 */
	public static void writer() {
		try {
			OutputStream out = new FileOutputStream("b.txt");
			BufferedOutputStream bos = new BufferedOutputStream(out);
			
			bos.write("eagro打工我真是的qoae".getBytes());
			bos.flush();
			bos.close();
			out.close();
			System.out.println("写出成功！");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在这里插入图片描述

5字符缓冲流

package demo3;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 字符缓冲流 jdk1.7新特性:try-with-resource 流不用自己手动关闭，它自动关闭
 * 
 * @author 11327
 *
 */
public class TestBufferedReaderWriter {
	public static void main(String[] args) {
//		writer();
		reader();
	}

	// 读入
	public static void reader() {
		try (BufferedReader br = new BufferedReader(new FileReader("c.txt"))) {
			// 如果读到文件末尾，返回null
			// 一次读取一行
//			String str = br.readLine();
			String line = null;
			StringBuilder sbf = new StringBuilder();
			while ((line = br.readLine()) != null) {
				sbf.append(line);
				sbf.append("\n");
			}
			System.out.println(sbf);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// 写出
	public static void writer() {
		Writer w = null;
		BufferedWriter bw = null;
		try {
			w = new FileWriter("c.txt");
			bw = new BufferedWriter(w);
			bw.write("地ofo啊fe io,g aoiodf");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				bw.close();
				w.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("写出成功！");
		}
	}
}

在这里插入图片描述

6数据流

package demo4;

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

/**
 * 数据流
 * DateInputStream和DataOutputSteam
 * 注意:读写的顺序要保持一致
 * @author 11327
 *
 */
public class TestDataStream {
	public static void main(String[] args) {
//		writer();
		reader();
	}
	//读入
	/**
	 * 注意:这里没有文件指针，不能跳着读取数据
	 */
	public static void reader() {
		//数据输入流里new一个字节输入流
		try(DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"))) {
			String name1 = dis.readUTF();
			String name2 = dis.readUTF();
			boolean b = dis.readBoolean();
			int a = dis.readInt();
			long c = dis.readLong();
			char d = dis.readChar();
			System.out.println(name1+"\t"+name2);
			System.out.println(b+"\t"+a+"\t"+c+"\t"+d);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//写出
	public static void writer() {
		//数据流里new一个字节流
		try(DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"))) {
			dos.writeUTF("张三");
			dos.writeUTF("王五");
			dos.writeBoolean(true);
			dos.writeInt(78);
			dos.writeLong(789);
			dos.writeChar('a');
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("写出成功");
	}
}

在这里插入图片描述

7随机流

待续

8压缩流

待续

克隆(浅克隆)

Book.java

package com.wdzl.entity;

import java.io.Serializable;

public class Book implements Cloneable, Serializable {
	private String name;
	private float price;
	//禁止序列化
//	transient private String author;
	private Author author;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	public Author getAuthor() {
		return author;
	}
	public void setAuthor(Author author) {
		this.author = author;
	}
	
	@Override
	public Object clone() throws CloneNotSupportedException {
		Book book = (Book) super.clone();
		
		Author au = (Author) book.author.clone();
		book.setAuthor(au);
		
		return book;
		
	}
}

Author.java

package com.wdzl.entity;

import java.io.Serializable;

public class Author implements Cloneable, Serializable {
	private String name;
	private int age;
	public Author(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}

TestClone.java

package com.wdzl.demo04;

import com.wdzl.entity.Author;
import com.wdzl.entity.Book;

/**
 * 1.实现Cloneable接口
 * 2.重写clone()方法,（访问权限）
 * 	默认克隆属于浅克隆
 *	
 *	浅克隆（只克隆基本属性(基本类型和String,包装类)）和深克隆（克隆基本属性，而且克隆关联引用的对象）
 */
public class TestClone {

	public static void main(String[] args) {
		Book book = new Book();
		Author author = new Author("张三",34);
		book.setAuthor(author);
		book.setPrice(45);
		book.setName("Java实战");
		
		try {
			Book book1 = (Book) book.clone();
			
			System.out.println(book1.getName());
			System.out.println(book1.getAuthor().getName()+"=="+book.getAuthor().getName());
		
			System.out.println(book1+"==="+book);
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

运行结果:
在这里插入图片描述

对象序列化(深克隆)

Author.java

package entity;

import java.io.Serializable;

public class Author implements Serializable {
	private String name;
	private int age;
	public Author(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}

Book.java

package entity;

import java.io.Serializable;

public class Book implements Serializable{
	private String name;
	private float price;
	private Author author;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	public Author getAuthor() {
		return author;
	}
	public void setAuthor(Author author) {
		this.author = author;
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
		Book book = (Book) super.clone();
		
		Author author = (Author) book.author.clone();
		book.setAuthor(author);
		return book;
	}
	
}

TestObjectStream .java

package demo4;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import entity.Author;
import entity.Book;

/**
 * 对象序列化
 * 把对象状态数据转为可存储或可传输的状态
 * 反序列化
 * 把存储状态或可传输状态数据转为对象状态
 * 注意       1序列化对象类要实现Serializable接口
 *      2禁止个别属性系列化时，要用transient关键字
 * 克隆 （两种方式）
 *      序列化
 *      Object.Clone();
 * @author 11327
 * 
 */
public class TestObjectStream {
	public static void main(String[] args) {
		Book book = new Book();
		Author author = new Author("宁楠", 33);
		
		book.setAuthor(author);
		book.setName("Java实战");
		book.setPrice(45);
		writer(book);
		System.out.println("反序列化后:");
		reader();
	}
	/**
	 * 序列化
	 * 
	 */
	public static void writer(Object obj) {
		//对象输出流+字节输出流
		try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("book.obj"));) {
			oos.writeObject(obj);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		System.out.println("序列化成功！");
	}
	/**
	 * 反序列化
	 */
	public static void reader() {
		//对象输入流+字节输入流
		try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("book.obj"))) {
			Book book = (Book) ois.readObject();
			System.out.println(book.getAuthor()+"\t"+book.getName());
			System.out.println(book.getAuthor().getName());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在这里插入图片描述