Java---File类以及字节流

最新推荐文章于 2024-05-03 13:04:14 发布

airar

最新推荐文章于 2024-05-03 13:04:14 发布

阅读量957

点赞数

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/airar/article/details/121363824

版权

Java 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

1.文件操作

文件---把数据持久化到磁盘的载体

文件的组成:1.文件的基本属性【文件命名，文件类型，文件的创建时间，文件的大小.......】
2.文件中的数据

2.File类的创建对象和常用方法

File类的定义：public class File

1. File类的静态成员变量：

static String----pathSeparator与系统相关的路径分隔符，为方便起见，表示为字符串

static char----pathSeparatorChar与系统相关的路径分隔符。

static String----separator与系统相关的默认名称分隔符，为方便起见，表示为字符串

static char----separatorChar与系统相关的默认名称分隔符。

例如：

package com.wangxing.test1;

import java.io.File;

public class MyFileClass {

	public static void main(String[] args) {
		// static  String----pathSeparator与系统相关的路径分隔符，为方便起见，表示为字符串
		System.out.println(" static  String pathSeparator---"+File.pathSeparator);
       //static   char----pathSeparatorChar与系统相关的路径分隔符。
		System.out.println(" static  String pathSeparatorChar---"+File.pathSeparatorChar);
      //static   String----separator与系统相关的默认名称分隔符，为方便起见，表示为字符串
		System.out.println(" static  String separator---"+File.separator);
     //static   char----separatorChar与系统相关的默认名称分隔符。
		System.out.println(" static  String separatorChar---"+File.separatorChar);
		//separator/separatorChar表示的是文件的路径分割符号，路径分割符号的静态常量就是让我们在编写文件路径的时候来使用。
		//转义字符写出来的，或许会在其他的操作系统中会出错
		System.out.println("C:\\Program Files\\Autodesk");
		//上面的错误也可以通过File类中的表示文件的路径分割符号的静态常量
		System.out.println("C:"+File.separator+"Program Files"+File.separator+"Autodesk");
		//使用File类中的表示文件的路径分割符号的静态常量，可以不受到操作系统对文件的路径分割符号的限制。
	}

}

2.File类的构造方法

1.File(String pathname)---通过给定的文件路径字符串创建新的File实例

2.File(String parent,String child)---通过给定的文件位置字符串和个定的文件名称字符串创建新的File实例

3.File(File parent,String child)---通过给定的文件位置File对象和给定的文件名称字符串创建新的File实例

package com.wangxing.test1;

import java.io.File;

public class MyFileClass2 {
	public static void main(String[] args) {
		//File类的构造方法
		//File(String pathname) 通过给定的文件路径字符串创建新的 File实例。 
		String pathname="E:"+File.separator+"Program Files"+File.separator+"mytest.text";
		File file1=new File(pathname);
		//File(String parent, String child) 通过给定的文件位置字符串和给定的文件名称字符串创建新的 File实例。
		String parent1="E:"+File.separator+"Program Files";
		String child1="mytest.txt";
		File file2=new File(parent1,child1);
		//File(File parent, String child) 通过给定的文件位置File对象和给定的文件名称字符串创建新的 File实例。
		String parent2="E:"+File.separator+"Program Files";
		File fileparent=new File(parent2);
		String child2="mytest.txt";
		File file3=new File(fileparent,child2);
		//文件File类的对象创建以后，不会生成实际的文件/文件夹。
	}

}

3.File类的实例方法：

boolean exists()----判断路径名表示的文件或木目录是否存在

boolean createNewFile()----创建新文件

boolean mkdirs()----创建文件/文件夹

boolean delete()----删除文件/文件夹(删除文件夹的时候会将该文件夹的文件和子文件夹全部删除)

boolean canRead()----判断文件是否为可读

boolean canWrite()----判断文件是否为可写

boolean isHidden()----判断文件是否为隐藏文件

boolean isFile()----判断文件是否为普通文件

boolean isDirectory----判断文件对象是否为目录

String getPath()----得到文件对象的路径名

String getName()----得到文件对象所表示的文件或目录的名称

String getParent()----得到文件对象所表示的路径的父目录路径

long length()----得到文件对象所表示的文件长度

long lastModified()---- 得到文件对象所表示的文件上次修改的时间

