Java——输入与输出

我不是女神ヾ 2023-06-03 04:57 8阅读 0赞

### Java——输入与输出 ###

*  1）file类：文件或目录信息的处理
 *   *  ①构造函数：
     *  ②常用操作方法
 *  2+3）InputStream和OutputStream类：字节输入流及输出流
 *   *  ①InputStream常用操作方法
     *  ②OutputStream常用操作方法
     *  ③FileInputStream类的构造函数
 *  4）Filter类：多字节数据读取类
 *   *  ①FilterInputStream类
     *  ②FilterOutputStream类
     *  ③
     *  ④DataOutputStream类常用方法：
     *  ⑤DataInputStream类常用方法：
 *  5+6)Reader类和Writer类 ：字符流
 *   *  ①抽象字符输入流Reader类的使用
     *  ②抽象字符输出流Writer类的使用
     *  ③读取带缓存的BufferedReader字符流
     *  ④带缓存的字符输出流BufferedWriter类
 *  7）用标准输入流System.in来获取数据
 *  8 )随机文件访问RandomAccessFile类

--------------------

***本人是个新手，写下博客用于自我复习、自我总结。  
如有错误之处，请各位大佬指出。  
参考教材：零基础学Java***

--------------------

输入和输出是向某个方向流动的数据流。  
流就是数据流向某个对象，并且到达这个对象的过程。  
输入流就是从目标程序中，将数据以流的形式复制到前面说的流对象中，然后，再从流对象中将数据读取出来。输出流就是将数据以流的形式复制到流对象中，再从这些流对象中取出流，写入到目标中。  
程序读取数据称为打开输入流，程序向其他源写入数据称为打开输出流。

有关输入和输出，在Java类库中有一个与之相对应的类库java.io包。  
也就是说，如果要使用输入输出类的方法和属性值，就需要引入java.io类。  
经常使用的输入输出类：  
1）file类  
2）OutputStream类  
3）InputStream类  
4）FilterStream类  
5）Writer类  
6）Reader类

# 1）file类：文件或目录信息的处理 #

## ①构造函数： ##

public File(String pathname)  
使用指定的路径，创建一个File对象  
public File(String parent,String child)  
使用指定的路径和字符串，创建一个File类  
public File(File parent,String child)  
使用一个File类的对象parent与字符串创建一个新的File对象

通过以上的构造函数来构造File对象。然后使用这个类提供的方法函数和属性值，来进行文件和目录信息的操作。

## ②常用操作方法 ##

public boolean canread() 测试这个文件是否可读

public boolean canwrite() 测试这个文件是否可写

public boolean createNewFile() 看这个文件或目录是否存在

public static File create TempFile(String prefix,String suffix,File directory) 在目录directory中创建以prefix为文件名，suffix为拓展名的临时文件

public boolean delete() 删除当前对象所指文件。删除成功返回true，否则返回false

例：

import java.io.*; //导入包
    public class InputAndOutput { 
         public void print(File f){  //实现判断文件类对象性质的方法
    		if(f.isDirectory()){  //当为目录时
    			System.out.println("这是一个目录！");
    		} else{ 
    			System.out.println("这不是一个目录！");
    		}
    		if(f.exists()){   //当文件存在时
    			System.out.println("这个文件存在！");
    		}else{ 
    			System.out.println("这个文件不存在！");
    			try{ 
    				f.createNewFile(); //创建文件
    			}catch(Exception e){ 
    			}
    		}
    	}
    	public void print1(File f){   //实现获取文件对象信息的方法
    		//输出文件的名字
    		System.out.println(f.getName());
    		//输出文件的父目录
    		System.out.println(f.getParent());
    		//输出文件的路径
    		System.out.println(f.getPath());
    	}
    	public void print2(File f){  //实现获取文件对象信息的方法
    		if(f.isFile()){ 
    			//输出文件的最后修改日期，以long型来表示
    			System.out.println(f.lastModified());
    			//输出文件的大小
    			System.out.println(f.length());
    		}
    	}
        public static void main(String args[]){ //主方法
        	InputAndOutput f1=new InputAndOutput();//创建对象f1
    		File f=new File("d:\\filetest","file.txt"); //创建对象f
    		//
    		   try{     //创建相应文件
    		     f.createNewFile();
    		   }catch(Exception(e)){ 
    		   }
    		//
    		/** 也就是说，如果不用代码方式创建相应文件，直接用以上的方法声明， 则什么都没有，即不会主动创建。也可以使用手动方式创建相应文件， 即去D磁盘，创建文件夹，放入相应文件。 */
    
    		 //获取f2指示的目录下的所有文件，并用数组方式存储
    		 File f2=new File("d:\\filetest");
    		 File[] ff=f2.listFiles();
    		 通过循环语句输出
    		 for(int i=0;i<ff.length;i++){ 
    		     System.out.println("文件名称为："+ff[i]);
    		 }
    
    		f1.print(f);   //调用方法
    		f1.print1(f);  //调用方法
    		f1.print2(f);  //调用方法
        }
     }

