黑马程序员——java之IO体系中File类、编码问题、对象序列化

------------android培训、java培训、期待与您交流！ -------------

知识点总结

1、File类的由来、三种常见的构造方法。

文件也有自己对应的属性信息，比如所在目录、文件类型、大小、建立修改日期。Java通过面向对象的方法对其进行封装，方便对其进行操作。

File(String pathname)

File(File parent ,String child)

File(String parent,String child)

2、File的几种操作方法：创建、判断、删除、获取信息。

1，创建。

boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

boolean mkdir():创建文件夹。

boolean mkdirs():创建多级文件夹。

2，删除。

boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

void deleteOnExit();在程序退出时删除指定文件。解决了在占用文件时删除不了的问题。

3，判断。

boolean exists() :文件是否存在.非常常用。

isFile():【注意】：在判断文件对象是否是文件或者目录时，

亦一般要先通过exists先判断文件对象封装内容是否存在。

isDirectory();

isHidden();

isAbsolute();

4，获取信息。

getName():

getPath():

getParent()://只要没有明确指定父目录，返回为空；

String getAbsolutePath();//返回绝对路径，字符串类型

File getAbosoluteFile();返回对象

long lastModified() //返回最近一次修改时间

long length() //返回该文件的长度

5.设置

public boolean renameTo(File dest)

重新命名此抽象路径名表示的文件。

但是，重命名操作无法将一个文件从一个文件系统移动到另一个文件系统，

该操作不是不可分的，如果已经存在具有目标抽象路径名的文件，那么该操作可能无法获得成功。应该始终检查返回值，以确保重命名操作成功。

6、列出内容：public String[]list(); 只传入实现FileNameFilter接口的对象

列出内容：public File[]listFiles()，既可以传入FileNameFilter，又可以传FileFilter

FileNameFilter 中只有 booleanaccept(File dir, String name) 方法

测试指定文件是否应该包含在某一文件列表中。

FileFilter 中只有 booleanaccept(File pathname)

测试指定抽象路径名是否应该包含在某个路径名列表中。

[java] view plain copy print ?

示例代码：
public class FileDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
listDemo();
listDemo1();
listDemo_2();
}
public static void listDemo()
{
File f = new File("D:\\JAVA\\code");
String[] names = f.list();//调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
for(String name : names)
{
System.out.println(name);
}
}
public static void listDemo_2()
{
File dir = new File("d:\\java\\code");
String[] arr = dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.endsWith(".java");
}
});
System.out.println("len:"+arr.length);
for(String name : arr)
{
System.out.println(name);
}
}
public static void listDemo1(){
File dir = new File("d:\\java\\code");
File [] arr = dir.listFiles(new FilenameFilter(){
public boolean accept(File dir,String name){
return name.endsWith(".java");
}
});
for(File f :arr){
Print.sop(f);
}
}
}

3、列出指定目录下文件或者文件夹，包含子目录中的内容。

也就是列出指定目录下所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。

在列出过程中出现的还是目录的话，还可以再次调用本功能。

也就是函数自身调用自身。

这种表现形式，或者编程手法，称为递归。

递归要注意：

1，限定条件。

2，要注意递归的次数。尽量避免内存溢出。

[java] view plain copy print ?

public class ListFileDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File f = new File("d:"+File.separator+"java");
getFile(f,0);
}
public static void getFile(File f,int level){
if(!f.exists())//先判断文件或目录是否存在
new IOException("找不到文件");
if(f.isDirectory()){//判断是不是目录
File[] files = f.listFiles();//是就获取目录下的文件
for(File f1 : files){
if(f1.isDirectory()){//在循环目录的过程中判断是否还是目录，是 //的话递归调用本方法
level++;
getFile(f1,level);
}
System.out.println(getLevel(level)+f1);//不是目录就打印
}
}
System.out.println(getLevel(level)+f);//不是目录就打印
}
//获取层级目录，打印出层次效果，毕老师想的，牛！
public static String getLevel(int level){
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x =0; x<level; x++)
{
sb.insert(0,"| ");
}
return sb.toString();
}
}

