字 word

字节 byte

位 bit，来自英文bit，音译为“比特”，表示二进制位。

字长是指字的长度

1字=2字节(1 word = 2 byte)

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

 

一个字的字长为16

一个字节的字长是8

bps 是 bits per second 的简称。一般数据机及网络通讯的传输速率都是以「bps」为单位。如56Kbps、100.0Mbps 等等。

Bps即是Byte per second 的简称。而电脑一般都以Bps 显示速度，如1Mbps 大约等同 128 KBps。

bit 电脑记忆体中最小的单位，在二进位电脑系统中，每一bit 可以代表0 或 1 的数位讯号。

Byte一个Byte由8 bits 所组成，可代表一个字元(A~Z)、数字(0~9)、或符号(,.?!%&+-*/)，是记忆体储存资料的基本单位，至於每个中文字则须要两Bytes。当记忆体容量过大时，位元组这个单位就不够用，因此就有千位元组的单位KB出现，以下乃个记忆体计算单位之间的相关性：

1 Byte = 8 Bits

1 KB = 1024 Bytes

1 MB = 1024 KB

1 GB = 1024 MB

usb2.0标准接口传输速率。许多人都将“480mbps”误解为480兆/秒。其实，这是错误的，事实上“480mbps”应为“480兆比特/秒”或“480兆位/秒”，它等于“60兆字节/秒”，大家看到差距了吧。

这要从bit和byte说起：bit和byte同译为"比特"，都是数据量度单位，bit=“比特”或“位”。

byte=字节即1byte=8bits,两者换算是1：8的关系。

mbps=mega bits per second(兆位/秒)是速率单位，所以正确的说法应该是说usb2.0的传输速度是480兆位/秒,即480mbps。

mb=mega bytes(兆比、兆字节)是量单位，1mb/s（兆字节/秒）=8mbps（兆位/秒）。

我们所说的硬盘容量是40gb、80gb、100gb，这里的b指是的byte也就是“字节”。

1 kb = 1024 bytes =2^10 bytes

1 mb = 1024 kb = 2^20 bytes

1 gb = 1024 mb = 2^30 bytes

比如以前所谓的56kb的modem换算过来56kbps除以8也就是7kbyte，所以真正从网上下载文件存在硬盘上的速度也就是每秒7kbyte。

也就是说与传输速度有关的b一般指的是bit。

与容量有关的b一般指的是byte。

最后再说一点: usb2.0 480mbps=60mb/s的传输速率还只是理论值，它还要受到系统环境的制约（cpu、硬盘和内存等），其实际读、取写入硬盘的速度约在11～16mb/s。但这也比usb1.1的12mbps(1.5m/s)快了近10倍。

扩展阅读

字节的来由

最开始计算机只是处理数据运算，也就是0-9，加上运算符号，4bit足够了。举个例子(实际不是这样):用0000表示0，0001表示1，0010表示2，依次类推。 

后来加入了字母，程序符号等，8bit也足够了，而这时诞生了ASCII编码的标准，大家就说把8bit表示出来的值叫做字节(byte)吧，于是就有了字节这个单位。 

所以1byte等于8bit是计算机发展中的一个约定出来的规则。

汉字：

1 汉字 = 2 byte = 16 bit （这里不是很准确，当编码不同的时候，1个汉字所占的字节数也会有所不同，有些编码是占 2个字节，有些则不是，可能是 3个或者 4个）



Java的八大基本数据类型

 
			
 
			
 
			
 
			
字节
			
内存
			
取值范围
		
数据类型
			

			
基本数据类型

			
、

			
内置类型

			
 
			
			
整数类型
			
byte（字节型）
			
1
			
8位
			

			
-128~127

			
（-2^7 ~2^7 -1） 
			
		
short（短整型）
			
2
			
16位
			

			
-32768~32767

			
（-2^15~2^15-1）
			
		
int（整型）
			
4
			
32位
			

			
-2147483648~2147483647

			
（-2^31~2^31-1）
			
		
long（长整型）
			
8
			
64位
			

			
-9223372036854774808~9223372036854774807

			
（-2^63~2^63-1）
			
		
浮点类型
			
float（单精度型）
			
4
			
 
			
 
		
double（双精度类型）
			
8
			
 
			
 
		

			
字符类型

			
 
			
			
char
			
1
			
 
			
 
		
布尔类型
			
boolean
			
1
			
 
			
 
		
 
			
引用类型
			
 
			
 
			
 
			
 
			
 
		
 

Byte类型的缓存值和Short、Integer、Long一样都是-128 ~ 127
public final class Byte extends Number implements Comparable<Byte> {
    @java.io.Serial
    private static final long serialVersionUID = -7183698231559129828L;
    public static final byte   MIN_VALUE = -128;            // 缓存最小值
    public static final byte   MAX_VALUE = 127;             // 缓存最大值
    public static final int SIZE = 8;                       // 一个byte占8位
    public static final int BYTES = SIZE / Byte.SIZE;       // 占8/8=1个字节
    private final byte value;                               // 存储数据的成员变量
    @SuppressWarnings("unchecked")
    public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte"); 

