简介：术道并行，从零打造IT知识体系，图文视频同步更新。

本文学习章节：Java基础-02基本数据类型与算法

本文学习内容: Java基本数据类型（八大基础数据结构、引用类型）；Java基本算法（Java运算符：算术运算符、位移运算、关系运算、逻辑运算、三目条件运算符、赋值运环等；Java循环语句；Java条件语句；Java条件分支语句）

本文视频地址：待更新

当前知识体系图谱

绿色：已学习内容。蓝色：本次学习内容

1 Java的数据类型

Java数据类型（type） 包括：基本类型（primitive types）和引用类型（reference types）

Java是一种强类型语言，必须为每个变量声明其类型。在Java中，一共有8种基本类型，其中4种整型，2种浮点类型，1种表示Unicode编码的字符单元的字符类型char，1种用于表示真假值得boolean类型。

1.1 基本类型（primitive types）1.1.1 基本类型简介

基本类型 包括：boolean类型 和 数值类型（numeric types）

数值类型（numeric types）又分为整型（integer types）和 浮点型（floating-point type）

整型有5种：byte、short、int、long、char(char本质上是一种特殊的int)。浮点类型有float 和 double

8种类型表示范围如下：

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。short：16位，最大存储数据量是65536，数据范围是-32768~32767之间。int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。boolean：1位，只有true和false两个取值。char：16位，存储Unicode码，用单引号赋值。1.1.2 基本类型的封装器类

Java每个基本类型都对应着封装类

byte：Byteshort：Shortint：Integerlong：Longfloat：Floatdouble：Doubleboolean：Booleanchar：Character1.1.3 基本类型与其封装类类型比较原始数据类型在传递参数时都是按值传递，封装类是对象，都是按引用传递封装类实际是对象的引用，当new一个封装类时，实际上是生成一个指针指向此对象；而基本类型则是直接存储数据值Java基本类型存储在栈中Integer的默认值是null，int的默认值是0，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，返回数据库字段值是null的话，实体类中用int类型接收的话会报错。int是基本数据类型，其声明的是变量，而null则是对象。所以建议用integerInteger对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了int 和 Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。其它数值类型也是一样。Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱Java语言中，默认声明的小数是double类型的，因此对float类型的变量进行初始化时需要进行类型转换基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较。1.1.4 数据类型转换

byte <（short=char）< int < long < float < double

如果从小转换到大，可以自动完成，而从大到小，必须强制转换。short和char两种相同类型也必须强制转换。

1.2 引用类型（reference types）

引用类型（reference types）包括类（class）、接口（interface）、数组（array）、空（null）

引用类型记住一点，传递参数时是引用传递，以后会继续学习。

2 Java基本算法（参考菜鸟教程）

Java 运算符 - 算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符Java 循环结构 - for, while 及 do...whileJava 条件语句 - if...elseJava switch case 语句

Java的语法主要包含运算符、循环结构、条件语句、分支选择switch语句。接下来我们通过代码一个一个认识这些语法。

2.1 Java运算符2.1.1 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

运算符：

加法（+）：

相加运算符两侧的值：A + B减法（-）：

左操作数减去右操作数：A - B乘法（*）：

相乘操作符两侧的值：A * B除法（/）：

左操作数除以右操作数：A / B取余（％）：

左操作数除以右操作数的余数 ：A ％ B自增（++）：

操作数的值增加1 ：B++ 或 ++BB自增（--）：

操作数的值增加1 ：B-- 或 --BB

示例代码：

