Java SE学习之文件操作与IO流

1.文件操作

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.io.IOException;

/**
 * 
File(File parent, String child) 
从父抽象路径名和子路径名字符串创建新的 File实例。  
File(String pathname) 
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。  
File(String parent, String child) 
从父路径名字符串和子路径名字符串创建新的 File实例。  
 * @author zhou'en'xian
 *
 */

public class FileLearning {

	public static void main(String[] args) throws IOException {
		File f1=new File("E:\\abc","a");
		File f2=new File("E:\\abc\\b");
		File f3=new File(f1,"aa.txt");
		/**
	     * File类的获取
		 */
		/*String absoultPath=f1.getAbsolutePath();//getAbsolutePath()方法：获取文件的绝对路径
		System.out.println(absoultPath);
		String path=f2.getPath();//getPath()方法：获取文件路径名
		System.out.println(path);
		String name=f3.getName();//getName()方法：获取文件名称
		System.out.println(name);
		long fileLength=f3.length();//length()方法：获取文件大小(字节长度)
		System.out.println(fileLength);*/
		/**
		 * 文件以及文件夹的创建和删除
		 */
		/*if(f3.createNewFile()) {
		//createNewFile方法：创建文件，如果文件不存在，新建文件并返回true;如果文件存在则返回false
			System.out.println("文件创建成功！");
		}else{
			System.out.println("文件已经存在！");
		};
		System.out.println(f3.exists());
		//exists()方法：判断文件是否存在
		//delete()方法：删除文件，不进回收站
		if(f2.exists()) {
			f2.delete();
			System.out.println("文件已经删除！");
		}else {System.out.println("文件不存在！");};
		File f4=new File("E:\\abc\\e");
		//mkdir()方法：创建单级目录并返回true,如果存在，返回false
		//mkdirs()方法：创建多级目录并返回true,如果存在，返回false
		if(f4.mkdir()) {
			System.out.println("单级目录已经创建！");
		};
		File f5=new File(f1,"ab");
		if(f5.mkdirs()) {
			System.out.println("多级目录已经创建！");
		};
		//判断此路径名下的文件是文件还是文件夹
		//isFile()方法：判断文件，返回boolean值；isDirectory():判断文件夹，返回boolean值
		System.out.println(f3.isDirectory());
		System.out.println(f3.isFile());*/
		/**
		 * 文件过略
		 */
		/*String file[]=f1.list();
		for(String i:file) {
			System.out.println(i);
		};
		File files[]=f2.listFiles();
		for(File fie:files) {
			System.out.println(fie);
		};*/
		/**listFiles(FileFilter filter)方法:File类中的listFiles(FileFilter filter)
		 * 方法参数是接口Interface FileFilter，并且该接口没有实现类，仅有一个方法
		 * accept(File pathname) ，于是建立myFileter类  实现FileFilter，重写accept（）方法*/
		File Files[]=f1.listFiles( new myFilenameFilter());
		for(File f:Files) {
			System.out.println(f);
		};
		//File f2=new File("E:\\abc\\b");
		File file1[]=f2.listFiles(new MyFilter());
		for(File u:file1) {
			System.out.println(u);
		};

	}

}
class myFilenameFilter implements FilenameFilter{

	@Override
	public boolean accept(File dir, String name) {
		
		return name.endsWith("csv");
	}}
class MyFilter implements FileFilter{

	@Override
	public boolean accept(File pathname) {
		String s=pathname.getName();
		return s.endsWith("txt");
	}}

 

2.IO流

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
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.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.util.Date;

public class FileLearn  {
	