# 2+3）InputStream和OutputStream类：字节输入流及输出流 #

数据流对象分为两大类：一类是负责输入的输入流对象；另一类是负责输出的输出流对象。这两大类的父类是InputStream类和OutputStream类，这两个类都是抽象类。

## ①InputStream常用操作方法 ##

int read() 自输入流读取并返回0~255之间的一个int整数。若文件读完或者再无可读数据，则返回-1

int read(byte\[\] b) 从输入流中读取数据并存入字节数组b中。它的返回值是所读取的byte数。若无可读数据，则返回-1

int read(byte\[\] b,int off,int len)从输入流中读取len个字节的数据，并存入字节数组b中，并且从字节数组的第off位开始存储。它的返回值是所读取的字节数。若无可读数据，则返回-1

void close() 关闭输入流，并且释放与输入流相关的系统资源

## ②OutputStream常用操作方法 ##

int write(int b) 将b转换成字节，然后写到输出流中，每次写一个字节

int write(byte\[\] b) 将字节数组中的数据写到输出流中

int write(byte\[\] b,int off,int len)将字节数组中从第off位置开始长度为len个字节的数据写入到输出流中

void close() 关闭输出流，并且释放与输出流相关的系统资源

FileInputStream类是InputStream类的子类，并且其不是一个抽象类。这样，程序员就可以利FileInputStream类的对象来使用前面的方法。同理FileOutputStream类也是一样。

## ③FileInputStream类的构造函数 ##

public FileInputStream(String name)：创建一个FileInputStream对象，从以name为名称的文件中读取数据

public FileInputStream(File file)：创建一个FileInputStream对象，从指定的对象file中读取数据

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
    		File f=new File("d:\\filetest\\file.txt"); //创建文件对象f
    		//获取文件对象f的输入流对象fis
    		FileInputStream fis=new FileInputStream(f);
    		char ch;
    		for(int i=0;i<f.length();i++){  //通过循环实现文件的读取
    			ch=(char)fis.read();
    			System.out.print(ch);
    		}
    		fis.close(); //关闭输入流
        }
     }

\#\#④FileOutputStream类的构造函数

public FileOutputStream(String name)  
按照指定字符串创建的目标，创建一个输出流对象。若文件不存在则创建它。若文件存在则覆盖它

public FileOutputStream(File file)  
使用指定的文件对象创建输出流对象

public FileOutputStream(String name,boolean append)  
按照指定字符串创建的目标，创建一个输出流对象。若文件存在且append为真，新写入的数据将追加在原数据之后。若append为假，新数据将覆盖原来的数据

public FileOutputStream(File file,boolean append)  
使用指定的文件对象创建输出流对象。若文件存在且append为真，新写入的数据将追加在原数据之后

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
    		File f=new File("d:\\filetest\\file.txt"); //创建文件对象f
    		//创建一个文件输出流对象fos
    		FileOutputStream fos=new FileOutputStream(f);
    		for(int i='a';i<='z';i++){  //通过循环语句向f中写数据
    			fos.write(i);
    		}
    		fos.close(); //关闭输出流
        }
     }

综合例：

import java.io.*; //导入包
    public class InputAndOutput { 
        public static void main(String args[])throws Exception{ 
        	//创建文件类对象f和f1
    		File f=new File("d:\\filetest\\file.txt"); 
    		File f1=new File("d:\\filetest\\file2.txt"); 
    		//创建文件输出流对象fos和文件输入流对象fis
    		FileInputStream fis=new FileInputStream(f);
    		FileOutputStream fos=new FileOutputStream(f1);
    		//创建字节数组对象b
    		byte[]b=new byte[(int)f.length()];
    		fis.read(b);//使用字节数组将f中的数据读出
    		for(int i=0;i<f.length();i++){  //通过循环语句向f中写数据
    			fos.write(b[i]);
    		}
    		fos.close(); //关闭输出流
    		fis.close(); //关闭输入流
        }
     }

# 4）Filter类：多字节数据读取类 #

