Java中的流和文件

package net.onest.demo1;

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

public class MyFile {
	public static void main(String[] args) {
		File file = new File("F:/1.txt");
		//定义一个文件对象，就像是我们定义一个Teacher类的对象似的，Teacher teacher = new Teacher();，我们创建的文件他都是所属于File类的，也就是我们创建的文件文件夹都是File类的对象
//		 private File(String pathname, int prefixLength) {
//		        this.path = pathname;
//		        this.prefixLength = prefixLength;
//		    }
		//判断该对象是否存在
		if(!file.exists()) {
			try {//该对象不存在
				boolean sucess = file.createNewFile();
				if(sucess) {
					System.out.println("创建文件成功");
				}else {
					System.out.println("创建文件失败");
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		File dir = new File("F:/1");
		if(!dir.exists()) {
			boolean sucess1 = dir.mkdir();
			if(sucess1) {
				System.out.println("创建目录成功");
			}else {
				System.out.println("创建目录失败");
			}
		}
		
		//得到目录列表是
		//调用list()函数得到的是String类型的一个数组，该数组内存储的是文件夹内个文件或文件夹的名称
		String[] files = dir.list();
		for(String str:files) {
			System.out.println(str);
		}
		//2   2.txt
		
		
		//调用listFile()函数得到的结果是该目录下个文件或文件夹的盘符信息
		File[] filess = dir.listFiles();
		for(File f:filess) {
			System.out.println(f);
		}
		//F:\1\2    F:\1\2.txt
		
		//路径.getName()得到的是文件夹或者是文件的名字
		for(File f:filess) {
			System.out.println(f.getName());
		}
		
		//2 2.txt
		
		for(File f:filess) {
			System.out.println(f.getAbsolutePath());
		}
		
		//F:\1\2    F:\1\2.txt
		
		
		//下面是4个抽象类（两个是有关字节的，两个是有关字符的）
		//下面我们先说有关字节的类
		//输入流是用来读取数据的
		//字节输入流InputStream类，Java中所有的字节输入流都用InputStream来表示，读取单位为一个字节
		//但是为了方便不同的外部资源输入，Java中对于不同的外部资源对应了不同的输入流类，他们都继承自InputStream类
		//①FileInputStream类型的对象调用read（）方法读出数据
		try {
			InputStream input = new FileInputStream("F:/1.txt");//存在向上转型，小括号里面要传入你要读的那个文件的地址
			int b = input.read();//用一个int类型的数据b来存储read（）函数的返回值，当b=-1时，表示读到了文件的末尾
			System.out.println(b);//1.txt内的数据为：asafdhgfv
			//这时返回的值b = 97，即为a的Unicode码
			while(input.read()!=-1) {
				System.out.println((char)b);//使用强制类型转换输出英文字母，但是需要注意的是字节输出输入流每次只能输入或者输出一个字节，英文字母占用一个字节，但是中文汉字却是占用两个字节，所以说用字节输出流输出中文汉字的时候会返回？
				
			}
            input.close();//无论是读完数据还是写完数据都要记得关闭流
		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		
	}

}

package net.onest.demo1;

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

public class File2 {
	public static void main(String[] args) {
		try {
			//FileInputStream类对象使用read（byte[],int off,int len）来读取数据
			InputStream input = new FileInputStream("F:/1.txt");
			byte[] inputs = new byte[3];//中括号内定义每次读取的数据个数
			int len = input.read(inputs);//实际读取到的数据个数，并将其存储在缓冲区的数组inputs内
			//这里也是，当len=-1时也表示已经读到文件末尾
			
				System.out.println(new String(inputs,0,len));//运用了new String方法将byte数组转化成字符串进行输出
            input.close();//读完数据后一定记得要关闭流
		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

package net.onest.demo1;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class File3 {
	public static void main(String[] args) {
		//前面我们已经介绍了FileInputStream类的对象读取数据两种方式，分别是read()和read(byte[],off,len),那么接下来我们看一下带缓冲的字节输入流
		//带缓冲的字节输入流
		try {//使用带缓冲的字节输入流前首先是要创建一个FileInputStream类型的对象，然后将他作为创建bufferedInputStream对象时构造函数内的参数
			//所谓的带缓冲的字节输入流是因为CPU读取速度与硬件相差较大，所以就将读取到的数据存储在一个缓冲区内，而BufferedInputStream就为我们提供了这么一个缓冲区
			//所以说在创建BufferedInputStream类的调用构造方法时会传入一个FileInputStream类型的对象
			/*
			 * 带缓冲的字节输入流：上面我们知道文件字节输入流的读取时，
			 * 是直接同字节流中读取的。由于字节流是与硬件（存储介质）进行的读取，
			 * 所以速度较慢。而CPU需要使用数据时通过read()、read(byte[])读取数据时就要
			 * 受到硬件IO的慢速度限制。我们又知道，CPU与内存发生的读写速度比硬件IO快10倍
			 * 不止，所以优化读写的思路就有了：在内存中建立缓存区，先把存储介质中的字节读
			 * 取到缓存区中。CPU需要数据时直接从缓冲区读就行了，缓冲区要足够大，在被读
			 * 完后又触发fill()函数自动从存储介质的文件字节内容中读取字节存储到缓冲区
			 * 数组。BufferedInputStream 内部有一个缓冲区，默认大小为8M，
			 * 每次调用read方法的时候，它首先尝试从缓冲区里读取数据，
			 * 若读取失败（缓冲区无可读数据），则选择从物理数据源 （譬如文件）
			 * 读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中
			 * ，最后再将缓冲区中的内容返回给用户.由于从缓冲区里读取数据远比直接
			 * 从存储介质读取速度快，所以BufferedInputStream的效率很高。
			 */
			InputStream	fis = new FileInputStream("F:/1.txt");
			InputStream input = new BufferedInputStream(fis);
			while((input.read())!=-1) {
				System.out.println((char)input.read());
			}fis.close();
			input.close();
			fis.close();//两个流都要关闭但是关闭的顺序不能交换
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

package net.onest.demo1;

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

public class File4 {
	public static void main(String[] args) {
		//前面我们已经了解到了字节输入流，那么下面我们来看一下字节输出流
		//同样字节输出流我们也有两个他的子类：文件字节输出流和带缓冲的字节输出流
		//所谓的输出流就是我要写入的数据
		try {
			//在创建FileOutputStream对象的时候我们可以传入一个或i两个参数，如果只传如一个参数，即文件地址的话，那就默认第二个参数为false，所以无论是我们主动传入第二个参数为false还是默认为false，那么写入的数据就会覆盖原来文件内的数据，只有我们自行输入第二个参数为trye时才表示再源文件后追加我们要写入的数据
			OutputStream output = new FileOutputStream("F:1.txt",true);
			output.write(97);//使用write方法写入一个字节的数据，传入的时Unicode码
			output.write("我是张张啊".getBytes());//使用getByte（）方法写入一个字节数组的数据
			output.close();
		} catch (FileNotFoundException e) {

			
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

package net.onest.demo1;

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

public class File4 {
	public static void main(String[] args) {
		//前面我们已经了解到了字节输入流，那么下面我们来看一下字节输出流
		//同样字节输出流我们也有两个他的子类：文件字节输出流和带缓冲的字节输出流
		//所谓的输出流就是我要写入的数据
		try {
			//在创建FileOutputStream对象的时候我们可以传入一个或i两个参数，如果只传如一个参数，即文件地址的话，那就默认第二个参数为false，所以无论是我们主动传入第二个参数为false还是默认为false，那么写入的数据就会覆盖原来文件内的数据，只有我们自行输入第二个参数为trye时才表示再源文件后追加我们要写入的数据
			OutputStream output = new FileOutputStream("F:1.txt",true);
			output.write(97);//使用write方法写入一个字节的数据，传入的时Unicode码
			output.write("我是张张啊".getBytes());//使用getByte（）方法写入一个字节数组的数据
			output.close();//写入的数据先放在缓冲区内，可以采用bos.flush()方法将数据写入文件，或者使用bos.close（）将数据写入文件中
			//close的作用：会刷新缓冲区，在close前会检测缓冲区是否有数据，有的话就会写入到文件之中
		} catch (FileNotFoundException e) {

			
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

package net.onest.demo1;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Reader1 {
	public static void main(String[] args) {
		/*
		 * 和字节流一样，字节流包括文件字符输入流和带缓冲的字符输入流；
		 * 字节字符输出流和带缓冲的字符输出流
		 * 下面我们先学习文件字符输入流输入数据的第一种方法read()
		 * 1.字符流的输入输出主要以字符为单位。主要用于外部设备中字符序列的读取
		 * 和外部设备中字符序列的显示。
		 * Java中采用16为的Unicode来表示字符串和字符，它可以自行判断自己应该都一个字节还是两个字节
		 * 也就是说如果他发现这是一个英文字母的话
		 * 那么他就会自己只读一个字节的数据
		 * 如果发现是汉字，那么他就会读取两个字节的数据
		 * 所以字符流相对于字节流来说更加的灵活
		 * Java中默认所有的 字符输入流都用Reader来表示，读取单位为1字符，2字节
		 * 但是由于Reader是一个抽象类，所以我们经常会使用他的子类FileReader和BufferedReader
		 */
		
		try {//文件字符输入流FileReader类的对象
			//使用read方法读取数据
			Reader reader = new FileReader("F:1.txt");
			System.out.println((char)reader.read());//读取一个字符，并将其转化为Unicode码对应的字符
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package net.onest.demo1;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Reader2 {
	public static void main(String[] args) {
		try {//对于FileReader类的对象使用read(char[],off,len)来读取数据
			//要注意的是，这里的数组是字符类型的，因为你是将读取到的每个字符放到里面的
			Reader read = new FileReader("F:1.txt");
			char[] reads = new char[10];
			int len = read.read(reads);//记录每次读到的字符个数
			System.out.println(new String(reads,0,len));//将数组转换成字符串进行输出
			read.close();
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

package net.onest.demo1;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Read3 {
	
	public static void main(String[] args) {
		//带缓冲的字节
		Reader fi;
		try {
			fi = new FileReader("F:1.txt");
			Reader read = new BufferedReader(fi);
			System.out.println((char)read.read());
			read.close();
			fi.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}

}

package net.onest.demo1;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Reader4 {
	public static void main(String[] args) {
		/*
		 * 前面我们说过字符输入流Reader类有两个子类
		 * 而字符输出流也是一样的，他也有两个子类：FileWriter和BufferedWriter
		 */
		try {
			Writer writer = new FileWriter("F:1.txt",true);
			writer.write("我现在有一点点困哎");
			writer.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

package net.onest.demo1;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Reader5 {
	public static void main(String[] args) {
		//带缓冲的字符输出流
		try {
			Writer w = new FileWriter("F:1.txt",true);
			Writer write = new BufferedWriter(w);
			write.write("11111哈哈哈");
			write.write("aaa");
			write.close();
			w.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

package net.onest.demo1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Reapt {
	public static void main(String[] args) {
		//使用带缓冲的字符流实现文件的复制
		try {
			Reader fileReader = new FileReader("F:1.txt");
			Writer fileWriter = new FileWriter("F:2.txt");
			
			Reader bufferedReader = new BufferedReader(fileReader);
			Writer bufferedWriter = new BufferedWriter(fileWriter);
			//第一种方法
			char[] buffer = new char[1024];
			int length = 0;
			while((length=bufferedReader.read(buffer))!=-1) {
				bufferedWriter.write(buffer,0,length);
				bufferedWriter.flush();
			}
			
			//第二种方法
			String content = null;
			while((content=((BufferedReader) bufferedReader).readLine())!= null) {
				//每次只能读入一行数据，且该方法不能自动换行，所以在写入数据的时候
				//我们需要自己给他加上换行符
				bufferedWriter.write(content+"\r\n");
				bufferedWriter.flush();//不刷新的话是没有办法将数据写入进去的
				
			}
			bufferedWriter.close();
			bufferedReader.close();
			fileReader.close();
			fileWriter.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}