字节与字符_字节流与字符流_ASCII与Unicode_GB2312_GBK_GB18030_BIG-5

字节(Byte):通常将可表示常用英文字符8位二进制称为一字节.

一个英文字母(不分大小写)占一个字节的空间,一个中文汉字占两个字节的空间.

符号:英文标点2占一个字节,中文标点占两个字节.

一个二进制数字序列,在计算机中作为一个数字单元,一般为8位二进制数,如一个ASCII码就是一个字节,此类单位的换算为:

1千吉字节(KGB,KiloGigaByte)=1024吉字节

1吉字节(GB,GigaByte) =1024兆字节

1兆字节(MB,MegaByte) =1024千字节

1千字节(KB,KiloByte) =1024字节

1字节(Byte) = 8位(bit)

------------------------------------------------------------------------------------------------------------------

1. bit:位

一个二进制数据0或1,是1bit;

2. byte:字节

存储空间的基本计量单位,如:MySQL中定义 VARCHAR(45)  即是指 45个字节;

1 byte = 8 bit

3. 一个英文字符占一个字节;

1 字母 = 1 byte = 8 bit

4. 一个汉字占2个字节;

1 汉字 = 2 byte = 16 bit

5. 标点符号

A>.  汉字输入状态下,默认为全角输入方式;

B>.  英文输入状态下,默认为半角输入方式;

C>.  全角输入方式下,标点符号占2字节;

D>.  半角输入方式下,标点符号占1字节;

故:汉字输入状态下的字符,占2个字节 (但不排除,自己更改了默认设置);

英文输入状态下的字符,占1个字节 (但不排除,自己更改了默认设置);

-----------------------------------------------------------------------------------------------------------------------

字节流与字符流

先来看一下流的概念:

在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。

程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。

字节流与字符流

在java.io包中操作文件内容的主要有两大类:字节流、字符流,两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类完成,输入流主要使用Reader类完成。(这四个都是抽象类)

java中提供了专用于输入输出功能的包Java.io,其中包括:

InputStream,OutputStream,Reader,Writer

InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,

Reader和 Writer.两个是为字符流(一个字符占两个字节)设计的,主要用来处理字符或字符串.

字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点

所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列

字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以

字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

==================我们还可以看到:============

Reader类的read()方法返回类型为int :作为整数读取的字符(占两个字节共16位),范围在 0 到 65535 之间 (0x00-0xffff),如果已到达流的末尾,则返回 -1

inputStream的read()虽然也返回int,但由于此类是面向字节流的,一个字节占8个位,所以返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节,则返回值 -1。因此对于不能用0-255来表示的值就得用字符流来读取!比如说汉字.

操作流程

在Java中IO操作也是有相应步骤的,以文件操作为例,主要的操作流程如下:

1 使用File类打开一个文件

2 通过字节流或字符流的子类,指定输出的位置

3 进行读/写操作

4 关闭输入/输出

IO操作属于资源操作,一定要记得关闭

字节流

字节流主要是操作byte类型数据,以byte数组为准,主要操作类就是OutputStream、InputStream

字节输出流:OutputStream

OutputStream是整个IO包中字节输出流的最大父类,此类的定义如下:

public abstract class OutputStream extends Object implements Closeable,Flushable

从以上的定义可以发现,此类是一个抽象类,如果想要使用此类的话,则首先必须通过子类实例化对象,那么如果现在要操作的是一个文件,则可以使用:FileOutputStream类。通过向上转型之后,可以为OutputStream实例化

Closeable表示可以关闭的操作,因为程序运行到最后肯定要关闭

Flushable:表示刷新,清空内存中的数据

FileOutputStream类的构造方法如下:

public FileOutputStream(File file)throws FileNotFoundException

写数据:

1 import java.io.File;

2 import java.io.FileOutputStream;

3 import java.io.IOException;

4 import java.io.OutputStream;

5

6 public class Test11 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建

10         String str="Hello World";

11         byte[] b=str.getBytes();

12         out.write(b);//因为是字节流,所以要转化成字节数组进行输出

13         out.close();

14     }

15 }

也可以一个字节一个字节进行输出,如下:

1 import java.io.File;

2 import java.io.FileOutputStream;

3 import java.io.IOException;

4 import java.io.OutputStream;

5

6 public class Test11 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建

10         String str="Hello World";

11         byte[] b=str.getBytes();

12         for(int i=0;i<b.length;i++){

13             out.write(b[i]);

14         }

15         out.close();

16     }

17 }

以上输出只会进行覆盖,如果要追加的话,请看FileOutputStream类的另一个构造方法:

