Java文件和数据流

最新推荐文章于 2023-01-17 12:02:27 发布

转圈的行星

最新推荐文章于 2023-01-17 12:02:27 发布

阅读量940

点赞数

分类专栏： Java基础文章标签： Java文件 Java数据流

本文链接：https://blog.csdn.net/weixin_40819786/article/details/97244650

版权

Java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

输入流和文件输入流
InputStream：按字节输入
FileInputStream：按字符串或文件输入

import java.io.InputStream;
import java.io.IOException;

//回显例程
public class J_Echo{
	public static void mb_echo(InputStream in){
		try{
			while (true){
				int i =in.read();
				if( i ==-1)
					break;
				char c =(char) i;
				System.out.print(c);
			}
		}
		catch(IOException e){
			System.err.println("发生异常：" +e);
			e.printStackTrace();
		}
		System.out.println();
	}
	public static void main(String args[ ]){
		mb_echo(System.in);
	}	
}

import java.io.FileInputStream;
import java.io.IOException;

public class J_EchoFile{
	public static void main(Strng args[ ] ){
		try{
			FileInputStream f = new FileInputStream("test.txt");
			int i;
			int b=f.read();
			for(i=0;i!=-1;i++){
				System.out.print((char)b);
				b=f.read();
			}
			System.out.println();
			System.out.println("文件\"test.txt\"字节数为："+i);
			f.close();
		}
		catch(IOException e){
			System.out.println("发生异常：" +e);
			e.printStackTrace();
		}
	}
}

输出流和文件输出流
OutputStream:按字节流输出
FileOutputStream：按文件流或字符串流输出

import java.io.IOException;
import java.io.OutputStream;