4、删除一个带内容的目录

[java] view plain copy print ?

/*
删除一个带内容的目录。
删除原理：
在window中，删除目录从里边往外面删除的。
既然是从里边往外删除，就需要用到递归。
*/
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File dir =new File("b:\\bxd");
removeDir(dir);
}
//java删除是不走回收站的
public static void removeDir(File dir)
{
File[] files =dir.listFiles();
//删除目录中的内容
for(int x =0; x<files.length; x++)
{
//java不能访问隐藏文件，所以遍历的时候最好判断下 //(!files[x].isHidden())&&files[x].isDirectory()
if(files[x].isDirectory())
removeDir(files[x]);
else
sop(files[x]+":-file-:"+files[x].delete());
}
//删除目录
sop(dir+"::del::"+dir.delete());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

5、打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

打印流有自己的PrintWriter.println();等方法。

把标准输入流写到文件中

[java] view plain copy print ?

示例代码：

class  PrintStreamDemo

{

    public static void main(String[] args) throws IOException

    {

        BufferedReader bufr =

            new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true); //不用使用转换流



        String line =null;

        while((line=bufr.readLine())!=null)

        {

            if("over".equals(line))

                break;

            out.println(line.toUpperCase());

            //out.flush();

        }

        out.close();

        bufr.close();

    }

}

6、Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

常用方法：

Object setProperty(String key,String value):

调用Hashtable的put方法，设置键值对

String getProperty(String key):

Set<String> stringPropertyNames:

获取集合中所有的键

void load(InputStream in):

从输入流中读取属性列表（键和元素对）。

void load(Reader reader):

按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

void list(PrintStream out)

将属性列表输出到指定的输出流。

voidlist(PrintWriter out)

将属性列表输出到指定的输出流。

Store(OutputStream out,String comments):

Store(Writer writer,String comments)

[java] view plain copy print ?

　　练习代码：
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
public class PropertiesDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//getSystemInfoToFile();
getPropertiseAndChange();
}
public static void getPropertiseAndChange(){//测试加载流方法load
File sysInfo = new File("D:"+File.separator+"Systeminfo.txt");
Properties prop = new Properties();
PrintWriter pw= null;
//prop.setProperty("userName", "caoRuiXiang");
try {
prop.load(new FileReader(sysInfo));
prop.setProperty("userName", "caoRuiXiang");//添加一个键值对
System.out.println(prop);
pw= new PrintWriter(new File("d:"+File.separator+"sys.txt"));
prop.store(pw, null);
/*从上面的例子中可以看出，setProperty方法只是修改了内存中的值，而硬盘中的值并没有改变，
* 所以Properties集合中海油一种方法，store,这种方法存到流中，进而存到硬盘中去，
* */
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
pw.close();
}
}
public static void getSystemInfoToFile() { //测试list方法
Properties prop = System.getProperties();
PrintWriter pw = null;
try {
pw = New PrintWriter(newFile("D:\\Systeminfo.txt"));
prop.list(pw);
pw.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(pw!=null)
pw.close();
}
}
}

7、练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

[java] view plain copy print ?

/用于记录应用程序运行次数。

如果使用次数已到，那么给出注册提示。

很容易想到的是:计数器。

可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。

可是随着该应用程序的退出，该计数器也在内存中消失了。

下一次在启动该程序，又重新开始从0计数。这样不是我们想要的。程序即使结束，该计数器的值也存在。下次程序启动在会先加载该计数器的值并加1后在重新存储起来。

所以要建立一个配置文件。用于记录该软件的使用次数。该配置文件使用键值对的形式。

这样便于阅读数据，并操作数据。键值对数据是map集合。

数据是以文件形式存储，使用io技术。

