其他分享
首页 > 其他分享> > 秃头星人进化记(IO流学习总结)

秃头星人进化记(IO流学习总结)

作者:互联网

IO流.学习笔记.总结

开始

(以下内容为听网课学习的总结见解,若有bug还请包涵指教,)
IO流说白了就是像在搬家,从老家(源头)搬到新家(目的地),当然你绝对不会把整栋房子地基平移过去,你会叫搬家公司或者自个把家具等重要的东西一点点运到新家,就相当于数据被当成无结构的字节或字符序列,以流的形式传递,进行输入输出…
注(*代表星级)

基本概念

流的意思:流动,从一端移动到另一端,源头与目的地
程序与文件|数组|网络连接|数据库,以程序为中心
流的方向:
输入流inputStream Reader
输出流outputSream writer
处理数据单元(节点流):
字节流:二进制,可以一切文件包括纯文本doc音频视频等
字符流:文本文件,只能处理纯文本
功能不同:
节点流:可以直接从数据源或目的地读写数据
处理流:不直接连接到数据源或目的地,是处理流的流,通过对其他的处理提高程序的性能 ,就相当于对节点流的修饰。

File类(*****)

构造方法

File(String pathname)这个pathname就是指路径 也是最常用的
例如:`File src = new File(“D:/1.txt”);
File (String parent,String child)这就相当于把上面那个肢解了
例如:

    String parentPath="D:/";
	String name="1.txt";
	File src=new File(parentPath, name) ;

这里值得注意的是路径表示有三种:

//路径表示形式
		String path1="‪D:\\1.txt";
		String path2="‪D:"+File.separator+"1.txt";//中间这个separator是名称分隔符“/”;而pathSeparator则是路径分隔符“;”
		String path3="‪D:/1.txt";

注意:路径名称不能直接复制电脑上的,D:\1.txt 这样会报错1
报错1

常用方法

getName() 返回文件或目录的名称
getPath() 返回路径名字字符串
isFile() 判断是否是一个文件
isDirectory()判断是否是一个目录

import java.io.File;
import java.io.IOException;

public class Demo03 {
	public static void main(String[] args) throws IOException {
		File src = new File("D:/1.txt");
		System.out.println(src.getName());//返回名称
		System.out.println(src.getPath());//如果是绝对路径的话返回完整路径,否则相对路径
		System.out.println(src.getAbsolutePath());//返回绝对路径
		System.out.println(src.getParent());//返回上一级目录
		//System.out.println(src.get);
		System.out.println("文件是否存在"+src.exists());
		System.out.println("是否可读可写"+src.canWrite()+src.canRead());
		System.out.println("");
		if(src.isFile()) {
			System.out.println("文件");//存在
			
		}else {
			System.out.println("文件夹");//不存在
		}
		//创建新的文件 ,要是已经有了就不新建了 返回失败
		File src2=new File("D:/1.txt");
		if(!src2.exists()) {
			boolean flog=src2.createNewFile();
			System.out.println(flog?"成功":"失败");
		}
		//删除文件
		boolean flog=src2.delete();
		System.out.println(flog?"成功":"失败");
		
	}
 

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

字节流(*****)

一:读取文件
1:建立联系 File对象 源头(老家)
2:选择流 文件输入流 inputstream Fileinputstream
3:操作: byte[] x=new byte[10] + read()+读取大小
输出
4:释放资源:关闭 .close()

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
//读取文件
public class inputstream {
	public static void main(String[] args) {
		//1:建立联系 File对象
		File src=new File("D:/1.txt");
		//2:选择流
		InputStream is=null;
		try {
			 is=new FileInputStream(src);
			 //3:操作不断读取,缓冲数组
			 byte[] x=new byte[1024];
			 int cr=0;//接收实际读取大小
			    try {
				    //循环读取
				    while(-1!=(cr=is.read(x))) {
					String y=new String(x, 0, cr);
					System.out.println(y);
				       }
			       } catch (FileNotFoundException e) {
				e.printStackTrace();
				 System.out.println("文件不存在");
			}	
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("读取文件失败");
		}finally {
			if(is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					System.out.println("无法关闭");
					e.printStackTrace();
				}
			}
		}
	}
}

二:写出文件
1:建立联系 File对象 目的地(新家)
2:选择流 文件输出流 outputstream Fileoutputstream
3:操作: write()+flush
输出
4:释放资源:关闭 .close()

//写入数据
public class outputstream {
	public static void main(String[] args) {
		//1:建立连接  file  目的地
		File src= new File("D:/1.txt");
		//2:选择流
		OutputStream os=null;
		//以追加形式写出文件
		try {
			os=new FileOutputStream(src,true);//注意了 这里的true是说  你第一次写入数据后 如果再执行若你不写true或者写flase就会覆盖上一次的结果,但是若是true则会追加,在后面继续添加
			//3:操作
			String x="1234567你好呀";
			//字符串转字节数组
			byte[] data=x.getBytes();
			try {
				os.write(data, 0, data.length);
				os.flush();//强制刷新出去
			} catch (IOException e) {
				System.out.println("文件写出失败");
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			System.out.println("文件不存在");
			e.printStackTrace();
		}finally {
			if(os!=null) {
				try {
					os.close();
				} catch (IOException e) {
					System.out.println("关闭失败");
					e.printStackTrace();
				}
			}
		}
	}
}

三:文件|文件夹的拷贝 程序为桥梁,就是把读取的内容拷贝到写出的目的地里面,两个不同的路径,也就是把前两个结合起来了
1:建立联系 File对象 源头和目的地
2:选择流 文件输入流 inputstream Fileinputstream 文件输出流 outputstream Fileoutputstream
3:操作: byte[] x=new byte[10] + read()+读取大小
write()+flush

4:释放资源:关闭 .close()
文件的拷贝

//复制文件 就是将前两个合并  先读取后合并
public class copy {
	public static void main(String[] args) throws IOException {
		String srcpath="D:/1.JPG";
		String destpath="D:/4.JPG";
		try {
			copyfile(srcpath, destpath);
		} catch (FileNotFoundException e) {
			 e.printStackTrace();
			 System.out.println("404NotFound");
		}catch (IOException e) {
			 e.printStackTrace();
			 System.out.println("复制失败,关闭流失败");
		}
	}
	public static void copyfile(String srcpath,String destpath)  throws IOException{
		File src=new File(srcpath);
		File dest= new File(destpath);
		if(!src.isFile()) {
			System.out.println("只能拷贝文件");
		}
		InputStream is=null; 
		is=new FileInputStream(src);
		OutputStream os=null;
		os=new FileOutputStream(dest,true); 
		 //读取1.txt(必须存在且为文件)
		 byte[] x=new byte[1024];
		 int cr=0; 
			while(-1!=(cr=is.read(x))) {
				 os.write(x,0,cr); 
			}
			//2:copy 将上面读取的写入到3.txt(可以不存在)
			os.flush();//强制刷新出去
			os.close();
			is.close();			 
	}
	}
 

文件夹的拷贝(如果将父目录复制到子目录会报错):

//复制文件夹
public class copydir {
	public static void main(String[] args) throws IOException {
		String srcpath="G:/1";
		String destpath="F:/1";
		File src=new File(srcpath);
		File dest=new File(destpath);
		if(src.isDirectory()) {
			dest=new File(destpath,src.getName());
		}
		copyDirDetail(src, dest);
	}
	public static void copyDirDetail(File src,File dest) throws IOException {
		if(src.isFile()) {//如果是文件 则直接读取复制
			 FileUtil.copyfile(src, dest);
		}else if(src.isDirectory()) {//如果是文件夹
			//确保目标文件夹存在
			dest.mkdirs();
			//这里有一个bug解决   
			if(dest.getAbsolutePath().contains(src.getAbsolutePath())) {
				System.out.println("父目录不能拷贝到子目录中");
				return;
			}
			//获取下一级目录文件
			for(File sub:src.listFiles( )) {
				copyDirDetail(sub, new File(dest,sub.getName()));
			}
		}
	}
}

字符流(*****)

                                          字符流(只能处理纯文本,全部为可见字符 .txt .html)

一:纯文本读取
1:建立联系
2:选择流 Reader FlieReader
3: 执行操作
4:关闭流

//字符流读取
public class reader {
	public static void main(String[] args) {
		
		//建立连接
		String path="D:/1.txt";
		File src=new File(path);
		//选择流
		Reader r=null;
		try {
			r=new FileReader(src);
			char[] cr=new char[1024];//这里不是byte 是char
			int len=0;
			try {
				while(-1!=(len=r.read(cr))) {
					String s=new String(cr,  0, len);
					System.out.println(s);
				}
			} catch (IOException e) {
				 System.out.println("文件读取失败");
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			System.out.println("文件找不到404");
			e.printStackTrace();
		}finally {
			if(r!=null) {
				try {
					r.close();
				} catch (IOException e) {
					 System.out.println("关闭流失败");
					e.printStackTrace();
				}
			}
		}
	}
}

二:纯文本写出
1:建立联系
2:选择流
3:读取write(字符数组,0,长度)+flush
write(字符串)
write(字符|字符串)
4:关闭流

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
//纯文本写出
public class writer {
	public static void main(String[] args) {
		String path="D:/1.txt";
		File dest =new File(path);
		Writer wt=null;
		try {
			wt=new FileWriter(dest,true);
			String s="java";
			wt.write(s);
			wt.append("123");
			wt.flush();
		} catch (IOException e) {
			System.out.println("404");
			e.printStackTrace();
		}
	}
}

三:纯文本拷贝:

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
//只能拷贝纯文本
public class copytxt {
	public static void main(String[] args) {
		String srcpath="D:/1.txt";
		String destpath="D:/4.txt";
		try {
			copy(srcpath,destpath);
		} catch (IOException e) {
			System.out.println("拷贝失败");
			e.printStackTrace();
		}
	}
	public static void copy(String srcpath,String destpath) throws IOException {
		File src=new File(srcpath);
		File dest=new File(destpath);
		Reader r=null;
		r=new FileReader(src);
		Writer w=null;
		w=new FileWriter(dest,true);
		char[] c=new char[1024];
		int len=0;
		while(-1!=(len=r.read(c))) {
			w.write(c, 0, len);
			 w.flush();
		}
		 r.close();
		 w.close();
	}
}

处理流(*****)

                                                   处理流:增强性能、提供性能,节点流之上

一:缓冲流
1:字节缓冲流
BufferedinputStream
BufferedoutputStream
没有新增的方法

//		InputStream is=null; 
//		is=new FileInputStream(src);
//		OutputStream os=null;
//		os=new FileOutputStream(dest,true); 
		InputStream is=null; 
		is=new BufferedInputStream(new FileInputStream(src));
		OutputStream os=null;
		os=new BufferedOutputStream(new FileOutputStream(src)); 
		/*
		 * 注意这里加了缓冲流
		 */

2:字符缓冲流
Bufferedreader
Bufferedwriter
有新增的方法

	//注意这里加了缓冲流,新增了两个方法
		r=new BufferedReader(new FileReader(src));
		BufferedWriter w=null;
		w=new BufferedWriter(new FileWriter(dest,true));
//		char[] c=new char[1024];
//		int len=0;
//		while(-1!=(len=r.read(c))) {
//			 
//			w.write(c, 0, len);
//			 w.flush();
//			
//		}
		String line=null;
		while(null!=(line=r.readLine())) {
			w.write(line);
			w.newLine();
			w.flush();
		}

二:转换流
字节流(byte)转为字符流(char) 处理乱码(编码集,解码集)
1:编码与解码的概念
编码 字符 —>编码字符集—>二进制
解码 二进制 —>解码字符集—> 字符
2:乱码问题:
编码和解码的字符集不统一;字节缺少,长度丢失
例如:

import java.io.UnsupportedEncodingException;

public class conver {
	public static void main(String[] args) throws UnsupportedEncodingException {
		//解码
		String str="你好呀";//gbk字符集
		//编码 char---byte
		byte[] data=str.getBytes();
		//默认情况下编码与解码字符集相同
		System.out.println(new String(data));
		
		//不相同的情况
		try {
			byte[] data2 =str.getBytes("utf-8");
			System.out.println(data2);
		} catch (UnsupportedEncodingException e) {
			System.out.println("字符集不相同");
			e.printStackTrace();
		}
		
		//修改方法
		//编码
		byte[] data3 = str.getBytes("utf-8");
		//解码
		System.out.println( new String(data3,"utf-8"));
		//就是这俩地都得设置成一样的
	
	
		//还有一种错误乱码的情况就是字节丢失缺少
		String str2="你好呀";
		byte[] data4=str2.getBytes();
		System.out.println(new String(data4,0,3));
	
	
	}
}

3:转换流:字节转为字符
输出流OutputStreamWriter 编码
输入流InputStreamReader 解码

     BufferedReader   r=null;
        r=new BufferedReader(new InputStreamReader( new FileInputStream(src),"utf-8"));
     BufferedWriter w=null;
		w=new BufferedWriter(new OutputStreamWriter( new FileOutputStream(dest),"utf-8"));

关闭流(***)

由于每次都要.close(),太麻烦了
因此编写工具类,实现关闭功能

public class FileUtil {
	/*一:
	 * 工具类关闭流
	 * 可变参数:...   只能放在形参的最后一个位置,处理方式与数组一致
	 */
	public static void close( Closeable ... io) {
		for(Closeable temp:io) {
			if(null!=temp) {
				try {
					temp.close();
				} catch (IOException e) {
					 
					e.printStackTrace();
				}
			}
		}
		
	}//所以在is.close();  os.close(); 这样的关闭方法中  可以用FileUtil.close(is,os);
	
	/*二:
	 * 使用泛型方法
	 */
	public static <T extends Closeable> void closseall(T ... io) {
		for(Closeable temp:io) {
			if(null!=temp) {
				try {
					temp.close();
				} catch (IOException e) {
					 
					e.printStackTrace();
				}
			}
		}
	}//所以在is.close();  os.close(); 这样的关闭方法中  可以用FileUtil.closseall(is,os);
}
               /*三:
               * try {声明}{操作}这是Jdk1.7以后新出的
               */
 

打印流(***)

                                        PrintStream

一:先了解一下这三个常量

public class Systemio {
	public static void main(String[] args) throws FileNotFoundException {
		System.out.println("out");
		System.err.println("err");
		//键盘输入
		//Scanner sc=new Scanner(System.in);也就是下面这个
//		InputStream is=System.in;
//		Scanner sc=new Scanner(is);
//		System.out.println(sc.nextLine());
	    //text2();
	    //控制台--->文件
	    System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("D:/5.txt",true)),true));//第一个true早就知道了是每次输入都不覆盖的意思(每次输入追加);所以这里的第二个true 就是让他自动刷新,要不然没内容
	    System.out.println("aaaaaaaa");//此时运行你会发现5.txt里面木有东西  是因为没有刷新  .flush()
	    //回到控制台
	    System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
	    System.out.println("back.......");
	}
	public static void text2() throws FileNotFoundException {
		//也可以从文件输出输入
				InputStream is2=System.in;
				is2=new BufferedInputStream(new FileInputStream("D:/5.txt"));
				Scanner sc2=new Scanner(is2);
				System.out.println("请输入:");
				System.out.println(sc2.nextLine());
	}
}

二:PrintStream打印输出流练习:

public class PrintStreamio {
	public static void main(String[] args) throws FileNotFoundException {
		System.out.println("text");
	  PrintStream ps=System.out;
	  ps.println("sjw");//这就是把上面的分解了
	  
	  //输出到文件
	  File src=new File("D:/5.txt");
	  ps=new PrintStream(new BufferedOutputStream(new FileOutputStream(src)));
	 ps.println("123456"); 
	 FileUtil.closseall(ps);//看这个就调用了咱们的工具类  关闭流方法
	}
}

其他流(**)

一:节点流

1:字节数组 节点流

输入流:ByteArrayInputStream  read(byte[]b,int off,int len)+close()
输出流:ByteArrayInputStream  write(byte[]b,int off,int len)+toByteArray()  不要使用多态

文件---程序---字节数组
文件输入流
字节数组输出流

字节数组---程序---文件
字节数组输入流
文件输出流
public class byteArrayfile {
	public static void main(String[] args) throws IOException {
		byte[] data=getBytesFromFile("D:/1.jpg");
		toFileFromByteArray(data, "D:/7.jpg");
	}
	/*
	 * 文件---程序---字节数组
	文件输入流
	字节数组输出流
	 */
	public static byte[]  getBytesFromFile(String path) throws IOException {
		File src=new File(path);
		byte[] dest=null;
		InputStream is=new BufferedInputStream(new FileInputStream(src));
		//字节数组输出流不能使用多态
		ByteArrayOutputStream bos= new ByteArrayOutputStream() ;
		byte[] flush=new byte[1024];
		int len=0;
		while(-1!=(len=is.read(flush))){
			dest=bos.toByteArray();//转为字节数组
		}
		
		return dest;
		
	}
	/*
	 * 字节数组---程序---文件
	字节数组输入流
	文件输出流
	 */
	public static void toFileFromByteArray(byte[] src,String destPath) throws IOException {
		//创建源
		//目的地
		File dest =new File(destPath);
		//选择流
		//字节数组输入流
		InputStream is=new BufferedInputStream(new ByteArrayInputStream(src));
		//文件输出流
	 OutputStream os=new BufferedOutputStream(new FileOutputStream(dest));
		//操作不断读取数组
		byte[] by=new byte[1024];
		int len=0;
		while(-1!=(len=is.read(by))) {
			os.write(by,0,len);
		}
		os.flush();
		os.close();
	
	}
}

二:处理流

2:基本数据类型+String 保留数据+类型

输出流:DataInputStream  readxxx
输入流:DataOutputStream writexxx
一般可以结合节点数组使用
注意:所读取的数据类型和顺序必须与目标相同
若不同会报错*EOFException*  意思是说已经读取到末尾 没读取到你指定类型的数据
public class Data {
	public static void main(String[] args) throws IOException {
		datain("D:/7.txt");
		//dataout("D:/7.txt");
	}
	//读取
	public static void datain(String srcpath) throws IOException {
		//创建源
		File src=new File(srcpath);
		//选择流
		DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream(src)));
		//操作读取的顺序与写出一致,必须存在才能读取
		dis.readDouble();
		dis.readInt();
		dis.readUTF();
		System.out.println(dis.readUTF());
		dis.close();
	}
	
	
	public static void dataout(String destpath) throws IOException {
		
		Double y=1.2;
		int z=100;
		String x="你好";
		
		File dest=new File(destpath);
		DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
		dos.writeDouble(y);
		dos.writeInt(z);
		dos.writeUTF(x);
		dos.flush();
		dos.close();
	}
}

3:引用类型(对象)保留数据类型

反序列化:输入流 ObjectInputStream readObject
序列化: 输出流:ObjectOutputStream writeObject
先序列化后反序列化 反序列化必须与序列化顺序一致
java.io.NotSerializableException报错 解决方法implements java.io.Serializable
不是所有的属性都需要序列化 若加了transient 此属性就不会被序列化
注意 数组也可以序列化 跟对象一样

```java
public class Objectio {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		//seri("D:/4.txt");
		datain("D:/4.txt");
	}
	//反序列化
	public static void datain(String srcpath) throws IOException, ClassNotFoundException {
		//创建源
		File src=new File(srcpath);
		//选择流
		ObjectInputStream dis=new ObjectInputStream(new BufferedInputStream(new FileInputStream(src)));
		Object obj=dis.readObject();
		if(obj instanceof Demo4 ) {
			Demo4  de=(Demo4 )obj;
			System.out.println(de.getName());//他输出来不会是你好,会是null,  因为他加了transient没有序列化
			System.out.println(de.getx());
		}
		obj=dis.readObject();
		int[] arr=(int[])obj;
		System.out.println(Arrays.toString(arr));
		 
		dis.close();
	}
	//序列化
	public static void seri(String destPath) throws FileNotFoundException, IOException {
		Demo4  de=new Demo4 ("你好",100000.2);
		int[] arr= {1,2,3};
		File dest=new File(destPath);
		ObjectOutputStream dos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
	    dos.writeObject(de);
	    dos.writeObject(arr);
		dos.flush();
		dos.close();
	}
}        

附:

 
public class Demo4 implements java.io.Serializable{
    //不需要序列化就加transient
	private transient String name;
	private double x;
	public Demo4() {
		
	}
	public Demo4(String name,double x) {
		super();
		this.name=name;
		this.x=x;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getx() {
		return x;
	}
	public void setx(double x) {
		this.x = x;
	}
	
}

结束…

此次学习是对IO流的初步理解,具体的深水区会慢慢探索,若文章笔记内容有错,还请提出指教。。。

标签:String,IO,System,File,println,new,秃头,out,星人
来源: https://blog.csdn.net/s10110110000111/article/details/105616348