黑马程序员————Java基础日常笔记---IO其他流

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

黑马程序员————Java基础日常笔记---IO其他流

3.1 IO包中的其他类

3.1.1 打印流

printWriter与printStream

可以直接操作输入流和文件。

printStream：打印字节流

代码如下：

/*
java.io 
类 PrintStream
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
PrintStream 永远不会抛出 IOException；
为了自动刷新，可以创建一个 PrintStream；
这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。 
构造函数，接收三种类型的值：
1. 字符串路径 String
2. File对象 file
3. 字节输出流 OutputStream

java.io 
类 PrintWriter
向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。
构造函数，接收三种类型的值：
1. 字符串路径 String
2. File对象 file
3. 字节输出流 OutputStream
4. 字符输出流 Writer
PrintWriter(OutputStream out, boolean autoFlush) 
          通过现有的 OutputStream 创建新的 PrintWriter。
 PrintWriter(Writer out, boolean autoFlush) 
          创建新 PrintWriter。
*/
import java.io.*;
class PrintDemo
{
public static void main(String[] args) throws Exception
{
printStreamdemo();
printWriterdemo();
}
public static void printStreamdemo() throws Exception{
PrintStream out=new PrintStream("E:\\print.txt");
out.write(97);// 只写最低8位 void write(int b)  将指定的字节写入此流。 

//print方法将97先变成字符串保持原样将数据打印到目的地
        out.print(99); //97
out.println(100); 
out.close();
}
public static void printWriterdemo() throws Exception{
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));

//PrintWriter out=new PrintWriter("E:\\print1.txt");
//如果不写刷新，那么他的另外一个构造方法，有自动刷新
PrintWriter out=new PrintWriter(new FileWriter("E:\\print1.txt"),true);
String line=null;
while((line=bufr.readLine())!=null){
if("ok".equals(line)){
break;
}
out.println(line.toUpperCase());
//out.flush();
}
bufr.close();
out.close();

}
}

结果：

1方法的结果：

3.1.2 序列流-合并流

SequenceInputStream：对多个流进行合并。

代码：

<span style="font-size:12px;">/*
需求：
将1.txt、2.txt、3、txt文件中的数据合并到一个文件中。
java.io 
类 SequenceInputStream
SequenceInputStream 表示其他输入流的逻辑串联
它从输入流的有序集合开始，并从第一个输入流开始读取，
直到到达文件末尾，接着从第二个输入流读取，依次类推，
直到到达包含的最后一个输入流的文件末尾为止。 
构造方法 
SequenceInputStream(Enumeration<? extends InputStream> e) 
SequenceInputStream(InputStream s1, InputStream s2) 
可以将多个流对象拼成一个流对象， 
*/

import java.io.*;
import java.util.*;

class SequenceInputStreamDemo
{
public static void main(String[] args) throws Exception
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("E:\\1.txt"));
v.add(new FileInputStream("E:\\2.txt"));
v.add(new FileInputStream("E:\\3.txt"));
//遍历
Enumeration<FileInputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);//将集合中的流对象串联起来