在JAVA中，有时候需要一行一行地读取数据，有时候需读取特定格式的数据。  
因此JAVA提供了一种机制，能够用数据流做连接，让原本没有特殊访问方法的流，经过接到特殊的流后，变得可以用特定方法来访问数据。这就是所谓的Filter机制，这是一个非常有用的类，它能够进行多字节数据的读取。Filter流对象被分为FilterInputStream和FilterOutputStream两个流类。

## ①FilterInputStream类 ##

数据的数据类型可以是字节、字符、整型、浮点型等。先通过FilterInputStream类读取数据，然后通过FilterInputStream类对数据进行组合，最后再输出数据。

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	//创建文件类对象f
    		File f=new File("d:\\filetest\\file.txt"); 
    		//创建文件输入流对象fis
    		FileInputStream fis=new FileInputStream(f);
    		//创建一个过滤输入流对象filter
    		FilterInputStream filter=new FilterInputStream(fis);
    		for(int i=0;i<f.length();i++){  //通过循环语句向f中写数据
    			System.out.print(filter.read(i));
    		}
    		fis.close(); //关闭输入流
        }
        //编译失误，是因为FilterInputStream类是一个protected类型。
    }

## ②FilterOutputStream类 ##

数据的数据类型可以是字节、字符、整型、浮点型等。先通过FilterOutputStream类，将所有这些类型的数据分解成字节类型的数据，再将字节类型的数据通过FileOutputStream类，向目标对象输出数据。

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	//创建文件类对象f
    		File f=new File("d:\\filetest\\file.txt"); 
    		//创建文件输出流对象fos
    		FileOutputStream fos=new FileOutputStream(f);
    		//创建一个过滤输出流对象filter
    		FilterOutputStream filter=new FilterOutputStream(fos);
    		for(int i='a';i<='z';i++){  //通过循环语句向f中写数据
    			filter.write(i);
    		}
    		fos.close(); //关闭输出流
        }
     }

//FilterOutputStream类不像使用FileOutputStream类那样，必须用字节数组来存储数据。FilterOutputStream类可以直接处理除字节以外的数据。

## ③ ##

其实FilterInputStream和FilterOutputStream类同样很难处理整型，字符串型等数据，因为它们都继承InputStream和OutputStream，并且这两个子类中，没有新的方法函数，只有一些简单的write()和read()方法。这些方法不能处理整型、字符串型等数据。为了解决这个问题，出现了DataInput和DataOutput接口，同时DataInputStream类和DataOutputStream类分别实现了以上两个接口，并继承了FilterInputStream和FilterOutputStream类。

## ④DataOutputStream类常用方法： ##

boolean writeBoolean(boolean v);
     byte writeByte(byte v);
     char writeChar(char v);
     short writeShort(short v);
     int writeInt(int v);
     long writeLong(long v);
     float writeFloat(float v);
     double writeDouble(double v);
     String writeUTF(String str);

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	String st; //关于字符串对象st
        	//创建文件类对象f
    		File f=new File("d:\\filetest\\1.dat"); 
    		//创建文件输出流对象fos
    		FileOutputStream fos=new FileOutputStream(f);
    		//创建一个多字节输出流对象dos
    		DataOutputStream dos=new DataOutputStream(fos);
    		//使用dos对象将数据写入到f中
    		try{ 
    			dos.writeUTF("明天要下雨了。");
    			dos.writeUTF("明天要下雨了。");
    			dos.writeUTF("明天要下雨了。");
    			dos.writeUTF("明天要下雨了。");
    		}catch(Exception e){ 	
    		}
    		dos.close(); //关闭输入流
        }
     }

## ⑤DataInputStream类常用方法： ##

boolean readBoolean();  
byte readByte();  
char readChar();  
short readShort();  
int readInt();  
long readLong();  
float readFloat();  
double readDouble();  
String readUTF();

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	//创建文件类对象f
    		File f=new File("d:\\filetest\\1.dat"); 
    		//创建文件输入流对象fis
    		FileInputStream fis=new FileInputStream(f);
    		//创建一个多字节输入流对象dis
    		DataInputStream dis=new DataInputStream(fis);
    		//使用dis对象将数据从f中读取
    		try{ 
    			System.out.println(dis.readUTF());
    		}catch(Exception e){ 	
    		}
    		dis.close(); //关闭输入流
        }
     }

综合例：