public class ArithmeticOperation {    public static void main(String[] args) {        int a = 10;        int b = 20;        int c = 25;        int d = 25;        System.out.println("a + b = " + (a + b) );        System.out.println("a - b = " + (a - b) );        System.out.println("a * b = " + (a * b) );        System.out.println("b / a = " + (b / a) );        System.out.println("b % a = " + (b % a) );        System.out.println("c % a = " + (c % a) );        System.out.println("a++   = " +  (a++) );        System.out.println("a--   = " +  (a--) );        // 查看 d++ 与 ++d 的不同        System.out.println("d++   = " +  (d++) );        System.out.println("++d   = " +  (++d) );    }}

运算结果：

a + b = 30a - b = -10a * b = 200b / a = 2b % a = 0c % a = 5a++   = 10a--   = 11d++   = 25++d   = 27

关系运算符，用于2个操作数的比较，其结果要么为真，要么为假。

运算符：

是否相等（==）：

检查如果两个操作数的值是否相等，如果相等则条件为真。是否不相等（!=）：

检查如果两个操作数的值是否相等，如果值不相等则条件为真。是否大于（>）：

检查左操作数的值是否大于右操作数的值，如果是那么条件为真。是否小于（<）：

检查左操作数的值是否小于右操作数的值，如果是那么条件为真。是否大于等于（>=）：

检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。是否小于等于（<=）：

检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

示例代码：

RelationalOperation {    public static void main(String[] args) {        int a = 10;        int b = 20;        System.out.println("a == b = " + (a == b) );        System.out.println("a != b = " + (a != b) );        System.out.println("a > b = " + (a > b) );        System.out.println("a < b = " + (a < b) );        System.out.println("b >= a = " + (b >= a) );        System.out.println("b <= a = " + (b <= a) );    }}

运算结果：

a == b = falsea != b = truea > b = falsea < b = trueb >= a = trueb <= a = false

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符首先转化为二进制，再按照对应位进行位运算规则计算，由于直接操作位移，效率极高。

运算符:

与（＆）：

如果相对应位都是1，则结果为1，否则为0或（|）：

如果相对应位都是 0，则结果为 0，否则为 1异或（^）：

如果相对应位值相同，则结果为0，否则为1非（〜）：

按位取反运算符翻转操作数的每一位，即0变成1，1变成0。左移（<<）：

将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）"有符号"右移（>>）：

将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1。"无符号"右移（>>>）：

将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制，也就是说，无论值的正负，都在高位补0。

示例代码:

public class BitOperation {    public static void main(String[] args) {        int a = 60; /* 60 = 0011 1100 */        int b = 13; /* 13 = 0000 1101 */        int c = 0;        c = a & b;       /* 12 = 0000 1100 */        System.out.println("a & b = " + c );        c = a | b;       /* 61 = 0011 1101 */        System.out.println("a | b = " + c );        c = a ^ b;       /* 49 = 0011 0001 */        System.out.println("a ^ b = " + c );        c = ~a;          /*-61 = 1100 0011 */        System.out.println("~a = " + c );        c = a << 2;     /* 240 = 1111 0000 */        System.out.println("a << 2 = " + c );        c = a >> 2;     /* 15 = 1111 */        System.out.println("a >> 2  = " + c );        c = a >>> 2;     /* 15 = 0000 1111 */        System.out.println("a >>> 2 = " + c );    }}

运算结果：

a & b = 12a | b = 61a ^ b = 49~a = -61a << 2 = 240a >> 2  = 15a >>> 2 = 15

顾名思义，进行2个操作数的逻辑上的判断。

运算符:

与（&&）：

称为逻辑与运算符。而且仅当两个操作数都为真，条件才为真。或（||）：

称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。非（！）：

称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

示例代码:

public class LogicOperation {    public static void main(String[] args) {        boolean a = true;        boolean b = false;        System.out.println("a && b = " + (a&&b));        System.out.println("a || b = " + (a||b) );        System.out.println("!(a && b) = " + !(a && b));    }}

运算结果：

a && b = falsea || b = true!(a && b) = true

将操作数进行指定的运行后，进行赋值覆盖。

运算符:

赋值（=）：

简单的赋值运算符，将右操作数的值赋给左侧操作数：C = A + B将把A + B得到的值赋给C加和赋值（+ =）：

加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数：C + = A等价于C = C + A减和赋值（- =）：

减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数：C - = A等价于C = C - A乘和赋值（ =）：

乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数：C = A等价于C = C * A除和赋值（/ =）：

除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数：C / = A，C 与 A 同类型时等价于 C = C / A取模和赋值（（％）=）：

取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数：C％= A等价于C = C％A左移位赋值（<< =）：

左移位赋值运算符：C << = 2等价于C = C << 2右移位赋值（>> =）：

右移位赋值运算符：C >> = 2等价于C = C >> 2按位与赋值（＆=）：

按位与赋值运算符：C＆= 2等价于C = C＆2按位异或赋值（^ =）：

按位异或赋值操作符：C ^ = 2等价于C = C ^ 2按位或赋值（| =）：

按位或赋值操作符：C | = 2等价于C = C | 2

示例代码:

public class AssignmentOperators {    public static void main(String[] args) {        int a = 10;        int b = 20;        int c = 0;        c = a + b;        System.out.println("c = a + b = " + c );        c += a ;        System.out.println("c += a  = " + c );        c -= a ;        System.out.println("c -= a = " + c );        c *= a ;        System.out.println("c *= a = " + c );        a = 10;        c = 15;        c /= a ;        System.out.println("c /= a = " + c );        a = 10;        c = 15;        c %= a ;        System.out.println("c %= a  = " + c );        c <<= 2 ;        System.out.println("c <<= 2 = " + c );        c >>= 2 ;        System.out.println("c >>= 2 = " + c );        c >>= 2 ;        System.out.println("c >>= 2 = " + c );        c &= a ;        System.out.println("c &= a  = " + c );        c ^= a ;        System.out.println("c ^= a   = " + c );        c |= a ;        System.out.println("c |= a   = " + c );    }}

运算结果：

c = a + b = 30c += a  = 40c -= a = 30c *= a = 300c /= a = 1c %= a  = 5c <<= 2 = 20c >>= 2 = 5c >>= 2 = 1c &= a  = 0c ^= a   = 10c |= a   = 10

三目条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

运算符：

三目条件运算（?:）：

根据A的结果，若为真则返回B，若为假则返回C： A?B:C

示例代码：

public class ConditionalOperator {    public static void main(String[] args){        int a , b;        a = 10;        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30        b = (a == 1) ? 20 : 30;        System.out.println( "Value of b is : " +  b );        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30        b = (a == 10) ? 20 : 30;        System.out.println( "Value of b is : " + b );    }}

运算结果

Value of b is : 30Value of b is : 20

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

( Object reference variable ) instanceof (class/interface type)

运算符：

类型判断运算（instanceof）：

判断A类型是否是B类型、B类型的实现、B类型的子类。

示例代码：

public class InstanceofOperation {    public static void main(String[] args){        String name = "James";        boolean result1 = name instanceof String; // 由于 name 是 String 类型，所以返回真        System.out.println( result1);        Vehicle a = new Car();        boolean result2 =  a instanceof Car;        System.out.println( result2);        Bar bar = new Bar();        boolean result3 =  bar instanceof Foo;        System.out.println( result3);    }}interface Foo{}class Bar implements Foo{}class Vehicle {}class Car extends Vehicle {}

运算结果：

truetruetrue

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。

实际开发中，应以括号辅助优先级管理。

参考文档：

菜鸟教程：

java运算符优先级记忆口诀