FileOutputStream fos=new FileOutputStream("E:\\4.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}</span><span style="font-size: 12pt;">
</span>

结果：

３.１.２.１　切割流

代码：

<span style="font-size:12px;">/*
一个文件数据切割分到三个文件中存储， 
文件一般是等分的， 不等分， 一般是最后一个文件不等分
就是一个读取流， 对应有三个输出流， 
一个图片有3M多，只有把文件先切完， 然后在发上去， 
分卷压缩，
按1M来切。
*/
import java.io.*;
import java.util.*;

class SplitFile
{
public static void main(String[] args) throws Exception
{
splitFile();
merge();
}
public static void splitFile() throws Exception{
FileInputStream fis=new FileInputStream("E:\\火影忍者 - 青鸟.mp3");
FileOutputStream fos=null;
byte[] buf=new byte[1024*1024];
int len=0;
int count=1;
while((len=fis.read(buf))!=-1){
fos=new FileOutputStream("E:\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
//数据存到ArrayList中，然后用枚举取。这样需要复写枚举中的方法了，用到匿名内部类
public static void merge()throws Exception{
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int i=1;i<=4;i++){
al.add(new FileInputStream("E:\\"+i+".part"));
}
Iterator<FileInputStream> it=al.iterator();
Enumeration<FileInputStream> en=new Enumeration<FileInputStream>(){
public boolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fis=new FileOutputStream("E:\\还原青鸟.mp3");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fis.write(buf,0,len);
}
sis.close();
fis.close();
}

}</span><span style="font-size: 16px;">
</span>

结果：

3.1.3  对象的序列化

类：ObjectInputStream和ObjectOutputStream

可以直接操作对象的流，对象本身存在于堆内存中， 将堆内存中的对象存到硬盘上，而对象中会封装一些数据，

那么这些数据也随着对象存在硬盘上了，从而实现对象的持久化存储，

功能是将流和对象相结合，

代码：

<span style="font-size:12px;">/*
需求：直接将对象写入文件中
ObjectOutputStream(OutputStream out) 
          创建写入指定 OutputStream 的 ObjectOutputStream。
*/
import java.io.*;
class Person
{
String name;
int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){
return name+"..."+age;
}
}
class ObjectStreamDemo
{
public static void main(String[] args) throws Exception
{
writeObj();
}
public static void writeObj()throws Exception{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("E:\\obj.txt"));
oos.writeObject(new Person("wangwu",34));
oos.close();
}
}</span><span style="font-size: 14px;">
</span>

结果：

因此需要将Person这个类序列化，因此需要实现java.io.Serializable 接口。

但是经过查找，没有方法，而没有方法的接口一般称为标记接口，

通常：如果一个类希望被序列化， 就有个ID标识，通常是给编译器所使用的，

class Person implements Serializable

这样就ok了，

结果：

如果在加上一个读对象的流：

public static void readObj()throws Exception{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("E:\\obj.txt"));
Person p=(Person)ois.readObject();
System.out.println(p);
ois.close();
}

结果：

静态的成员不可以被序列化，

静态在方法区中，

只能把堆中的数据序列化，

如果不想对非静态的成员进行序列化的话， 那么可以加上关键字修饰：transient;

3.1.4 RandomAccessFile

RandomAccessFile类

随机访问文件，自身具备读写的方法。

通过skipBytes(int x),seek(int x)来达到随机访问。

既能读， 也能写，

代码：

/*
该类不能算是IO体系中的子类，而是直接继承自Object,

但是他是IO包中的成员，因为他具备读和写功能，

内部封装了一个数组，而且通过对数组元素进行操作，
可以通过getFilePointer获取指针的位置，同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式，只读r，读写rw等

如果模式是只读，不会创建文件，会去读取一个已存在文件
如果该文件不存在，则会出现异常，

如果模式rw,操作的文件不存在，该对象的构造函数要操作的文件不存在，会自动创建，如果存在会不会覆盖，

*/
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
writeFile();
readFile();
}
public static void writeFile()throws IOException{
RandomAccessFile raf=new RandomAccessFile("E:\\raf.txt","rw");
raf.write("李四".getBytes());
//raf.write(97);//a
raf.writeInt(97);//a

raf.write("王五".getBytes());
raf.writeInt(99);//a
raf.close();
}
public static void readFile() throws IOException{
RandomAccessFile raf=new RandomAccessFile("E:\\raf.txt","r");
//raf.write("你好，".getBytes());//拒绝访问，

//调整对象中指针，这样就可以直接取到王五的了，
/*
随机访问文件， 通过指针的设定， 可以取到任意的数据， 
但是必须保证这个数据是有规律的， 
如果都是8位的话， 可以通过8的倍数来取姓名和年龄，前后都可以指
*/
raf.seek(8);

//跳过指定的字节数//raf.skipBytes(8);byte[] buf=new byte[4];raf.read(buf);String name=new String(buf);int age=raf.readInt();System.out.println("name="+name);//就会得到李四了，System.out.println("age="+age);raf.close();}}

结果：

3.1.5  操作基本数据类型的流对象DataStream

代码；

/*
DataInputStream 和DataOutputStream，
可以用于操作基本数据类型的数据的流对象，
DataInputStream(InputStream in) 
          使用指定的底层 InputStream 创建一个 DataInputStream。
DataOutputStream(OutputStream out) 
          创建一个新的数据输出流，将数据写入指定基础输出流。

*/
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args) throws IOException
{
writeData();
readData();
}
public static void writeData()throws IOException{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("E:\\data.txt"));
dos.writeInt(89);
dos.writeBoolean(true);
dos.writeDouble(78.243);
dos.close();

}
public static void readData()throws IOException{
DataInputStream dis=new DataInputStream(new FileInputStream("E:\\data.txt"));
int num=dis.readInt();
boolean b=dis.readBoolean();
double d=dis.readDouble();
System.out.println("num="+num+"\nb="+b+"\nd="+d);
dis.close();
}
}

