IO（Input Output）流
l IO流用来处理设备之间的数据传输
l Java对数据的操作是通过流的方式
l Java用于操作流的对象都在IO包中
l 流按操作数据分为两种：字节流与字符流。
l 流按流向分为：输入流，输出流。
输入流和输出流的流向的理解？
流就是处理数据的一种方式或者一种手段，或者理解为一种数据流。
从硬盘已有的数据读取出来放内存里面的这个过程就是输入流。
把内存中的数据存储到硬盘中的这个过程就是输出流。
简单理解就是：以内存为中心。
什么时候使用流对象？
操作设备上的数据或操作文件的时候可以使用。
字符流
字符流的抽象基类：Reader， Writer。
字符流的理解，由来和作用？
由于很多国家的文字融入进来，比如说中文在编码表中默认占2个字节。而为了按照文字的单位来处理，所以出现了字符流。
由来：早期的字节流+编码表，为了更便于操作文字数据。
作用：为了处理文字数据。
复制文件的原理和代码。
原理：
首先用一个读取流对象和一个文件进行关联，然后用一个写入流对象作为目地的，
为了把读取流中的文件传输到目的地流对象中，我们就提供了一个字符数组，
为了关联这个数组，所以读取流对象有一个read()方法与这个字符数组进行关联，
同理，写入流对象也有一个write()方法与这个字符数组进行关联，
这样2个流对象就相连接了，而这个字符数组就相当于一个中转站。
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
/*
* 对文本文件进行复制。将c盘的文件复制到d盘中。
* 原理：其实就是一个最简单的读写过程。
* 从c盘源，读取数据，并将读到的数据，写入到目的d盘中。
*/
publicclass CopyTextFileTest {
publicstatic void main(String[] args) {
FileReaderfr = null;
FileWriterfw = null;
try{
//1,创建一个字符读取流读取与源数据相关联。
fr= new FileReader("demo.txt");
//2,创建一个存储数据的目的地。
fw= new FileWriter("copyDemo.txt");
//3,创建一个字符数组将读取流对象和写入流对象相连接。
char[]buf = new char[1024];
//4,每次读取的长度不一样，所以定义一个变量.
intlen = 0;
//5,用循环读取文件中的数据
while((len=fr.read(buf)) != -1) //判断是否读取完没
fw.write(buf,0,len); //为了只读取有效的数据
}catch (Exception e) {
}finally{
try{
fr.close();
}catch (IOException e) {
e.printStackTrace();
}
try{
fw.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
}
读取字符流对象的两种方式
第一种读取方式 一次读一个字符
//1，创建一个文件读取流对象，和指定名称的文件相关联
//2，要保证该文件时已经存在的。如果不存在，会发生异常。FileNotFoundException
FileReader fr = new FileReader("Demo.txt");
//3，调用读取流的方法,read方法一次读一个字符，而且会自动往下读。
int line=0; //read返回时int型的数，即返回的是字符的ascII表对应的数字
while ((line=fr.read())!=-1)
{
sop((char)ch);
}
第二种读取方式
//1,创建一个文件读取流对象，和指定名称的文件相关联
//2,要保证该文件时已经存在的。如果不存在，会发生异常。FileNotFoundException
FileReader fr = newFileReader("Demo.txt"); //把Demo.txt中的数据读到控制台
//3,定义一个字符数组，用于存储独到的字符该read(char[]) //返回的是读到字符的个数
char[] buf = new char[1024];
int len=0;
while((len=fr.read(buf))!=-1) //把读到的字符暂时存到buf数组中
{
sop("num="+num+"...."+new String(buf,0,len));
}
缓冲区的基本思想？提高效率的原理。
缓冲区的基本思想就是对要处理的数据进行临时存储。譬如购物车以及篮子。
原理：
减少频繁的操作。
给读取流对象和写入流对象提供中转站。
相对于来回跑的麻烦，利用缓冲区的容量，可以一边先存储，满了后再写入的方式，这样就提高了效率。
BufferedReader ，BufferedWriter.高效的体现？
内部将数组进行封装。
变成对象后，方便于对缓冲区的操作。提高效率。
并提供了对文本便捷操作的方法。
readLine
newLine。
自定义缓冲区，MyBufferedReader
import java.io.IOException;
import java.io.Reader;
/*
* 模拟一个缓冲区
* 基于已有的缓冲区思想，我们可以从源读取用read方法。
* 我们的缓冲区，应该是一个更高效的read读取方法。
*/
public class MyBufferTest extends Reader{
privateReader r;
privatechar[] buf = new char[1024];
privateint count = 0,pos = 0;
publicMyBufferTest(Reader r){
this.r= r;
}
/**
* 一次从缓冲区中取一个
* @return 返回一个缓冲区中的字符
* @throws IOException
*/
publicint myRead() throws IOException {
//1,首先判断缓冲区中是否有数据，如果没有就从源中去拿。
if(count== 0){
count= r.read(buf);
pos= 0;
}
//2,当缓冲区中没数据了且源中也没有数据时，count自减1小于0时就返回-1结束.
if(count< 0)
return-1;
//3,如果以上都不满足，那么从缓冲区中写入一个字符到新的文件中。
charch = buf[pos];
pos++;
count--;
returnch;
}
/**
* 按照文本特点，提供一个特有的操作文本的方法。
* 一次读取一行文本，只要是到行结束符之前的文本即可。
* @return 返回读取到的一行文本
* @throws IOException
* 原理：
* 就是从缓冲区中取出数据，并存储到一个临时容器中。
* 如果取到了回车符，就将临时容器中的数据转成字符串返回。
*/
publicString myReadLine() throws IOException{
//1,定义一个临时容器，进行临时存储
StringBuildersb = new StringBuilder();
//2,定义一个变量，接收读取到的字符，也就是转成ask码表后的一个int型数字
intch = 0;
while((ch= myRead()) != -1){
//3,当读取到\r时，直接跳出本次循环
if(ch== '\r')
continue;
//4,当读取到\n时，直接跳出当前循环
if(ch== '\n')
returnsb.toString();
//5,当都没有读取到时，就将这些数据存储到临时容器中。
sb.append((char)ch);
}
//6,当临时容器中的长度不等于0时，就输出字符。
if(sb.length()!= 0)
returnsb.toString();
returnnull;
}
publicvoid close() throws IOException {
}
publicint read(char[] arg0, int arg1, int arg2) throws IOException {
return0;
}
}
readLine方法的原理。
就是从缓冲区中获取数据，并进行临时存储，知道读取到了换行符，
将临时存储的数据转成字符串返回。
它对于操作文本是毕竟方便，可以完成一行一行的读取文本。
装饰设计模式，以及和继承的区别？
对原有类进行了功能的改变，增强。
区别：
1，
继承在对对象进行增强时，采用的是子类覆盖父类中的写方法，
且这些子类使用的功能的原理都一样，这样就显得很臃肿。
而BufferWriter的出现避免了继承体系关系的臃肿，比继承更为灵活。
2，
在为了增强功能的情况下，相较于继承，BufferWriter这种方式解决起来更为方便。
使用字符流可以复制图片吗？为什么？
不能，因为字符流就是字节流+编码表，而用字符流去复制图片时，字符流会默认将图片的字节码格式进行编码，
所以会导致复制后的图片与原图片可能不一致。
字节流的抽象基类：InputStream，OutputStream。
字节流的基本应用？复制MP3的例子。
基本操作与字符流类相同
但它不仅可以操作字符，还可以操作其他媒体文件
复制MP3的四种方式。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
publicclassCopyMediaFileTest {
/**
* @param args
* @throws IOException
*/
publicstaticvoid main(String[] args)throws IOException {
long start = System.currentTimeMillis();
copy_4();
long end = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
privatestaticvoid copy_4()throws IOException {
FileInputStreamfis = newFileInputStream("c:\\0.mp3");
FileOutputStreamfos = newFileOutputStream("c:\\4.mp3");
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
}
fos.close();
fis.close();
}
privatestaticvoidcopy_3()throwsIOException {
FileInputStreamfis = newFileInputStream("c:\\0.mp3");
FileOutputStreamfos = newFileOutputStream("c:\\3.mp3");
BufferedInputStreambufis =newBufferedInputStream(fis);
BufferedOutputStreambufos =newBufferedOutputStream(fos);
int ch = 0;
while((ch=bufis.read())!=-1){
bufos.write(ch);
}
bufos.close();
bufis.close();
}
privatestaticvoidcopy_2()throwsIOException {
FileInputStreamfis = newFileInputStream("c:\\0.mp3");
FileOutputStreamfos = newFileOutputStream("c:\\2.mp3");
byte[] buf =newbyte[fis.available()];
fis.read(buf);
fos.write(buf);
fos.close();
fis.close();
}
privatestaticvoidcopy_1()throwsIOException {
FileInputStreamfis = newFileInputStream("c:\\0.mp3");
FileOutputStreamfos = newFileOutputStream("c:\\1.mp3");
byte[] buf =newbyte[1024*4];
int len = 0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
fis.close();
}
}
转换流InputStreamReader,OutputStreamWriter
转换流的由来？
为了方便于字符流与字节流进行转换，也就是建立一个桥梁。
建立桥梁后，它就将字节流和编码表进行了封装，实现了对字符的便捷操作。
另外也为了方便字符流与字节流之间的操作。
转换流的应用？
字节流中的数据都是字符时，转成字符流操作更高效。
转换流的两个桥梁都是从哪里到哪里？
首先将文件通过InputStreamReader的方式将字节数据转成字符，为了高效，将其先存储到缓冲区中。
然后通过OutputStreamReader将缓冲区中的字符数据转成字节，最后输出。
转换流的另一个功能，编码的体现？
对操作的文本文件使用指定编码表进行编码解码的操作。
转换流的子类和转换流的区别？
区别：
1，
转换流：字节流+编码表
转换流的子类：FileReader&FileWriter：字节流+本地默认码表（GBK）。
2，
转换流可以指定任意码表。
而转换流子类需要构造一个其父类的对象。
标准输入输出流
l System类中的字段：in，out。
l 它们各代表了系统标准的输入和输出设备。
l 默认输入设备是键盘，输出设备是显示器。
l System.in的类型是InputStream.
l System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类.
什么是标准输入输出流？
例:获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的地。
通过System类的setIn，setOut方法对默认设备进行改变。
• System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。
• System.setOut(new PrintStream(“2.txt”));//将目的改成文件2.txt
因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。
BfferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw =
newBufferedWriter(new OutputStreamWriter(System.out));
流的基本应用小节
流是用来处理数据的。
处理数据时，一定要先明确数据源，与数据目的地（数据汇）。
数据源可以是文件，可以是键盘。
数据目的地可以是文件、显示器或者其他设备。
而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理.转换处理等
IO流的操作规律总结：
1，明确体系：
数据源：InputStream，Reader
数据汇：OutputStream，Writer
2，明确数据：因为数据分两种：字节，字符。
数据源：是否是纯文本数据呢？
是：Reader
否：InputStream
数据汇：
是：Writer
否：OutputStream
到这里就可以明确具体要使用哪一个体系了。
剩下的就是要明确使用这个体系中的哪个对象。
3，明确设备：
数据源：
键盘：System.in
硬盘：FileXXX
内存：数组。
网络：socket
数据汇：
控制台：System.out
硬盘：FileXXX
内存：数组
网络：socket
4，明确额外功能：
1，需要转换？是，使用转换流。InputStreamReaderOutputStreamWriter
2，需要高效？是，使用缓冲区。Buffered
3，需要其他？
1， 复制一个文本文件。
1，明确体系：
源：InputStream ，Reader
目的：OutputStream ，Writer
2，明确数据：
源：是纯文本吗？是 Reader
目的；是纯文本吗？是 Writer
3，明确设备：
源：硬盘上的一个文件。 FileReader
目的：硬盘上的一个文件。FileWriter
FileReader fr =new FileReader("a.txt");
FileWriter fw =new FileWriter("b.txt");
4，需要额外功能吗？
需要，高效，使用buffer
BufferedReaderbufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriterbufw = new BufferedWriter(new FileWriter("b.txt"));
2， 读取键盘录入，将数据存储到一个文件中。
1，明确体系：
源：InputStream ，Reader
目的：OutputStream ，Writer
2，明确数据：
源：是纯文本吗？是 Reader
目的；是纯文本吗？是 Writer
3，明确设备：
源：键盘，System.in
目的：硬盘，FileWriter
InputStream in =System.in;
FileWriter fw = newFileWriter("a.txt");
4，需要额外功能吗？
需要，因为源明确的体系时Reader。可是源的设备是System.in。
所以为了方便于操作文本数据，将源转成字符流。需要转换流。InputStreamReader
InputStreamReader isr =new InputStreamReader(System.in);
FileWriter fw = new FileWriter("a.txt");
需要高效不?需要。Buffer
BufferedReader bufr = newBufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw = new BufferedWriter(new FileWriter("a.txt"));
3， 读取一个文本文件，将数据展现在控制台上。
1，明确体系：
源：InputStream ，Reader
目的：OutputStream ，Writer
2，明确数据：
源：是纯文本吗？是 Reader
目的；是纯文本吗？是 Writer
3，明确设备：
源：硬盘文件，FileReader。
目的：控制台：System.out。
FileReader fr = newFileReader("a.txt");
OutputStream out =System.out;
4，需要额外功能？
因为源是文本数据，确定是Writer体系。所以为了方便操作字符数据，
需要使用字符流，但是目的又是一个字节输出流。
需要一个转换流，OutputStreamWriter
FileReader fr = newFileReader("a.txt");
OutputStreamWriter osw= new OutputStreamWriter(System.out);
需要高效吗？需要。
BufferedReader bufr =new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw =new BufferedWriter(new OutputStreamWriter(System.out));
4， 读取键盘录入，将数据展现在控制台上。
1，明确体系：
源：InputStream ，Reader
目的：OutputStream ，Writer
2，明确数据：
源：是纯文本吗？是 Reader
目的；是纯文本吗？是 Writer
3，明确设备：
源：键盘：System.in
目的：控制台：System.out
InputStream in =System.in;
OutputStream out =System.out;
4，需要额外功能吗？
因为处理的数据是文本数据，同时确定是字符流体系。
为方便操作字符数据的可以将源和目的都转成字符流。使用转换流。
为了提高效率，使用Buffer
BufferedReaderbufr =new BufferedReader(newInputStreamReader(Systme.in));
BufferedWriter bufw =new BufferedWriter(new OutputStreamWriter(System.out));
5， 读取一个文本文件，将文件按照指定的编码表UTF-8进行存储，保存到另一个文件中。
1，明确体系：
源：InputStream ，Reader
目的：OutputStream ，Writer
2，明确数据：
源：是纯文本吗？是 Reader
目的；是纯文本吗？是 Writer
3，明确设备：
源：硬盘：FileReader.
目的：硬盘：FileWriter
FileReader fr = newFileReader("a.txt");
FileWriter fw = newFileWriter("b.txt");
4，额外功能：
注意：目的中虽然是一个文件，但是需要指定编码表。
而直接操作文本文件的FileWriter本身内置的是本地默认码表。无法明确具体指定码表。
这时就需要转换功能。OutputStreamWriter,而这个转换流需要接受一个字节输出流，而且
对应的目的是一个文件。这时就使用字节输出流中的操作文件的流对象。FileOutputStream.
FileReader fr = newFileReader("a.txt");
OutputStreamWriter osw= new OutputStreamWriter(newFileOutputStream("b.txt"),"UTF-8");
需要高效吗？
BufferedReader bufr =new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw =
newBufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt"),"UTF-8"));
File类
File类的作用？
1，用来将文件或者文件夹封装成对象
2，方便对文件与文件夹的属性信息进行操作。
3，File对象可以作为参数传递给流的构造函数。
File对象基本使用。了解创建，删除，获取，判断等。
创建：
booleancreateNewFile():创建一个新的空文件,不过该文件已存在，就不会创建
booleanmkdir():创建指定的目录
booleanmkdirs():创建指定的目录已经父目录
删除：
boolean delete():删除文件或目录
voiddeleteOnExit():虚拟机结束时，会自动删除指定的文件或目录
获取：
StringgetAbsolutePath():绝对路径
StringgetPath():相对路径
StringgetParent():返回此路径名父目录的路径，如果没有则返回null
StringgetName():返回此路径名表示的文件或目录的名称
longlength():返回此路径名表示的文件的长度
longlastModified():返回此文件最后一次被修改的时间
判断：
booleanexists():判断此路径名表示的文件或目录是否存在
booleanisFile():判断此路径名表示的文件或目录是否是一个标准的文件
booleanisDirectory():判断此路径名表示的文件或目录是否是一个目录
File对象的过滤器。
实现FilenameFilter接口，然后覆盖其accept方法并指定需要过滤的扩展名就哦了。实现此接口的类实例可用于过滤器文件名。
booleanaccpet(File dir, String name):当且仅当该名称应该包含在文件列表中时返回 true；否则返回 false。
递归
什么是递归？
函数自己调用自己。
递归的使用和注意事项，并举例。
递归就是函数自身直接或间接调用自身。
当一个功能被重复使用，而且使用过程中，参数运算的数据不断的在发生着变化。
这时可以使用递归这种手法来解决问题。
注意事项：
1，必须要定义条件，否则会出现栈内存溢出。
2，要控制递归的次数。
例如：当我们传递一个参数超出了栈内存的范围，且这些数据并没有出栈，所以就会出问题。
Properties类
Properties类的作用？
主要用于存储键值的map集合中Hashtable的子类。
操作配置文件最方便的对象。
Properties的特点？
1，它没有泛型。
2，它里面的键和值都是固定的类型，字符串。
3，它自己有特有的存储和取出的动作。
4，它有和IO流相关联的方法。
5，它经常用于简单配置文件的解析。
Properties常见方法的使用？
voidlist(PrintWriter out):列出属性值
voidstore(OutputStream out, String comments):将集合中的键值信息进行持久化存储
voidload(Reader reader)：从持久化设备上将指定格式的键值信息加载到Properties集合中
IO中的其他功能流对象：
1，打印流：
PrintStream:
特点：
1，构造函数可接收File对象，字符串路径，字节输出流。意味着打印目的可以有很多。
2，该对象具备特有的方法打印方法print println,可以任何类型的数据。
3，特有的print方法可以保持任意类型的数据表现形式的原样性，将数据输出到目的地。
而对于OutputStream父类中的write方法，是将数据的最低字节写出去。
PrintWriter:
特点：
1，当操作的数据是字符时，可以选择PrintWriter，比PrintStream要方便。
2，它的构造函数可以接收File对象，字符串路径，字节输出流，字符输出流。
3，构造函数中，如果参数是输出流，那么可以通过指定另一个参数true完成自动刷新，该true对println方法有效。
什么时候用？
当需要保证数据表现的原样性时，就可以使用打印流的打印方法来完成，这样更为方便。
保证数据表现形式的原样性的原理：其实就是将数据变成字符串，再进行写入操作。
print(int)和 write(int)的区别？
print(int)方法可以保持任意类型的数据表现形式的原样性，将数据输出到目的地。
write(int)方法只是将数据的最低字节写出去。
PrintWriter可以打印的目的地有什么？
有字节和字符。
PrintWriter在什么情况下可以自动刷新？
构造函数中，如果参数是输出流，那么可以通过指定另一个参数true完成自动刷新，该true对println方法有效。
PrintWriter对象的println自动刷新图
注意，自动刷新功能只对字节流对象和字符流对象有效。
2，序列流：
SequenceInputStream:
特点：
1，将多个字节读取流合并成一个读取流，将多个源合并成一个源，操作起来更方便。
2，需要的枚举接口可以通过Collections.enumeration(collection);
可以完成什么功能？
可以将多个字节读取流合并成一个读取流，将多个源合并成一个源的功能。
文件切割的原理？
通过读取流关联源文件，然后读取流将一个临时的数据进行了一个临时的缓冲，然后通过这个临时的缓冲区将数据分散到不同的文件当中。
也就意味着一个读取流对应着多个输出流。
ArrayList集合如何获取其对应的枚举对象？
实例化一个Enumeration对象，实现其内部方法，并且其内部实现过程和迭代器的功能一样，所以可以使用迭代的方法完美枚举的功能。
3，对象序列化
ObjectInputStream和ObjectOutputStream :对象的序列化和反序列化
实现Serializable接口。
启用其序列化功能的。
序列化是验证序列化对象的。
必须添加默认ID号。
ID号的作用：可以对对象的声明周期进行延长。
关键字transient。
对象的序列化和反序列化，怎么理解的？
理解：序列化是验证序列化对象的。对象的持久化过程。
也就是将对象写入设备的方式，当然，也可以完成多个对象才存储，那么每个对象都需要有一个顺序。
Serializable接口有什么用？
启用其序列化功能的。
关于序列化中数字签名的小细节
数字签名不一致，也就是Seriable接口相关的类发生了改变，ID号发生了改变
非静态数据不需要序列化，如何解决？
使用关键字transient。
4，随机访问文件
RandomAccessFile:
• 随机访问文件，自身具备读写的方法。
• 通过skipBytes(int x),seek(int x)来达到随机访问。
特点：
1，既可以读取，也可以写入。
2，内部维护了一个大型的byte数组，通过对数组的操作完成读取和写入。
3，可以通过getFilePointer方法获取指针的位置，还可以通过seek方法设置指针的位置。
4，该对象的内部应该封装了字节输入流和字节输出流。
5，该对象只能操作文件。（局限性）
完成随机访问的原理？
对数组不断的操作。
通过seek方法操作指针，可以从这个数组中的任意位置上进行读和写。
可以完成对数据的修改，但是数据必须有规律。
5，管道流：
需要和多线程技术相结合的流对象。
特点：
1，可以将管道输出流连接到管道输入流通信管道。
2，需要和多线程技术相结合的流对象。
6，操作基本数据类型（额外功能的对象）
DataInputStream和DataOutputStream
特点：用于操作基本数据类型值的对象。
7，操作字节数组
ByteArrayInputStream和ByteArrayOutputStream
8，设备是内存的流对象。
操作字符数组
• CharArrayReader与CharArrayWrite
操作字符串
• StringReader 与 StringWriter
IO中的这些功能流对象在用流操作规律分析时，都在第四步，是否需要额外功能呢？
1，转换吗？
一是需要桥梁吗？
2，高效吗？
随机访问文件 RandomAccessFile
3，序列化吗？
ObjectInputStream和ObjectOutputStream :对象的序列化和反序列化 Serializable接口
4，操作基本数据类型吗？
DataInputStream 和 DataOutputStream
5， 需要保证数据原样性？
printWriter
编码表
编码表的由来
l 计算机只能识别二进制数据，早期由来是电信号。
l 为了方便应用计算机，让它可以识别各个国家的文字。
l 就将各个国家的文字用数字来表示，并一一对应，形成一张表。
l 这就是编码表。
字符编码
字符流的出现为了方便操作字符。
更重要是的加入了编码转换。
通过子类转换流来完成。
• InputStreamReader
• OutputStreamWriter
在两个对象进行构造的时候可以加入字符集。
OutputStreamWriterosw = new OutputStreamWriter(new FileWriter(“test.txt”));
常见的码表有哪些，都有什么特点？
ASCll：美国标准信息交换码
用一个字节的7位可以表示
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示
GB2312:中国的中文编码表
GBK：中国的中文编码表升级，融合了更多的中文文字字符号。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符
编解码的原则：编对解错，编错。
编码：字符串-->字节数组 可以理解为将认识的变成不认识的就是编码
解码：字节数组-->字符串 可以理解为将不认识的变成认识的就是解码
编码错了，就解不出来了。
编码对了，解错了，有可能有救。
当涉及向服务端提交中文数据时，服务器是iso8859-1的码表，如何获取正确的中文？
对乱码进行iso8859-1编码，在用gbk解码即可。
联通是怎么回事？
联通的GBK的编码正好符合了UTF-8的编码，所以就用了UTF-8的码表进行解码，因此出现了乱码。
也就是联通的GBK编码表和UTF-8重复了。
---------------------- android培训、 java培训、期待与您交流！ ----------------------
825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
