字节与字符_字节流与字符流_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
写数据：
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f);//假设文件不存在会自己主动创建
String str="Hello World";
byte[] b=str.getBytes();
out.write(b);//由于是字节流，所以要转化成字节数组进行输出
out.close();
}
}
也能够一个字节一个字节进行输出，例如以下：
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f);//假设文件不存在会自己主动创建
String str="Hello World";
byte[] b=str.getBytes();
for(int i=0;i<b.length;i++){
out.write(b[i]);
}
out.close();
}
}
以上输出仅仅会进行覆盖，假设要追加的话，请看FileOutputStream类的还有一个构造方法：
public FileOutputStream(File file,boolean append)throws FileNotFoundException
在构造方法中。假设将append的值设置为true，则表示在文件的末尾追加内容。
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f,true);//追加内容
String str="\r\nHello World";
byte[] b=str.getBytes();
for(int i=0;i<b.length;i++){
out.write(b[i]);
}
out.close();
}
}
文件里换行为：\r\n
字节输入流：InputStream
既然程序能够向文件里写入内容，则就能够通过InputStream从文件里把内容读取进来，首先来看InputStream类的定义：
public abstract class InputStream extends Object implements Closeable
与OutputStream类一样，InputStream本身也是一个抽象类。必须依靠其子类，假设如今是从文件里读取，就用FileInputStream来实现。
观察FileInputStream类的构造方法：
public FileInputStream(File file)throws FileNotFoundException
读文件：
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test12 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int len=in.read(b);
in.close();
System.out.println(new String(b,0,len));
}
}
但以上方法是有问题的。用不用开辟这么大的一个字节数组，明显是浪费嘛，我们能够依据文件的大小来定义字节数组的大小。File类中的方法：public long length()
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test13 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int) f.length()];
in.read(b);
in.close();
System.out.println(new String(b));
}
}
我们换种方式，一个字节一个字节读入~
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test14 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int) f.length()];
for(int i=0;i<b.length;i++){
b[i]=(byte) in.read();
}
in.close();
System.out.println(new String(b));
}
}
但以上情况仅仅适合知道输入文件的大小。不知道的话用例如以下方法：
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test15 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int temp=0;
int len=0;
while((temp=in.read())!=-1){//-1为文件读完的标志
b[len]=(byte) temp;
len++;
}
in.close();
System.out.println(new String(b,0,len));
}
}
字符流
在程序中一个字符等于两个字节，那么java提供了Reader、Writer两个专门操作字符流的类。
字符输出流：Writer
Writer本身是一个字符流的输出类，此类的定义例如以下：
public abstract class Writer extends Object implements Appendable，Closeable，Flushable
此类本身也是一个抽象类，假设要使用此类，则肯定要使用其子类，此时假设是向文件里写入内容，所以应该使用FileWriter的子类。
FileWriter类的构造方法定义例如以下：
public FileWriter(File file)throws IOException
字符流的操作比字节流操作好在一点。就是能够直接输出字符串了。不用再像之前那样进行转换操作了。
写文件：
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Test16 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Writer out=new FileWriter(f);
String str="Hello World";
out.write(str);
out.close();
}
}
在默认情况下再次输出会覆盖，追加的方法也是在构造函数上加上追加标记
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Test17 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Writer out=new FileWriter(f,true);//追加
String str="\r\nHello World";
out.write(str);
out.close();
}
}
字符输入流：Reader
Reader是使用字符的方式从文件里取出数据，Reader类的定义例如以下：
public abstract class Reader extends Objects implements Readable，Closeable
Reader本身也是抽象类。假设如今要从文件里读取内容，则能够直接使用FileReader子类。
FileReader的构造方法定义例如以下：
public FileReader(File file)throws FileNotFoundException
以字符数组的形式读取出数据：
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Test18 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Reader input=new FileReader(f);
char[] c=new char[1024];
int len=input.read(c);
input.close();
System.out.println(new String(c,0,len));
}
}
也能够用循环方式，推断是否读究竟：
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Test19 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Reader input=new FileReader(f);
char[] c=new char[1024];
int temp=0;
int len=0;
while((temp=input.read())!=-1){
c[len]=(char) temp;
len++;
}
input.close();
System.out.println(new String(c,0,len));
}
}
字节流与字符流的差别
字节流和字符流使用是很相似的，那么除了操作代码的不同之外，还有哪些不同呢？
字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的。而字符流在操作的时候是使用到缓冲区的
字节流在操作文件时，即使不关闭资源（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：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 码。
最新文章
- ppp数据帧的格式
- SpinEdit
- liunx之：wps for liunx的安装经验
- Android 实现切换主题皮肤功能（类似于众多app中的 夜间模式，主题包等）
- pl/sql的工具导入和代码导入
- 刷入临时recovery
- java开发经验分享（三）
- Palindrome Linked List 解答
- POJ1185 炮兵阵地 状态压缩
- tomcat的自我理解与使用心得
- PHP模板解析类实例
- pyqt系列原创入门教程
- CROS跨域请求处理
- python脚本对 mysql数据库进行增删改查操作
- 用tar命令把目标压缩包解压到指定位置
- 初步了解redux
- 在Win32程序中嵌入Edge浏览器组件
- LeetCode算法题-Intersection of Two Arrays（Java实现-四种解法）
- Spark SQL 之 Join 实现
- Android Studio复制项目作为一个新的工程