结果：

文件内容看不到？ 

因为，记事本显示的是字符， 会拿字节取查表，

把表中对应的返回了，

所以看不懂，因此只能按照顺序读， 否则会错，

3.1.6 ByteArrayInputStream与ByteArrayOutputStream

代码：

/*
ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。
内部计数器跟踪 read 方法要提供的下一个字节。 
关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，
而不会产生任何 IOException。 

ByteArrayOutputStream
此类实现了一个输出流，其中的数据被写入一个 封装了内部byte 数组。
ByteArrayOutputStream() 
          创建一个新的 byte 数组输出流。 
ByteArrayOutputStream(int size) 
          创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。 
因为这两个流对象都操作的数组，并没有使用系统资源，所以不用进行close关闭。
<span> void writeTo(OutputStream out) 
          将此 byte 数组输出流的全部内容写入到指定的输出流参数中，
<span></span>  这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。</span>
*/
import java.io.*;
class ByteArrayStreamDemo
{
public static void main(String[] args) 
{
//数据源
ByteArrayInputStream bis=new ByteArrayInputStream("BABDEG".getBytes());
//数据目的
ByteArrayOutputStream bos=new ByteArrayOutputStream();
int by=0;
while((by=bis.read())!=-1){
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
}
}

结果：

因此：

源设备：

键盘：System.in 硬盘：FileStream 内存：ArrayStream

目的设备：

键盘：System.out 硬盘：FileStream 内存：ArrayStream

用流的思想来操作数据。

3.1.7 转换流的字符编码

字符编码：

字符流的出现为了方便操作字符，

更重要的是加入了编码转换，

通过子类转换流来完成的，

-->InputStreamReader

-->OUtputStreamWriter

这两个对象进行构造的时候可以加入字符集；

编码表的由来，

计算机只能识别二进制数据，早期由来是电信号，

为了方便应用计算机，让他可以识别各个国家的文字，就将各个国家的文字用数据来表示，并一一对应，形成一张表，

这就是编码表。

常见的编码表
    -->ASCII：美国标准信息交换码，用一个字节的7位可以表示。
    -->ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表示。
    -->GB2312：中国的中文编码表。
    -->GBK：中国的中文编码表升级，融合了更多的中文文字符号。
    -->Unicode：国际标准码，融合了多种文字。
    -->所有文字都用两个字节来表示,Java语言使用的就是unicode
-->UTF-8：最多用三个字节来表示一个字符。

用UTF-8可以识别中文， 用GBK也可以识别中文， 但是解析出现的问题， 就必须解决，

代码：

<span style="font-family:Microsoft YaHei;font-size:12px;">/*
用UTF-8可以识别中文， 用GBK也可以识别中文， 但是解析出现的问题， 就必须解决，
*/
import java.io.*;

class EncodeStreamDemo 
{
public static void main(String[] args) throws Exception
{
writeText();
readText();
}
public static void writeText()throws Exception{
//OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E://GBK.txt"));
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E://GBK.txt"),"GBK");
//以上两种结果一样

OutputStreamWriter osw1=new OutputStreamWriter(new FileOutputStream("E://UTF-8.txt"),"UTF-8");

osw.write("你好");
osw1.write("你好");
osw.close();
osw1.close();
}
public static void readText()throws Exception{
InputStreamReader isr=new InputStreamReader(new FileInputStream("E://GBK.txt"),"GBK");
InputStreamReader isr1=new InputStreamReader(new FileInputStream("E://GBK.txt"),"UTF-8");
InputStreamReader isr2=new InputStreamReader(new FileInputStream("E://UTF-8.txt"),"GBK");

char[] buf=new char[10];
int len=isr.read(buf);
String str=new String(buf,0,len);
System.out.println("GBK.txt按照GBK编码表输出："+str);//打印你好

char[] buf1=new char[10];
int len1=isr1.read(buf1);
String str1=new String(buf1,0,len1);
System.out.println("GBK.txt按照UTF-8编码表输出："+str1);//打印??

char[] buf2=new char[10];
int len2=isr2.read(buf2);
String str2=new String(buf2,0,len2);
System.out.println("UTF-8.txt按照GBK编码表输出："+str2);

isr.close();
isr1.close();
isr2.close();
}

}
</span>

结果:

3.1.8 字符编码

然而上面这样是不可以的，

这里就需要将数据进行转换，

编码：将字符变成二级制的过程。字符串变成字节数组。

解码：字节数组变成字符串

代码：

/*
编码：将字符变成二级制的过程。字符串变成字节数组。
String-->byte[] str.getBytes();
解码：字节数组变成字符串
byte[]-->String; new String(byte[]);
*/
import java.util.*;

class  EncodeDemo
{
public static void main(String[] args) throws Exception
{
String s="你好";
//byte[] b1=s.getBytes();
byte[] b2=s.getBytes("GBK");
byte[] b3=s.getBytes("UTF-8");

System.out.println(Arrays.toString(b2));//默认的是GBK,[-60,-29,-70,-61]
System.out.println(Arrays.toString(b3));

String s2=new String(b2,"GBK");
System.out.println("按照GBK编码表解码："+s2);

String s3=new String(b3,"GBK");
System.out.println("按照UTF-8编码表编码用GBK编码表解码："+s3);

String s4=new String(b2,"ISO8859-1");
System.out.println("按照GBK编码表编码用ISO8859-1编码表解码："+s4);

//这样乱码产生，如何改？
byte[] b4=s4.getBytes("ISO8859-1");
String s5=new String(b4,"GBK");
System.out.println("由产生乱码的字节编码表来将其变回二进制，然后用正确的编码表重新解码："+s5);

}
}

结果：

3.1.9 练习：

代码；

/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据(包括姓名，三门课成绩)
输入的格式是：zhangsan，30,43,45计算出总成绩。
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件“student.txt”中。

1,描述学生对象， 
2，定义一个可以操作学生对象的工具类， 
思想，
1，通过获取键盘录入的一行数据，并将改行中的信息取出封装成学生对象，
2，因为学生对象有很多， 那么就需要存储， 使用到集合， 因为要对学生的总分排序， 
所以可以使用TreeSet， 
3，将集合中的信息写入到文件中， 

*/
import java.io.*;
import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int math,english,chinese;
private int sum;

Student(String name,int math,int english,int chinese){
this.name=name;
this.math=math;
this.english=english;
this.chinese=chinese;
sum=math+english+chinese;
}
public String getName(){
return name;
}
public int getSum(){
return sum;
}
public int hashCode(){
return name.hashCode()+sum*18;
}
public boolean equals(Object obj){
if(!(obj instanceof Student)){
throw new ClassCastException("类型不匹配");
}
Student s=(Student)obj;
return this.name.equals(s)&&this.sum==s.sum;
}
public int compareTo(Student s){
int num=new Integer(this.sum).compareTo(new Integer(s.sum));
if(num==0){
return this.name.compareTo(s.name);
}
return num;
}
public String toString(){
return "Student["+name+","+math+","+english+","+chinese+"]";
}
}
class studentInfoTool
{
public static Set<Student> getStudents()throws Exception{
return getStudents(null);
}
public static Set<Student> getStudents(Comparator<Student> cmp)throws Exception{
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));
String line=null;

Set<Student> stus=null;
if(cmp==null){
stus=new TreeSet<Student>();
}
else
stus=new TreeSet<Student>(cmp);

while((line=bufr.readLine())!=null){
if("over".equals(line)){
break;
}
String[] info=line.split(",");
Student stu=new Student(info[0],Integer.parseInt(info[1]),
Integer.parseInt(info[2]),Integer.parseInt(info[3]));
stus.add(stu);
}
bufr.close();
return stus;
}
public static void write2File(Set<Student> stus)throws Exception{
BufferedWriter bufw=
new BufferedWriter(new FileWriter("E:\\stusInfo.txt"));
for(Student stu:stus){
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");//反斜杠n的问题，解析是出错写入的是整数，写入的是后八位，
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}

class studentInfoTest
{
public static void main(String[] args) throws Exception
{
Comparator<Student> cmp=Collections.reverseOrder();
Set<Student> stus=studentInfoTool.getStudents(cmp);
studentInfoTool.write2File(stus);
}
}

结果：

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------