黑马程序员_IO流总结

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

IOInput 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这种方式解决起来更为方便。

使用字符流可以复制图片吗?为什么?

不能,因为字符流就是字节流+编码表,而用字符流去复制图片时,字符流会默认将图片的字节码格式进行编码,

       所以会导致复制后的图片与原图片可能不一致。

字节流的抽象基类:InputStreamOutputStream

字节流的基本应用?复制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类中的字段:inout

l  它们各代表了系统标准的输入和输出设备。

l  默认输入设备是键盘,输出设备是显示器。

l  System.in的类型是InputStream.

l  System.out的类型是PrintStreamOutputStream的子类FilterOutputStream的子类.

什么是标准输入输出流?

:获取键盘录入数据,然后将数据流向显示器,那么显示器就是目的地。

通过System类的setInsetOut方法对默认设备进行改变。

    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,明确体系:

       数据源:InputStreamReader

       数据汇:OutputStreamWriter

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,方便对文件与文件夹的属性信息进行操作。

3File对象可以作为参数传递给流的构造函数。

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完成自动刷新,该trueprintln方法有效。            

       什么时候用?

       当需要保证数据表现的原样性时,就可以使用打印流的打印方法来完成,这样更为方便。

       保证数据表现形式的原样性的原理:其实就是将数据变成字符串,再进行写入操作。

print(int)  write(int)的区别?

print(int)方法可以保持任意类型的数据表现形式的原样性,将数据输出到目的地。

              write(int)方法只是将数据的最低字节写出去。

PrintWriter可以打印的目的地有什么?

       有字节和字符。

PrintWriter在什么情况下可以自动刷新?

构造函数中,如果参数是输出流,那么可以通过指定另一个参数true完成自动刷新,该trueprintln方法有效。

PrintWriter对象的println自动刷新图

注意,自动刷新功能只对字节流对象和字符流对象有效。

2,序列流:

       SequenceInputStream:

              特点:

              1,将多个字节读取流合并成一个读取流,将多个源合并成一个源,操作起来更方便。

              2,需要的枚举接口可以通过Collections.enumeration(collection);

可以完成什么功能?

       可以将多个字节读取流合并成一个读取流,将多个源合并成一个源的功能。

文件切割的原理?

通过读取流关联源文件,然后读取流将一个临时的数据进行了一个临时的缓冲,然后通过这个临时的缓冲区将数据分散到不同的文件当中。

       也就意味着一个读取流对应着多个输出流。

ArrayList集合如何获取其对应的枚举对象?

实例化一个Enumeration对象,实现其内部方法,并且其内部实现过程和迭代器的功能一样,所以可以使用迭代的方法完美枚举的功能。

3,对象序列化

       ObjectInputStreamObjectOutputStream :对象的序列化和反序列化

       实现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,操作基本数据类型(额外功能的对象)

       DataInputStreamDataOutputStream

              特点:用于操作基本数据类型值的对象。

7,操作字节数组

       ByteArrayInputStreamByteArrayOutputStream

8,设备是内存的流对象。

操作字符数组

    CharArrayReaderCharArrayWrite

操作字符串

    StringReader StringWriter

IO中的这些功能流对象在用流操作规律分析时,都在第四步,是否需要额外功能呢?

1,转换吗?

一是需要桥梁吗?

2,高效吗?

随机访问文件 RandomAccessFile

3,序列化吗?

ObjectInputStreamObjectOutputStream :对象的序列化和反序列化       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培训、期待与您交流! ----------------------

详细请查看:http://edu.csdn.net/heima

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