String[] list()得到文件对象代表的文件夹中的所有文件和文件夹名称，返回一个字符串数组

File[] listFiles()---得到文件对象代表的文件夹中的所有文件和文件夹，返回一个文件对象数组

package com.wangxing.test1;

import java.io.File;
import java.io.IOException;
import java.sql.Date;
import java.text.SimpleDateFormat;

public class MyFileClass3 {
	public static void main(String[] args) throws IOException {
		/*
		String pathname="E:"+File.separator+"Program Files"+File.separator+"mytest.text";
		File file1=new File(pathname);
		String dirpathname="E:"+File.separator+"Program Files"+File.separator+"mytest";
		File dir=new File(dirpathname);
		// boolean	exists() 判断路径名表示的文件或目录是否存在。
		System.out.println("file exists---"+file1.exists());
		System.out.println("dir exists---"+dir.exists());
		//boolean 	createNewFile() 创建新文件
		System.out.println("createNewFile---"+file1.createNewFile());
		//boolean	 mkdirs()  创建新的文件夹
		System.out.println("mkdirs---"+dir.mkdirs());
		//boolean 	delete()  删除文件/文件夹 ,删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除
		System.out.println("delete--"+dir.delete());
		//	boolean	canRead() 判断文件是否可读
		System.out.println("canRead--"+file1.canRead());
		//boolean	 canWrite() 判断文件是否可写 
		System.out.println("canWrite--"+file1.canWrite());
		//boolean	  isHidden() 判断文件是否为隐藏文件。 
		System.out.println("isHidden--"+file1.isHidden());
		//boolean	  isFile() 判断文件对象是否为普通文件。 
		System.out.println("isFile--"+file1.isFile());
		//boolean	 isDirectory() 判断文件对象是否为目录\
		System.out.println("isDirectory--"+file1.isDirectory());
		//String	getPath() 得到文件对象的路径名字符串。
		System.out.println("getPath--"+file1.getPath());
		//String	getName() 得到文件对象所表示的文件或目录的名称。 
		System.out.println("getName--"+file1.getName());
		//String	getParent() 得到文件对象所表示的路径的父目录路径
		System.out.println("getParent--"+file1.getParent());
		//long	length() 得到文件对象所表示的文件的长度。 
		System.out.println("length--"+file1.length());
		//long	lastModified() 得到文件对象所表示的文件上次修改的时间。
		System.out.println("lastModified--"+file1.lastModified());
		*/
		//	String[] 	list() 得到文件对象代表的文件夹中的所有文件和文件夹名称返回一个字符串数组
		String dirpathname="E:"+File.separator+"Program Files"+File.separator+"mytest";
		File dir=new File(dirpathname);
		/*
		String filename[]=dir.list();
		for(String name:filename){
			System.out.println"name);
		}
		*/
		//File[]	listFiles() 得到文件对象代表的文件夹中的所有文件和文件夹的文件对象，返回一个文件对象数组
		File file2[]=dir.listFiles();
		SimpleDateFormat stf=new SimpleDateFormat("yyyy-MM-dd E hh:mm");
		for(File files:file2){
			String name=files.getName();
			Date date=new Date(files.lastModified());
			String strdate=stf.format(date);
			String filetype="";
			long leng=0;
			if(files.isDirectory()){
				filetype="文件夹";
			}else{
				filetype="文本文档";
				leng=files.length();
			}
			System.out.println(name+"\t"+strdate+"\t"+filetype+"\t"+leng+"KB");
		}
		
	}

}

3.输入输出流

1.输入输出流---读写文件

2.输入---从文件中获取数据到自己的程序中【读】

3.输出---将自己的程序中处理好的数据保存在文件中【写】

4.流---数据移动轨迹

4.流的分类

1.按照数据移动的轨迹分为输入流和输出流

2.按照每一次读/写数据量将流分为字节流和字符流

3.字节流:每一次可以读写一个字节的数据量，一个字节就是8位2进制，可以处理任何类型的文件【文本，图片，视频等等】

3.字符流:每一次可以读写一个字符的数据量，一个字符就是16为2进制，可以处理文本类型的数据

4.详细划分：字节输入流、字节输出流、字符输入流、字符输出流

5.字节流相关类的使用

