一:字节流
1.文件的字节输入流;一次获取一个字节的读取方法:为了获取到文件中的字节数据;
#该方法的read()方法返回值为int类型,表示下一个数据字节;如果文件到达末尾,则返回-1,根据这一特点,可以获取该数据中的字节:
package IOText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 需求:针对字节流的读写操作的代码优化
* 1.创建FileInputStream类的对象,该类是InputStream的子类,因为InputStream是抽象类,该类无法实例化
* 2.在当前项目下创建一个a.txt文件,
* 3.调用FIleInputStream类的read()方法,该方法返回值为int类型,表示下一个数据字节；如果已到达文件末尾，则返回-1。
* 4.用while循环遍历该字节文件
* */
public class InputStreamText_01 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("a.txt");
//方法一:
// int i = fis.read();//返回下一个数据字节
// while(i!=-1){
// System.out.print((char)i);//因为read()方法返回的是int类型,表示下一个数据字节,需要强转为char类型,才能打印出字符
// i = fis.read();//继续调用fis的read()方法,判断下一个数据字节是否存在
// }
//方法二:
int bys=0;
while((bys=fis.read())!=-1){
System.out.print((char)bys);
}
fis.close();
}
}
2.一次获取一个字节数组:
package IOText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 需求:一次读取一个字节数组来读取该文件
* 1.创建FileInputStream类的对象,该类是InputStream的子类,因为InputStream是抽象类,该类无法实例化
* 2.在当前项目下创建一个a.txt文件,
* 3.调用FIleInputStream类的public int read(byte[] b),该方法的返回值表示读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回-1
* 4.用Wwhile()循环判断该文件数组是否读完,并且读取
* */
public class InputSteamText_02 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("a.txt");
byte[] bys=new byte[1024];
int length=0;
while((length=fis.read(bys))!=-1){
System.out.print(new String(bys,0,length));
}
}
}
1. 使用InputStream输入流复制文件副本:
2. package IOText;
3.
4. importjava.io.FileInputStream;
5. import java.io.FileNotFoundException;
6. importjava.io.FileOutputStream;
7. import java.io.IOException;
8. /**
9. * 需求:在当前项目下有一个a.txt文件,将其内容复制到当前项目下的b.txt
10. * 1.创建InputSTream的子类FileInputStream对象,用来封装数据源
11. * 2.创建OutputStream类的子类FileOutPutStream对象,用来封装目的地
12. * 3.对于当前的文本文件,可以用InputStream的read()方法,一次读取一个字节来读取文件
13. * 4.用while循环来进行判断,看是否还有下一个数据字节,若没有值返回-1,且结束循环,若有,则用FileOutputStream的对象调用write()方法,进行输出数据
14. * 5.关闭流资源
15. * */
16.public class InputStreamText_03{
17. public static void main(String[]args) throws IOException {
18. FileInputStreamfis=new FileInputStream("a.txt");//用来封装数据源
19.
20. FileOutputStreamfos=new FileOutputStream("b.txt");//用来封装目的地
21.
22. //一次获取一个字节的方式来获取该数据字节
23. int bys=0;
24. while((bys=fis.read())!=-1){
25. fos.write(bys);
26. System.out.print((char)bys);
27. }
28. fis.close();
29. fos.close();
30.
31. }
32. }
b.txt:
you are Beautiful!
You're beautiful
You're beautiful it's true
I saw your face in a crowded place
And I don't know what to do
'Cause I'll never be with you
Yeah she caught my eye
As we walked on by
She could see from my face that I was
F**king high
And I don't think that I'll see her again
But we shared a moment that will last tillthe end
You're beautiful You're beautiful
You're beautiful it's true
I saw your face in a crowded place
And I don't know what to do
'Cause I'll never be with you
You're beautiful You're beautiful
You're beautiful it's true
There must be an angel with a smile on herface
When she thought up that I should be withyou
But it's time to face the truth
I will never be with you
4.使用字节输入输出流进行复制图片:
package IOText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 需求:用字节输入输出流将"E:\\JAVA\\1.jpg"通过获取功能复制到当前项目下
* 1.创建InputSTream的子类FileInputStream对象,用来封装数据源
* 2.创建OutputStream类的子类FileOutPutStream对象,用来封装目的地
* 3.对于当前的图片文件,可以用InputStream的read()方法,一次读取一个字节来读取文件
* 4.用while循环来进行判断,看是否还有下一个数据字节,若没有值返回-1,且结束循环,若有,则用FileOutputStream的对象调用write()方法,进行输出数据
* 5.关闭流资源
* */
public class InputStreamText_04 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("e:\\JAVA\\1.jpg");//用来封装数据源
FileOutputStream fos=new FileOutputStream("c.jpg");//用来封装目的地
//一次获取一个字节的方式来获取该数据字节
int bys=0;
while((bys=fis.read())!=-1){
fos.write(bys);
}
fis.close();
fos.close();
}
}
5.使用字节流一次获取一个字节数组方式,将视频文件复制到当前项目下
package IOText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 需求:使用字节流将E:\CloudMusic\MV下的视频文件复制到当前项目下
* 1.创建InputSTream的子类FileInputStream对象,用来封装数据源
* 2.创建OutputStream类的子类FileOutPutStream对象,用来封装目的地
* 3.对于当前的数据源文件,因为其内存比较大,所以考虑使用字节输入流的一次获取一个字节数组的方式来获取该文件
* 4.用while循环判断是否获取结束,
* 5关闭流资源
* */
public class InputStreamText_05 {
publicstatic void main(String[] args) throws IOException {
FileInputStreamfis=new FileInputStream("e:\\CloudMusic\\MV\\赵雷 - 成都.mp4");//用来封装数据源
FileOutputStreamfos=new FileOutputStream("mv.mp4");//用来封装目的地
//使用输入流的一次获取一个字节数组方式来获取该文件资源
byte[]bys=new byte[1024];
intlen=0;
while((len=fis.read(bys))!=-1){
fos.write(bys,0, len);
}
fis.close();
fos.close();
}
}
二:字节缓冲流
1. 字节缓冲输出流:BufferedOutputStream
该流中的成员方法:flush()----刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
Close()---关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!
publicBufferedOutputStream(OutputStream out):默认缓冲区大小(默认缓冲大小已经足够大了)
2. packageBufferedOutputStreamText;
3. importjava.io.BufferedOutputStream;
4. import java.io.FileNotFoundException;
5. importjava.io.FileOutputStream;
6. importjava.io.IOException;
7. /**
8. * 需求:使用BufferedOutputStream通过其特有方法向文件写数据
9. * 1.创建BufferedOutputStream对象,因为该类为抽象类,所以需要创建FIleOutputSTream类来进行数据输出
10. * 2.调用其writer()方法,向文件内写数据
11. * 3.写完数据之后,在调用flush()方法,进行刷新
12. * 4.最后关闭流资源
13. * */
14.public classBufferedOutputStreamText_01 {
15. public static void main(String[]args) throws IOException {
16. BufferedOutputStreambos=new BufferedOutputStream(new FileOutputStream("bos.txt"));//创建对象
17. //向该文件中写数据
18. bos.write(12);
19. bos.write(23);
20. bos.write(26);
21. //刷新该流
22. bos.flush();
23. //关闭流资源
24. bos.close();
25. }
26.}
2. 字节缓冲输入流:BufferedInputStream
package BufferedInputStreamText;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 需求:使用字节缓冲输入流获取文件数据:
* 1.创建字节缓冲输入流对象,因为该类是抽象类,所以应该用FileInputStream类来进行实例化
* 2.使用该类的一次获取一个字节来获取该文件中的数据
* 3.关闭流资源
* */
public class BufferedInputStreamText_01 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("bis.txt"));//创建字节缓冲输入流
//使用一次获取一个字节来获取该文件数据
int bys=0;
while((bys=bis.read())!=-1){
System.out.print(bys);
}
bis.close();
}
}
1. 计算机底层识别中文;
2. public classBufferedOutputStreamText_01 {
3. public static void main(String[]args) throws IOException {
4. //定义一个中文字符串
5. String Str="信仰";
6. //将该字符串转化为字节数组
7. byte []bys=Str.getBytes();//调用此方法将字符串转化为字节数组
8. //打印该数组
9. System.out.println(Arrays.toString(bys));
10.
11. }
12.}
1)每个中文左边对应的字节一定是负数
2)GBK格式:右边的字节可以中正数,可以是0,可以是负数
4.分别用字节流的两种获取文件的方法和高效字节流的两种获取文件的方法来复制文件:
package CopyText;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 需求:封装一个方法,分别用四种方式来复制文件到当前项目下,并计算出复制这个文件每个方法总共耗时多少?
* 1.先获取系统当前的毫秒值,用long 类型去接收
* 2.定义一个方法,传入两个参数,第一个用来封装数据源,第二个参数用来封装目的地
* 3.再获取一次系统当前的毫秒值,定义一个方法计算两次时间差额
* 4.输出
* */
public class CopyText_01 {
public static void main(String[] args) throws IOException {
long startTime=System.currentTimeMillis();//获取开始复制之前的系统时间
//method1("e:\\JAVA\\1.jpg","copy.jpg");
//method2("e:\\JAVA\\1.jpg","copy.jpg");
//method3("e:\\JAVA\\1.jpg","copy.jpg");
method4("e:\\JAVA\\1.jpg","copy.jpg");
long endTime=System.currentTimeMillis();//获取复制结束时的系统当前时间
long result=GetTime(startTime,endTime);
System.out.println("该方法复制文件总共耗时为" + result + "毫秒!");
}
private static void method4(String string, String string2) throws IOException {
//该方法是高效字节输入流一次获取一个字节数组的复制文件方法
BufferedInputStream bis=new BufferedInputStream (newFileInputStream(string));//创建高效字节输入流对象
BufferedOutputStream bos=new BufferedOutputStream(newFileOutputStream(string2));//创建高效字节输出流对象
//一次获取一个字节数组来复制文件
byte[] bys=new byte[1024];
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys, 0, len);
bos.flush();
}
bos.close();
bis.close();
}
//private static voidmethod3(String string, String string2) throws IOException {
// //该方法使用高效字节输入流的一次获取一个字节来复制文件
// BufferedInputStream bis=new BufferedInputStream (newFileInputStream(string));//创建高效字节输入流对象
//
// BufferedOutputStream bos=new BufferedOutputStream(newFileOutputStream(string2));//创建高效字节输出流对象
//
// //一次获取一个字节来复制文件
// int bys=0;
// while((bys=bis.read())!=-1){
// bos.write(bys);
// bos.flush();//高效字节输出流在获取文件后,需要刷新该流资源
// }
// bis.close();
// bos.close();
// }
// private static void method2(String string, String string2) throwsIOException {
// //该方法是字节输入流的一次获取一个字节数组方法类复制图片
// FileInputStream fis=new FileInputStream(string);//创建字节输入流对象
//
// FileOutputStream fos=new FileOutputStream(string2);//创建字节输出流对象
//
// //一次获取一个字节数组
// byte[] bys=new byte[1024];
// int len=0;
// while((len=fis.read(bys))!=-1){
// fos.write(bys, 0, len);
// }
// fis.close();
// fos.close();
//
// }
private static long GetTime(long startTime, long endTime) {
return endTime-startTime;
}
// private static void method1(String string, String string2) throwsIOException {
// //该方法用字节输入流的一次获取一个字节方法来复制图片
// FileInputStream fis=new FileInputStream(string);//创建字节输入流对象
//
// FileOutputStream fos=new FileOutputStream(string2);//创建字节输出流对象
//
// //一次获取一个字节
// int bys=0;
// while((bys=fis.read())!=-1){
// fos.write(bys);
// }
//
// fis.close();
// fos.close();
//
// }
}
三:字符流
1.编码: 就是能看懂的字符串转换成看不懂的字节数组; public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)
2. 解码:就是将看不懂的字节数组----->能看懂的:将字节数组--->字符串; publicString(byte[] bytes, Charset charset)通过使用指定的 编码格式 解码指定的 byte 数组，构造一个新的String
#编码和解码应用:
package BianMaText;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class BianMaText_01 {
public static void main(String[] args) throws IOException {
//编码----将字符串转换为字节数组
String s="信仰";
byte []bys=s.getBytes("utf-8");//指定编码格式为utf-8,如果没有明确格式,则系统默认为GBk格式
System.out.println(Arrays.toString(bys));
//解码
String str=new String(bys,"GBK");//指定解码格式为GBK
System.out.println(str);
}
}
3. 字符输入流:字节输入流+编码格式(默认GBK);public InputStreamReader(InputStream in,charset sc) ;
#字符输入流的两种获取文件的方式:
package InputStreamReaderText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 需求:使用字符输入流的一次获取一个字符获取文件数据
* 1.创建字符输入流的对象,应为该类为抽象类,所以创建其子实现类FileInputStream来进行实例化
* 2.定义一个while()循环,调用该类的特有方法read()方法,来判断是否获取完这个文件
* 3.获取完毕,之后,关闭流资源
* */
public class InputStreamReaderText_01 {
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(new FileInputStream("isr.txt"),"GBK");//创建字符输入流对象
//一次获取一个字符
// int ch=0;
// while((ch=isr.read())!=-1){
// System.out.println(char(ch));
// }
// isr.close();
//一次获取一个字符数组
char[] ch=new char[1024];
int len=0;
while((len=isr.read(ch))!=-1){
System.out.println(new String(ch,0,len));
}
isr.close();
}
}
4. 字符输出流:Writer:是一个抽象类;
使用的是该抽象类的子类:OutputStreamWriter------>字符转换流:可以将字节输出流转换字符流
public OutputStreamWriter(OutputStreamout,Charset cs):创建一字符输出转换流对象,指定编码格式;默认编码格式为GBK
字符输出流写数据的方法:
publicvoid write(int c):写单个字符
publicvoid write(char[] cbuf):写一个字符数组
publicabstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
publicvoid write(String str):写字符串
publicvoid write(String str, int off,int len):写字符串的一部分
#字符输出流写文件:
package OutputStreamWriterText;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Arrays;
/**
* 需求:使用OutputStreamWriter字符输出流写文件
* 1.创建OutputStreamWriter类的对象,通过抽象类多态的形式,传入FileOutputStream类来实例化
* 2.调用该类的writer()方法,向该文件中添加数据
* 3.刷新该流
* 4.关闭该流
* */
public class OutputStreamWriterText_01 {
public static void main(String[] args) throws IOException {
Writer w=new OutputStreamWriter(new FileOutputStream("w.txt"));//通过抽象类的多态形式,创建字符输出流的对象
//写数据
w.write("you");
w.write("are");
w.write("my");
w.write("sunshine!");
//关闭流资源
w.close();
//打印该文件
}
}
#使用字符流将当前项目下的a.txt文件的内容复制到当前项目下的h.txt文件下:
package OutputStreamWriterText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/**
* 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的h.txt中使用字符流进行读写操作
* 1.创建字符输入流对象,用来封装数据源
* 2.创建字符输出流,用来封装目的地
* 3.用字符输入流的一次获取一个字符数组来获取文件
* 4.定义一个while循环,调用字符输入流的read()方法判断是否获取完该文件
* 5.若没有完,则进行写数据,并且写完之后需要进行刷新该流资源
* 6.关闭流资源
* */
public class OutputStreamWriterText_02 {
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(new FileInputStream("a.txt"));//创建字符输入流对象
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("h.txt"));//创建字符输出流对象
//使用字符输入流的一次获取一个字符数组来获取该文件数据
char[] ch=new char[1024];
int len=0;
while((len=isr.read(ch))!=-1){
osw.write(ch, 0, len);//写文件
osw.flush();//刷新流资源
}
isr.close();
osw.close();//关闭流资源
}
}
5.便捷类:
字符转换输入流:InputStreamReader----->FileReader
字符转换输出流:OutputStreamWriter---->FileWriter
#使用字符流的便捷类写文件:
package OutputStreamWriterText;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的h.txt中使用字符流进行读写操作
* 1.创建字符输入流的便捷类的对象,从来封装数据源
* 2.创建字符输出流的便捷类的对象,用来封装目的地
* 3.使用字符输入流的一次输入一个字符数组来获取该文件
* 4.定义while循环,调用字符输入流的read()方法判断是否获取完毕该文件中的数据
* 5.调用字符输出流的writer()方法,同时刷新流资源
* 6.关闭流资源
* */
public class FileReaderAndWriter {
public static void main(String[] args) throws IOException {
FileReader fr=new FileReader("a.txt");//创建字符输入流的便捷类对象
FileWriter fw=new FileWriter("fw.txt");//创建字符输出流的便捷类的对象
//使用字符输入流的一次获取一个字符数组来获取该文件数据
char[] ch=new char[1024];
int len=0;
while((len=fr.read(ch))!=-1){
fw.write(ch, 0, len);//写数据
fw.flush();//刷新该资源
}
fw.close();
fr.close();
}
}
1. 字符缓冲流的类:
(1) 字符缓冲输入流:BuffferedReader:
public String readLine():一次读取一行
(2) 字符缓冲输出流:BufferedWriter:
public void newLine():写入一个换行符号
#分别使用字符缓冲输入流的两种获取文件数据的方式,来获取当前项目下的文件:
package BufferedReaderAndWriterText;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderAndWriterText_01 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("br.txt"));//创建字符缓冲输入流对象
//使用该字符流的一次获取一个字符来获取该文件
// int ch=0;
// while((ch=br.read())!=-1){
// System.out.print(ch);
// }
// br.close();
//使用字符流的一次获取一个字符数组来获取该文件
char[] ch=new char[1024];
int len=0;
while((len=br.read(ch))!=-1){
System.out.print(ch);
}
br.close();
}
}
#使用字符缓冲输出流向文件中写数据:
package BufferedReaderAndWriterText;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedText_02 {
public static void main(String[] args) throws IOException {
BufferedWriter bw=new BufferedWriter(new FileWriter("bw.txt"));//创建字符输出流的对象
//向该文件中写数据
bw.write("you " );
bw.write("are ");
bw.write("my ");
bw.write("sunshine!");
//刷新该流
bw.flush();
//关闭该流资源
bw.close();
}
}
#使用IO流进行标准输入流:
使用此方法来进行键盘录入:首先要将标准输入流包装为字符转换流,然后再包装为字符缓冲输入流,最后进项键盘录入:
package BufferedReaderAndWriterText;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* 需求:使用IO流的形式读数据
* 1.创建标准输入流对象,需要用字符缓冲输入流进行包装
* 2.创建字符转换输入流对象
* 3.创建字符缓冲输入流对象
* 4.键盘录入数据
* */
public class BufferedReaderText_03 {
public static void main(String[] args) throws IOException {
InputStream is=System.in;//创建标准输入流对象
// InputStreamReader isr=new InputStreamReader(is);//创建字符转换输入流对象
//
// BufferedReader br=new BufferedReader(isr);//创建字符缓冲输入流对象,用该流包装
//
// System.out.println("请输入一个字符串:");
//
// String Str=br.readLine();
// System.out.println(Str);
//多态形式
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个字符串:");
String Str=br.readLine();
System.out.println(Str);
}
}
7.字符缓冲输入流的特有功能:
#使用字符缓冲输入流的特有方法一次获取一行:
package BufferedReaderAndWriterText;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* 需求:字符缓冲输入流的特有功能应用:
* 1.创建字符缓冲输入流对象
* 2.使用该流的特有功能:public String readLine():一次读取一行;该方法的返回值:包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
* 3.输出该文件,关闭流资源
* */
public class BufferedText_04 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("br.txt"));//创建字符缓冲输入流对象
//使用该类的特有方法,一次获取一行
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
#使用字符输出流的特有功能publicnewline():该方法写入一个换行符:
package BufferedReaderAndWriterText;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* 需求:使用字符缓冲输出流的特有方法:public void newLine():写入一个换行符号
* 1.创建字符缓冲输出流对象
* 2.使用其特有方法一次写入一行
* 3.刷新流资源;
* 4.关闭流资源
* */
public class BufferedText_05 {
public static void main(String[] args) throws IOException {
BufferedWriter bw=new BufferedWriter(new FileWriter("bw2.txt"));//创建字符缓冲输出流对象
bw.write("But it'stime to face the truth ");
bw.newLine();//该方法写入分隔符
bw.write("I willnever be with you");
bw.newLine();
//刷新该流
bw.flush();
//关闭流资源
bw.close();
}
}
四: DataOutputStream和DataInputStream(都属于数据流): 可以针对Java基本数据类型的数据进行读写操作
#使用该数据流的读写操作对文件进行读写:
package DataStreamText;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 需求:分别使用数据输入流和数据输出流对文件进行读写操作:
* 1.定义两个方法,分别为read()方法和Writer()方法,
* 2.分别创建数据输入流对象和数据输出流对象
* 3.在输入流中进行读操作,在输出流中进行写操作;
* 4.最后关闭流资源
* */
public class DataStreamText_01 {
public static void main(String[] args) throws IOException {
Writer();
Read();
}
private static void Writer() throws IOException {
//创建数据输出流对象
DataOutputStream dos=new DataOutputStream(new FileOutputStream("ds.txt"));
//使用该类的特有方法进行写数据
dos.writeByte(23);
dos.writeBoolean(true);
dos.writeDouble(12.03);
//关闭流资源
dos.close();
}
private static void Read() throws IOException {
//创建数据输入流对象
DataInputStream dis=new DataInputStream(new FileInputStream("ds.txt"));
//使用该类的特有方法进行读操作
byte b = dis.readByte();
char c = dis.readChar();
float f = dis.readFloat();
//关闭流资源
System.out.println(b);
System.out.println(c);
System.out.println(f);
}
}
五: ByteArrayInputStream和ByteArrayOutStream(内存操作流): 针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!(针对小文件进行操作)
ByteArrayOutputStream:的方法:
publicByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
publicbyte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
voidreset():重置内存操作输出流
ByteArrayInputStream:内存操作输入流方法:
publicByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
#内存操作流对文件的读写:
package ByteArrayText;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayText_01 {
publicstatic void main(String[] args) throws IOException {
//创建内存输出流对象
ByteArrayOutputStreambaos=new ByteArrayOutputStream();
for(inti=0;i<5;i++){
baos.write(("baby"+i).getBytes());//写文件
}
baos.close();
//将内存输出流对象装换为字节数组;调用toByteArray()
byte[]array = baos.toByteArray();
ByteArrayInputStreambais=new ByteArrayInputStream(array);//创建内存输出流对象
//一次读取一个字节数组的方式获取该文件
intby=0;
while((by=bais.read())!=-1){
System.out.print((char)by);
}
bais.close();
baos.close();
}
}
六: 打印流:
1. 字节打印流:PrintStream和字符打印流:PrintWriter
特点:
1) 在复制文件的,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)
2) 打印流可以有自动刷新的功能
3) 打印流可以直接针对文本文件进行操作:
2. PrintWriter(有自动刷新功能):构造方法: publicPrintWriter(String fileName)
刷新功能: public PrintWriter(Writer out,boolean autoFlush) 第二个参数指定为true,则启动自动刷新(该方法相当于writer(),newline(),与flush()方法一同使用的效果)
#使用字符打印流将文件中的数据打印出来:
package PrintWriterText;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* 需求:使用使用字符缓冲输入流封装源文件,只用字符打印流封装目的地,同时将文件内容打印在工作台
* 1.创建字符输入流对象
* 2.创建字符打印流对象
* 3.使用字符输入流的特有方法,一次获取一行文件
* 4.定义while循环,判断是否获取完该文件
* 5.使用字符打印流的特有方法,用来将文件内容的打印在控制台
* */
public class PrintWriterText_01 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("br.txt"));//创建字符缓冲输入流对象,用来封装源文件
PrintWriter pw=new PrintWriter(new FileWriter("pw.txt"));//创建字符打印流对象,用来封装目的地
//使用输入流的一次获取读取一行方法
String line=null;
while((line=br.readLine())!=null){
pw.println(line);
pw.flush();
}
pw.close();
br.close();
}
}
#键盘录入的两种方法:1.使用Scanner对象进行键盘录入2.使用字符缓冲流进行键盘录入;步骤(1)创建标准输入流对象InputStreamis=System.in;(2)将该字节流转换为字符流,需要创建字符转换流对象,使用InputStreamReader isr=new InputStreamReader(is);来进行包装;(3)需要创建字符缓冲输入流对象来包装isr对象:BufferedReader br=new BufferedReader(isr);(4)最后通过br对象进行键盘录入;
package SystemText;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
public class SystemText_01 {
public static void main(String[] args) throws IOException {
InputStream is=System.in;//创建标准输入流对象
InputStreamReader isr=new InputStreamReader(is);//创建字符转换流对象
BufferedReader br=new BufferedReader(isr);//创建字符缓冲输入流对象
System.out.println("请输入一个字符串:");
String Str=br.readLine();
System.out.println(Str);
//Scanner类的键盘录入方法
Scanner Sc=new Scanner(System.in);//创建Scanner对象
System.out.println("请输入一个字符串:");
String Str1=Sc.nextLine();
System.out.println(Str1);
}
}
七RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入不是实际意义上的流,因为它继承自Object类
1. 常用的构造方法: public RandomAccessFile(String name, String mode)
参数一:指定该文件的路径
参数二:指定的一种模式:常用的模式:"rw",这种模式是可以读也可以写
#随机访问流进行文件的读写操作:
package RandomAccessFileText;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 需求:使用RandomAccessFile流进行文件的数据读写操作
* 1.分别定义两个方法,一个是writer()方法,用于给文件写数据,read()反方用于获取该文件
* 2.在两个方法中首先应该创建RandomAccessFile对象,
* 3.依次执行这两个方法,最后关闭流资源,
* */
public class RandomAccessFileText_01 {
publicstatic void main(String[] args) throws IOException {
writer();//该方法向文件中写数据
read();
}
privatestatic void read() throws IOException {
//创建RandomAccessFile对象;使用public RandomAccessFile(String name, String mode)
RandomAccessFileraf=new RandomAccessFile("raf.txt","rw");
//读文件
charc = raf.readChar();
System.out.println(c);
System.out.println("返回文件的偏移量:"+ raf.getFilePointer());//public long getFilePointer():返回此文件中的当前偏移量。 文件开头的偏移量（以字节为单位
Stringstring = raf.readUTF();
System.out.println("读取文件中的中文字符:"+ string);
}
privatestatic void writer() throws IOException {
//创建RandomAccessFile对象;使用publicRandomAccessFile(String name, String mode)
RandomAccessFileraf=new RandomAccessFile("raf.txt","rw");
//向该文件内写数据
raf.writeByte(20);
raf.writeChar('a');
raf.writeUTF("信仰只手");//该模式默认中文编码格式
raf.close();
}
}
八: SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联, 合并流在复制文件的时候,只能操作数据源,不能操作目的地
(1)构造方法: publicSequenceInputStream(InputStream s1,InputStream s2)
#使用SequenceInputStream将两个文件中的额内容复制到一个文件中去:
package SequenceInputStreamText;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
/**
* 需求:使用SequenceInputStream将当前项目下的a.txt文件和bw.txt文件的内容复制到当前项目下的sis.txt文件中
* 1.分别创建InputStream对象,用来封装数据源,
* 2.创建SequenceInputStream对象,用来封装这两个文件
* 3.创建BufferedOutputStream对象,用来封装目的地
* 4.最后使用输入流的一次获取一个字节数组的方法来获取文件数据内容
* 5.关闭流资源
* */
public class SequenceInputStreamText_01 {
public static void main(String[] args) throws IOException {
InputStream is1=new FileInputStream("a.txt");
InputStream is2=new FileInputStream("bw.txt");
//创建合并流对象
SequenceInputStream sis=new SequenceInputStream(is1,is2);//将两个文件封装在合并流对象中
//创建字符缓冲输出流对象
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("sis.txt"));//用来封装目的地
//使用输入流的一次获取一个字节数组来获取该文件数据
byte []bys=new byte[1024];
int len=0;
while((len=sis.read(bys))!=-1){
bos.write(bys, 0, len);
bos.flush();
}
sis.close();
bos.close();
}
}
(2)另一种构造方式: public SequenceInputStream(Enumeration<? extends InputStream> e)
Vector集合中的特有功能: public Enumeration<E>elements()
#使用集合获取文件数据:
package SequenceInputStreamText;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/**
* 需求:使用Victor集合的枚举类来获取文件内容,将当前项目下的a.txt和bw.txt以及bw2.txt三个文件的内容复制到sis2.txt文件中去
* 1.创建Victor集合对象,并指明其泛型为InputStream,
* 2.创建三个InputStream对象,分别用来封装这三个数据源,同时使用该集合的添加功能,将这三个文件封装在victor集合中
* 3.调用Victor集合的特有方法,public Enumeration<E> elements()
* 4.创建合并流对象SequenceInputStream对象,将上述对象封装起来
* 5.创建字节输出流对象,封装目的地
* 6.使用输入流的一次获取一个字节数组来获取获取该问价数据
* 7.刷新该流,最后挂你流资源
* */
public class VictorAndSequenceInputStreamText_01 {
public static void main(String[] args) throws IOException {
Vector<InputStream> v=new Vector<InputStream>();//创建vector集合
//创建三个inputStream对象,用来封装三个数据源文件
InputStream is1=new FileInputStream("a.txt");//通过抽象类多态的形式来封装数据源
InputStream is2=new FileInputStream("bw.txt");
InputStream is3=new FileInputStream("bw2.txt");
//向集合中添加元素
v.add(is1);
v.add(is2);
v.add(is3);
//调用集合的特有方法
Enumeration<InputStream> elements = v.elements();
//创建合并流对象
SequenceInputStream sis=new SequenceInputStream(elements);
//创建字节缓冲输出流对象
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("sis2.txt"));
//使用输入流的一次获取一个字节数组方式来获取文件数据
byte []bys=new byte[1024];
int len=0;
while((len=sis.read(bys))!=-1){
bos.write(bys, 0, len);
bos.flush();
}
bos.close();
sis.close();
}
}
九, 序列化流
1.序列化流: 将对象像流的方式或者网络传输中的数据写数据.对象---->流数据:ObjectOutputStream
成员方法: publicfinal void writeObject(Object obj):将obj对象写入到当前的序列化流中
2.反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原成对象:ObjectInputStream
成员方法: publicfinal Object readObject():从当前反序列化流中读取一个对象
3. Serializeable:序列化接口:
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化,如果自定义一个类没有实现这个接口,就不能使用
#序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口
如果一个类实现了标记接口:Serializable,那么对应的该类加载的时候,会产生一个ID
序列化和反序列化版本号不一致,会出现InvalidClassException; 解决这个异常两种方案:
(1) 要么改动当前某个类中的数据之后,然后重新序列化和反序列化;这种做法不符实实际要求,在实际开发中,可能直接读数据:将流数据--->还原成对象
(2) 发现黄色警告线,点击它:生成一个固定ID
4. transient关键字: 比如一个类中有很多成员变量,并不想让一些成员变量被序列化,Java提供了一个关键字: 不用被序列化的时候用它修饰
#序列化和反序列化考点:
(1) 将对象--->流数据或者流数据--->对象,该对象所在的类要实现一个标记接口:serializable 多线程有一个关键字:同步机制(synchronized)
(2) 序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决
(3) transient:修饰的变量不会被序列化...
#序列化与反序列化流读写数据:
package ObjectStreamText;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* 需求:使用序列化和反序列化流进行读写数据
* 1.定义两个方法,一个对文件进行写数据 ,另一个对文件进行读取
* 2.在写数据方法中创建ObjectOutputStream对象,并自定义一个学生对象,将该对象信息转换为流数据,
* (该学生类需要实现一个序列化接口),使用序列化流的writerObject()方法进行写数据
* 3.在读数据中创建ObjectInputStream对象,使用其特有功能readObject()方法进行读数据
* 4.关闭流资源
* */
public class ObjectStreamText_01 {
public static void main(String[] args) throws IOException,ClassNotFoundException {
writer();
read();
}
private static void read() throws IOException, IOException, ClassNotFoundException {
// 创建反序列化流对象
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("oos.txt"));
//使用其特有方法进行读数据
Object object = ois.readObject();
ois.close();
System.out.println(object);
}
private static void writer() throws IOException, IOException {
//创建序列化流对象
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("oos.txt"));
//创建学生类对象
Student s=new Student(22,"王抢");
//向文件中写数据
oos.writeObject(s);
oos.close();
}
}
class Student implements Serializable{
private int age;
private String name;
public Student() {
super();
// TODO Auto-generatedconstructor stub
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student[age=" + age + ",name=" + name + "]";
}
}
十: Properties:属性集合类
1. Properties: 该类继承自Hashtable<K,V>,该类属于Map集合; 表示了一个持久的属性集
2. 构造方法: public Properties():创建一个空属性列表
3. 遍历和添加元素的功能:
public Object setProperty(String key,String value) 向集合中添加元素
public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
public String getProperty(String key)用指定的键在此属性列表中搜索属性值
# Properties集合特有功能遍历集合元素
package PropertiesText;
import java.util.Properties;
import java.util.Set;
/**
* 需求:使用该Properties结合的特有方法遍历集合中的元素
* 1.创建Properties集合对象
* 2.使用该类的特有方法public Object setProperty(String key,String value)向集合中添加元素
* 3.使用该类的public Set<String> stringPropertyNames()方法,获取该集合中的所有键集
* 4.用增强for()循环遍历该集合,然后使用public String getProperty(String key)方法,用指定的键获取对应的值
* 5.最后输出该集合中的内容
* */
public class PropertiesText_01 {
public static void main(String[] args) {
Properties p=new Properties();//创建属性集合类对象
//象集合中添加元素
p.setProperty("23", "王抢");
p.setProperty("22","上官万成");
//获取该集合中的每一个键集
Set<String> names = p.stringPropertyNames();
//增强for()循环遍历该集合
for(String key:names){
String values = p.getProperty(key);
System.out.println(key + "=" + values);
}
}
}
4. Properties 可保存在流中或从流中加载。
(1) 将文件中的数据加载到属性集合中:public void load(Reader reader)
(2) 将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)第二个参数:comments:对当前属性列表 的描述
#使用Properties进行文件的加载与保存:
package PropertiesText;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* 需求:使用Properties集合加载,存储文件
* 1.分别定义两个方法,一个加载文件中的数据,另一个存储文件中的数据
* 2.在加载文件方法中先创建Properties对象,再创建字符输入流对象,
* 调用该类的特有方法public void load(Reader reader)将文件
* 加载到集合中去,然后关闭流资源
* 3.在存储方法中,先创建Properties对象,再用该集合添加元素
* 再创建字符输出流对象,将最后调用该类的public void store(Writer writer,Stringcomments)
* 将上述对象封装在该集合中,然后关闭流资源
* 4.最后输出
* */
public class PropertiesText_02 {
public static void main(String[] args) throws IOException {
myStore();
myload();
}
private static void myStore() throws IOException {
// 创建Properties对象
Properties p=new Properties();
p.setProperty("23", "王抢");
p.setProperty("22", "上官万成");
//创建字符输出流对象
FileWriter fw=new FileWriter("p.txt");
p.store(fw, "这是学生信息");//存储该文件
fw.close();
}
private static void myload() throws IOException {
// 创建Properties对象
Properties p=new Properties();
FileReader fr=new FileReader("p.txt");//创建字符输入流对象
p.load(fr);//加载该文件
fr.close();
System.out.println(p);
}
}
#使用Properties集合修改文件中存在指定键的值:
package PropertiesText;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/**
* 需求:判断文件p.txt中是否有键22存在,如果有就将其值改为dengcong
* 1.先要将该文件加载到属性集合中
* 2.调用Properties集合的stringPropertyNames()方法,获取该集合中的所有键,作出判断,看是否存在"22"这个键,
* 若存在,则调用属性集合的setProperty("22","dengcong") ;将其值改为dengcong
* 3.重新将属性集合写到p.txt文件中去
* */
public class PropertiesText_03 {
public static Properties p=new Properties();
public static void main(String[] args) throws IOException {
myload();
Check();
mystore();
}
private static void mystore() throws IOException {
// 创建字符输出流对象
FileWriter fw=new FileWriter("p.txt");
p.store(fw, "这是修改过的学生信息");
fw.close();
}
private static void Check() {
//判断该集合中有没有"22"这个键
//获取该集合中的键集
Set<String> keys = p.stringPropertyNames();
for(String key:keys){
if(key.equals("22")){
p.setProperty("22", "dengcong");
}
}
}
private static void myload() throws IOException {
// 创建属性集合对象
FileReader fr=new FileReader("p.txt");
p.load(fr);//将该文件加载到属相集合中
fr.close();//关闭流资源
}
}
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