import java.io.*; //导入包
    public class InputAndOutput { 
       public void read(DataInputStream dis){ 
    		//在类中创建以下参数
    		String name=" ";
    		int age=0;
    		float maths=0;
    		try{ 
    			//在read方法中，以多字节输入流对象作为参数，并且利用
    			//此对象读取数据
    			name=dis.readUTF();
    			age=dis.readInt();
    			maths=dis.readFloat();
    		}catch(Exception e){ 
    		}
    		//输出相应的值
    		System.out.println("姓名："+name);
    		System.out.println("年龄："+age);
    		System.out.println("数学成绩："+maths);
    	}
    	//在write方法中，以多字节输出流对象作为参数，并且利用此对象写入数据
    	public void write(String name,int age,float maths,DataOutputStream dos){ 
    		try{ 
    			dos.writeUTF(name);
    			dos.writeInt(age);
    			dos.writeFloat(maths);
    		}catch(Exception e){ }
    	}
        public static void main(String args[])throws Exception{ 
        	InputAndOutput f2=new InputAndOutput();
        	//创建文件类对象f
    		File f=new File("d:\\filetest\\1.dat"); 
    		//创建文件输入流对象fis
    		FileInputStream fis=new FileInputStream(f);
    		//创建数据输入流对象dis
    		DataInputStream dis=new DataInputStream(fis);
    		//创建文件输出流对象fos
    		FileOutputStream fos=new FileOutputStream(f);
    		//创建数据输出流对象dos
    		DataOutputStream dos=new DataOutputStream(fos);
    		//在文件类对象中写入内容并将其内容读出来
    		f2.write("王鹏",18,87,dos);
    		f2.read(dis);
    		f2.write("松江",17,90,dos);
    		f2.read(dis);	
    		dos.close(); //关闭输出流
    		dis.close(); //关闭输入流
        }
    }

# 5+6)Reader类和Writer类 ：字符流 #

前面的处理数据的方式，都以字节为单位，只不过通过不同的流组合成其他类型数据而已。真正要处理的还得是字符流。也就是说，以字节为单位处理数据的流，称为字节流。可以一次性处理两个字节的流，称为字符流。字符流分为两个类：Reader类和Writer类。Reader类负责字符输入工作，Writer类负责字符输出工作。

## ①抽象字符输入流Reader类的使用 ##

这个类是抽象类，其中的方法没有被实现，所以无法使用，且无法创建对象。可以使用其子类来覆盖其抽象方法，从而创建对象。  
常用方法：  
public int read()：自输入流读取一个字符，并以int类型返回。 如无数据可读，返回-1.

public int read(char cbuf\[\])：自输入流读取cbuf这个数组长度的字符，并且存储在这个数组中。如无数据可读，返回-1.

## ②抽象字符输出流Writer类的使用 ##

这个类是抽象类，其中的方法没有被实现，所以无法使用，且无法创建对象。可以使用其子类来覆盖其抽象方法，从而创建对象。  
常用方法：  
public int write(int c)：将字符c写入输出流。

public int read(char cbuf\[\])：将字符数组中的字符写到输入流

public void write(String str)：将字符串str写入输出流。

## ③读取带缓存的BufferedReader字符流 ##

正因为Reader是抽象类，所以出现了非抽象类：InputStreamReader和BufferedReader

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	//创建文件类对象f
            File f=new File("d:\\filetest","2.txt"); 
            //创建输入流对象fis
            FileInputStream fis=new FileInputStream(f);
            //创建字符输入流对象isr
            InputStreamReader isr=new InputStreamReader(fis);
            //创建带缓冲的输入流对象，利用此对象读取一行数据
            BufferedReader br=new BufferedReader(isr);
            //输出读取到的内容
            System.out.println(br.readLine());
            System.out.println(br.readLine());
            /* 这是读取2.txt中的内容，需要自己建立。 * BufferedReader类是继承Reader类的子类，其在内部带有缓冲机制，所以可以以行为单位进行输入。 * 常用方法：public String readLine(); * 它每一次读取一行数据。 */
        }
     }

## ④带缓存的字符输出流BufferedWriter类 ##

