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培训、期待与您交流! ----------------------