一、字符流—读取文件
建立一个流对象,将已存放的一个文件加载进流
FileReader fr = new FileReader(“Test.tex”);
创建一个临时存放数据的数组,用于缓冲
Char[]ch = new char[1024];
调用流对象的读取方式将流中的数据读入到数组中
fr.read(ch);
文件的拷贝示例代码:
package cn.xushuai.io;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class copyfileDemo {
public static void main(String[] args){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("WriterDemo.txt");
fw = new FileWriter("readerDemo.txt",true);
int ch = 0;
int len = 0;
char[] buf = new char[1024];
while(( len =fr.read(buf))!=-1){
fw.write((char)ch);
fw.write(buf,0,len);
fw.flush();
}
}catch(IOException e){
System.out.println("文件读写失败");
}finally{
if(fr!=null)
try {
fr.close();
} catch (IOException e) {
System.out.println("读取流关闭失败!");
}
if(fw!=null)
try {
fw.close();
} catch (IOException e) {
System.out.println("写入流关闭失败!");
}
}
}
}
字符流缓冲区:
1、缓冲区的出现提高了对数据的读写效率。
对应类:BufferedWriter
BufferedReader
2、缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
3、字符读取流缓冲区:
该缓冲区提供了一个一次读一行的方法 readLine,方便于对文本数据的获取。
当返回null时,表示读到文件末尾。
4、readLine方法返回的时候只返回回车符之前的数据内容,并不返回回车符,
所以应该手动换行:println或者newLine()。
字符流缓冲区对象使用演示代码:
说明:基本操作与字符流类相同,但它不仅可以操作字符,还可以操作其他媒体文件
package cn.xushuai.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class copyTextByBuf {
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedReader bufr = null;
BufferedWriter bufw = null;
try {
bufr = new BufferedReader(new FileReader("readerDemo.txt"));
bufw = new BufferedWriter(new FileWriter("writerDemo.txt",true));
int ch = 0;
String str = null;
while((str = bufr.readLine())!=null){
bufw.write(str);
bufw.newLine();
bufw.flush();
//System.out.print((char)ch);
}
} catch (IOException e) {
System.out.println("文件读取失败!");
}finally{
try {
if(bufr!=null)
bufr.close();
} catch (IOException e) {
System.out.println("读取关闭失败!");
}
try {
if(bufw!=null)
bufw.close();
} catch (IOException e) {
System.out.println("写入关闭失败!");
}
}
}
}
二、字节流读写文件
import java.io.*;
class FileStream
{
public static void main(String[] args) throws IOException
{
readFile_3();
}
//使用缓冲区读取
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
//int num = fis.available(); //在操作较大数据时,可能出现内存溢出
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
public static void readFile_1()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
//不需要刷新,因为是对最小单位字节操作
public static void writeFile()throws IOException
{
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
fos.close();
}
}
练习:使用字节流复制图片
复制一个图片
思路:
1,用字节读取流对象和图片关联。
2,用字节写入流对象创建一个图片文件,用于存储获取到的图片数据。
3,通过循环读写,完成数据的存储。
4,关闭资源。
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream("c:\\2.bmp");
fis = new FileInputStream("c:\\1.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
fos.write(buf,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("写入关闭失败");
}
}
}
}
自定义字节流缓冲区
要求:定义一个字节缓冲区
原理:
自定义一个数组,用于存储数据,底层是通过inputStream的read(byte[ ] )方法进行读取,每次读取
后返回数组长度的字节,然后由缓冲区流对象BufferedInputStream的read()往外读取,每读取一个
字节指针向后移动1位,字节数减1,直到读取到数组的最后,计数器为0,重新read(byte[ ])
步骤:
定义一个数组,用于临时存放数据
定义一个指针,用于操作数据
定义一个计数器,用于确定数组是否为空
关键:在myRead的返回值上,为了避免连续8个1的出现导致读取结束,
因此将byte提升至int,然后保留最低8位,即可
自定义缓冲区示例代码:
package cn.xushuai.io;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class MyBufferedInputStream {
private InputStream in;
byte[] buf = new byte[1024];
private int pos,count;
MyBufferedInputStream(InputStream in){
this.in = in ;
}
public int myRead() throws IOException{
if(count==0){ //当计数器为0,即取完之后,进行下一次读取
pos = 0; //每次取完之后,指针要回到起始点
count = in.read(buf);
if(count<0) //如果count小于0,说明底层流对象读到结尾,那么直接返回-1
return -1;
}
if(count > 0){ //如果count>0说明数组里有数据,直接取就可以
byte b = buf[pos];
count--; //每获取一个,计数器就-1
pos++; //每获取一个,指针就向后移动1
return b&0xff; //取int的最低4位,返回读取到的一个字节
}
return -1;
}
public void myClose() throws IOException{
in.close();
}
}
read( )返回值类型
字节流的读一个字节的read方法为什么返回值类型不是byte,而是int。
因为有可能会读到连续8个二进制1的情况,8个二进制1对应的十进制是-1.
那么就会导致数据还没有读完,就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
所以,为了避免这种情况将读到的字节进行int类型的提升,
byte的-1 被提升为int后的-1:
11111111 11111111 11111111 11111111
&
00000000 00000000 00000000 11111111 (int的最低8位,255)
-------------------------------------------------------------
00000000 00000000 00000000 11111111
并在保留原字节数据的情况前面了补了24个0,变成了int类型的数值255,不再是-1。
而在写入数据时,只写该int类型数据的最低8位。
三、读取键盘录入
介绍了键盘录入的读取并进而引入转换流
System.out:对应的是标准输出设备,控制台。
System.in:对应的标准输入设备:键盘。
读取键盘录入练习
需求:
通过键盘录入数据。
当录入一行数据后,就将该行数据进行打印。
如果录入的数据是over,那么停止录入。
示例代码
package cn.xushuai.io;
import java.io.IOException;
import java.io.InputStream;
//键盘录入
public class ReadIn {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
InputStream in = System.in;
int ch = 0;
StringBuilder sb = new StringBuilder();
while(true){
ch = in.read();
if(ch=='\r')
continue;
if(ch=='\n'){
String s = sb.toString();
if(s.equals("over"))
break; //程序结束,不再读取
System.out.println(s.toUpperCase());
sb.delete(0, sb.length());//每次读取完,清空缓冲区中的内容,以便下次使用
}
else
sb.append((char)ch);
}
}
}
通过刚才的键盘录入一行数据并打印其大写,发现其实就是读一行数据的原理。
readLine方法是字符流BufferedReader类中的方法。
而键盘录入的read方法是字节流InputStream的方法,也就是readLine方法。
那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢?
所以就出现了转换流:
InputStreamReader :
OutputStreamWriter
四:转换流
1.、InputStreamReader:将字节流转换为字符流
为了提高键盘录入的效率。通过转换流,使字节流转化为字符流,然后使用字符流的方法操作,为了一次可以读取一行,所以用BufferedReader包装。
键盘录入:BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));
2、 OutputStreamWriter :将字符流转换为字节流
因为写入时字符输出流利用了字节缓冲区,所以需要刷新,同时希望换行,所以希望用 跨平台的newLine方法,又因为newLine方法属于BuffereWriter,,所以用BufferedWriter 进行包装。
标准输出:BufferedWriter bufw = newBufferedWriter(new OutputStreamWriter(System.out));
转换流的使用示例代码:
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//字节转向字符,提高操作效率
//获取键盘录入对象。
//InputStream in = System.in;
//将字节流对象转成字符流对象,使用转换流。InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);
//为了提高效率,可以一次读取一行,将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);
//键盘的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//字符通向字节的桥梁,将字符数据以字节的方式写出
// OutputStream out = System.out;
// OutputStreamWriter osw = new OutputStreamWriter(out);
// BufferedWriter bufw = new BufferedWriter(osw); //增强写入,因为newLine是缓冲区的方法
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
转换流的使用总结:
需求:想要把录入的数据按照指定的编码表(utf-8),将数据存到文件中。
分析:
目的:OutputStream Writer
是否是存文本?是!Writer。
设备:硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表:GBK.
而存储时,需要加入指定编码表utf-8,而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流,而且还可以操作的文件的字节输出流。
FileOutputStream OutputStreamWriterosw = new OutputStreamWriter(newFileOutputStream("d.txt"),"UTF-8");
需要高效吗?需要。
BufferedOutputStream bos = new BufferedOutputStream(osw);
转换流使用场合:
字符和字节之间的桥梁,通常,涉及到字符编码转换时,需要用到转换流。
五、创建日志信息
示例说明:主要是使用System.setOut来重定向输出流,并使用到了Date 和SimpleDateFormat来获得指定格式的日期
import java.io.*;
import java.util.*;
import java.text.*;
//使用System.setOut 创建日志信息
class ExceptionInfo
{
public static void main(String[] args)throws IOException
{
try
{
int[] arr = new int[2];
System.out.println(arr[3]);
}
catch (Exception e)
{
try
{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
PrintStream ps = new PrintStream("c:\\exeception.log");
ps.println(s);
System.setOut(ps);//将标准输出重新定向为一个文件
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
六、使用properties来获取系统信息
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties prop = System.getProperties();//获取系统信息
//System.out.println(prop);
prop.list(new PrintStream("sysinfo.txt"));//传入一个打印流,记录数据
}