那么map+io -->properties.

配置文件可以实现应用程序数据的共享。/



import java.util.;

import java.io.;



class  RunCount

{

    public static void main(String[] args)  throws IOException

    {

        Properties prop = new Properties();

        File file = new File("count.ini");

        if(!file.exists())

            file.createNewFile();

        FileInputStream fis = new FileInputStream(file);

        prop.load(fis);



        int count = 0;

        String value = prop.getProperty("time");

        if(value!=null)

        {

            count = Integer.parseInt(value);

            if(count>=5)

            {

                sop("您好，使用次数已到，拿钱！");

                return ;

            }

        }

        count++;



        prop.setProperty("time",count+"");

        FileOutputStream fos = new FileOutputStream(file);

        prop.store(fos,"");

        fos.close();

        fis.close();



    }

    public static void sop(Object obj)

    {

        System.out.println(obj);

    }

}

8、合并流

SequenceInputStream是能对多个流进行合并成一个读取流，它在构造时需要传入Enumeration，而这个只用Vector中有，所以这个多个读取流要加入Vector集合中。

注意：它只是对读取流进行合并。

它使用步骤：

1. 创建Vector<InputStream>

2. 将要合并的InputStream加入Vector

3. 通过Vector获取Enumeration

4. 创建SequenceInputStream，将Enumeration作为参数传入。

代码：

[java] view plain copy print ?

public class SequenceDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file1 = new File("D:\\abc.txt");
File file2 = new File("D:\\def.txt");
File file3 = new File("d:\\java.txt");
//将三个文件封装到vector集合中
Vector<FileInputStream> vec = new Vector<FileInputStream>();
vec.add(new FileInputStream(file1));
vec.add(new FileInputStream(file2));
vec.add(new FileInputStream(file3));
//返回Enumeration
Enumeration<FileInputStream> enu = vec.elements();
SequenceInputStream seq = new SequenceInputStream(enu);
PrintStream ps = new PrintStream("d:\\合并.txt");
byte[] ch = new byte[1024];
int len = 0;
while((len = seq.read(ch))!= -1){
ps.write(ch, 0, len);
}
seq.close();
ps.close();
}
}

9、练习：文件切割与合并 [java] view plain copy print ?

public class SplitAndMergeFile {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
// File pic = new File("d:\\pic.jpg");
// splitFile(pic);
mergeFile();
}
public static void mergeFile() throws IOException{
//Vector效率低，可以改用ArrayList
ArrayList<FileInputStream> arr = new ArrayList<FileInputStream>();
for(int x = 1;x<6;x++){
arr.add(new FileInputStream("d:\\pic"+(x++)+".part"));
}
//因为it要被Enumeration的匿名内部类对象使用，所以要加final
final Iterator<FileInputStream> it = arr.iterator();
//定义Enumeration子类对象进行，使用ArrayList的迭代器复写其方法，其实与ArrayList关联
Enumeration<FileInputStream> en =
　　new Enumeration<FileInputStream>(){
public boolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
//定义序列流，合并分割后的文件关联的流对象
SequenceInputStream sis = new SequenceInputStream(en);
byte [] buf = new byte[1024];
int len = 0;
PrintStream ps = new PrintStream("d:\\合并得到的.jpg");
while((len = sis.read(buf))!=-1){
ps.write(buf, 0, len);
}
sis.close();
ps.close();
}
public static void splitFile(File fNeedS) throws IOException{ //切割文件
FileInputStream fis = new FileInputStream(fNeedS);
PrintStream ps = null;
//指定切割后每个文件的大小或者缓冲区的大小
byte[] buf = new byte[1024*512];
int len = 0;
int count = 1;
while((len = fis.read(buf))!=-1){
//创建每个分割文件。
ps = new PrintStream("d:\\pic"+(count++)+".part");
ps.write(buf, 0, len);
ps.close();
}
fis.close();
}
}

10、

对象序列化