public FileOutputStream(File file,boolean append)throws FileNotFoundException

在构造方法中,如果将append的值设置为true,则表示在文件的末尾追加内容。

1 import java.io.File;

2 import java.io.FileOutputStream;

3 import java.io.IOException;

4 import java.io.OutputStream;

5

6 public class Test11 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         OutputStream out=new FileOutputStream(f,true);//追加内容

10         String str="\r\nHello World";

11         byte[] b=str.getBytes();

12         for(int i=0;i<b.length;i++){

13             out.write(b[i]);

14         }

15         out.close();

16     }

17 }

文件中换行为:\r\n

字节输入流:InputStream

既然程序可以向文件中写入内容,则就可以通过InputStream从文件中把内容读取进来,首先来看InputStream类的定义:

public abstract class InputStream extends Object implements Closeable

与OutputStream类一样,InputStream本身也是一个抽象类,必须依靠其子类,如果现在是从文件中读取,就用FileInputStream来实现。

观察FileInputStream类的构造方法:

public FileInputStream(File file)throws FileNotFoundException

读文件:

1 import java.io.File;

2 import java.io.FileInputStream;

3 import java.io.IOException;

4 import java.io.InputStream;

5

6 public class Test12 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         InputStream in=new FileInputStream(f);

10         byte[] b=new byte[1024];

11         int len=in.read(b);

12         in.close();

13         System.out.println(new String(b,0,len));

14     }

15 }

但以上方法是有问题的,用不用开辟这么大的一个字节数组,明显是浪费嘛,我们可以根据文件的大小来定义字节数组的大小,File类中的方法:public long length()

1 import java.io.File;

2 import java.io.FileInputStream;

3 import java.io.IOException;

4 import java.io.InputStream;

5

6 public class Test13 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         InputStream in=new FileInputStream(f);

10         byte[] b=new byte[(int) f.length()];

11         in.read(b);

12         in.close();

13         System.out.println(new String(b));

14     }

15 }

我们换种方式,一个字节一个字节读入~

1 import java.io.File;

2 import java.io.FileInputStream;

3 import java.io.IOException;

4 import java.io.InputStream;

5

6 public class Test14 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         InputStream in=new FileInputStream(f);

10         byte[] b=new byte[(int) f.length()];

11         for(int i=0;i<b.length;i++){

12             b[i]=(byte) in.read();

13         }

14         in.close();

15         System.out.println(new String(b));

16     }

17 }

但以上情况只适合知道输入文件的大小,不知道的话用如下方法:

1 import java.io.File;

2 import java.io.FileInputStream;

3 import java.io.IOException;

4 import java.io.InputStream;

5

6 public class Test15 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         InputStream in=new FileInputStream(f);

10         byte[] b=new byte[1024];

11         int temp=0;

12         int len=0;

13         while((temp=in.read())!=-1){//-1为文件读完的标志

14             b[len]=(byte) temp;

15             len++;

16         }

17         in.close();

18         System.out.println(new String(b,0,len));

19     }

20 }

字符流

在程序中一个字符等于两个字节,那么java提供了Reader、Writer两个专门操作字符流的类。

字符输出流:Writer

Writer本身是一个字符流的输出类,此类的定义如下:

public abstract class Writer extends Object implements Appendable,Closeable,Flushable

此类本身也是一个抽象类,如果要使用此类,则肯定要使用其子类,此时如果是向文件中写入内容,所以应该使用FileWriter的子类。

FileWriter类的构造方法定义如下:

public FileWriter(File file)throws IOException

字符流的操作比字节流操作好在一点,就是可以直接输出字符串了,不用再像之前那样进行转换操作了。

写文件:

1 import java.io.File;

2 import java.io.FileWriter;

3 import java.io.IOException;

4 import java.io.Writer;

5

6 public class Test16 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         Writer out=new FileWriter(f);

10         String str="Hello World";

11         out.write(str);

12         out.close();

13     }

14 }

在默认情况下再次输出会覆盖,追加的方法也是在构造函数上加上追加标记

1 import java.io.File;

2 import java.io.FileWriter;

3 import java.io.IOException;

4 import java.io.Writer;

5

6 public class Test17 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         Writer out=new FileWriter(f,true);//追加

10         String str="\r\nHello World";

11         out.write(str);

12         out.close();

13     }

14 }

字符输入流:Reader

Reader是使用字符的方式从文件中取出数据,Reader类的定义如下:

public abstract class Reader extends Objects implements Readable,Closeable

Reader本身也是抽象类,如果现在要从文件中读取内容,则可以直接使用FileReader子类。

FileReader的构造方法定义如下:

public FileReader(File file)throws FileNotFoundException

以字符数组的形式读取出数据:

1 import java.io.File;

2 import java.io.FileReader;

3 import java.io.IOException;

4 import java.io.Reader;

5

6 public class Test18 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         Reader input=new FileReader(f);

10         char[] c=new char[1024];

11         int len=input.read(c);

12         input.close();

13         System.out.println(new String(c,0,len));

14     }

15 }

也可以用循环方式,判断是否读到底:

1 import java.io.File;

2 import java.io.FileReader;

3 import java.io.IOException;

4 import java.io.Reader;

5

6 public class Test19 {

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

8         File f = new File("d:" + File.separator+"test.txt");

9         Reader input=new FileReader(f);

10         char[] c=new char[1024];

11         int temp=0;

12         int len=0;

13         while((temp=input.read())!=-1){

14             c[len]=(char) temp;

15             len++;

16         }

17         input.close();

18         System.out.println(new String(c,0,len));

19     }

20 }

字节流与字符流的区别

字节流和字符流使用是非常相似的,那么除了操作代码的不同之外,还有哪些不同呢?

字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的

字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不close的情况下输出内容

那开发中究竟用字节流好还是用字符流好呢?

在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的,包括图片也是按字节完成,而字符是只有在内存中才会形成的,所以使用字节的操作是最多的。

如果要java程序实现一个拷贝功能,应该选用字节流进行操作(可能拷贝的是图片),并且采用边读边写的方式(节省内存)。

-----------------------------------------------------------------------------------------------------------------------------------

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

为了方便应用计算机,让它可以识别各个国家的文字。

就将各个国家的文字用数字来表示,并一一对应,形成一张表。

ASCII:美国标准信息交换码。

用一个字节的7位可以表示。

ISO8859-1:拉丁码表。欧洲码表

用一个字节的8位表示。

GB2312:中国的中文编码表。

GBK:中国的中文编码表升级,融合了更多的中文文字符号。

GB18030:GBK的取代版本

BIG-5码:通行于台湾、香港地区的一个繁体字编码方案,俗称“大五码”。

Unicode:国际标准码,融合了多种文字。

所有文字都用两个字节来表示,Java语言使用的就是unicode

UTF-8:最多用三个字节来表示一个字符。

UTF-8不同,它定义了一种“区间规则”,这种规则可以和ASCII编码保持最大程度的兼容:

它将Unicode编码为00000000-0000007F的字符,用单个字节来表示

它将Unicode编码为00000080-000007FF的字符用两个字节表示

它将Unicode编码为00000800-0000FFFF的字符用3字节表示

------------------------------------------------------------------------------------------------------------------------------

Ascii码表特殊字符对应的十进制的值

A:65

a:97

0:48

--------------------------------------------------------------------------------------------------------------------------------------------------------

1.ASCII的特点

ASCII 是用来表示英文字符的一种编码规范。每个ASCII字符占用1 个字节,因此,ASCII 编码可以表示的最大字符数是255(00H—FFH)。这对于英文而言,是没有问题的,一般只什么用到前128个(00H--7FH,最高位为0)。而最高位为1 的另128 个字符(80H—FFH)被称为“扩展ASCII”,一般用来存放英文的制表符、部分音标字符等等的一些其它符号。

但是对于中文等比较复杂的语言,255个字符显然不够用。于是,各个国家纷纷制定了自己的文字编码规范,其中中文的文字编码规范叫做“GB2312—80”, 它是和ASCII 兼容的一种编码规范, 其实就是利用扩展ASCII没有真正标准化这一点,把一个中文字符用两个扩展ASCII 字符来表示,以区分ASCII 码部分。

但是这个方法有问题,最大的问题就是中文的文字编码和扩展ASCII 码有重叠。而很多软件利用扩展ASCII 码的英文制表符来画表格,这样的软件用到中文系统中,这些表格就会被误认作中文字符,出现乱码。另外,由于各国和各地区都有自己的文字编码规则,它们互相冲突,这给各国和各地区交换信息带来了很大的麻烦。

2.UNICODE的产生

要真正解决这个问题,不能从扩展ASCII 的角度入手,UNICODE作为一个全新的编码系统应运而生,它可以将中文、法文、德文……等等所有的文字统一起来考虑,为每一个文字都分配一个单独的编码。

3.什么是UNICODE

Unicode与ASCII一样也是一种字符编码方法,它占用两个字节(0000H—FFFFH),容纳65536 个字符,这完全可以容纳全世界所有语言文字的编码。在Unicode 里,所有的字符都按一个字符来处理, 它们都有一个唯一的Unicode 码。

