字 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
 
 
 
引用类型
 
 
 
 
 
 

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(堆区域)。

写程序时，误把byte写作Byte，调试了许久，便将二者的区别及用法详细理解一遍
 
 
1：byte和Byte详解
 
byte是java的基本数据类型，存储整型数据，占据1个字节(8 bits)，能够存储的数据范围是-128～+127。
 
Byte是java.lang中的一个类，目的是为基本数据类型byte进行封装。
 
2：二者关系：
 
Byte是byte的包装类,就如同Integer和int的关系，
 
一般情况包装类用于泛型或提供静态方法，用于基本类型或字符串之间转换，建议尽量不要用包装类和基本类型之间运算,因为这样运算效率会很差的
 
3：封装的好处
 
封装有几种好处，比如：
 3.1. Byte可以将对象的引用传递，使得多个function共同操作一个byte类型的数据，而byte基本数据类型是赋值之后要在stack(栈区域)进行存储的；
 3.2. 在java中包装类，比较多的用途是用在于各种数据类型的转化中。
 比如，现在byte要转为String
 byte a=0;
 String result=Integer.toString(a);
 3.3使用泛型时
 
 
 
 List<Integer> nums;
 
 
这里<>需要类。如果你用int。它会报错的

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字符串进行解码并返回转换后的值


}