数据可以封装成对象，对象运行时是在堆内存中的，如果对象的数据需要存储在硬盘上，那么就要用到对象的序列化流。对象序列化（也叫对象的可串行性）其实就是对象持久化，把内存中的对象，变成硬盘上的文件内容。IO*对象序列化的流对象为ObjectInputStream和ObjectOutputStream。

注意：

1. 用ObjectOutputStream写入的的文件，只能用ObjectInputStream来重构读取。

2. 被序列化的对象必须实现Serializable接口。

3. 对象的静态成员和被transient关键字修饰的成员不能被序列化。（当对象在堆内存的私有对象不希望被序列化时，可以使用transient关键字）。

此外，序列化的文件一般以.ojbect作为类型后缀名，一个文件中可以存放多个不同类型的序列化对象。

Serializable接口

在对对象进行序列化时，必须实行Serializable接口，否则使用ObjectOutputStream写入时，会出现NotSerializableException异常。

Serializable接口并没必须要实现的方法，类定义时仅标示一下实现即可。实现Serializable的类，都有serialVersionUID，如果你没有在类中显式定义一个serialVersionUID，那么编译器会根据该类中的成员生成一个具有唯一性的serialVersionUID。

显式定义serialVersionUID的好处：如果你在对类对象进行了序列化之后，又修改了这个类，那么再次读取修改前序列化的对象时，编译器可以识别；如果没有显式定义，你修改后的类经过编译器编译后会生成一个新的serialVersionUID，这个serialVersionUID跟修改前类的serialVersionUID不同，当你再次读取时，编译器会报出InvalidClassException异常。所以，如果类对象需要序列化，建议显式定义serialVersionUID。

[java] view plain copy print ?

代码示例:(借鉴优秀的博客思路，自己敲了一遍，掌握相关知识点)
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectStreamDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
// WriteObject();
ReadObject();
}
public static void ReadObject() throws Exception{
//通过ObjectInputStream读取序列化后的对象
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("D:\\caoRuiXiang.object"));
Person cao = (Person) ois.readObject();
System.out.println(cao.getInfo());
}
public static void WriteObject() throws IOException{
//通过ObjectOutputStream将对象序列化
ObjectOutputStream oop =
new ObjectOutputStream(new FileOutputStream("D:\\caoRuiXiang.object"));
oop.writeObject(new Person("曹睿翔",23,"hongkang"));//country为静态，不能序列化，所以，写入文件中的不是“HongKang”，而是CN
oop.close();
}
}
class Person implements Serializable{
public static final long serialVersionUID = 12L;
private String name;
private int age; //age如果不想序列化，可以在前边加 transient 关键字,保证其值在堆内存中存在而不在文本文件中存在。
static String county = "cn";
public Person(String aName,int aAge,String cCounty){
this.name = aName;
this.age = aAge;
this.county = cCounty;
}
public String getInfo(){
return this.name + this.age + county;
}
}
//Serializable serializable Serializable Serializable Serializable Serializable
//serialVersionUID serialVersionUID serialversionUID

11、用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

注意：

1．因为这两个流对象都操作的是数组，并没有使用系统资源，所以，不用进行close关闭，即使你关闭了，它的其他方法还可以使用，而不会抛出IOException。

2．使用这对对象操作时，它的源和目的都是内存。

用途：

这两个对象是在用流的思想来操作数组，当我们需要把一个文件中的数据加入内存中的数组时，就可以考虑用这个两个对象。此外，它还有writeTo（OutputStream os）可以把ByteArrayOutputStream对象内部定义的缓冲区内容，一次性写入os中。

操作字符数组、字符串的流对象类型与之相似，可以参与它们的使用方法。

在流操作规律讲解时：

用流的读写思想来操作数据。

[java] view plain copy print ?