字节输出流---OutputStream---抽象类---不能new---子类

1.FileOutputStream类

1.FileOutputStream类的构造方法：

FileOutputStream(File file)---通过File对象创建一个不可追加的字节输出流

FileOutputStream(File file,boolean append)---通File对象创建一个是否可以追加的字节输出流

FileOutputStream(String name)---通过String对象创建一个不可追加的字节输出流

FilwOutputStream(String name,boolean append)通过String对象创建一个是否可以和追加的字节输出流

例如：

package com.object.test2;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class Filetest1 {

	public static void main(String[] args) throws Exception {
		//FileOutputStream类构造方法：
		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
		String pathname="E:"+File.separator+"MyDownloads"+File.separator+"file.txt";
		File file1=new File(pathname);
		FileOutputStream fileout1=new FileOutputStream(file1);
		OutputStream fileout11=new FileOutputStream(file1);
		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
		FileOutputStream fileout2=new FileOutputStream(file1,true);
		OutputStream fileout22=new FileOutputStream(file1,true);
		//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
		FileOutputStream fileout3=new FileOutputStream(pathname);
		OutputStream fileout33=new FileOutputStream(pathname);
		//FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
		FileOutputStream fileout4=new FileOutputStream(pathname,true);
		OutputStream fileout44=new FileOutputStream(pathname,true);
	}

}

2.FileOutputStream类中的是实例方法

void write(byte[] b)---将b.length个字节从指定字节数组写入此文件输出流

void write(byte[] b,int index,int len)---将len个字节从位于便宜量off的指定自洁素组写入此文件输出流

void colse()---关闭文件输出流并释放此流相关联的任何系统资源

package com.object.test2;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class Filetest2 {

	public static void main(String[] args) throws Exception {
		File pathname=new File("E:"+File.separator+"MyDownloads"+File.separator+"test1.txt");
		FileOutputStream fileout1=new FileOutputStream( pathname);
		String info="hello,world";
		/*
		//void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 
		byte infobyte[]=info.getBytes();
		fileout1.write(infobyte);
		fileout1.close();
		*/
		//void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
		/*
		byte infobyte[]=info.getBytes();
		fileout1.write(infobyte, 0, 5);
		fileout1.close();
		*/
		//void	write(int b) 将指定的字节写入此文件输出流。 
		
		byte infobyte[]=info.getBytes();
		for(byte by:infobyte){
			fileout1.write(by);
		}
		fileout1.close();
		
		//void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源
	}

}

2.DataOutputStream类

DataOutputStream类的构造方法：

DateOutputStream(OutputStream out)--创建一个新的输出流，将数据写入指定的底层输出流

例如：

package com.object.test2;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class DateOutputStreamTest1 {

	public static void main(String[] args) throws FileNotFoundException {
		//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 
		File pathname=new File("E:"+File.separator+"MyDownloads"+File.separator+"test2.txt");
		OutputStream out=new FileOutputStream(pathname,true);
		DataOutputStream dataout=new DataOutputStream(out);
		
		FileOutputStream  fileout=new FileOutputStream(pathname,true);
		DataOutputStream dataout2=new DataOutputStream(fileout);
		
		DataOutputStream  dataout3=new DataOutputStream(new  FileOutputStream("F:"+File.separator+"20210907"+File.separator+"file1.txt"));
				
				
				
		
	}

}

DataOutputStream类实例方法

1.void writeBoolean(boolean v)---将boolean作为1字节值写入底层输出流。

2.void writeByte(int v)---将byte作为1字节值写入底层输出流

3.void writeChar(int v)---将char作为2字节值写入底层输出流，高字节优先

4.void writeDouble(double v)---双参数传递给long使用，通过使用doubleToLongBits()首先将double值更改为long值，然后将long值写入文件，最多8个字节，高字节。

5.void writeFloat(float v)--通过使用floatToIntBits()将浮点值更改为int，然后将该int作为4字节写入文件，高字节。

6.void writeInt(int v)---将底层输出流作为4字节写入int，高位字节

7. void writeLong(long v)---将long作为8字节写入底层输出流，高字节

8.void writeShort(short v)---将short作为2字节写入底层输出流，高字节优先

9.void writeUTF(String str)---使用modified UTF-8编码以机器无关的方式将字符串写入基础输出流

