技术贴
运算符&表达式
运算符其实就是一些符号（eg:+ - * /）
表达式
用运算符连接起来的一些式子，成为表达式。如果用算术运算符连接起来，就是算术表达式

1. 算术运算符
+ - * / %
整数相除结果只能是整数
%取余，结果是余数

字符相+
先把自己转换成int值，然后再运算，转换时的原则：按照其在计算机底层的存储值进行转换
'A'        65
'a'        97
'0'        48
自动类型提升：
基本数据类型（boolean除外）进行算术运算时，会有自动类型提升：
a. byte、short、char参与运算时，会自动转换成int类型，然后再进行运算
b. 在算术表达式中，讲数据类型转换成参与运算的所有数据中的最高级别。
（byte/short/char<int<long<float<double）

字符串相+

其实就是字符串的拼接
从左往右依次执行，在遇到字符串之前，会找原有的规则进行运算。
如果遇到了字符串，就开始进行字符串拼接。

自增/自减运算符
++/--        变量增加/减少1
使用：
单独使用        在前或在后，对运算结果没有影响
参与运算
自增或自减在前，先进行自增减然后再参与其他运算
自增或自减在后，先进行其他运算，然后再进行自增减
2.赋值运算符 =
3.
int i = 10;        //将10赋值给int类型的变量i
i = i + 20;        //将i的值加上20之后，重新赋值给变量i

复合赋值运算符
+=、-=、*=、/=、%=

i += 10;  //在结果上等同于i = (i的类型)(i +10);
一般不建议使用强转，建议使用复合赋值运算符
3.关系运算符
关系表达式的结果只能是boolean类型，也就是只能是true或者false
==、>、<、>=、<=、!=

不要将==错写成了=
System.out.println(i=j+k),把j的值赋值给变量i，并且输出

4. 逻辑运算符
连接了两个及以上的关系表达式
&、|、^、!
& 与        并且        只要有false，结果就是false，同时为true，结果才是true
| 或        或者        只要有true，结果就是true；同时为false，结果才是false
^a异或        男女关系        相同为false，不同为true
! 非        否定        !true = false, !false=true; !!true = true;

短路逻辑运算符
&&        短路与        只要遇到false，后面的关系表达式便不执行
||        短路或        只要遇到true，后面的关系表达式便不执行

工作中常用的是 &&、||、!


5. 三元运算符
格式：关系表达式 ? 表达式1 : 表达式2
示例： a > b ? c : d
执行流程：
判断关系表达式的值
如果该值为true，三元表达式的值就是表达式1的值
如果该值为false，三元表达式的值就是表达式2的值
求两个数据中，较大的数值
变量类型 max = a > b ? a : b;




6. 键盘录入的三个步骤
导包                import java.util.Scanner;
创建对象        Scanner sc = new Scanner(System.in);
接收数据        int i = sc.nextInt();


7. if语句格式1
if(关系表达式){
语句体
}
执行流程
1. 判断关系表达式的值
2. 如果关系表达式的值为true，就执行语句体，然后继续执行后面的其他代码
3. 如果关系表达式的值为false，就不执行语句体，接续执行后面的其他代码

8. if语句格式2
if(关系表达式){
语句体1;
} else {
语句体2;
}

执行流程：
1. 判断关系表达式的值
2. 如果关系表达式的值是true，执行语句体1，然后继续执行后面的其他代码
3. 如果关系表达式的值是false，执行语句体2，然后继续执行后面的其他代码


9. if语句格式3
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}
……
else{
语句体n+1;
}