	public static void main(String[] args) throws IOException  {
		File fi=new File("E:\\abc\\c\\ca.txt");
		/**字节输入输出流
		 *FileOutputStream：字节输出流；write
		 *FileInputStream:字节输入流；read
		 */
		/* FileOutputStream out=new FileOutputStream(fi);
		String s="i love java!";
		byte by[]=s.getBytes();//编码过程
		out.write(by);
		out.close();
		FileOutputStream fos=new FileOutputStream(fi,true);
		String ss="\r\n"+"i love hpu!";//换行写
		fos.write(ss.getBytes());
		fos.close();*/
		/**FileInputStream构造方法
		 * FileInputStream(String name) 
		 * FileInputStream(File file) 
		 */
		/*FileInputStream fis=new FileInputStream(fi);
     	int ch =0;
     	//read()方法：从该输入流读取一个字节的数据，读不到返回-1
		while((ch=fis.read())!=-1) {
			System.out.print((char)ch);
		};
		byte by[]=new byte[1024];
		int len;
		//read(byte[] b)方法:从该输入流读取最多 b.length个字节的数据为字节数组，读不到返回-1
		while((len=fis.read(by))!=-1) {
			System.out.println(new String(by,0,len));
		};
		fis.close();*/
		/**
		 * 字符输入输出流
		 * 字符输入流：Reader
		 * 字符输出流：Writer
		 */
		/*File fi1=new File("E:\\abc\\b\\ba.txt");
		FileOutputStream outs=new FileOutputStream(fi1);
		String sx="我爱中国！";
		outs.write(sx.getBytes());
		outs.close();
		//FileReader:读取字符流
		Reader rea=new FileReader(fi1);
		int lengt;
		char ch[]=new char[1024];
		while((lengt=rea.read(ch))!=-1) {
			System.out.print(new String(ch,0,lengt));
		};
		rea.close();
		//FileWriter:写入字符流
		File fi2=new File("E:\\abc\\b\\bc.txt");
		FileWriter fiwi=new FileWriter(fi2);
		String sa="我在未来等你！";
		fiwi.write(sa);
		fiwi.flush();
		fiwi.close();*/
		/**
		 * 转化流	
		 * OutputStreamWriter类：字符流通向字节流的桥梁；将字符串按照指定的编码表转成字节
		 * 构造方法：OutputStreamWriter(OutputStream out, String charsetName) 
		 *          OutputStreamWriter(OutputStream out) 
		 * InputStreamReader类：字节流通向字符流的桥梁；使用指定的字符编码表读取字节并将
		  *其解码为字符
		  *构造方法：InputStreamReader(InputStream in, String charsetName)
		  *          InputStreamReader(InputStream in) 
		 */        
		
		 /*FileOutputStream fi3=new FileOutputStream("E:\\abc\\c\\ca.txt");
	     OutputStreamWriter fops=new OutputStreamWriter(fi3, "utf-8");
	     fops.write("我在河南理工大学等你！");
	     fops.close();
	     fi3.close();
	     FileInputStream fi4=new FileInputStream("E:\\abc\\c\\ca.txt");
	     InputStreamReader isr=new InputStreamReader(fi4, "utf-8");
	     int len;
	     while((len=isr.read())!=-1) {
	    	 System.out.print((char)len);
	     };
	     fi4.close();
	     isr.close();*/
		/**
		 * 缓冲流
		 */
		/**
		 * 字节缓冲输出流BufferedOutputStream
		 * 构造方法：public BufferedOutputStream(OutputStream out)
		 * 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
		 */
		/*File fie4=new File ("E:\\abc\\d\\da.txt");
		FileOutputStream out1=new FileOutputStream(fie4);
		BufferedOutputStream buf=new BufferedOutputStream(out1);
		String s_1="I wait for you in hpu";
		buf.write(s_1.getBytes());
		buf.close();*/
		/**
		 * 字节缓冲输入流 BufferedInputStream
		 * 构造方法：public BufferedInputStream(InputStream in)
		 */
		/*FileInputStream fin1=new FileInputStream("E:\\abc\\d\\da.txt");
		BufferedInputStream buf1=new BufferedInputStream(fin1);
		int ch=0;
		while((ch=buf1.read())!=-1) {
			System.out.print((char)ch);
		};*/
		/**
		 * 字符缓冲输出流 BufferedWriter
		 * 构造方法：BufferedWriter(Writer out)
		 */
		/*FileWriter fil3=new FileWriter("E:\\abc\\d\\db.txt");
		BufferedWriter buf2=new BufferedWriter(fil3);
		for(int i=0;i<6;i++) {
			buf2.write("河南理工大学!");
			buf2.newLine();
			//newLine()写入一个行分隔符
		};
		buf2.close();*/
		/**
		 * 字符缓冲输入流 BufferedReader
		 * 构造方法：BufferedReader(Reader in)
		 */
		/*FileReader fil4=new FileReader("E:\\abc\\d\\db.txt");
		BufferedReader buf3=new BufferedReader(fil4);
		String line=null;
		//public String readLine() 读取一个文本行，包含该行内容的字符串，
		//不包含任何行终止符，如果已到达流末尾，则返回 null
		while((line=buf3.readLine())!=null) {
			System.out.println(line);
		};
		buf3.close();*/
		/**
		 * 字节数组流
		 *  ByteArrayInputStream和ByteArrayOutputStream
		 *  构造方法：ByteArrayInputStream(byte[] buf)
		 *  构造方法： ByteArrayOutputStream() 
		 */
	     //利用字节数组流复制图片C:\Users\zhou'en'xian\Pictures\2019-03
	    /*FileOutputStream fos1=null;
	    FileInputStream fis1=null;
        ByteArrayOutputStream baos=null;
        ByteArrayInputStream bais=null;
    try {
    	fis1=new FileInputStream("C:\\Users\\zhou'en'xian\\Pictures\\2019-03\\12.jpg");
    	baos=new ByteArrayOutputStream();
    	fos1=new FileOutputStream("C:\\Users\\zhou'en'xian\\Desktop\\my.jpg");
    byte buf[]=new byte[1024*1024];//设置缓冲数组容器
    int len=0;
    while((len=fis1.read(buf))!=-1) {
    	baos.write(buf, 0, len);
    } 
    byte[] by=baos.toByteArray();
    bais=new ByteArrayInputStream(by);
    int length;
    while((length=bais.read(buf))!=-1) {
    	fos1.write(buf, 0, length);
    };
    }catch(IOException e) {
    	e.printStackTrace();
    }finally{
    	try {
    		if(fis1!=null) {
    			fis1.close();
    		}
    	}catch(IOException e) {
    		e.printStackTrace();
    	}
    	try {
    		if(fos1!=null) {
    		fos1.close();	
    		};
    		}catch(IOException e) {
    		e.printStackTrace();
    	};
    }*/
		/**数据流
		 * DataInputStream和DataOutputStream
		 *提供了可以存取与机器无关的所有Java基础
		 *类型数据(如：int、double、String等)的方法。
		 *构造方法：DataInputStream(InputStream in) 
		 *构造方法：DataOutputStream(OutputStream  out)
		 */
		/*ByteArrayOutputStream byout=new ByteArrayOutputStream();
		//ByteArrayInputStream byin=new ByteArrayInputStream(null);
		DataOutputStream data=new DataOutputStream(new BufferedOutputStream(byout));
		data.write(4);
		data.writeBoolean(true);
		data.writeUTF("hpu");
		data.writeFloat(3);
		data.flush();
		byte[] by=byout.toByteArray();
		DataInputStream datain=new DataInputStream(new BufferedInputStream(
				new ByteArrayInputStream(by)));
		int a=datain.read();
		boolean b=datain.readBoolean();
		String c=datain.readUTF();
		float d=datain.readFloat();
		System.out.println(a+"-"+b+"-"+c+"-"+d);*/
		/**
		 * 对象流
		 * ObjectInputStream/ObjectOutputStream
		 */
		write();
		read();
		}
	public static void write() {
		FileOutputStream  fout=null;
		ObjectOutputStream obj=null;
		try {
			  fout=new FileOutputStream("E:\\abc\\e\\ec.txt");
			  obj=new ObjectOutputStream(fout);
			  obj.writeInt(3);;
			  obj.writeBoolean(true);
			  obj.writeObject(new Date());
			  obj.flush();
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} catch (IOException e) {	
			e.printStackTrace();
		}finally {
			if(fout!=null) {
				try {
					fout.close();
				} catch (IOException e) {
					
					e.printStackTrace();
				}
			
			};
			if(obj!=null) {
				try {
					obj.close();
				} catch (IOException e) {
					
					e.printStackTrace();
				}
			};
		};
	};
	public static void read() {
		FileInputStream fin=null;
		ObjectInputStream objin=null;
		BufferedInputStream buf=null;
		try {
			fin=new FileInputStream("E:\\abc\\e\\ec.txt");
			buf=new BufferedInputStream(fin);
			objin=new ObjectInputStream(buf);
			System.out.println(objin.readInt());
			System.out.println(objin.readBoolean());
			System.out.println(objin.readObject());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			
			e.printStackTrace();
		}finally {
			if(fin!=null) {
				try {
					fin.close();
				} catch (IOException e) {
					
					e.printStackTrace();
				}
			};
			if(buf!=null) {try {
				buf.close();
			} catch (IOException e) {
				
				e.printStackTrace();
			}};
			if(objin!=null) {
				try {
					objin.close();
				} catch (IOException e) {
					
					e.printStackTrace();
				}
			};
		}
	};
	
	}