转换流
1.输入字节流—InputStreamReader类
InputStreamReader是Reader的子类,可以将一个字节输入流转为字符输入流。
构造方法:
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)
创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
File file = new File("D:\\TL-BITE\\Test\\test1\\otptsmwriter.txt");
if(!file.getParentFile().exists()){
file.getParentFile().mkdirs();
}
try(
OutputStream outputStream=new FileOutputStream(file);
Writer writer=new OutputStreamWriter(outputStream)
){
String msg="I 老虎 U! !!";
writer.write(msg);
}catch (IOException e){
}
字符编码
GBK、GB2312:国标编码,GBK包含简体中文和繁体中文;GB2312只包含简体中文。
UNICODE编码:Java提供的16进制编码,可以描述世界上任意文字信息,若全部采用UNICODE编码,会造成网络传输负担。
ISO8859-1编码:国际通用编码
UTF编码:结合了UNICODE,ISO8859-1.
缓冲流
public BufferedReader(Reader in)
在读写数据时,让数据有缓冲区能减少系统实际对原始数据来源做存取的次数,因此使用缓冲区的流(即缓冲流),一般比没有缓冲区的流效率更高,包括BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
1.BufferedReader类
是Reader的子类,Reader类的方法read()每次都从数据源读入一个字符,为了提高效率,使用BufferedReader来配合其他字节流。BufferedReader提高readLine()可以分行读取文本。
File file=new File("D:\\TL-BITE\\Test\\write.txt");
Reader read=null;
String str="";
BufferedReader bin=null;
try{
read=new FileReader(file);
//BufferedReader需配合其他字节流
bin=new BufferedReader(read);
str=bin.readLine();
}catch (IOException e){
}
System.out.print(str);
2.BufferedWriter类
BufferedWriter是Writer的子类,BufferedWriter类主要改变的是重写了flush()方法,该方法可以确保缓冲区里的数据确实被写到输出流,BufferedWriter提供了缓冲区,能更有效率的写出字符数据流。
public BufferedWriter(Writer out)
File file=new File("D:\\TL-BITE\\Test\\buffwrite.txt");
FileWriter fw=null;
BufferedWriter bw=null;
String[] str={"锲而不舍","朽木不折"};
try{
fw=new FileWriter(file);
bw=new BufferedWriter(fw);
for(int i=0;i<str.length;i++){
bw.write(str[i]);
bw.newLine();//写一个结尾\n,以达到换行的目的
}
bw.close();
fw.close();
}catch (IOException e){
e.printStackTrace();
}
内存操作流
内存操作流一般用于处理临时信息,因为临时信息不需要保存,使用后就可以删除。因此需要进行IO处理,但是又不希望产生文件。这种情况下就可以使用内存作为操作终端。
1.ByteArrayInputStream类–内存输入流
ByteArrayInputStream是一个把字节数组作为源的输入流实现,可以将数据写入内存中。ByteArrayInputStream继承了InputStream类的read()方法后,没有抛出异常。
byte[] b=new byte[]{'a','c','b','g'};
ByteArrayInputStream bis = new ByteArrayInputStream(b, 0, b.length);
int temp=bis.read();
while (temp!=-1){
System.out.println((char)temp+"\t");
temp=bis.read();
}
try{
bis.close();//是没有任何操作的空方法
}catch (IOException e){
e.printStackTrace();
}
1.ByteArrayOutputStream类–内存输出流
ByteArrayOutputStream类是将一个字节数组作为源的输出实现,可以将内存中的数据输出。
byte[] b={'A','C','F','G','H'};
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bos.write(b,0,b.length);
//输出缓冲区的字节数目
System.out.println("缓冲区的字节数组"+bos.size());
byte[] bout=bos.toByteArray();
for(int i=0;i<bout.length;i++){
System.out.println((char)bout[i]+"\t");
}
打印流
打印流解决的是OutputStream的缺陷,属于OutputStream功能的加强版。OutputStream处理的只能是字节数组;对int,double等类型的操作不方便。
打印流可以方便的将各种不同类型的数据打印输出到另一个输出流.PrintStream流可以配合不同的输出流,用来输出数据到各个目的地,如文件,数组等.
构造方法:
public PrintStream(File file)
public PrintStream(OutputStream out)
public PrintStream(OutputStream out,boolean autoFlush)
常用方法:
1.使用指定格式字符串和参数,将格式化字符串写入输出流
public PrintStream format(Locale 1,String format,Object args)
2.打印String,然后终止改行
public void print(String s)
3.使用指定格式的字符串和参数,将格式化的字符串写入此输出流
public PrintStream printf((Locale 1,String format,Object args)
4.打印该行,然后终止该行
public void pintln(String s)
FileOutputStream fos=new FileOutputStream("D:\\TL-BITE\\Test\\write.txt");
PrintStream ps = new PrintStream(fos);
ps.println(12);
ps.print(false);
ps.print("nihao");
ps.close();
格式化输出:
//printf为格式化输出
//字符串:%s
//整数:%d
//浮点数:%f, %.3f表示是含三位小数位的浮点数
//在格式前添加整数代表右对齐,添加负数代表左对齐
System.out.printf("姓名:%4s,年龄:%-2d,身高:%.3f","长得三",23,1.83);
System.out.printf("姓名:%4s,年龄:%-2d,身高:%.3f", "张三", 28, 168.7D);
//利用String类的format方法,效果相同
String str=String.format("姓名:%4s,年龄:%-2d,身高:%.3f", "张三", 28, 168.7D);
System.out.println(str);
输出结果:
对象序列化
对象序列化是指将对象状态转化为可保持状态或传输格式(二进制流/字节序列)的过程,即将对象写入输出流;与对象序列化相反的是对象反序列化,是指由输入流将这种二进制流读入,重新恢复为原来的对象。将序列化和反序列化过程结合起来,可以轻松的进行存储和传输数据,使对象可以脱离程序的运行而独立存在。
若某个对象能支持序列化,必须让他实现Serializable接口,Serializable接口仅是一个标记接口,无任何实现方法。
可以参与序列化的成员:属性、类名
不能被序列化的内容:所有的方法、static关键字,transient关键字修饰的属性。
如果要想实现序列化与反序列化的对象操作,在java.io包中提供有两个处理类:ObjectOutputStream、 ObjectInputStream
//将需要序列化的类实现Serializable 接口,Serializable 接口没有任何实例方法
class Person implements Serializable {
private String name;
private int age;
private String school;
public Person(String name, int age, String school) {
this.name = name;
this.age = age;
this.school = school;
}
public void tell() {
System.out.println("名字" + name + "年龄" + age + "学校" + school);
}
}
public class SerializableTest {
public static File file = new File("D:\\TL-BITE\\Test\\print.txt");
//序列化实例对象
public static void serOutTest(Object obj) {
//将序列化对象写入文件
try (ObjectOutputStream obo = new ObjectOutputStream(new FileOutputStream(file))) {
obo.writeObject(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
//反序列化
public static void serInTest() {
//从文件中读取序列化对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
//将序列化对象(Object类)强转为Person类
Person p1=(Person)ois.readObject();
Person对象调用Person类的普通方法
p1.tell();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//给实现序列化的方法传入对象
serOutTest(new Person("张三", 23, "清华大学"));
调用实现反序列化的方法
serInTest();
}
}