执行流程
1. 判断关系表达式1的值，如果是true，就执行语句体1；
2. 如果为false，就继续判断关系表达式2的值，如果关系表达式2的值是true，就执行语句体2；
3. ……
4. 只要有一个关系表达式的值是true，就执行对应的语句体
5. 如果所有的关系表达式的值都是false，就执行else里面的语句体n+1
1. switch
        语句格式：
        switch(表达式){
                case 值1:
                        语句1;
                        break；
                case 值2:
                        语句2;
                        break；
                ……
               
                default:
                        语句n+1;
                        [break;]
        }
       
        表达式结果的类型：byte、short、char、int、枚举、String
       
        执行流程：
                计算表达式的值，然后从上往下和各个case后面的值进行比对，只要发现相同，就执行该case的语句，遇到break，switch语句结束；如果所有的case都不匹配，执行default的语句。
               
        case穿透
                如果某个case内没有break，在执行该case内语句后，并不会再次判断后面case的值是否匹配；
                而是直接执行后面case中的语句，直到遇到break或者语句结束。
               
        1. 星期的案例
       
        2. 春夏秋冬的案例
                case 1:
                case 2:
                case 12:
                        System.out.println("冬天");
                        break;
       

2. 循环结构可以通过
        for        while        do…while
        实现

3. for循环结构
        格式：
        for(①初始化语句; ②条件判断语句; ③条件控制语句){
                ④循环体语句;
        }

        执行流程：
        1. 执行初始化
        2. 执行条件判断语句，如果结果是true，就执行循环体语句；如果是false，for循环结束
        3. 执行条件控制语句，再次执行条件判断语句，重复第二步骤。

        ①②④③…②④③直到②的结果是false就结束

4. 案例练习：
        for循环的案例
        a. 输出1-5案例
        for(int i = 1; i <= 5 ; i++){
                System.out.println(i);
        }

        b. 求1-5的和，求和思想（或累加思想）
        int sum 记录数据的和
       
        int sum = 0;
        for(int i = 1; i <= 5 ; i++){
                //sum = sum + i;
                sum += i;
        }

        c. 求1-100以内的偶数和
        int sum = 0;
        for(int i = 1; i <= 100 ; i++){
                if(i % 2 == 0){
                        sum += i;
                }
        }

        d. 水仙花数
        求三位数每位上的值
        个位ge：i%10
        十位shi：i / 10 % 10
        百位bai：i / 100 % 10
       
        for(i = 100 ; i < 1000 ; i++){
                if(ge * ge * ge + shi * shi * shi + bai * bai * bai == i){
                        System.out.println(i);
                }
        }

        e. 水仙花数
        求三位数每位上的值
        个位ge：i%10
        十位shi：i / 10 % 10
        百位bai：i / 100 % 10
       
        计数器 int count = 0;

        for(i = 100 ; i < 1000 ; i++){
                if(ge * ge * ge + shi * shi * shi + bai * bai * bai == i){
                        count++;
                }
        }
       

4. while循环
        基本格式：
        while(条件判断语句){
                循环体语句;
        }

        完整格式：
        初始化语句①;
        while(条件判断语句②){
                循环体语句③;
                条件控制语句④;
        }

        执行流程（基于完整格式）：
       
        ① ②③④ ②③④ ②③④
        1. 执行初始化语句
        2. 执行条件判断语句
                结果为false，while循环结束；
                结果为true，执行while循环体语句
        3. 执行条件控制语句
        4. 重新执行第二步，直到条件判断语句的结果为false。

        案例练习：珠穆朗玛峰，折叠多少次以后可以超过珠穆朗玛峰：
       
        int count = 0;

        double paper = 0.1;
        while(paper < 8844430){
                count++;
                paper = paper *2;
        }
       
5. do…while
        基本格式：
        do{
                循环体语句;
        }while(条件判断语句);
       
        完整格式：
        初始化语句①;
        do{
                循环体语句③;
                条件控制语句④;
        }while(条件判断语句②);
       
       
        执行流程：       
                1. 初始化语句①
                2. 直接执行循环体语句③;
                3. 条件控制语句④;
                4. 执行条件判断语句，
                        如果结果是false，循环结束
                        如果结果是true，继续执行第二步
                       
                ① ③④② ③④② ③④②
               