正因为Writer是抽象类，所以出现了非抽象类：OutputStreamWriter和BufferedWriter

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
        	//创建文件类对象f
            File f=new File("d:\\filetest","2.txt"); 
            //创建输出流对象fos
            FileOutputStream fos=new FileOutputStream(f);
            //创建字符输出流对象osw
            OutputStreamWriter osw=new OutputStreamWriter(fos);
            //创建带缓冲的输出流对象，利用此对象读取一行数据
            BufferedWriter bw=new BufferedWriter(osw);
            //输出相应内容和空格
            bw.write("小王是一个好学生");
            bw.newLine();
            bw.write("他也是一个好学生。");
            bw.newLine();
            bw.close();  //关闭输出流对象
            /* 这是向2.txt中书写内容，需要自己建立txt。 * BufferedWriter类是继承Writer类的子类，其在内部带有 * 缓冲机制，所以它可以以行为单位进行输入。 * 常用方法：public void newLine()：向输出流中写入一个行结束 * 标记。 * public void flush()：将缓冲区内的数据强制写入 * 输出流。 * public void write(String str)： * 将字符串写入到输出流中。 */
        }
    }

# 7）用标准输入流System.in来获取数据 #

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
            //创建一个多字节输入流对象isr
            InputStreamReader isr=new InputStreamReader(System.in);
            //创建带缓冲的输入流对象br
            BufferedReader br=new BufferedReader(isr);
            System.out.println(br.readLine());
            br.close(); //关闭对象br
        }
    }

# 8 )随机文件访问RandomAccessFile类 #

所谓的随机文件访问，就是指可以读写任意位置数据的文件。通过移动文件指针，来达到随机访问的目的。这个类实现了DataInput和DataOutput接口，所以可以读取基本数据类型的数据。为了能够随机访问，必须先创建对象。

它的构造函数：  
public RandomAccessFile(String name,String mode)  
public RandomAccessFile(File file,String mode)  
//使用给定的字符串或文件对象和存取模式创建一个RandomAccessFile类对象

对于RamdomAccessFile类的存取模式，总共有4种：分别是"r",“rw”,“rws”,“rwd”。"r"代表以只读方式打开文件，若此时进行写操作会出错。“rw”,“rws”,"rwd"是以读写模式打开文件，若文件不存在，则创建它。创建完对象后，就要使用它的方法来操作数据：

public native void seek(long pos):将文件位置指针移动到pos处  
public native long length():获取文件大小，以字节为单位  
public native long getFilePointer():取到文件位置指针  
readBoolean(),readByte(),readChar(),readShort()…:  
读取不同类型的数据  
write(int b),writeBoolean(boolean v),writeByte(byte v)…:  
将不同类型的数据输出到文件

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
            //创建一个文件类对象 f
        	File f=new File("d://raf.txt");
        	//创建一个随机访问类对象raf
        	RandomAccessFile raf=new RandomAccessFile(f,"rw");
        	RandomAccessFile raf1=new RandomAccessFile(f,"rw");
        	//创建各种变量
        	int x=4;
        	char c='a';
        	String str="这些都是基本数据类型的数据";
        	//利用raf写入不同数据类型的数据到f中
        	raf.writeInt(x);
        	raf.writeChar(c);
        	raf.writeUTF(str);
        	//利用raf读取不同的数据类型的数据
        	System.out.println(raf1.readInt());
        	System.out.println(raf1.readChar());
        	System.out.println(raf1.readUTF());
        	//关闭对象raf
        	raf.close();
        	raf1.close();
        }
    }

例：

import java.io.*; //导入包
    public class InputAndOutput { 
    	public static void main(String args[])throws Exception{ 
            //创建一个文件类对象 f
        	File f=new File("d://raf.txt");
        	//创建一个随机访问类对象raf
        	RandomAccessFile raf=new RandomAccessFile(f,"rw");
        	//创建字符串对象
        	String s="这个就是学校最好的学生";
        	System.out.println("现在要添加数据了！");
        	//让raf的指针指向内部数据的末端
        	try{ 
        		long l=raf.length();
        		raf.seek(l);
        		raf.writeUTF(s);
        		System.out.println("刚刚加到后面的字符串是：");
        		raf.seek(l);
        		System.out.println(raf.readUTF());
        		raf.seek(0);
        		System.out.println(raf.readUTF());
        		raf.close();
        	}catch(Exception e){ }
        }
    }

注：  
1、字节流与字符流的主要区别：  
字节流是最基本的，所有的InputStream和OutputStream的子类都是字节流，其主要用于处理二进制数据，并按字节来处理。实际开发中很多的数据都是文本，这就提出了字符流的概念，它按虚拟机的encode来处理，也就是要进行字符集的转化。这两者之间通过InputStreamReader和OutputStreamWriter来关联。实际上，通过byte\[\]和String来关联 在实际开发中出现的汉字问题，这都是在字符流和字节流之间转化不统一  
而造成的。在从字节流转化为字符流时，实际上就是byte\[\]转化为String