10.void flush---刷新数据输出流

11.void close()---关闭此输出流并且释放与此输出流相关联的任何资源

package com.object.test2;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class DateOutputStreamTest2 {

	public static void main(String[] args) throws IOException {
		// DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
		File pathname = new File("E:" + File.separator + "MyDownloads" + File.separator + "test2.txt");
		OutputStream out = new FileOutputStream(pathname, true);
		DataOutputStream dataout = new DataOutputStream(out);
		int id=1001;
		String name="张三";
		boolean sex=true;
		double height=185.7;
		short number=3000;
		long number2=124L;
		float height2=160.5f;
		char cha='B';
		byte num=100;
		// 1.void    writeBoolean(boolean v)---将boolean作为1字节值写入底层输出流。
		dataout.writeBoolean(sex);
		// 6.void   writeInt(int v)---将底层输出流作为4字节写入int，高位字节
		dataout.writeInt(id);
		// 4.void    writeDouble(doublev)---双参数传递给long使用，通过使用doubleToLongBits()首先将double值更改为long值，然后将long值写入文件，最多8个字节，高字节。
		dataout.writeDouble(height);
		// 9.void      writeUTF(String str)---使用modified UTF-8编码以机器无关的方式将字符串写入基础输出流
		dataout.writeUTF(name);
		// 2.void    writeByte(int v)---将byte作为1字节值写入底层输出流
		dataout.writeByte(num);
		// 3.void   writeChar(int v)---将char作为2字节值写入底层输出流，高字节优先
		dataout.writeChar(cha);
		// 5.void    writeFloat(floatv)--通过使用floatToIntBits()将浮点值更改为int，然后将该int作为4字节写入文件，高字节
		dataout.writeFloat(height2);
		// 7. void   writeLong(long v)---将long作为8字节写入底层输出流，高字节
		dataout.writeLong(number2);
		// 8.void    writeShort(short v)---将short作为2字节写入底层输出流，高字节优先
		dataout.writeShort(number);
		// 10.void    flush---刷新数据输出流
		dataout.flush();
		// 11.void    close()---关闭此输出流并且释放与此输出流相关联的任何资源
		dataout.close();
		out.close();
		
	}

}

优点:可以直接写出基本数据类型的数据和String，且不需要转换成字节数组

缺点：保存到文件中的数据是乱码

3.序列化---将一个Java对象转换成2进制数据流过程

因为我们做操作的Java对象可能会需要在多台计算机之间传递

如何实现序列化？

1.为被序列化的Java对象的生成类实现一个序列化接口【Serializable】

1.public interface Serializable

2.特殊---该接口中一个方法都没有

3.类的序列化由java.io.Serializable接口的类启用

4.不识闲此接口的类将不会是人和状态序列化或反序列化

5.可序列化类所有子类独类都是可序列化的

2.通过java提供的ObjectOutputStream类的writeObject(Object obj)

1.ObjectOutputStream的构造方法

ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的 ObjectOutputStream。

2.ObjectOutputStream的实例方法

void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

例如：

package com.object.test4;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ObjectOutputStreamClass {

	public static void main(String[] args) throws IOException {
		// ObjectOutputStream的构造方法
		//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
		File file1=new File("E:"+File.separator+"BaiduNetdiskDownload"+File.separator+"test2.txt");
		OutputStream out=new FileOutputStream(file1);
		ObjectOutputStream out1=new ObjectOutputStream(out);
		//void	writeObject(Object obj) 将指定的对象写入ObjectOutputStream。 
		Student student=new Student();
		out1.writeObject(student);
		out1.close();
		out.close();
		
		
	}

}

4.FileInputStream类

1.FileInputStream类构造方法：

FileInputStream(File file)---通过创建File对象创建一个字节输入

FileInputStream(String name)---通过String对象创建一个字节输入流

package com.object.test2;

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

public class FileInputStreamClass1 {

	public static void main(String[] args) throws FileNotFoundException {
		//FileInputStream(File file) 通过File对象创建一个字节输入流
		File file=new File("E:"+File.separator+"MyDownloads"+File.separator+"test2.txt");
		FileInputStream in=new FileInputStream(file);
		InputStream in11=new FileInputStream(file);
		//FileInputStream(String name) 通过String对象创建一个字节输入流
		String name="E:"+File.separator+"MyDownloads"+File.separator+"test2.txt";
	    FileInputStream in2=new FileInputStream(name);
	    InputStream in22=new FileInputStream(name);
	}

}

