------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------、
一、IO流概述
1、IO流：即InputOutput的缩写。
2、特点：
1）IO流用来处理设备间的数据传输。
2）Java对数据的操作是通过流的方式。
3）Java用于操作流的对象都在IO包中。
4）流按操作数据分为两种：字节流和字符流。
5）流按流向分为：输入流和输出流。
注意：流只能操作数据，而不能操作文件。
3、IO流的常用基类：
1）字节流的抽象基流：InputStream和OutputStream
2）字符流的抽象基流：Reader和Writer
注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子类FileReader
二、文件类：File类
package IO;
import java.io.File;
import java.io.IOException;
public class IOtest5 {
public static void main(String[]args) throws IOException
{
File file =new File ("c.txt");
file.createNewFile();
}
}
import java.io.File;
import java.io.IOException;
public class IOtest5 {
public static void main(String[]args) throws IOException
{
File file =new File ("c.txt");//创建File实例：
if (file.exists())//判断该文件是否存在
{
file.delete();//若存在则删除
System.out.println("删除成功");
}else
{
createFile(file);//如果不存在则继续创建
}
}
private static void createFile(File file) {//新建文件夹方法
// TODO 自动生成的方法存根
try {
file.createNewFile();
System.out.println("创建成功");
} catch (IOException e) {//抓取异常
// TODO 自动生成的 catch 块
System.out.println("创建失败");
e.printStackTrace();
}
}
}三、字节流：InputStream
1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。
2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。
3、读写字节流：InputStream 输入流（读）
OutputStream 输出流（写）
4、为何不用进行刷流动作：
因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。
5、InputStream特有方法：
int available();//返回文件中的字节个数
注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。
/*
练习：
复制一个图片
思路：
1、用字节读取流对象和图片关联。
2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3、通过循环读写，完成数据的存储。
4、关闭资源。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
//常用方法复制
byteArrayCopy();
//利用输入流的available方法进行复制
availableCopy();
//利用available方法对复制文件大小有限制，慎用
}
//使用available方法进行复制
public static void availableCopy()
{
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
//关联要复制的文件
fis=new FileInputStream("C:/Users/asus/Desktop/1.jpg");
//指定复制的路径
fos=new FileOutputStream("C:/Users/asus/Desktop/3.jpg");
//利用available方法指定数组长度
byte[] b=new byte[fis.available()];
fis.read(b);//复制关联文件数据
fos.write(b);//粘贴到指定路径
}
catch (IOException e)
{
throw new RuntimeException("图片复制失败");
}
finally
{
try
{
if(fis!=null)
fis.close();//关闭输入字节流
}
catch (IOException e)
{
throw new RuntimeException("读取字节流关闭失败");
}
try
{
if(fos!=null)
fos.close();//关闭输出字节流
}
catch (IOException e)
{
throw new RuntimeException("写入字节流关闭失败");
}
}
}
//使用读数组方式进行复制
public static void byteArrayCopy()
{
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
//关联要复制的文件
fis=new FileInputStream("C:/Users/asus/Desktop/1.jpg");
//指定复制的路径
fos=new FileOutputStream("C:/Users/asus/Desktop/2.jpg");
//利用数组的读取方式
byte[] b=new byte[1024];
int len=0;
while ((len=fis.read(b))!=-1)//复制文件的全部数据
{
fos.write(b,0,len);//粘贴到指定路径
}
}
catch (IOException e)
{
throw new RuntimeException("图片复制失败");
}
finally
{
try
{
if(fis!=null)
fis.close();//关闭输入字节流
}
catch (IOException e)
{
throw new RuntimeException("读取字节流关闭失败");
}
try
{
if(fos!=null)
fos.close();//关闭输出字节流
}
catch (IOException e)
{
throw new RuntimeException("写入字节流关闭失败");
}
}
}
} 四、字节流缓冲区
同样是提高了字节流的读写效率。
1、读写特点：
read()：会将字节byte型值提升为int型值
write()：会将int型强转为byte型，即保留二进制数的最后八位。
2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。
1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。
2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。
3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。
4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。
5）当文件中的全部数据都被读取出时，read()方法就返回-1。
实例（1）自定义字节缓冲区：
自义字节流读取缓冲区
思路：
1、定义一个固定长度的数组
2、定义一个指针和计数器用于读取数组长度，和计数数组元素是否取完为0
3、每次将字节数据存入元素要先将数组中的元素取完
*/
import java.io.*;
class MyBufferedInputStream
{
privateInputStream in;
privatebyte[] by=new byte[1024];
privateint count=0,pos=0;
MyBufferedInputStream(InputStreamin)
{
this.in=in;
}
//自定义读方法，一次读一个字节
publicint myRead()throws IOException
{
//通过in对象读取硬盘上数据，并存储by中。
//存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据
if(count==0)
{
count=in.read(by);
if(count<0)//文件数据全部被读取出来了
return-1;
pos=0;//初始化指针
byteb=by[pos];
count--;//每被读一个字节，表示数组中的字节数少一个
pos++;//指针加1
returnb&255;//返回的byte类型提升为int类型，字节数增加，且高24位被补1，原字节数据改变。
//通过与上255，主动将byte类型提升为int类型，将高24位补0，原字节数据不变。
//而在输出字节流写入数据时，只写该int类型数据的最低8位。
}
elseif(count>0)//如果数组中的数据没被读取完，则继续读取
{
byteb=by[pos];
count--;
pos++;
returnb&0xff;
}
return-1;
}
//自定义关闭资源方法
publicvoid close()throws IOException
{
in.close();
}
}
//测试自定义输入字节流缓冲区
class MyBufferedCopyMp3
{
publicstatic void main(String[] args)
{
longstart=System.currentTimeMillis();
//利用字节流的缓冲区进行复制
copy_2();
longend=System.currentTimeMillis();
System.out.println("复制共用时："+(end-start)+"毫秒");
}
//使用字节流的缓冲区进行复制
publicstatic void copy_2()
{
BufferedOutputStreambout=null;
MyBufferedInputStreambin=null;
try
{
//关联复制文件输入流对象到缓冲区
bin=newMyBufferedInputStream(new FileInputStream("C:/Users/asus/Desktop/一样的月光.mp3"));
//指定文件粘贴位置的输出流对象到缓冲区
bout=newBufferedOutputStream(new FileOutputStream("C:/Users/asus/Desktop/一样的月光2.mp3"));
intby=0;
while((by=bin.myRead())!=-1)
{
bout.write(by);//将缓冲区中的数据写入指定文件中
}
}
catch(IOException e)
{
thrownew RuntimeException("MP3复制失败");
}
finally
{
try
{
if(bin!=null)
bin.close();//关闭输入字节流
}
catch(IOException e)
{
thrownew RuntimeException("读取字节流关闭失败");
}
try
{
if(bout!=null)
bout.close();//关闭输出字节流
}
catch(IOException e)
{
thrownew RuntimeException("写入字节流关闭失败");
}
}
}
} 五、字符流：
1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
2、字符流只用于处理文字数据，而字节流可以处理媒体数据。
3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。查看API，找到一个专门用于操作文件的Writer子类对象：FileWriter。 后缀是父类名。前缀名是流对象的功能。该流对象一被初始化，就必须有被操作的文件存在。
字符流的读写
1、写入字符流步骤
a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。
b、调用write(String s)方法，将字符串写入到流中。
c、调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。
d、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。
close()和flush()区别：
flush()刷新后，流可以继续使用；
而close()刷新后，将会关闭流，不可再写入字符流。
注意：
1、其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。
2、文件的数据的续写是通过构造函数 FileWriter(Strings,boolean append)，在创建对象时，传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。（windows系统中的文件内换行用\r\n两个转义字符表示，在linux系统中只用\n表示换行）
3、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生IOException异常，所以在整个步骤中，需要对IO异常进行try处理。
实例（1）import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
writerDate("abcde");//写入数据
writerFrom("zheshi:\r\nshenma");//续写数据，并附换行操作
}
//在硬盘上创建一个文件并写入指定数据
public static void writerDate(String s)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt");//创建文件
fw.write(s);//将数据写入流
}
catch (IOException e)
{
throw new RuntimeException("写入失败");
}
finally
{
if(fw!=null)
try
{
fw.close();//将写入流的数据刷到指定文件内，并关闭流资源
}
catch (IOException e)
{
}
}
}
//对已有文件的数据续写指定数据
public static void writerFrom(String s)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt",true);//传递一个true参数，代表不覆盖已有的文件。
fw.write(s);
}
catch (IOException e)
{
throw new RuntimeException("写入失败");
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
}
}
}
}
读取字符流步骤
1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。
2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。
第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。
3）读取后要调用close方法将流资源关闭。
实例：
copy
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)
{
//第一种读取方式
singleCharReader();
//第二种读取方式
arrayCharReader();
}
//第一种读取方式，单个字符读取
public static void singleCharReader()
{
FileReader fr=null;
try
{
fr=new FileReader("demo.txt");//读取文件位置和文件名
for (int ch=0;(ch=fr.read())!=-1 ; )
{
System.out.print((char)ch);
}
}
catch (IOException e)
{
throw new RuntimeException("读取失败");
}
finally
{
try
{
if(fr!=null)
fr.close();//关闭读取流资源
}
catch (IOException e)
{
}
}
}
//第二种读取方式，通过字符数组进行读取
public static void arrayCharReader()
{
FileReader fr=null;
char[] arr=new char[1024];//定义一个字符数组，用于临时存储读取的字符
try
{
//读取一个.java文件，并打印在控制台上。
fr=new FileReader("FileReaderDemo.java");
for (int len=0;(len=fr.read(arr))!=-1 ; )
{
//显示字符数组的字符个数
System.out.print(new String(arr,0,len));
}
}
catch (IOException e)
{
throw new RuntimeException("读取失败");
}
finally
{
if(fr!=null)
try
{
fr.close();
}
catch (IOException e)
{
}
}
}
} 六：字符流缓冲区：
字符流的缓冲区——BufferedReader和BufferedWriter
1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。
2、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。
3、写入流缓冲区BufferedWriter的步骤：
1）创建一个字符写入流对象。
如：FileWriter fw=newFileWriter("buf.txt");
2）为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
如： BufferedWriter bufw =new BufferedWriter(fw);
3）调用write方法写入数据到指定文件
如：bufw.write("adfg");
记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）
如：bufw.flush();
4）其实关闭缓冲区，就是在关闭缓冲区中的流对象。
如： bufw.close();
小知识：BufferedWriter缓冲区中提供了一个跨平台的换行符：newLine();可以在不同操作系统上调用，用作数据换行。
如：bufw.newLine();
4、读取流缓冲区BufferedReader
该缓冲区提供了一个一次读一行的方法readLine，方便于堆文本数据的获取，当返回null时表示读到文件末尾。readLine方法返回的时候，只返回回车符之前的数据内容。并不返回回车符。
readLine方法原理：
无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。
步骤：
1）创建一个读取流对象和文件相关联
如： FileReader fr=newFileReader("buf.txt");
2）为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。
如： BufferedReader bufr=new BufferedReader(fr);
3）调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null
如： String s=bufr.readLine();
4）关闭流资源
如： bufr.close();、
扫一扫
1800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
