习惯沉淀
Java那些事儿
xgcd Lv2
  2022-11-25 23:12:05   2022-11-26 00:10:11  2.3k Words  9 Mins  

编程的本质，就是对内存中数据的访问和修改。

变量

Java中，变量分为两种：基本类型的变量和引用类型的变量。

基本类型

基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：

  • 整数类型：byte，short，int，long

  • 浮点数类型：float，double

  • 字符类型：char

  • 布尔类型：boolean

Java定义的这些基本数据类型有什么区别呢？要了解这些区别，我们就必须简单了解一下计算机内存的基本结构。

计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从00000000 ~ 11111111，换算成十进制是0 ~ 255，换算成十六进制是00 ~ ff。

内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。

一个字节是1byte，1024字节是1K，1024K是1M，1024M是1G，1024G是1T。一个拥有4T内存的计算机的字节数量就是：

1
2
3
4
5
4T = 4 x 1024G
= 4 x 1024 x 1024M
= 4 x 1024 x 1024 x 1024K
= 4 x 1024 x 1024 x 1024 x 1024
= 4398046511104

不同的数据类型占用的字节数不一样。我们看一下Java基本数据类型占用的字节数：
byte：□
short：□□
int：□□□□
long：□□□□□□□□
float：□□□□
double：□□□□□□□□
char：□□

byte恰好就是一个字节，而long和double需要8个字节。

整型

对于整型类型，Java只定义了带符号的整型，因此，最高位的bit表示符号位（0表示正数，1表示负数）。各种整型能表示的最大范围如下：

  • byte：-128 ~ 127
  • short: -32768 ~ 32767
  • int: -2147483648 ~ 2147483647
  • long: -9223372036854775808 ~ 9223372036854775807

浮点型

浮点类型的数就是小数，因为小数用科学计数法表示的时候，小数点是可以“浮动”的，如1234.5可以表示成12.345x102，也可以表示成1.2345x103，所以称为浮点数。

布尔类型

布尔类型boolean只有true和false两个值，布尔类型总是关系运算的计算结果。
Java语言对布尔类型的存储并没有做规定，因为理论上存储布尔类型只需要1 bit，但是通常JVM内部会把boolean表示为4字节整数。

字符类型

字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符。
注意char类型使用单引号’，且仅有一个字符，要和双引号”的字符串类型区分开。
字符类型char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符：

1
2
char c1 = 'A';
char c2 = '中';

因为Java在内存中总是使用Unicode表示字符，所以，一个英文字符和一个中文字符都用一个char类型表示，它们都占用两个字节。要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可：

1
2
int n1 = 'A'; // 字母“A”的Unicodde编码是65
int n2 = '中'; // 汉字“中”的Unicode编码是20013

还可以直接用转义字符\u+Unicode编码来表示一个字符：

1
2
3
// 注意是十六进制:
char c3 = '\u0041'; // 'A'，因为十六进制0041 = 十进制65
char c4 = '\u4e2d'; // '中'，因为十六进制4e2d = 十进制20013

引用类型

除了上述基本类型的变量，剩下的都是引用类型。例如，引用类型最常用的就是String字符串。引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置。

字符串类型

和char类型不同，字符串类型String是引用类型，我们用双引号”…”表示字符串。一个字符串可以存储0个到任意个字符：

1
2
3
4
String s = ""; // 空字符串，包含0个字符
String s1 = "A"; // 包含一个字符
String s2 = "ABC"; // 包含3个字符
String s3 = "中文 ABC"; // 包含6个字符，其中有一个空格

因为字符串使用双引号”…”表示开始和结束，那如果字符串本身恰好包含一个”字符怎么表示？例如，”abc”xyz”，编译器就无法判断中间的引号究竟是字符串的一部分还是表示字符串结束。这个时候，我们需要借助转义字符\：

1
String s = "abc\"xyz"; // 包含7个字符: a, b, c, ", x, y, z

因为\是转义字符，所以，两个\表示一个\字符：

1
String s = "abc\\xyz"; // 包含7个字符: a, b, c, \, x, y, z

常见的转义字符包括：

  • \“ 表示字符”
  • \‘ 表示字符’
  • \\ 表示字符\
  • \n 表示换行符
  • \r 表示回车符
  • \t 表示Tab
  • \u#### 表示一个Unicode编码的字符
    例如：
    1
    String s = "ABC\n\u4e2d\u6587"; // 包含6个字符: A, B, C, 换行符, 中, 文