2.FileInputStream类实例方法

1.int   read() 从该输入流读取一个字节的数据。返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1

2.int   read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。返回值:读取的总字节数，如果到达文件末尾返回-1

3.void   close() 关闭此文件输入流并释放与流相关联的任何系统资源

2.DataInputStream类

DataInputStream类的构造方法

DataInputStream(InputStream in) 创建一个新的数据输出流，以将数据写入指定的底层输出流。

package com.object.test2;

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.InputStream;
import java.io.OutputStream;

public class DataOutputStreamClass {

	public static void main(String[] args) throws FileNotFoundException {
		//DataInputStream(InputStream  in)创建使用指定的底层InputStream的DataInputStream。
		File pathname=new File("E:"+File.separator+"MyDownloads"+File.separator+"test2.txt");
		InputStream in=new FileInputStream(pathname);
		DataInputStream dataout=new DataInputStream(in);
		
		FileInputStream fileIn=new FileInputStream(pathname);
		DataInputStream in=new DataInputStream(fileIn);
		 DataInputStream in2=new DataInputStream(new FileInputStream(new File("E:"+File.separator+"MyDownloads"+File.separator+"test2.txt")));
	}

}

DataInputStream类实例方法

boolean   readBoolean()---读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。

byte   readByte() ---读取并返回一个输入字节。该字节被看作是 -128 到 127（包含）范围内的一个有符号值。

char   readChar() ---读取两个输入字节并返回一个 char 值。

double   readDouble() ---读取八个输入字节并返回一个 double 值。

float   readFloat() ---读取四个输入字节并返回一个 float 值。

int   readInt() ---读取四个输入字节并返回一个 int 值。

long   readLong() ---读取八个输入字节并返回一个 long

short   readShort() ---读取两个输入字节并返回一个 short 值。

String   readUTF() ---读入一个已使用 UTF-8 修改版格式编码的字符串。

void   close() ---关闭此输出流并释放与此流有关的所有系统资源。

package com.object.test2;

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;
import java.io.InputStream;
import java.io.OutputStream;

public class DataOutputStreamClass2 {

	public static void main(String[] args) throws IOException {
		DataInputStream in=new DataInputStream(new FileInputStream(new File("E:"+File.separator+"MyDownloads"+File.separator+"test2.txt")));
		System.out.println(in.readBoolean());
		System.out.println(in.readInt());
		System.out.println(in.readDouble());
		System.out.println(in.readUTF());
		System.out.println(in.readByte());
		System.out.println(in.readChar());
		System.out.println(in.readFloat());
		System.out.println(in.readLong());
		System.out.println(in.readShort());	
		}
}

3.反序列化---将2进制流数据转换成java对象的过程

需要ObjectInputStream类的Object readObject()方法读取对象。

ObjectInputStream类的构造方法

ObjectInputStream(InputStream in)

ObjectInputStream类的实例方法

Object readObject() 从ObjectInputStream读取一个对象。

例如：

package com.object.test4;

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

public class ObjectInputStreamClass2 {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//ObjectInputStream类的构造方法
		//ObjectInputStream(InputStream  in)
		File file1=new File("E:"+File.separator+"BaiduNetdiskDownload"+File.separator+"test2.txt");
		InputStream in=new FileInputStream(file1);
		ObjectInputStream in1=new ObjectInputStream(in);
		//ObjectInputStream类的实例方法
		//Object	readObject() 从ObjectInputStream读取一个对象。 
		Object obj=in1.readObject();
		Student student=(Student)obj;
		in.close();
		in1.close();
		student.getStudent();
	}
}

airar

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java---File类以及字节流

1.文件操作文件---把数据持久化到磁盘的载体文件的组成:1.文件的基本属性【文件命名，文件类型，文件的创建时间，文件的大小.......】 2.文件中的数据2.File类的创建对象和常用方法 File类的定义：public class File 1.File类的静态成员变量：static String----pathSeparator与系统相关的路径分隔符，为方便起见，表示为字符串static char----path...
复制链接

扫一扫

专栏目录