时间: 2024-10-28 20:22:17

字节与字符_字节流与字符流_ASCII与Unicode_GB2312_GBK_GB18030_BIG-5的相关文章

java基础(IO流---字节流、字符流、字节数组流)

字节流: FileInputStream:通过字节的方式读取文件,适合读取所有类型的文件(图像.视频等),全字符请考虑FileReader FileOutputStream:通过字节的方式写出或追加数据到文件,适合所有类型的文件(图像.视频等),全字符请考虑FileWriter 字符流: FileReader :通过字符的方式读取文件,仅适合字符文件 FileWriter :通过字节的方式写出或追加数据到文件中,仅适合字符文件 字节数组流: ByteArrayInputStream:字节数组输入

java IO的字节流和字符流及其区别

1. 字节流和字符流的概念    1.1 字节流继承于InputStream    OutputStream,    1.2 字符流继承于InputStreamReader    OutputStreamWriter.在java.io包中还有许多其他的流,主要是为了提高性能和使用方便. 2. 字节流与字符流的区别    2.1 要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这

字节流与字符流简单操作(OutputStream、InputStream、Writer、Reader)

操作流程 使用File类打开一个文件 通过字节流或者字符流的子类.指定输出的位置. 进行读/写操作 关闭输入/出 字节流与字符流 在java.io包中操作文件内容主要有两大类:字节流字符流.两大类分为输入和输出操作,在字节流中输出数据主要是OutputStream完成,输入使用InputStream,在字符流冲输出主要是使用Writer类完成,输入主要是Reader完成 字节流 字节流主要是操作byte类型数据,以byte数组为准,主要操作类是OutputStream和InputSream 字节

java中字节流与字符流的区别

字节流 在I/O类库中,java.io.InputStream和java.io.OutputStream分别表示字节输入流和字节输出流,它们都是抽象类,不能实例化,数据流中的最小单位是字节,所以叫做字节流. 一.InputStream中的读取数据的方法如下: 1 .int read() 功能:读取一个字节的数据,并且返回读到得数据,如果返回-1,则表示读到输入流的末尾. 2.int read(byte[] b) 功能:从输入流中读取一定量的字节,并将其存储在字节数组b中,返回实际读取的字节数,如

java 字节流与字符流的区别

字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示.下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流. 范例:使用字节流不关闭执行 package org.lxh.demo12.byteiodemo; import java.io.File; import java.io.FileO

字节流与字符流的区别

要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这个抽象描述方式起名为IO流,对应的抽象类为OutputStream和InputStream ,不同的实现类就代表不同的输入和输出设备,它们都是针对字节进行操作的. 在应用中,经常要完全是字符的一段文本输出去或读进来,用字节流可以吗?计算机中的一切最终都是二进制的字节形式存在.对于“中国”这些字符,首先要得到其对应的字节,然后将字

再论流之字节流和字符流

Java定义了两种类型的流:字节流和字符流.字节流为处理字节的输入和输出提供了方法.例如,当读取和写入二进制数据时,使用的就是字节流.字符流为处理字符的输入和输出提供了方便的方法.它们使用Unicode编码,所以可以被国际化.另外一点:在最底层,所有I/O仍然是面向字节的.基于字符的流只是为处理字符提供了一种方便和高效的方法. 字节流类 字节流是通过两个类层次定义的.在顶级是两个抽象类:InputStream和OutputStream.每个抽象类都有几个处理各种不同设备的具体子类. 流类    

文件操作的字节流和字符流

在java.io包中流的操作主要有字节流.字符流两大类,两类都有输入和输出操作.在字节流中输出数据主要使用OutputStream类完成,输入使用的是InputStream类. 在字符流中输出主要是使用Writer类完成,输入主要是使用Reader类完成. 这四个类都是抽象类,使用中需通过子类进行实例化(向上转型),或者直接使用子类进行io操作. 文件操作的字节流 FileOutputStream,FileInputStream.文件操作的字符流 FileWriter,FileReader. 一

java的IO操作:字节流与字符流操作

流的概念 程序中的输入输出都是以流形式,流中保存的实际上都是字节文件. 字节流与字符流 字节流的操作: 1)输入:inputStream, 2)输出:outPutStream; 字符流的操作: 1)输入主要使用:write类. 2)输出主要使用:reader类. 内容操作就四个类. 操作流程: 使用File类操作一定有路径问题,注意分隔符: 实际上四个操作类都是抽象类(区别接口,抽象类的成员都是抽象,并且只能单继承,接口可以有全局变量,但是接口可以多继承) IO操作属于资源操作,对于资源操作,操