    /**
     * -128到127的值会被缓存
     */
    private static class ByteCache {
        private ByteCache() {}
        static final Byte[] cache;
        static Byte[] archivedCache;
        static {
            final int size = -(-128) + 127 + 1;// 总共256
            VM.initializeFromArchive(ByteCache.class);
            if (archivedCache == null || archivedCache.length != size) {
                Byte[] c = new Byte[size];
                byte value = (byte)-128;
                for(int i = 0; i < size; i++) {
                    c[i] = new Byte(value++); // 将-128到127的值存入数组中
                }
                archivedCache = c;
            }
            cache = archivedCache;
        }
    }

    /**
     * 构造方法
     */
    @Deprecated(since="9")
    public Byte(byte value) {}
    @Deprecated(since="9")
    public Byte(String s) throws NumberFormatException {} // 传入10进制的字符串s进行转换

    /**
     * byte转其它类型数据
     */
    @HotSpotIntrinsicCandidate
    public byte byteValue() {}                  // 返回byte值
    public short shortValue() {}                // 返回short类型的值
    public int intValue() {}                    // 返回int类型的值
    public float floatValue() {}                // 返回float类型的值
    public long longValue() {}                  // 返回long类型的值
    public double doubleValue() {}              // 返回double类型的值
    public boolean equals(Object obj) {}        // 判断当前值和obj是否相等
    public int compareTo(Byte anotherByte) {}   // 比较当前值和anotherByte的大小
    public String toString() {}                 // 将当前值转换成字符串
    public int hashCode() {}                    // 当前值的hash值


    /**
     * 静态方法
     */
    @HotSpotIntrinsicCandidate
    public static Byte valueOf(byte b) {}                   // 将b封装为Byte
    public static int hashCode(byte value) {}               // value的hash值
    public static String toString(byte b) {}                // 转换为字符串
    public static int compare(byte x, byte y) {}            // 比较x，y的大小
    public static int compareUnsigned(byte x, byte y) {}    // 比较无符号x，y的大小
    public static int toUnsignedInt(byte x) {}              // 转换为无符号int值
    public static long toUnsignedLong(byte x) {}            // 转换为无符号long值
    public static byte parseByte(String s) throws NumberFormatException {}          // 按默认10进制解析字符串s为byte数据
    public static byte parseByte(String s, int radix) throws NumberFormatException{}// 按照radix进制，解析字符串s
    public static Byte valueOf(String s, int radix) throws NumberFormatException {} // 将字符串按照radix进制转换并返回
    public static Byte valueOf(String s) throws NumberFormatException {}            // 将字符串按照10进制转换并返回
    public static Byte decode(String nm) throws NumberFormatException {}            // 将nm字符串进行解码并返回转换后的值


}

java的基本数据类型中有byte这种，byte存储整型数据，占据1个字节(8 bits)，能够存储的数据范围是-128～+127。
Byte是java.lang中的一个类，目的是为基本数据类型byte进行封装。封装有几种好处。比如：1. Byte可以将对象的引用传递，使得多个function共同操作一个byte类型的数据，而byte基本数据类型是赋值之后要在stack(栈区域)进行存储的；2. 定义了和String之间互相转化的方法。Byte的大小是8个字节。因为Byte是需要通过关键字new来申请对象，而此部分申请出来的对象放在内存的heap(堆区域)。

‘utf-8’ codec can’t decode byte 0xff in position 0: invalid start byte
觉得有用的话,欢迎一起讨论相互学习~


今天使用语句
image_raw_data_jpg = tf.gfile.FastGFile('../test_images/test_1.jpg', 'r').read()

读取图片文件的时候遇到了以下问题:
'utf-8' codec can't decode byte 0xff in position 0: invalid start byte

原因:
0x92 即 10010010，UTF8 中编码一个字符的第一个字节（start byte）只可能是 0xxxxxxx、110xxxxx、1110xxx、11110xxx……而后面的字节只可能是 10xxxxxx。也就是说 0x92 只能作为后面的字节，却出现在了第一个字节的位置。
出现这种问题绝大部分情况是因为文件不是 UTF8 编码的（例如，可能是 GBK 编码的），而系统默认采用 UTF8 解码。解决方法是改为对应的解码方式。
极少数情况是因为文件损坏了或者和一部分非 UTF8 编码混在一起，可以修复文件或采用 replace 等方式解码。
解决方案
将’r’改为’rb’的形式,即:
image_raw_data_jpg = tf.gfile.FastGFile('../test_images/test_1.jpg', 'rb').read()

参考文献:

https://segmentfault.com/q/1010000004268196