6. 三种循环语句的区别
        1. for、while先进行条件判断语句，然后再执行循环体
           do…while先执行一次循环体，然后再进行判断。最少执行一次循环体
       
        2. for和while的区别
                for控制循环的变量在循环结束以后，无法继续使用
                while循环的控制变量在循环结束以后，可以继续使用
               
        3. 死循环
                for(;;){}
                while(true){}
                do{}while(true);
               
        4. 使用
                一般情况下选择for循环
                死循环选择while(true)
               
        5.break和continue
                break结束整个循环（还可以用在switch语句中）
                continue，结束本次循环，继续下一次循环
        6. 循环嵌套
                for(外层初始化语句;外层条件判断语句;外层条件控制语句){
                        //下面内容就是外层的循环体语句
                        for(内层初始化语句;内层条件判断语句;内层条件控制语句){
                                内层循环体语句;
                        }
                }
7. Random        随机数生成器
                使用分三步
                1. 导包 import java.util.Random;
                2. 创建对象 Random r = new Random();
                3. 生成随机数 int i = r.nextInt(n);
               
                生成随机数的范围是 [0,n)，包左不包右。
               
                生成1-100的一个随机整数： r.nextInt(100)+1
               
        猜数字
                Scanner、Random、while、if…else if、break
1. 数组
        a 概念：存储多个同一类型数据的容器（内存空间）
        b 格式：数据类型[] 变量名;（不推荐：数据类型 变量名[]）
         
       
        c 数组的初始化
        数据需要先初始化后使用（变量也是一样）
        初始化的工作：
                a). 开辟内存空间
                b). 为数组中元素赋值
       
        数组初始化方式：
                a) 动态初始化(指定数组长度)
                b) 静态初始化(不指定数组长度，)
               
        动态初始化就是只给定数组的长度，元素的初始化交给系统默认处理。
       
        动态初始化格式：
                数据类型[] 变量名 = new 数据类型[n];
                左边：
                        数据类型        存储在这个数组中元素的类型
                        []                        表示这是一个数组
                        变量名                数组的名字
                       
                右边：
                        new                        申请内存空间
                        数据类型        存储在这个数组中元素的类型
                        []                        表示这是一个数组
                        n                        数组长度，是一个int值
               
                       
                        int[] arr = new int[3];

        d 数组的使用：直接输出
       
        直接输出数组
        [I@1e643faf
                [        表示是数组
                [[        表示是二维数组
                I        数组中元素的类型
                1e643faf        通过地址等信息算出来的一个数值（十六进制hash值）
       
       
        [Ljava.lang.String;@6e8dacdf
                [        表示是数组
                [[        表示是二维数组       
                L        数组中元素的类型是引用数据类型
                java.lang.String;        数组中元素的类型（完整类名）
                6e8dacdf        通过地址等信息算出来的一个数值（十六进制hash值）
        特例：char[]                                   直接输出char[]，结果与上面的不同，会输出一个字符串，字符串内容是字符数组中的内容拼接而成
       
        e 数组的使用：输出/获取数组中的每一个元素
                索引：索引就是一个整型的编号，用来获取数组中的每一个元素
                索引的使用方法/数组中元素的获取方法：
                        数组名[索引]
                索引特性：
                        1. 从0开始的整数
                        2. 连续
                        3. 索引每次递增1
       
                int数组中元素的默认值都是0
               
               
               
        f 内存图解1
       
        左面的内存区域是 栈内存       
        右面的内存区域是 堆内存
       

       
       
       
        局部变量
                写在一对大括号({}，类除外)里面的变量，称为局部变量。
                int[] arr 写在main方法里面 就是局部变量
                局部变量存储在栈内存中
                在main方法结束以后，该局部变量会立即消失
               
        对象
                通过new出来的称之为对象
                对象存在堆内存中，使用完以后不会立即消失（被回收）
                等垃圾回收器空闲时在合适的时间回收。
                在堆里面的数据都有默认的初始化值
                整型                                        0
                浮点型                                        0.0
                布尔类型                                false
                字符                                        空字符
                引用类型(包括String)        null
        建立关系
                对象开辟内存空间并且初始化之后，会把自己空间的地址值给到指向自己的变量（该变量存储在栈内存中）
               
        直接使用数组变量
                如果直接输出arr（局部变量），输出的实际是arr指向的对象的地址值（该对象在堆里面的地址值）
               
        操作数组中的每个元素
                arr[i]
                首先找到栈里面的arr，arr指向的是堆内存中的某个地址。
                找到该地址以后，会根据索引[i]找到对应的元素，找到以后可以进行赋值/读取等操作。
       
        g 内存图解2
                两个不同的int数组类型的变量，指向了同一个int数组对象
                通过任意一个变量，均可操作数组对象内的元素。
       
               
               
               
               
2. 数组大厂面试题实战（百度）
        在一个数组中，某一个元素出现的次数>length/2，请用程序获取数组中的该数字。
        {1,2,6,1,5,1,3,1,1}
        1. 遍历数组，统计每个元素出现的次数，如果某个元素出现次数大于长度的一半。
       
        2. 排序
                从小到大排序 结果是 1 1 1 1 1 2 3 5 6    6 5 3 2 1 1 1 1 1

                1 1 1 1 1  3 5 6    6 5 3  1 1 1 1 1
               
                对数组进行排序，获取数组中索引为length/2的元素，即为该数字
               
               
        3. 火拼
               
                1 1 1 1 1  3 5 6
                {1,6,1,1,1,3,1,5}
               
                第一个元素上场前
                场上目前胜利的帮派/某个值winner = 0;
                场上有的人数/元素数量count = 0;
               
                第一元素1上场后
                winner = 1;
                count = 1;
               
                第二个元素6上场后
                winner = 0;
                count = 0;
               
                第三元素1上场后
                winner = 1;
                count = 1;
               
                第四个元素1上场后
                winner = 1;
                count = 2;
                ……
               
               
                上场 看count == 0
                        是 winer = 自己
                           count++
                          
                        否
                                看是不是自己人
                                        是winner==自己       
                                                count++
                                                //winer=自己
                                        否 count--

技术贴
运算符&表达式
运算符其实就是一些符号（eg:+ - * /）
表达式
用运算符连接起来的一些式子，成为表达式。如果用算术运算符连接起来，就是算术表达式

1. 算术运算符
+ - * / %
整数相除结果只能是整数
%取余，结果是余数

字符相+
先把自己转换成int值，然后再运算，转换时的原则：按照其在计算机底层的存储值进行转换
'A'        65
'a'        97
'0'        48
自动类型提升：
基本数据类型（boolean除外）进行算术运算时，会有自动类型提升：
a. byte、short、char参与运算时，会自动转换成int类型，然后再进行运算
b. 在算术表达式中，讲数据类型转换成参与运算的所有数据中的最高级别。
（byte/short/char<int<long<float<double）

字符串相+

其实就是字符串的拼接
从左往右依次执行，在遇到字符串之前，会找原有的规则进行运算。
如果遇到了字符串，就开始进行字符串拼接。

自增/自减运算符
++/--        变量增加/减少1
使用：
单独使用        在前或在后，对运算结果没有影响
参与运算
自增或自减在前，先进行自增减然后再参与其他运算
自增或自减在后，先进行其他运算，然后再进行自增减
2.赋值运算符 =
3.
int i = 10;        //将10赋值给int类型的变量i
i = i + 20;        //将i的值加上20之后，重新赋值给变量i

复合赋值运算符
+=、-=、*=、/=、%=

i += 10;  //在结果上等同于i = (i的类型)(i +10);
一般不建议使用强转，建议使用复合赋值运算符
3.关系运算符
关系表达式的结果只能是boolean类型，也就是只能是true或者false
==、>、<、>=、<=、!=

不要将==错写成了=
System.out.println(i=j+k),把j的值赋值给变量i，并且输出

4. 逻辑运算符
连接了两个及以上的关系表达式
&、|、^、!
& 与        并且        只要有false，结果就是false，同时为true，结果才是true
| 或        或者        只要有true，结果就是true；同时为false，结果才是false
^a异或        男女关系        相同为false，不同为true
! 非        否定        !true = false, !false=true; !!true = true;

短路逻辑运算符
&&        短路与        只要遇到false，后面的关系表达式便不执行
||        短路或        只要遇到true，后面的关系表达式便不执行

工作中常用的是 &&、||、!


5. 三元运算符
格式：关系表达式 ? 表达式1 : 表达式2
示例： a > b ? c : d
执行流程：
判断关系表达式的值
如果该值为true，三元表达式的值就是表达式1的值
如果该值为false，三元表达式的值就是表达式2的值
求两个数据中，较大的数值
变量类型 max = a > b ? a : b;




6. 键盘录入的三个步骤
导包                import java.util.Scanner;
创建对象        Scanner sc = new Scanner(System.in);
接收数据        int i = sc.nextInt();


7. if语句格式1
if(关系表达式){
语句体
}
执行流程
1. 判断关系表达式的值
2. 如果关系表达式的值为true，就执行语句体，然后继续执行后面的其他代码
3. 如果关系表达式的值为false，就不执行语句体，接续执行后面的其他代码

8. if语句格式2
if(关系表达式){
语句体1;
} else {
语句体2;
}

执行流程：
1. 判断关系表达式的值
2. 如果关系表达式的值是true，执行语句体1，然后继续执行后面的其他代码
3. 如果关系表达式的值是false，执行语句体2，然后继续执行后面的其他代码


9. if语句格式3
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}
……
else{
语句体n+1;
}

执行流程
1. 判断关系表达式1的值，如果是true，就执行语句体1；
2. 如果为false，就继续判断关系表达式2的值，如果关系表达式2的值是true，就执行语句体2；
3. ……
4. 只要有一个关系表达式的值是true，就执行对应的语句体
5. 如果所有的关系表达式的值都是false，就执行else里面的语句体n+1
1. switch
        语句格式：
        switch(表达式){
                case 值1:
                        语句1;
                        break；
                case 值2:
                        语句2;
                        break；
                ……
               
                default:
                        语句n+1;
                        [break;]
        }
       
        表达式结果的类型：byte、short、char、int、枚举、String
       
        执行流程：
                计算表达式的值，然后从上往下和各个case后面的值进行比对，只要发现相同，就执行该case的语句，遇到break，switch语句结束；如果所有的case都不匹配，执行default的语句。
               
        case穿透
                如果某个case内没有break，在执行该case内语句后，并不会再次判断后面case的值是否匹配；
                而是直接执行后面case中的语句，直到遇到break或者语句结束。
               
        1. 星期的案例
       
        2. 春夏秋冬的案例
                case 1:
                case 2:
                case 12:
                        System.out.println("冬天");
                        break;
       

2. 循环结构可以通过
        for        while        do…while
        实现

3. for循环结构
        格式：
        for(①初始化语句; ②条件判断语句; ③条件控制语句){
                ④循环体语句;
        }

        执行流程：
        1. 执行初始化
        2. 执行条件判断语句，如果结果是true，就执行循环体语句；如果是false，for循环结束
        3. 执行条件控制语句，再次执行条件判断语句，重复第二步骤。

        ①②④③…②④③直到②的结果是false就结束

4. 案例练习：
        for循环的案例
        a. 输出1-5案例
        for(int i = 1; i <= 5 ; i++){
                System.out.println(i);
        }

        b. 求1-5的和，求和思想（或累加思想）
        int sum 记录数据的和
       
        int sum = 0;
        for(int i = 1; i <= 5 ; i++){
                //sum = sum + i;
                sum += i;
        }

        c. 求1-100以内的偶数和
        int sum = 0;
        for(int i = 1; i <= 100 ; i++){
                if(i % 2 == 0){
                        sum += i;
                }
        }

        d. 水仙花数
        求三位数每位上的值
        个位ge：i%10
        十位shi：i / 10 % 10
        百位bai：i / 100 % 10
       
        for(i = 100 ; i < 1000 ; i++){
                if(ge * ge * ge + shi * shi * shi + bai * bai * bai == i){
                        System.out.println(i);
                }
        }

        e. 水仙花数
        求三位数每位上的值
        个位ge：i%10
        十位shi：i / 10 % 10
        百位bai：i / 100 % 10
       
        计数器 int count = 0;

        for(i = 100 ; i < 1000 ; i++){
                if(ge * ge * ge + shi * shi * shi + bai * bai * bai == i){
                        count++;
                }
        }
       

4. while循环
        基本格式：
        while(条件判断语句){
                循环体语句;
        }

        完整格式：
        初始化语句①;
        while(条件判断语句②){
                循环体语句③;
                条件控制语句④;
        }

        执行流程（基于完整格式）：
       
        ① ②③④ ②③④ ②③④
        1. 执行初始化语句
        2. 执行条件判断语句
                结果为false，while循环结束；
                结果为true，执行while循环体语句
        3. 执行条件控制语句
        4. 重新执行第二步，直到条件判断语句的结果为false。

        案例练习：珠穆朗玛峰，折叠多少次以后可以超过珠穆朗玛峰：
       
        int count = 0;

        double paper = 0.1;
        while(paper < 8844430){
                count++;
                paper = paper *2;
        }
       
5. do…while
        基本格式：
        do{
                循环体语句;
        }while(条件判断语句);
       
        完整格式：
        初始化语句①;
        do{
                循环体语句③;
                条件控制语句④;
        }while(条件判断语句②);
       
       
        执行流程：       
                1. 初始化语句①
                2. 直接执行循环体语句③;
                3. 条件控制语句④;
                4. 执行条件判断语句，
                        如果结果是false，循环结束
                        如果结果是true，继续执行第二步
                       
                ① ③④② ③④② ③④②
               
6. 三种循环语句的区别
        1. for、while先进行条件判断语句，然后再执行循环体
           do…while先执行一次循环体，然后再进行判断。最少执行一次循环体
       
        2. for和while的区别
                for控制循环的变量在循环结束以后，无法继续使用
                while循环的控制变量在循环结束以后，可以继续使用
               
        3. 死循环
                for(;;){}
                while(true){}
                do{}while(true);
               
        4. 使用
                一般情况下选择for循环
                死循环选择while(true)
               
        5.break和continue
                break结束整个循环（还可以用在switch语句中）
                continue，结束本次循环，继续下一次循环
        6. 循环嵌套
                for(外层初始化语句;外层条件判断语句;外层条件控制语句){
                        //下面内容就是外层的循环体语句
                        for(内层初始化语句;内层条件判断语句;内层条件控制语句){
                                内层循环体语句;
                        }
                }
7. Random        随机数生成器
                使用分三步
                1. 导包 import java.util.Random;
                2. 创建对象 Random r = new Random();
                3. 生成随机数 int i = r.nextInt(n);
               
                生成随机数的范围是 [0,n)，包左不包右。
               
                生成1-100的一个随机整数： r.nextInt(100)+1
               
        猜数字
                Scanner、Random、while、if…else if、break
1. 数组
        a 概念：存储多个同一类型数据的容器（内存空间）
        b 格式：数据类型[] 变量名;（不推荐：数据类型 变量名[]）
         
       
        c 数组的初始化
        数据需要先初始化后使用（变量也是一样）
        初始化的工作：
                a). 开辟内存空间
                b). 为数组中元素赋值
       
        数组初始化方式：
                a) 动态初始化(指定数组长度)
                b) 静态初始化(不指定数组长度，)
               
        动态初始化就是只给定数组的长度，元素的初始化交给系统默认处理。
       
        动态初始化格式：
                数据类型[] 变量名 = new 数据类型[n];
                左边：
                        数据类型        存储在这个数组中元素的类型
                        []                        表示这是一个数组
                        变量名                数组的名字
                       
                右边：
                        new                        申请内存空间
                        数据类型        存储在这个数组中元素的类型
                        []                        表示这是一个数组
                        n                        数组长度，是一个int值
               
                       
                        int[] arr = new int[3];

        d 数组的使用：直接输出
       
        直接输出数组
        [I@1e643faf
                [        表示是数组
                [[        表示是二维数组
                I        数组中元素的类型
                1e643faf        通过地址等信息算出来的一个数值（十六进制hash值）
       
       
        [Ljava.lang.String;@6e8dacdf
                [        表示是数组
                [[        表示是二维数组       
                L        数组中元素的类型是引用数据类型
                java.lang.String;        数组中元素的类型（完整类名）
                6e8dacdf        通过地址等信息算出来的一个数值（十六进制hash值）
        特例：char[]                                   直接输出char[]，结果与上面的不同，会输出一个字符串，字符串内容是字符数组中的内容拼接而成
       
        e 数组的使用：输出/获取数组中的每一个元素
                索引：索引就是一个整型的编号，用来获取数组中的每一个元素
                索引的使用方法/数组中元素的获取方法：
                        数组名[索引]
                索引特性：
                        1. 从0开始的整数
                        2. 连续
                        3. 索引每次递增1
       
                int数组中元素的默认值都是0
               
               
               
        f 内存图解1
       
        左面的内存区域是 栈内存       
        右面的内存区域是 堆内存
       

       
       
       
        局部变量
                写在一对大括号({}，类除外)里面的变量，称为局部变量。
                int[] arr 写在main方法里面 就是局部变量
                局部变量存储在栈内存中
                在main方法结束以后，该局部变量会立即消失
               
        对象
                通过new出来的称之为对象
                对象存在堆内存中，使用完以后不会立即消失（被回收）
                等垃圾回收器空闲时在合适的时间回收。
                在堆里面的数据都有默认的初始化值
                整型                                        0
                浮点型                                        0.0
                布尔类型                                false
                字符                                        空字符
                引用类型(包括String)        null
        建立关系
                对象开辟内存空间并且初始化之后，会把自己空间的地址值给到指向自己的变量（该变量存储在栈内存中）
               
        直接使用数组变量
                如果直接输出arr（局部变量），输出的实际是arr指向的对象的地址值（该对象在堆里面的地址值）
               
        操作数组中的每个元素
                arr[i]
                首先找到栈里面的arr，arr指向的是堆内存中的某个地址。
                找到该地址以后，会根据索引[i]找到对应的元素，找到以后可以进行赋值/读取等操作。
       
        g 内存图解2
                两个不同的int数组类型的变量，指向了同一个int数组对象
                通过任意一个变量，均可操作数组对象内的元素。
       
               
               
               
               
2. 数组大厂面试题实战（百度）
        在一个数组中，某一个元素出现的次数>length/2，请用程序获取数组中的该数字。
        {1,2,6,1,5,1,3,1,1}
        1. 遍历数组，统计每个元素出现的次数，如果某个元素出现次数大于长度的一半。
       
        2. 排序
                从小到大排序 结果是 1 1 1 1 1 2 3 5 6    6 5 3 2 1 1 1 1 1

                1 1 1 1 1  3 5 6    6 5 3  1 1 1 1 1
               
                对数组进行排序，获取数组中索引为length/2的元素，即为该数字
               
               
        3. 火拼
               
                1 1 1 1 1  3 5 6
                {1,6,1,1,1,3,1,5}
               
                第一个元素上场前
                场上目前胜利的帮派/某个值winner = 0;
                场上有的人数/元素数量count = 0;
               
                第一元素1上场后
                winner = 1;
                count = 1;
               
                第二个元素6上场后
                winner = 0;
                count = 0;
               
                第三元素1上场后
                winner = 1;
                count = 1;
               
                第四个元素1上场后
                winner = 1;
                count = 2;
                ……
               
               
                上场 看count == 0
                        是 winer = 自己
                           count++
                          
                        否
                                看是不是自己人
                                        是winner==自己       
                                                count++
                                                //winer=自己
                                        否 count--