public class J_Write{
	public static void mb_write(OutputStream out){
		String s="输出流例程";
		byte[ ] b =s.getBytes[ ];
		try {
			out.write(b);
			out.flush();
		}
		catch(IOException e){
			System.err.print("发生异常: " +e);
			e.printStackTrace();
		}
	}
	public static void main(String args[ ]){
		mb_write(System.out）；
	}
}

import java,io.IOException;
import java.io.FileOutputStream;

public class J_WriteFile{
	public static void main(String args[ ]){
		String s="文件输出例子";
		byte[ ] b =s.getByte();
		try{
			FileOutputStream f=new FileOutpurStream("out.txt");
			f.write(b);
			f.flush();
			f.close();
		}
		catch(IOException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

标准输出
有三种：
按字节输出：System.out.print();
按字符串输出：System.out.println();
兼容c语言的输出：printf();format();

import java.io.PrintStream;
import java.io.FileNotFoundException;

public clas J_PrintStream{
	public static void main(String args[ ]){
		try{
			PrintStream f =new PrintStream（"out.txt"）;
			f.printf("%1$d+%2$d=%3$d",1,2,(1+2));
			f.close();
		}
		catch(IOException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

数据的输入流和输出流
DataInputStream 和DataOutputStream
数据的输入流和输出流针对数据，提供一些readInt()和writeInt();

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

public class J_Data{
	public static void main(String args[ ]){
		try{
			FileOutputStream fout = new FileOutputStream("out.txt");
			DataOutputStream dfout = new DataOutputStream(fout);
			int i;
			for(i=0;i<4;i++){
				dout.writeInt('0' +i);
			dout,close();

			FileInputStream fin = new FileInputStream("out.txt");
			DataInputStream dfin = new DataInputStream(fin);
			for(i=0;i<4;i++)
				System.out.print(dfin.readInt() + ", ");
			dfin.close(0;
		}
		catch(IOException e){
			System.err.println("发生异常：" +e);
			e.printStackTrace();
		}
	}
}

带缓存的输入流和输出流

在内存中开辟一个字节数组的存储单元（一般称为缓存），用来存放在数据流中数据。这样，借助于字节数组缓存，在读取或存储数据时可以将一个较大的数据块读入内存中，或将在内存中较大数据块一次性写入指定的文件中，从而达到提高读/写效率的目的。

import java.io.BufferdInputStream;
import java.io.FileInputStream;
import java.io.util.Data;

public class J_BufferedInputStream{
	private static String m_fileName = "J_BufferedInputStream.class";
	public static void main(String args[ ]){
		try{
			int i,ch;
			i =0 ;
			Date d1 = new Date();
			FileInputStream f = new  FileInputStream(m_fileName);
			while((ch=f.read()) !=-1)//read entire file
				i++;
			f.close();
			Date d2 =new Date();

			long t =d2.getTime() - d1.getTime();
			System.out.printf("读取文件%1$s(共%2$d字节）%n",m_fileName,i);
			System.out.printf("不带缓存的方法需要%1$dms%n",t);

			i=1;
			d1=new Date();
			f = new FileInputStream(m_fileName);
			BufferedInputStream fb =new BufferedInputStream(f);
			while (ch=fb.read())!=-1)
				i++;
			fb.close();
			d2.new Date(0;
			t = d2.getTime() - d1.getTime();
			System.out.pitnf("带缓存的方法需要%1$dms%n",t);
		}
		catch(Exception e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

重定向

标准输入流、标准输出流和标准错误输出流的重定向就是将这些标准输入流、标准输出流和标准错误输出流分别与指定的文件建立对应关系：当需要输入数据时，数据将从文件中读取；当需要输出数据时，数据将写入文件。
成员方法：
public static void setIn(InputStream in)
将标准输入输入流重定向为参数in指定的输入流。

public static void setOut(PrintStream out)
将标准输出流重定向为参数out指定的输出流。
public static void setErr(PrintStream err)
将标准错误输出流重定向为参数err指定的输出流

import java.io.FileInputStream;

public class J_SetIn{
	public static void main(String args[ ]){
		try{
			System.setIn(new FileInputStream("test.txt"));
			J_Echo.mb_echo(System.in);
		}
		catch(Exception e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

随机访问文件

前面介绍的输入流和输出流在对文件内容进行操作室一般是顺序读取或存储数据，而且读取数据和存储数据必须使用不同的类。随机访问文件就是突破这种限制，它所对应点类是是java.io.RandomAccessFile。采用类java.io.RandomAccessFile允许使用同一个实例对象对同一个文件交替进行读写，而且读写的数据在文件的位置可以指定
RandomAccessFile(String name,String mode)throws FileNotFoundException
name :文件名
mode: 打开模式只读，只写，读写

成员方法：
public void seek(long pos)throws IOException //将文件指针移到由参数pos 指定的位置

public long getFilePointer() throws IOException //返回当前文件指针所在的位置

public int skipBytes(int n) throws IOException //将文件指针向前移动n个字节，
public long length() throws IOException // 返回当前文件的长度
public int read() throws IOException//读入一个字节

public final String readline() throws IOException //读取当前位置到当前行结束的数据，并以字符串的形式返回，读取后文件指针移动到下一行数据的开始处
public void write(int b) throws IOException //按字节写入

//随机访问文件数据流例程
import java.io.IOException;
import java.io.RandomAccessFile;

public class J_RandomAccessFile{
	public static void main(String args[ ]){
		try{
			RandomAccessFile f =new RandomAccessFile("test.txt");
			int i;
			double d;
			for(i =0;i<10;i++)
				f.writeDouble(Math.PI*i);
			f.seek(16);
			f.writeDouble(0);
			f.seek(0);
			for(i=0;i<10;i++){
				d=f.readDouble();
				System.out.println("[" +i+ "]:" +d);
			}
			f.close();
		}
		catch(IOException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

读写器

Reader 和 Writer
java.io.Reader 和java.io.Writer
java.io.FileReader 和java.io.FileWriter

public int read() throws IOException
public void write() throws IOException

public FileReader(String fileName) throws FileNotFoundException
public FileWriter(String fileName) throws IOException

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

public class J_FileReaderWriter{
	public static void main(String args[ ]){
		try{
			fileWriter f_out = new FileWriter("test.txt");
			f_out.write("有志者，事竟成");
			f_out.close();
			
			FileReader f_in = new FileWriter("test.txt");
			for(int c=f_in.read();c!=-1;c=f_in.read())
				System.out.print((char)c);
			f_in.close();
		}
		catch(IOException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

带缓存的读写器

import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWrite;
import java.io.IOException;
import java.io.LineNumberReader;
public class J_BufferedReaderWriter{
	public static void main(String args[ ]){
		try{
			BufferedWriter bw = new BufferedWriter(new FileWrite("test.txt"));
			bw.write("有志者，事竟成");
			bw.newLine();
			bw.write("苦心人，天不负");
			bw.newLine();
			bw.close();
			
		于	LineNumberReader br=new LineNumberReader(new FileReader("test.txt");
			String s;
			for(s=br.readLine();s!=null;s=br.readLine())
				System.out.println(br.getLineNumber()+":"+s);
			br.close();
		}
		catch(IOException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

PrintWrite
java.io.PrintWrite是输出字符流类，与java.io.printStream相似。但处理字节时更强一些。

import java.io.PrintWriter;
import java.io.FileNotFoundException;

public class J_PrintWriter
{
	public static void main(String args[ ]){
		try{
			PrintWriter f=new PrintWriter("out.txt");
			f.println("莫等闲，白了少年头，空悲切");
			f.close();
		}
		catch(FileNotFoundException e){
			System.err.println("发生异常："+e);
			e.printStackTrace();
		}
	}
}

从控制台窗口读入数据

public InputStreamReader(InputStream in)
public OutputStreamWriter(OutputStream out)

import class J_ReadData{
	public static void mb_printInfo(){
		System.out.println("输入整数还是浮点数？");
		System.out.println("\t0:退出; 1:整数; 2:浮点数");
	}
	
	//接受整数的输入
	public static int mb_getInt(BufferedReader f){
		try{
			String  s= f.readLine();
			int i = Integer.parseInt(s);
			return i;
		}
		catch(Exception e){
			return -1;
		}
	}
	public static double mb_getDouble(BufferedReader f);{
		try{
			String s =f.readLine();
			double d =Double.parseDouble(s);
			return d;
			
		}
		catch(Exception e){
			return 0d;
		}
	}
	public static void main(String args[ ]){
		int i;
		double d;
		try{
			BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
			do{
				mb_printInfo();
				i=mb_getInt(f);
				if(i==0)
					break;
				else if(i==1){
					System.out.print("\t请输入整数："0;
					i = mb_getInt(f);
					System.out.println("\t输入整数：" +i);
				}
				else if(i==2){
					System.out.print("\t请输入浮点数：");
					d=mb_getDouble(f);
					System.out.println("\t请输入浮点数："+d);
				}
			}while(true);
			f.close();
		}
		catch(Exception e){
			System.err.println("发生异常：" +e);
			e.printStackTrace();
		}
	}
}

对象序列化

public ObjectInputStream(OutputStream out) throws IOException
public ObjectInputStream(InputStream in) throws IOException

public final void writeObject(Object obj) throw IOException
public final Object readObject() throws IOException,ClassNotFoundException

//对象序列化
import java.io.Serialzable;
public class J_Student implements Serializable{
		static final long serialVersionUID = 123456L;
		String m_name;
		int m_id;
		int m_height;
		
		public J_Student(String name,int id,int h){
			m_name=name;
			m_id=id;
			m_height =h;
		}
		public void mb_output(){
			System.out.println("姓名：" +m_name);
			System.out.println("学号：" +m_height);
		}
}
//第二个源文件
```java
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class J_ObjectOutputStream{
	public static void main(String args[ ]){
		try{
			ObjectOutputStream f =new ObjectOutputStream(new FileOutputStream("object.dat"));
			j_Student s = new J_Student("张三",2003001,172);
			f.writeObject(s);
			s.mb_output();
			f.close();
		}
		catch(Exception e){
			System.err.println("发生异常：" +e);
			e.printStackTrace();
		}
	}
}

//第三个源文件

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class J_ObjectInputStream{
	public static void main(String args[ ]){
		try{
			ObjectInputStream f =new ObjectInputStream(new FileInputStream("object.dat"));
			J_Student s= (J_Student)(j.readObject());
			s.mb_output();
			f.close();
		}
		catch(Exception e){
			System.err.println("发生异常：" +e);
			e.printStackTrace();
		}
	}
}

//下面假设程序版本升级，类J_Student发生了变化。设类J_Student增加了成员域 int m_weight;

import java.io.Serializable;

public class J_Student implements Serializable{
	static final long serialVersionUID = 123456L;
	String m_name;
	int m_id;
	int m_height;
	int m_weight;
	
	public J_Student(String name,int id , int h){
		m_name=name;
		m_id=id;
		m_height=h;
	}
	public void mb_output(){
		System.out.println("姓名：" +m_name);
		System.out.println("学号："+m_id);
		System.out.println("身高：" +m_height);
	}
}

文件名

前面介绍的类基本上都可以对文件的内容进行处理，例如，在文件中读取或存储数据。
当需要读取数据的文件不存在时往往不能直接作出判断，二必须通过异常才能得到这种信息。类java.io.File很好滴解决了这个问题。
类java.io.File一般不涉及文件按内部的具体内容，而是从整体上对文件进行处理，入获取各种各样的文件信息或者
删除文件。类java.io.File不仅可以对文件进行操作，而且可以对路径进行操作。

成员方法有：
判断当前对象表示的文件或路径是否存在: public boolean exists()
判断当前对象是否表示文件： public boolean isFile()
判断指定的当前对象是否表示路径：public boolean isDirectory()
判断当前对象表示的文件或路径是否可读： public boolean canRead()
判断当前对象表示的文件或路径是否可写： public boolean canWrite()
判断当前对象是否表示可执行文件： public boolean canExecute()
判断当前对象表示的文件或路径是否具有隐藏属性： public boolean isHidden()
判断当前对象的表示形式是否绝对路径采用绝对路径的形式： public boolean isAbsolute()
获取当前对象的绝对路径：public String getAbsolutePath() public File getAbsoluteFile()
获取最后修改的时间： public long length ()
当前对象的表示的文件或路径的名称： public String getName()
带路径名称：public String getPath()
父路径名称：public String getParent()
返回当前对象表示的路径下的所有目录和文件名列表：public String[] list() 或 public File[] listFiles()
返回系统的所有可用根目录： public static File[] listRoots()
分别返回当前路径下的所有空间大小、空闲空间大小和可用空间大小。
public long getTotalSpace()
public long getFreeSpace()
public long getUsableSpace()
重命名：public boolean ranameTo(File dest)
删除： public boolean delete()
创建新路径： public boolean mkdir() 或 public boolean mkdirs()

import java.io.File;

public class J_File{
	public static void main(String args[ ]){
	for(int i=0;i<args.length;i++){
		File f = new File(args[i]);
		if(f.exists()){
			System.out.println("getName: " +f.getName());
			System.out.println("getPath: " +f.getPath());
			System.out.println("getParent: "+f.getParent());
			System.out.println("length: "+f.length());
		}
		else
			System.out.printf("文件%1$s不存在%n" ,args[i]);
	}
	}
}

转圈的行星

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java文件和数据流

输入流和输出流InputStream：按字节输入FileInputStream：按字符串或文件输入import java.io.InputStream;import java.io.IOException;//回显例程public class J_Echo{ public static void mb_echo(InputStream in){ try{ while (t...
复制链接

扫一扫