import java.io.*;
class ByteArrayStream {
public static void main(String[] args) {
//数据源---字节数组，在内存中
ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());
//数据目的--bos内部封装的数组，在内存中
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());//把缓冲区中的字节按照默认的编码转成为字符串返回。
//bos.writeTo(new FileOutputStream("a.txt"));//把bos内部的byte数组内容一次性写入字节输出流对象中。
}
}

12、管道流

管道流分为字节管道流（PipedInputStream和PipedOutputStream）和字符管道流（PipedReader和PipedWriter）：它是IO技术和多线程技术的结合。在一条线程上写入的数据可以在另外一条线程上读取，它们是一对对配合使用的。如果在一条线程上使用管道读取和写入流会发生死锁的情况。

其使用步骤：

1. 分别定义写入和读取的Runnable接口子类，把相应的管道流作为构造参数传入给定义的私有管道流成员。

2. 将配对的管道流通过connect()方法连接起来。

3. 启动线程

[java] view plain copy print ?

示例代码：
　　import java.io.*;
　　class Read implements Runnable{
　　 private PipedInputStream in;
　　 Read(PipedInputStream in)
　　 {
　　 this.in = in;
　　 }
　　 public void run(){
　　 try
　　 {
　　 byte[] buf = new byte[1024];
　　 System.out.println("读取前。。没有数据阻塞");
　　 int len = in.read(buf);
　　 System.out.println("读到数据。。阻塞结束");
　　 String s= new String(buf,0,len);
　　 System.out.println(s);
　　
　　 in.close();
　　
　　 }
　　 catch (IOException e)
　　 {
　　 throw new RuntimeException("管道读取流失败");
　　 }
　　 }
　　}
　　
　　class Write implements Runnable
　　{
　　 private PipedOutputStream out;
　　 Write(PipedOutputStream out)
　　 {
　　 this.out = out;
　　 }
　　 public void run()
　　 {
　　 try
　　 {
　　 System.out.println("开始写入数据，等待6秒后。");
　　 Thread.sleep(6000);
　　 out.write("piped lai la".getBytes());
　　 out.close();
　　 }
　　 catch (Exception e)
　　 {
　　 throw new RuntimeException("管道输出流失败");
　　 }
　　 }
　　}
　　
　　class PipedStreamDemo
　　{
　　 public static void main(String[] args) throws IOException
　　 {
　　
　　 PipedInputStream in = new PipedInputStream();
　　 PipedOutputStream out = new PipedOutputStream();
　　 in.connect(out);
　　
　　 Read r = new Read(in);
　　 Write w = new Write(out);
　　 new Thread(r).start();
　　 new Thread(w).start();
　　 }
　　}

13、RundomAccessFile（重点，即可读又可写）

此类的实例支持对随机访问文件的读取和写入。

该类不是算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

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

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

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

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

[java] view plain copy print ?

import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile_2();
//writeFile();
//readFile();
RandomAccessFile raf = new RandomAccessFile("raf1.txt","rw");
raf.write("hha".getBytes());
}
//读取，模式设置为“r”
public static void readFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","r");
//调整对象中的指针，seek前后都能设置，所以比skipBytes使用范围广。
//raf.seek(8*0);//里边存入的数据都是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();
}
public static void writeFile_2() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","rw");
raf.seek(8*0);//修改数据，网络分段下载原理，要重点掌握。
raf.write("周期".getBytes());
raf.writeInt(103);
raf.close();
}
//写入，模式设置为“rw”
public static void writeFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","rw");
raf.write("李四".getBytes());
// raf.write(97);write(int x)方法只写入低8位。如果写入的数字在byte取值范围内，那么可以read()正常读取，如果超出，读取时就会出现数据错乱。
raf.writeInt(97);//要把四个字节都写入，所以用writeInt
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}

编码的练习及总结：

