I/O流
一.文件
相关记录或放在一起的数据集合，存放在光盘，硬盘中
*
访问文件属性：java.io.File类
*
创建文件对象
*
File a=new File(String 地址) //“c:\test,txt” 或 “c:/test.txt”
*
调用方法
*
a.exists() 【返回值boolean】//判断文件或者目录是否存在
*
a.isFile() 【返回值boolean】//判断是否是文件
*
a.isDirectory() 【返回值boolean】//判断是否是目录
*
a.getPath() 【返回值String】 //返回文件的相对路径名
*
a.getAbsolutePath() 【返回值String】 //返回文件的绝对路径名
*
a.getName() 【返回值String】 //返回文件或者目录的名字
*
a.delete() 【返回值boolean】 //删除文件或目录
*
a.createNewFile() 【返回值boolean】 //创建空文件，不创造文件夹
*
a.length() 【返回值long】//返回文件长度，单位是字节；如果文件不存在返回0L
*
一个汉字字符是2个字节，一个英文字符是一个字节
packagecn.com.abner.IO.File;
import java.io.File;
import java.io.IOException;
//文件操作：创建文件，查看文件的相关信息，删除文件
public class Demo1 {
//创建文件
public void CJ(File it) {
if(!it.exists()) {
try {
it.createNewFile();
System.out.println("文件创建");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//查看文件的相关信息
public void show(File it) {
if(it.exists()) { //文件存在查看信息
if(it.isFile()) { //是文件
System.out.println("该文件名是： "+it.getName());
System.out.println("文件的相对路径："+it.getAbsolutePath());
System.out.println("文件的绝对路径："+it.getPath());
System.out.println("文件大小："+it.length()+"字节");
}
}else {
System.out.println("文件不存在");
}
}
//删除文件
public void delete(File it) {
if(it.exists()) {
it.delete();
System.out.println("文件删除");
}
}
public static void main(String[] args) {
Demo1 a=new Demo1();
File it=new File("d:/abner/testIT.txt"); //要确认这个文件夹存在
File b=new File("testB.txt");
a.CJ(it);
a.CJ(b);
a.show(it);
a.show(b);
a.delete(b);
}
}
**
二.流
流是一组有序的数据序列
*
输入流（InputStream）：来自数据源的数据流 【程序读】
*
输出流（OutputStream）：流向目的地的数据流 【程序写】
*
分类
*
按流向分类
*
输出流
*
outputStream或Write作为父类
*
输入流
*
InputStream或Reader作为父类
*
按处理数据单元划分
*
字节流
*
字节输入流
*
字节输出流
*
字符流
*
字符输入流
*
字符输出流
三.字节流
*
1.字节输入流InputStream 【抽象类】
*
常用方法
*
1.对象.read() 【返回int】 //把输入流的数据一个字节一个字节的读取，返回对应的整数，到了输入流的末尾返回-1
*
2.对象.read(byte [] b) 【返回int】 //把输入流的若干字节保存在在数组b中，读取，返回字节数，到了输入流的末尾返回-1
*
3.对象.read(byte [] b，int off,int len) 【返回int】 //把输入流的off字节开始之后的len个字节保存在在数组b中，读取，返回对应的字节数，到了输入流的末尾返回-1
*
4.对象.close(); //关流
*
5.对象.available(); //可以从输入流中读取到的字节数目
*
FileInputStream 【子类】
*
构造方法
*
FileInputStream（File file） //文件
*
FileInputStream（String path） //路径
*
使用步骤
*
引入类
*
构造输入流FileInputStream对象
*
读取文件的数据
*
关闭文件流数据
packagecn.com.abner.IO.byte1;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
//读取d:\abner\testIT.txt文件内容
public class Demo {
public static void main(String[] args) {
FileInputStream it=null;
try {
it=new FileInputStream("d:\\abner\\testIT.txt");
try {
System.out.println("可以读取的字节流字节数目"+it.available()); //5.对象.available(); //可以从输入流中读取到的字节数目
} catch (IOException e1) {
e1.printStackTrace();
}
//read()
// int data;
// try {
// while((data=it.read())!=-1) { //1.对象.read() 把输入流的数据一个字节一个字节的读取，返回对应的整数，到了输入流的末尾返回-1
// System.out.print((char)data);
// }
// } catch (IOException e) {
// e.printStackTrace();
// }
//对象.read(byte [] b)
byte[] b=new byte[1024];
int date1 = 0; //字节数
try {
while((date1=it.read(b))!=-1) {
for(int i=0;i<date1;i++) { //2.对象.read(byte [] b) 把输入流的若干字节保存在在数组b中，读取，返回字节数，到了输入流的末尾返回-1
System.out.print((char)b[i]);
}
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
//关闭流
try {
it.close(); //4.对象.close(); //关流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
*
2.字节输出流OutputStream 【抽象类】
*
常用方法
*
1.对象.write( int c) 【返回void】 //把数据一个字节一个字节的写
*
2.对象.write(byte [] buf) 【返回void】
*
3.对象.write(byte [] b，int off,int len) 【返回void】 //把数据的off字节开始之后的len个字节写出来
*
4.对象.close(); //关流
*
5.对象.flush(); //强制把缓冲区的数据写到输出流中
*
FileOutputStream 【子类】
*
构造方法
*
FileOutputStream（File file） //文件
*
FileOutputStream（String path） //路径
*
FileOutputStream（String path,boolean append） //指定覆盖或者追加文件内容
*
append=true; //原有文件中追加数据
*
append=false; //覆盖原有文件数据
*
使用步骤
*
引入类
*
构造输入流FileOutputStream对象
*
写文件的数据
*
关闭文件流数据
packagecn.com.abner.IO.byte1;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo2 {
public static void main(String[] args) {
FileOutputStream a=null;
try {
a=new FileOutputStream("d:\\abner\\hollo.txt");
String word="hollo abner!";
byte[] b=word.getBytes(); //将字节数组打算在字节数组中
try {
a.write(b,0,b.length);
System.out.println("写入成功");
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//关流
try {
a.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
*
--------------------综合练习-----------------------
packagecn.com.abner.IO.byte1;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//D:\\abner\\我的青春谁做主.txt文件内容写到C:\\Users\\Administrator\\Desktop\\新建文件夹\\hollo.txt中
public class Demo3 {
public static void main(String[] args) {
FileInputStream a=null;
FileOutputStream b=null;
try {
a=new FileInputStream("D:\\abner\\我的青春谁做主.txt");
b=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\新建文件夹\\hollo.txt",true);
byte[] c=new byte[1024];
int len=-1;
try {
while((len=a.read(c))!=-1) {
b.write(c,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//关流
try {
a.close();
b.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
四.字符流
*
1.字符输入流 Reader
*
常用方法
*
1.对象.read() 【返回int】 //把输入流的数据一个字符一个字字符的读取，返回对应的整数，到了输入流的末尾返回-1
*
2.对象.read(char[] b) 【返回int】 //把输入流的若干字符保存在在字符数组b中，读取，返回字符数，到了输入流的末尾返回-1
*
3.对象.read(char [] b，int off,int len) 【返回int】 //把输入流的off字符开始之后的len个字符保存在在数组b中，读取
*
4.对象.close(); //关流
*
InputStreamReader 【子类】//解决编译不同，中文乱码
*
构造方法
*
InputStreamReader （InputStream）
*
InputStreamReader （InputStream，String charSetname） //定义字符编码格式
*
FileReader 【子类】
*
构造方法
*
FileReader （File file） //文件
*
FileReader （String path） //路径
*
使用步骤
*
引入类
*
构造输入流FileReader 对象
*
读取文件的数据
*
关闭文件流数据
packagecn.com.abner.IO.char1;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
//读取D:\\abner\\我的青春谁做主.txt
public class Demo2 {
public static void main(String[] args) {
Reader a=null;
FileInputStream f=null;
try {
// a=new FileReader("D:\\abner\\我的青春谁做主.txt");
f=new FileInputStream("D:\\abner\\我的青春谁做主.txt");
try {
a=new InputStreamReader(f,"GBK"); //解决字符编码异常，中文乱码
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
StringBuffer s=new StringBuffer(); //将字符添加到StringBuffer
char[] c=new char[1024];
try {
while((a.read(c))!=-1) {
s.append(c);
}
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
f.close();
a.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
*
*
BufferedReader 【缓冲流】
构造方法：BufferedReader(Reader);
readLine();
package cn.com.abner.IO.char1;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.util.stream.Stream;
//读取D:\\abner\\我的青春谁做主.txt
public class Demo3 {
public static void main(String[] args) {
Reader a=null;
FileInputStream f=null;
BufferedReader r=null;
try {
// a=new FileReader("D:\\abner\\我的青春谁做主.txt");
f=new FileInputStream("D:\\abner\\我的青春谁做主.txt");
try {
a=new InputStreamReader(f,"GBK"); //解决字符编码异常，中文乱码
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
r=new BufferedReader(a); //缓冲区，一行一行的读
String line=null;
try {
while((line=r.readLine())!=null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
f.close();
a.close();
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
*
2.字符输出流 Writer
*
常用方法
*
1.对象.write( String str)
*
2…对象.write(String str，int off,int len) 【返回void】 //把数据的off字符串开始之后的len写出来
*
4.对象.close(); //关流
*
5.对象.flush(); //强制把缓冲区的数据写到输出流中
*
OutputStreamWriter 【子类】//解决编译不同，中文乱码
*
构造方法
*
OutputStreamWriter（OutputStream）
*
OutputStreamWriter（OutputStream，String charSetname） //定义字符编码格式
*
FileWriter 【子类】
*
构造方法
*
FileWriter（File file） //文件
*
FileWriter（String path） //路径
*
FileWriter（String path,boolean append） //指定覆盖或者追加文件内容
*
append=true; //原有文件中追加数据
*
append=false; //覆盖原有文件数据
*
使用步骤
*
引入类
*
构造输入流FileWriter 对象
*
写文件的数据
*
关闭文件流数据
packagecn.com.abner.IO.char1;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo4 {
public static void main(String[] args) {
Writer it=null;
try {
it=new FileWriter("C:\\Users\\Administrator\\Desktop\\新建文件夹\\hollo.txt", true);
String a="写入文件";
it.write("\r\n"); //换行写数据
it.write(a);
it.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
it.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.com.abner.IO.char1;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class Demo6 {
public static void main(String[] args) throws InterruptedException {
Writer a=null;
FileOutputStream b=null;
try {
b=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\新建文件夹\\hollo.txt",true);
a=new OutputStreamWriter(b,"GBK");
a.write("\r\n");
a.write("我不玩");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
a.close();
b.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
*
BufferedWriter 【缓冲流】
*
构造方法：BufferedWriter(writer);
*
newLine().创建新的一行
packagecn.com.abner.IO.char1;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo5 {
public static void main(String[] args) {
Writer a=null;
BufferedWriter b=null;
try {
a=new FileWriter("C:\\Users\\Administrator\\Desktop\\新建文件夹\\hollo.txt",true);
b=new BufferedWriter(a);
b.newLine();
b.write("我不玩蛇！");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
b.close();
a.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
综合练习： //第一个文件中的问题，把答案写到第二个文件中
packagecn.com.abner.IO.char1;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
int i=1;
//读问题
Reader a=null;
FileInputStream b=null;
StringBuffer c=new StringBuffer();
try {
b=new FileInputStream("C:\\Users\\Administrator\\Desktop\\新建文件夹\\aaa.txt");
try {
a=new InputStreamReader(b, "GBK");
char[] v=new char[1024];
try {
while((a.read(v))!=-1) {
c.append(v);
System.out.println(c);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
a.close();
b.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//写答案
Writer w=null;
FileOutputStream o=null;
try {
o=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\新建文件夹\\bbb.txt");
try {
w=new OutputStreamWriter(o, "GBK");
do {
System.out.println("请输入第"+i+"个问题的答案");
String annal=input.next();
try {
if(i==2) {
w.write("\r\n");
}
w.write(annal);
} catch (IOException e) {
e.printStackTrace();
}
i++;
}while(i<=2);
System.out.println("答案录入成功");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
w.close();
o.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
下一篇： apache服务器下，显示目录文件列表
推荐阅读