I/O流(类和类中方法）
流分类
输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中，输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。
一、I/O流分为字节流和字符流。字节流（以2进制为单位）又分为字节输入流和字节输出流；字符流（字符为单位）分为字符输出流和字符输入流。当我门把字节流转换成相应的字符流时我把种方法称为转换流。输入和输出流以程序为判断点，输入程序就是输入流，从程序流出就是输出流。
输入流是用来读数据，输出是用来写数据。
二、还可以根据输入和输出的对象不同来进行区分，当操作的输入或者输出流为磁盘时被称为字节流，当操作的对象为内存时他被称为缓冲流。
File类概述和构造方法
I/O流可以对文件的内容机械能读写操作，但是对于文件本身而言无法通过I/O流来实现。
File：文件和目录都可以通过File封装成对象。
对于一个File而言，其封装并不是一个正真存在的文件，仅仅是一个路径名而已，可以存在，也可以不存在，将来时要通过具体的操作吧这个路径的内容转换成具体存在。
1、创建文件对象常用方法
package IO_Stream;
import java.io.File;
public class IO_Str {
public static void main(String[] args){
File file=new File("D:\\BaiduNetdiskDownload");
System.out.println("文件名:"+file.getName());
System.out.println("文件相对路径:"+file.getAbsolutePath());
File f2=new File("D:\\BaiduNetdiskDownload","java.txt");
System.out.println(f2);
File f3=new File("D:\\BaiduNetdiskDownload");
File f4=new File(f3,"java.txt");
}
}
2、创建目录和文件
package IO_Stream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
public class IO_Str {
public static void main(String[] args)throws IOException {
File file=new File("D:\\BaiduNetdiskDownload\\java.txt");
System.out.println("创建的文件名为:"+file.createNewFile());
File f2=new File("D:\\BaiduNetdiskDownload\\java1");
System.out.println("创建目录:"+f2.mkdir());
File f3=new File("D:\\BaiduNetdiskDownload\\javas\\1\\2\\3");
System.out.println("创建多级目录:"+f3.mkdirs());
System.out.println("删除文件或目录："+f3.delete());//可以删除单级目录，不可以删除多级
System.out.println("是否为目录"+f3.isDirectory());
System.out.println("是否为文件"+file.isFile());
System.out.println("路径是否存在:"+f2.exists());
//输出文件名称
File[] fileArrF=f3.listFiles();
for(File fileName:fileArrF){
if(f3.isFile())
System.out.println(fileName.getName());
else
System.out.println("is not File");
}
/* String[] fileArr= file.list();
for(String file_1:fileArr){
System.out.println(file_1);
}
*/
}
}
递归删除
package IO_Stream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
public class IO_Str {
public static void main(String[] args)throws IOException {
File file=new File("D:\\BaiduNetdiskDownload\\javas\\1\\2\\3");
System.out.println("创建多级目录:"+file.mkdirs());
//斐波那契数列求和 1 1 2 3 5 8
int[] arr=new int[20];
arr[0]=1;
arr[1]=1;
for(int i=2;i<arr.length;i++){
arr[i]=arr[i-1]+arr[i-2];
}
System.out.println(arr[19]);
System.out.println( f(20));
}
//重复做相同的事情
public static int f(int m) {
if (m == 1 || m == 2) {
return 1;
} else {
return f(m-1)+f(m-2);
}
}
}
递归深入理解
package IO_Stream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
public class IO_Str {
public static void main(String[] args)throws IOException {
File file=new File("D:\\BaiduNetdiskDownload\\javas\\1\\2\\3");
System.out.println("创建多级目录:"+file.mkdirs());
int result=jc(5);
System.out.println(result);
}
public static int jc(int n){
if(n==1){
return 1;
}else
return n*jc(n-1);
}
}
import jdk.internal.dynalink.beans.StaticClass;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
File file = new File("D:\\BaiduNetdiskDownload");
//System.out.println("创建多级目录:" + file.createNewFile());
getAllFilePath(file);
}
public static void getAllFilePath(File file) {
File[] fireArray= file.listFiles();
if (fireArray != null) {
for (File file1 : fireArray) {
if (file1.isDirectory()) {
getAllFilePath(file);
} else {
System.out.println(file.getAbsoluteFile());
}
}
}
}
}
字节流
文件写入与读出
写出
public class IO_Str {
public static void main(String[] args)throws IOException {
//调用系统功能创建对象
//创建字节流输出对象
//让字节流对象指向创建好的文件
FileOutputStream fo=new FileOutputStream("D:\\BaiduNetdiskDownload\\java.txt");
fo.write(97);
fo.close();
byte[] bys="abcde".getBytes();//字符串转换对应的字节数组写出
fo.write(bys);
for(int i=0;i<10;i++){
fo.write("hello".getBytes());
fo.write("\r\n".getBytes());
}
}
读入
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
FileInputStream fo=new FileInputStream("D:\\BaiduNetdiskDownload\\java.txt");
int b=0;
while ( (b=fo.read()) !=-1){
System.out.println(b);
}
fo.close();
}
}
写出追加
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
FileOutputStream fo=new FileOutputStream("D:\\BaiduNetdiskDownload\\java.txt",true);//写上true就是追加
String str="Hello Wrold";
fo.write(str.getBytes());
System.out.println(fo);
fo.close();
}
}
改进追加
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
FileOutputStream out=new FileOutputStream("D:\\BaiduNetdiskDownload\\java.txt",true);
try {
String str = "Hello Wrold";
out.write(str.getBytes());
}finally {
try{
if(out != null){
out.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
文件copy
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
FileInputStream inner=new FileInputStream("source/src.jpg");
FileOutputStream out=new FileOutputStream("target/tar.jgp");
int len=0;
//获取copy文件前面的系统时间
long beginTime=System.currentTimeMillis();
try {
//通过循环读取到文件字节信息写入到文件
while ((len = inner.read()) != -1) {
out.write(len);
}
//获取copy之后的系统时间
long endTime = System.currentTimeMillis();
//输出copy花费的时间
System.out.println("系统花费时间为：" + (endTime - beginTime) + "毫秒");
}finally {
try {
if (inner != null){
inner.close();
}
}catch (Exception e){
e.printStackTrace();
}
try{
if(out!=null){
out.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
字节流的缓冲区
定义一个字节数组将数据放到字节数组中，这个数组就叫做缓冲区。
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
FileInputStream inner=new FileInputStream("source/src.jpg");
FileOutputStream out=new FileOutputStream("target/tar.jgp");
byte[] bys=new byte[2048];
int len=0;
long beginTime=System.currentTimeMillis();
//通过文件读取填充到字节数组,然后通过len记住数组的字节数
while ((len=inner.read(bys))!=-1){
out.write(bys,0,len);
}
long endTime=System.currentTimeMillis();
System.out.println("花费时间为:"+(endTime-beginTime)+"ms");
inner.close();
out.close();
}
}
字节缓冲流
缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
BufferedInputStream inner=new BufferedInputStream(new FileInputStream("source/src.jpg"));
//字节流缓冲流是以字节流来实现的。
BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream("target/tar.jgp"));
int len=0;
byte[] buffer=new byte[1024];
long beginTime=System.currentTimeMillis();
while ((len=inner.read(buffer))!=-1){
out.write(buffer,0,len);
}
long endTime=System.currentTimeMillis();
System.out.println("花费时间为:"+(endTime-beginTime)+"ms");
inner.close();
out.close();
}
}
字符流操作文件
由于字节流对中文操作不方便，所以使用字符流。
字符流=字节流+编码表（不同的字母代表成二进制）
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
//读取文件
/* FileReader inner=new FileReader("source/1");
int len=0;
while ((len=inner.read())!=-1){
System.out.print((char)len);
}
inner.close();*/
//写入文件
/* FileWriter out=new FileWriter("target/2");
out.write("努力学习：\r\n");
out.write("努力变强：\r\n");
out.close();*/
//文件追加
/* FileWriter out=new FileWriter("target/2",true);
out.write("努力学习：\r\n");
out.write("努力变强：\r\n");
out.write("努力变强：\r\n");
out.write("努力变强：\r\n");
out.close();*/
//文件copy
/* FileReader inner=new FileReader("source/1");
FileWriter out=new FileWriter("target/2");
int len=0;
char[] buffer=new char[1024];
long beginTime=System.currentTimeMillis();
while ((len=inner.read(buffer))!=-1){
out.write(buffer,0,len); //write(byte,0,len)byte:指定数组
}
long endTime=System.currentTimeMillis();
System.out.println("花费时间为:"+(endTime-beginTime)+"ms");
inner.close();
out.close();*/
//使用缓冲区读写文件
BufferedReader inner=new BufferedReader(new FileReader("source/1"));
BufferedWriter out=new BufferedWriter(new FileWriter("target/2"));
String str=null;
char[] buffer=new char[1024];
long beginTime=System.currentTimeMillis();
while( (str=inner.readLine())!=null){//readLine():一次读取一行文本
out.write(str);
}
long endTime=System.currentTimeMillis();
System.out.println("花费时间为:"+(endTime-beginTime)+"ms");
inner.close();
out.close();
}
}
转换流
将字节流转换成字符流
package IO_Stream;
import java.io.*;
import java.util.ArrayList;
public class IO_Str {
public static void main(String[] args)throws IOException {
//创建字节输入流
FileInputStream inner=new FileInputStream("source/1");
//将字节流转换成字符流
InputStreamReader inn=new InputStreamReader(inner);
//创建字符输入缓冲流对象
BufferedReader out_1=new BufferedReader(inn);
//创建字节输出流对象,这个流是写入到文件的
FileOutputStream out=new FileOutputStream("target/2");
//字节输出流对象转换成字符输出流对象
OutputStreamWriter osw=new OutputStreamWriter(out);
//创建字符输出缓冲流
BufferedWriter bw=new BufferedWriter(osw);
String str=null;
while ((str=out_1.readLine())!=null){
bw.write(str);
bw.newLine();
}
out_1.close();
bw.close();
}
}
IO流小结
NIO
NIO采用内存映射文件的方式来处理输入输出，他将文件或文件的一段区域映射到内存，这样就可以想访问内存一样访问文件了。
扫一扫
7445
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