字符流的出现是为了方便操作字符数据，其方法操作的原因是因为内部加入了编码表。Java中能够实现字节根据指定编码表转成字符的，有四个类：InputStreamReader和OutputStreamWriter，PrintStream和PrintWriter。它们都能够加构造时，指定编码表；但后两个是打印流，只能用于打印，使用有局限，所以相对而言，还是前两个转换流使用多一些。

编码表的由来

计算机只能识别二进制数据，早期是电信号。为了应用计算机方便，让它可以识别各个国家的文字，就将各个国家的文字用数字来表示，并将文字与二进制数字一一对应，形成了一张表，这个表就是编码表。

常见的编码表

地域码表

1. ASCII：美国码表，息交换码，用一个字节的7位表示。

2. ISO8859-1：欧洲码表，拉丁码表，用一个字节的8位表示，最高位1

3. GB2312：中国中文编码表，它用两个字节表示，为兼容ASCII，它的两个字节的高位都是1，也即是两个负数；但与ISO8859-1冲突。大概有六七千个字。

4. GBK：中国的中文编码表的升级版，扩容到2万多字。

通用码表：

1. Unicode：国际标准码，融合多种语言文字。所有的文字都用两个字节表示，Java默认使用的就是Unicode。

2. UTF-8：UnicodeTransform Format -8。Unicode码把用一个字节能装下的文字，也用两个字节表示，有些浪费空间，对之进行优化的结果就是UTF-8。UTF-8编码表，一个文字最用一个字节表示，最多用3个字节表示，并且每个字节开始都有标识头，所以很容易于其他编码表区分出来。

代码示例：

[java] view plain copy print ?

class EncodeStream
{
public static void main(String[] args) throws Exception
{
//writeText();
readText();
}
//按照指定的码表读取数据
public static void readText() throws Exception
{
InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"UTF-8");
char [] buf = new char[10];
int len = isr.read(buf);
System.out.println(new String(buf,0,len));
isr.close();
}
//按照指定的码表写入数据
public static void writeText() throws Exception
{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK");
osw.write("你好");
osw.close();
}
}

编码问题的产生与解决

从上边的那些编码表可以看出，GBK和Unicode都能识别中文，那么当一台电脑使用GBK，而另一台电脑使用Unicode时，虽然在各自的电脑上都能识别中文，但他们其中一方向另一方发送中文文字时，另一方却不能识别，出现了乱码。这是一万年GBK和Unicode虽然都能识别中文，但对同一个中文文字，他们在两个编码表对应的编码值不同。这时，在解读别人传来的中文数据时，就需要指定解析中文使用的编码表了。

而转换流就能指定编码表，它的应用可以分为：

1. 可以将字符以指定的编码格式存储。

2. 可以对文本数据以指定的编码格式进行解读。

它们指定编码表的动作是由构造函数完成的。

编码：字符串变成字节数组，Stringàbyte[]，使用str.getBytes(charsetName)；

解码：字节数组变成字符串，byte[]àString，使用new String(byte[] b, charsetName);

编码编错：

是指你对一个文字进行编码时，使用了不识别该文字的编码表，比如你编码一个汉字，却使用了ISO8859-1这个拉丁码表，ISO8859-1根本就不识别汉字。编码编错时，你用任何方式对编码后的数据进行处理，都不可能再拿到这个汉字了。

解码解错：

是指你对一个文字进行编码事，使用了正确的码表，编码正确，但在解码时使用了错误的码表，那么你还有可能拿到这个文字。这分为两种情况：

第一种情况：

你使用的是GBK编码，解码时用的是ISO8859-1，因为GBK编译一个汉字，使用两个字节，ISO8859-1解码时是一个字节一个字节读取，虽然解码出现了乱码，但是这个汉字的二进制数据没有变化，那么你可以通过再次编译获取其原来的二进制数据，然后再次使用GBK编码，解码成功。

第二种情况：

你使用的是GBK编码，解码时用的却是UTF-8，因为这两个码表都识别汉字，那么你再次使用UTF-8编码时，就有可能把一个汉字的2个字节，变成3个，这时再用GBK解码时，得到的仍然是乱码，解码仍然失败。