不可变特性

Java的字符串除了是一个引用类型外，还有个重要特点，就是字符串不可变。考察以下代码：

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        String s = "hello";
        System.out.println(s); // 显示 hello
        s = "world";
        System.out.println(s); // 显示 world
    }
}

观察执行结果，难道字符串s变了吗？其实变的不是字符串，而是变量s的“指向”。

执行String s = “hello”;时，JVM虚拟机先创建字符串”hello”，然后，把字符串变量s指向它：
s → “hello”
紧接着，执行s = “world”;时，JVM虚拟机先创建字符串”world”，然后，把字符串变量s指向它：
s → “world”

原来的字符串”hello”还在，只是我们无法通过变量s访问它而已。因此，字符串的不可变是指字符串内容不可变。至于变量，可以一会指向字符串”hello”，一会指向字符串”world”。

空值null

引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。例如：

1
2
3
String s1 = null; // s1是null
String s2 = s1; // s2也是null
String s3 = ""; // s3指向空字符串，不是null

注意要区分空值null和空字符串””，空字符串是一个有效的字符串对象，它不等于null。

常量

定义变量的时候，如果加上final修饰符，这个变量就变成了常量。
常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。

var关键字

有些时候，类型的名字太长，写起来比较麻烦。例如：

1
StringBuilder sb = new StringBuilder();

这个时候，如果想省略变量类型，可以使用var关键字：

1
var sb = new StringBuilder();

编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：

1
var sb = new StringBuilder();

实际上会自动变成：

1
StringBuilder sb = new StringBuilder();

因此，使用var定义变量，仅仅是少写了变量类型而已。

流程控制

break和continue

无论是while循环还是for循环，有两个特别的语句可以使用，就是break语句和continue语句。

break

在循环过程中，可以使用break语句跳出当前循环。我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1; ; i++) {
            sum = sum + i;
            if (i == 100) {
                break;
            }
        }
        System.out.println(sum);
    }
}

使用for循环计算从1到100时，我们并没有在for()中设置循环退出的检测条件。但是，在循环内部，我们用if判断，如果i==100，就通过break退出循环。

因此，break语句通常都是配合if语句使用。要特别注意，break语句总是跳出自己所在的那一层循环。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
    public static void main(String[] args) {
        for (int i=1; i<=10; i++) {
            System.out.println("i = " + i);
            for (int j=1; j<=10; j++) {
                System.out.println("j = " + j);
                if (j >= i) {
                    break;
                }
            }
            // break跳到这里
            System.out.println("breaked");
        }
    }
}

上面的代码是两个for循环嵌套。因为break语句位于内层的for循环，因此，它会跳出内层for循环，但不会跳出外层for循环。

continue

break会跳出当前循环，也就是整个循环都不会执行了。而continue则是提前结束本次循环，直接继续执行下次循环。我们看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1; i<=10; i++) {
            System.out.println("begin i = " + i);
            if (i % 2 == 0) {
                continue; // continue语句会结束本次循环
            }
            sum = sum + i;
            System.out.println("end i = " + i);
        }
        System.out.println(sum); // 25
    }
}

注意观察continue语句的效果。当i为奇数时，完整地执行了整个循环，因此，会打印begin i=1和end i=1。在i为偶数时，continue语句会提前结束本次循环，因此，会打印begin i=2但不会打印end i = 2。

在多层嵌套的循环中，continue语句同样是结束本次自己所在的循环。

 Comments
Comment plugin failed to load
Loading comment plugin
  1. 变量
    1. 基本类型
      1. 整型
      2. 浮点型
      3. 布尔类型
      4. 字符类型
    2. 引用类型
      1. 字符串类型
        1. 不可变特性
      2. 空值null
  2. 常量
  3. var关键字
  4. 流程控制
    1. break和continue
      1. break
      2. continue
  1. 变量
    1. 基本类型
      1. 整型
      2. 浮点型
      3. 布尔类型
      4. 字符类型
    2. 引用类型
      1. 字符串类型
        1. 不可变特性
      2. 空值null
  2. 常量
  3. var关键字
  4. 流程控制
    1. break和continue
      1. break
      2. continue