------android培训、java培训、期待与您交流！ ----------
一、什么是文件
文件，对我们并不陌生，文件是数据源(保存数据的地方)的一种，比如大家经常使用的word文档、txt文件、excel文件...都是文件。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频、声音...等。
文件流--基本概念
文件在程序中是以流的形式来操作的
流：数据在数据源(文件)和程序(内存)之间经历的路径
输入流：数据从数据源(文件)到程序(内存)的路径
输出流：数据从程序(内存)到数据源(文件)的路径
如何判断是输入流、输出流？
以内存为参照，如果数据流向内存流动，则是输入流；反之，则是输出流。
文件流--分类
java流分为两种流
1、字节流：可以用于读写二进制文件及任何类型文件byte
2、字符流：可以用于读写文本文件，不能操作二进制文件
字节流字符流
输入InputStreamReader
输出OutputStreamWriter
常用io流--文件对象
目的：文件数据源File类介绍(文件流对象中最为重要的File类，对File了解后对子类理解会更加容易。
Java流操作有关的类或接口
| 类 | 说明 |
| File | 文件类 |
| RandomAccessFile | 随机存取文件类 |
| InputStream | 字节输入流 |
| OutputStream | 字节输出流 |
| Reader | 字符输入流 |
| Writer | 字符输出流 |
流的概念和作用
流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流.
流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作.
IO流的分类
根据处理的数据类型的不同分为: 字节流和字符流.
根据数据流向不同分为: 输入流和输出流.
字节流和字符流
字符流的由来: 因为数据编码的不同,,而有了对字符进行高效操作的流对象,本质其实就是基于字节流读取时去查了指定的编码表.字节流和字符流的区别:
读写单位不同: 字节流以字节(8bit)为单位,字符流以字符为单位没根据编码表映射字符,一次可能读多个字节.
处理对象不同: 字节流处理所有类型的数据(如图片,AV等等),而字符流只能处理字符类型的数据.
结论: 只要处理纯文本数据,就优先考虑使用字符流,除此之外都使用字节流.
输入输出流
对输入流只能进行的操作,对传输流只能就行写操作,程序中需要根据待传输数据的不同特性而使用不同的流.
Java IO流对象
1,输入字节流InputStream()中输入字节流的继承图可见上图,可以看出:
1,InputStream是所有的输入字节流的父类,它是一个抽象类.
2,ByteArrayInputStream, StringBufferInputStream, FileInputStream是三种基本的介质流,它们分别从Byte数组, StringBuffer, 和本地文件中读取数据,PiperInputStream是从与其他线程公用的管道中读取数据,.
3,ObjectInputStream和所有FileInputStream的子类都是装饰流(装饰器模式的主角).
2,输出字节流OutputStream
IO中输出字节流的继承图可以看出:
1,OutputStream是所有的输出字节流的父类, 它是一个抽象类.
2,ByteArrayOutputStream, FileOutputStream是两种基本的介质流,它们分别向Byte数组和本地文件中写入数据.PipedOutputStream是向其它线程公用的管道中子写入数据.
3,ObjectOutputStream和所有FileOutputStream的子类都是装饰流.
3,字符输入流Reader
1,Reader是所有的输入字符流的父类,它是一个抽象类.
2,CharReader, StringReader是两种基本的介质流,它们分别将Char数组,String中读取数据,PipedReader是从与其它线程共用的管道中读取数据.
3,BufferReader很明显就是一个装饰器,它和子类负责装饰其它Reader对象.
4,FileReader是所有自定义具体装饰流的父类,其子类PushbackReader对Reader对象进行装饰,会增加一个行号.
5,InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流. FileReader可以说是一个达到此功能,常用的工具类, 在其源代码中明显是用了将FileInputStream转变为Reader的方法. 我们可以将这个类中得到一定的技巧. Reader中各个类的用途和使用方法基本和InputStream中的类使用一致.后面会有Reader与InputStream的对应关系.
4,字符输出流Writer
1,Writer是所有的输出字符流的父类,它是一个抽象类.
2,CharArrayWriter, StringWriter是两种基本的介质流, 它们分别向Char数组, String中写入数 据.PiperWriter
3,BufferedWriter是一个装饰器为Writer提供缓冲功能.
4,PrintWriter和PrintStream及其类似,功能和使用也非常相似.
5,OutputStreamWriter是OutputStream到Writer转换的桥梁,它的子类FileWriter其实就是一个实现此 功能的具体类(具体可以研究---SourceCode).功能和使用OutputStream极其相似.
5,字符流与字节流转换
转换流的特点:
1,它是字符流和字节流之间的桥梁.
2,可对读取到的字节数据经过指定编码转换成字符.
3,可对读取到的字符数据经过指定编码转换成字节.
如何使用转换流?
1,当字节和字符之间有转换动作时.
2,流的数据需要编码或解码时.
具体的对象体现:
1,InputStreamReader. 字节到字符的桥梁.
2,OutputStreamWriter. 字符到字节的桥梁.
这两个流对象是字符体系中的成员.它们有转换作用,本身又是字符流.所以在构造的皇后需要传入字节流对象进来.
6,File类
File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹.File类保存文件或者目录的各种元数据信息, 包括文件名,文件长度,最后修改时间,是否可读,获取当前文件的路径名,判断指定文件是否存在,获得当前目录中的文件列表.创建,删除文件和目录等方法.
7,RandomAccessFile类
该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据,该对象特点:
1,该对象只能操作文件,所以构造函数接收两种类型的参数:a字符串文件路径; b,File对象.
2,该对象即可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r, nv).
注意: 该对象在进行实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容.可以用于多线程下载或多个线程同时写数据到文件.
File类--使用[Io01.java]
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
*/
import java.io.*;//必需加载IO包
public class Io01 {
public static void main(String[] args) {
//创建一个文件对象
File f1=new File("e:\\aa.txt");
//得到文件的路径
System.out.println("文件路径"+f1.getAbsolutePath());
//得到文件的大小,字节数
System.out.println("文件的大小"+f1.length());
//创建文件夹
File f3=new File("e:\\ff");
//判断文件夹是否存在
if(f3.isDirectory()){
System.out.println("文件夹存在，不能创建!");
}else{
//创建文件夹
f3.mkdir();
}
//创建文件和创建文件夹
File f2=new File("e:\\ff\\hsp.txt");
//判断文件是否存在
if(!f2.exists()){
//可以创建
try {
f2.createNewFile();//创建一个新文件
} catch (Exception e) {
e.printStackTrace();
}
}else{
System.out.println("文件存在，不能创建!");
}
//列出一个文件夹下面的所有文件
File f4=new File("e:\\ff");
//判断文件夹是事存在
if(f4.isDirectory()){
//将文件夹的文件，传给lists数组
File lists[]=f4.listFiles();
//遍历数组
for(int i=0;i<lists.length;i++){
//输出文件夹下所有文件文件名
System.out.println("显示出文件名是"+lists[i].getName());
}
}
}
}</span></span>java文件编程--常用io流
常用io流--文件字节流
1、案例[Io02.java]：读取文件(文件字节输入流使用，目的：FileInputStream类)把用FileInputStream的对象把文件读入到内存
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
* io流--文件字节流
* FileInputStream类的使用
*/
import java.io.*;
public class Io02 {
public static void main(String[] args) {
//得到一个文件对象，f指向e:\ff\hsp.txt文件
File f=new File("e:\\ff\\hsp.txt");
FileInputStream fis=null;
try {
//因为File没有读写的能力，所以需要使用InputStream类
fis=new FileInputStream(f);
//定义一个字节数组，相当于缓存
byte []bytes=new byte[1024];
int n=0;//得到实际读取到的字节数
//循环读取
while((n=fis.read(bytes))!=-1){
//把字节转成String
String s=new String(bytes,0,n);
System.out.println(s);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
//关闭文件流必需放在finally语句块中
try {
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}</span></span>2、案例[Io03.java]：从键盘接收用户输入内容，并保存到文件中(文件字节输出流，目的：FileOutputStream类)
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
* io流--文件字节流
* FileOutputStream类的使用
*/
import java.io.*;
public class Io03 {
public static void main(String[] args) {
File f=new File("e:\\ff\\ss.txt");//直接覆盖写同一个文件
//字节输出流
FileOutputStream fos=null;
if(f.exists()){
System.out.println("文件已存在");
}else{
try {
fos=new FileOutputStream(f);
String s="hello,world!\r\n";
String s1="中国人";
fos.write(s.getBytes());
fos.write(s1.getBytes());
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
fos.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
}</span></span>3、案例[Io04.java]：图片拷贝
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
* io流--文件字节流
* 图片拷贝--FileInputStream类与 FileOutputStream类
*/
import java.io.*;
public class Io04 {
public static void main(String[] args) {
//先将图片读入到内存，再将内存中的图片写入到某个文件
//因为二进制文件只能拿使用字节流来处理
//输入流
FileInputStream fis=null;
//输出流
FileOutputStream fos=null;
try {
fis=new FileInputStream("e:\\ff\\a.jpg");
fos=new FileOutputStream("e:\\a.jpg");
byte buf[]=new byte[1024];
int n=0;//记录实际读取到的字节数
//循环读取图片
while((n=fis.read(buf))!=-1){
//输出到指定文件
fos.write(buf);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
//一定要关闭打开的文件流
try {
fis.close();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}</span></span>java文件编程--常用io流
常用io流--文件字符流
案例[Io05.java](文件字符输入、输出流，目的：FileReader、FileWriter类)读取一个文件并写入到另一个文件中char[]来中转
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
* io流--文件字符流，只能用于完全为字符的文件
* TXT文件拷贝--FileReader类与 FileWriter类
*/
import java.io.*;
public class Io05 {
public static void main(String[] args) {
//文件取出字符流对象(输入流)
FileReader fr=null;
//写入到文件(输出流)
FileWriter fw=null;
try {
//创建fr对象
fr=new FileReader("e:\\ff\\hsp.txt");
//创建输出对象
fw=new FileWriter("e:\\hsp.txt");
//创建字符数组
char c[]=new char[1024];
int n=0;
//读入到内存
while((n=fr.read(c))!=-1){
//控制台输出TXT文件内容
String s=new String(c,0,n);
System.out.println(s);
fw.write(c, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
fr.close();
fw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}</span></span>常用io流--缓冲字符流
为了提高效率引入了缓冲字符流
案例[Io06.java](文件缓冲字符流，目的：BufferedReader和BufferedWriter类介绍，直接操作String)
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* File类的基本用法
* io流--缓冲字符流
* BufferedReader类与BufferedWriter类
*/
import java.io.*;
public class Io06 {
public static void main(String[] args) {
BufferedReader br=null;
BufferedWriter bw=null;
try {
//先创建FileReader对象
FileReader fr=new FileReader("e:\\ff\\hsp.txt");
br=new BufferedReader(fr);
//创建FileWriter对象
FileWriter fw=new FileWriter("e:\\hsp1.txt");
bw=new BufferedWriter(fw);
//循环读取
String s="";
while((s=br.readLine())!=null){
//输出到磁盘
bw.write(s+"\r\n");
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
br.close();
bw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}</span></span>常用io流—缓冲字节流BufferedInputStream
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">import java.io.*;
public class BufferedStreamTest01 {
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
try {
is = new BufferedInputStream(new FileInputStream("c:\\test.txt"));
os = new BufferedOutputStream(new FileOutputStream(
"d:\\test.txt.bak"));
int b = 0;
while ((b = is.read()) != -1) {
os.write(b);
}
// 手动调用flush，将缓冲区中的内容写入到磁盘
// 也可以不用手动调用，缓存区满了自动回清楚了
// 而当输出流关闭的时候也会先调用flush
os.flush();
System.out.println("文件复制完毕！");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (is != null) {
is.close();
}
if (os != null) {
// 在close 前会先调用flush
os.close();
}
} catch (IOException e) {
}
}
}
}</span></span>常用io流--打印输出流PrintWriter
打印输出流PrintWriter可以使用print/println及writer方法。但不换行。需在文本内容中加入\r\n通配符才可以做到。
PrintWriter的使用方法与FileReader、FileWriter/BufferedReader、BufferedWriter基本相同
记事本实例[Io07.java]
<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
* 我的记事本(界面+功能)
*/
import java.awt.*;
import javax.swing.*;
import java.io.*;
import java.awt.event.*;
public class Io07 extends JFrame implements ActionListener{
//定义组件
JTextArea jta=null;//文本框
//菜单条
JMenuBar jmb=null;
//定义第一个JMenu
JMenu jm1=null;
//定义JMenuItem
JMenuItem jmi1=null;
JMenuItem jmi2=null;
JMenuItem jmi3=null;
public static void main(String[] args) {
Io07 io=new Io07();
}
//构造函数
public Io07(){
//创建组件
jta=new JTextArea();
jmb=new JMenuBar();
jm1=new JMenu("文件(F)");
//设置助记符
jm1.setMnemonic('F');
jmi1=new JMenuItem("打开(O)");
//open打开注册监听
jmi1.addActionListener(this);
jmi1.setActionCommand("open");
jmi2=new JMenuItem("保存(S)");
//save保存注册监听
jmi2.addActionListener(this);
jmi2.setActionCommand("save");
jmi3=new JMenuItem("退出(X)");
//exit退出注册监听
jmi3.addActionListener(this);
jmi3.setActionCommand("exit");
//加入到菜单
this.setJMenuBar(jmb);
//把jm1放到jmb
jmb.add(jm1);
//把 jmi1放入jm1
jm1.add(jmi1);
jm1.add(jmi2);
jm1.add(jmi3);
//设置界面管理器(默认BorderLayout边界布局管理器)
//加入组件
this.add(jta);
//设置JFrame面板
this.setTitle("记事本界面与功能");
this.setSize(500, 400);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent e) {
//判断"打开"菜单被选中
if(e.getActionCommand().equals("open")){
/**
* 隆重推荐JFileChooser组件
*/
//创建一个文件选择组件
JFileChooser jfc=new JFileChooser();
//设置名字
jfc.setDialogTitle("请选择要打开的文件...");
//使用默认方式
jfc.showOpenDialog(null);
//显示
jfc.setVisible(true);
//得到用户选择的文件全(绝对)路径
String filename=jfc.getSelectedFile().getAbsolutePath();
FileReader fr=null;
BufferedReader br=null;
try {
fr=new FileReader(filename);
br=new BufferedReader(fr);
//从文件中读取信息并显示到jta(JTextArea)中
String s="";
String allCon="";
while((s=br.readLine())!=null){
allCon+=s+"\r\n";//"\r\n"显示文本时将文件中原有的格式显示到jta中
}
//放置到jta即可
jta.setText(allCon);
} catch (Exception e2) {
e2.printStackTrace();
}finally{
try {
br.close();
fr.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}//判断"保存"菜单被选中
}else if(e.getActionCommand().equals("save")){
//创建保存对话框
JFileChooser jfc=new JFileChooser();
//设置名字
jfc.setDialogTitle("将文件保存到...");
//使用默认方式
jfc.showSaveDialog(null);
//显示
jfc.setVisible(true);
//得到用户希望把文件保存到何处，文件全路径
String file=jfc.getSelectedFile().getAbsolutePath();
//准备写入到指定文件
FileWriter fw=null;
BufferedWriter bw=null;
try {
fw=new FileWriter(file);
bw=new BufferedWriter(fw);
//将JtextArea中的内容输出到指定文件中
bw.write(this.jta.getText());
} catch (Exception e2) {
e2.printStackTrace();
}finally{
try {
bw.close();
fw.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}else if(e.getActionCommand().equals("exit")){
System.exit(0);
}
}
}
</span></span>
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