[java] view plain copy print ?

class EncodeDemo
{
//解决编码问题示例
public static void main(String[] args) throws Exception
{
String s ="黑马训练营";
byte[] b1= s.getBytes("GBK");
System.out.println(Arrays.toString(b1));
//String s1 = new String(b1,"ISO8859-1");
String s1 = new String(b1,"UTF-8");
System.out.println("s1="+s1);
//对s1进行编码
//byte [] b2 = s1.getBytes("ISO8859-1");
byte [] b2 = s1.getBytes("UTF-8");
System.out.println(Arrays.toString(b2));
String s2 = new String(b2,"GBK");
System.out.println("s2="+s2);
}
}
“联通”的编码问题（联系也一样）
问题描述：打开记事本仅写入“联通”两个汉字，关闭后，再次打开会出现乱码。
class EncodeDemo2
{
public static void main(String[] args) throws Exception
{
String s = "联通";
byte [] by = s.getBytes("GBK");
for(byte b:by)
{
System.out.println(Integer.toBinaryString(b&255));
/*
* “联通”编码问题的原因：
//boBinaryString(int)它接受的是int，byte类型的b参与运算时会类型提升为int，我们需要的是提升后的低8位，所以&255
对联通的结果进行GBK编码时，其二进制码为：
11000001
10101010
11001101
10101000
编码的结果符合UTF-8的格式，所以再次打开记事本时，它会把它按照UTF-8的格式进行解码，结果就是两个乱码。
*/
}
}
}

IO综合练习：录入学生成绩并将信息存储在硬盘文件中。

[java] view plain copy print ?

/*
有5个学生，每个学生有三门课的成绩。
从键盘输入以上数据（包括姓名，三门课成绩）；
输入的格式：如zhangsan，30,40,60计算出总成绩。
并把学生的信息和计算出的总分数，按由高到低顺序存在在磁盘文件stud.txt中。
1.描述学生对象。
2.定义一个学生对象的工具类
思想：
1.通过获取键盘录入的一行数据。并将该行数据中的信息取出，封装成学生对象。
2. 因为学生对象有很多，就需要存储使用的集合，因为要对学生的总分排序，
所以可以使用TreeSet。
3.将集合中的信息写入到一个文件中。
*/
import java.io.*;
import java.util.*;
//使用TreeSet需要将其中的元素实现Comparable接口
class Student implements Comparable<Student>
{
private String name;
private int ma,cn,en;
private int sum;
Student(String name,int ma,int cn,int en)
{
this.name = name;
this.ma = ma;
this.cn = cn;
this.en = en;
sum =ma+cn+en;
}
//Comparable接口要实现compareTo方法。
public int compareTo(Student s )
{
//注意，一般自然信息定义的都是升序，即成绩从低到高的顺序
int num =new Integer(this.sum).compareTo(new Integer(s.sum));
if(sum==0)
return this.name.compareTo(s.name);
return num;
}
public String getName()
{
return name;
}
public int getSum()
{
return sum;
}
//学生类也有可能存入HashSet中，所以要复写hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+sum*78;
}
public boolean equals (Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.sum==s.sum;
}
//复写toString方法，提供学生类特有的字符串表现形式。
public String toString()
{
return "Student["+name+","+ma+","+cn+","+en+"]";
}
}
//定义学生信息录入和存储工具类
class StudentInfoTool
{
//函数重载，提供一个默认的方法，对学生对象按照定义的自然顺序进行排序
public static Set<Student> getStudents() throws IOException
{
return getStudents(null);
}
//定义录入工具，并将键盘录入的结果存入Set集合中，因为要排序，所以要用TreeSet。
//这里加入比较器作为参数，是为了让集合可以按照不同的要求进行排序，比如按照某一单科成绩或总分从高到底
public static Set<Student> getStudents(Comparator<Student> cmp) throws IOException
{
//定义缓冲区，包装键盘录入流对象
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);
//也可以用三元运算符进行优化
// Set<Student>stus=(cmp==null)?(new TreeSet<Student>()):(new TreeSet<Student>(cmp));
// 循环读取录入的信息，注意定义结束标记。
while((line =bufr.readLine())!=null)
{
if("over".equals(line))
break;
//用","进行切割---其实这里可以将录入信息line用正则表达式过滤一下，对于非法的信息不写入，并进行提示，防止录入非法的数据。
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 IOException
{
BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));
for(Student stu: stus)
{
bufw.write(stu.toString()+"\t");
//这里写入的数据是int类型的值，并且write会截取其低8位，所以要把它转成字符串，否则会出现乱码
bufw.write(stu.getSum()+"");
bufw.newLine();//写入跨平台的换行符
bufw.flush();//字符缓冲区一定要记得刷新动作
}
//关闭资源。
bufw.close();
}
}
class StudentInfoTest
{
public static void main(String[] args) throws IOException
{
//通过Collections集合工具类的反转命名方法，获得一个逆序比较器
Comparator<Student> cmp = Collections.reverseOrder();
//如果没有传入逆序比较器，学生会按照自然顺，即总成绩从低到高的排序，这与我们的现实生活习惯不符合。
Set <Student> stus = StudentInfoTool.getStudents(cmp);
//将集合中的学生信息写入文件。
StudentInfoTool.write2File(stus);
}
}

黑马程序员——java之IO体系中File类、编码问题、对象序列化

1、File类的由来、三种常见的构造方法。

2、File的几种操作方法：创建、判断、删除、获取信息。

4、删除一个带内容的目录

5、打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

打印流有自己的PrintWriter.println();等方法。

把标准输入流写到文件中

6、Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

常用方法：

Object setProperty(String key,String value):

调用Hashtable的put方法，设置键值对

String getProperty(String key):

Set<String> stringPropertyNames:

获取集合中所有的键

void load(InputStream in):

从输入流中读取属性列表（键和元素对）。

void load(Reader reader):

按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

void list(PrintStream out)

将属性列表输出到指定的输出流。

voidlist(PrintWriter out)

将属性列表输出到指定的输出流。

Store(OutputStream out,String comments):

Store(Writer writer,String comments)

7、练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

10、

11、用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

注意：

1． 因为这两个流对象都操作的是数组，并没有使用系统资源，所以，不用进行close关闭，即使你关闭了，它的其他方法还可以使用，而不会抛出IOException。

2． 使用这对对象操作时，它的源和目的都是内存。

用途：

操作字符数组、字符串的流对象类型与之相似，可以参与它们的使用方法。

在流操作规律讲解时：

用流的读写思想来操作数据。

12、管道流

其使用步骤：

1. 分别定义写入和读取的Runnable接口子类，把相应的管道流作为构造参数传入给定义的私有管道流成员。

2. 将配对的管道流通过connect()方法连接起来。

3. 启动线程

13、RundomAccessFile（重点，即可读又可写）

此类的实例支持对随机访问文件的读取和写入。

该类不是算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

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

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

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

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

编码的练习及总结：

编码表的由来

计算机只能识别二进制数据，早期是电信号。为了应用计算机方便，让它可以识别各个国家的文字，就将各个国家的文字用数字来表示，并将文字与二进制数字一一对应，形成了一张表，这个表就是编码表。

常见的编码表

地域码表

1. ASCII：美国码表，息交换码，用一个字节的7位表示。

2. ISO8859-1：欧洲码表，拉丁码表，用一个字节的8位表示，最高位1

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

1．因为这两个流对象都操作的是数组，并没有使用系统资源，所以，不用进行close关闭，即使你关闭了，它的其他方法还可以使用，而不会抛出IOException。

2．使用这对对象操作时，它的源和目的都是内存。