Java基础（二）

提示：该文档仅保留个人学习过程观点，如有不对，请各位大佬指正

---

前言

提示：本节记录了学习过程中个人感觉需要注意的点，仅供复习专用，谢谢

---

基础名词说明

变量

系统为程序分配的一块内存单元，数据内容可变（变量不能在类外申明）

数据类型

 变量存储的数据的内容、大小不同而引入的概念描述

8种基本数据类型： byte、short、int、long、float、double、char、boolean
引用类型： 类、接口、数组

计算机存储单位

位（Bit）

计算机存储处理信息的最基本单位，表示一个二进制码

字节（Byte）

1字节 = 8个位，8个二进制码

二进制

计算机内的二进制是以补码形式表示的

反码：

正数的补码反码是其本身，负数的反码是符号位保持不变，其余位取反

补码：

为解决计算机计算过程中忽略运算符位而产生的一种让计算机计算更简单明了的运算码。
正数的补码是其本身，负数的补码是在其反码的基础上+1，例如正数1的原码是[0000_0001],他的补码是其本身[0000_0001],-1的补码是[1111_1111]

• 二进制转十进制：

二进制数：1 0 1 1.0 1

2^3	2^2	2^1	2^0	2^-1	2^-2
1	0	1	1	0	1

原码 1011.01 = 1×2^3 ＋ 0×2^2 ＋ 1×2^1 ＋ 1×2^0 ＋ 0×2^-1 ＋ 1×2^-2 = 11.25

• 十进制转二进制(整数)：151

  151/2 … 1
  75/2 … 1
  37/2 … 1
  18/2 … 0
  9/2 … 1
  4/2 … 0
  2/2 … 0
  1/2 … 1
  1*1 + 2*1 + 4*1 + 8*0 + 16*1 + 32*0 + 64*0 + 128*1 = 151

• 十六进制（解决二进制表示冗长问题）

    Java 中十六进制数据要以 0x 或 0X 开头。[0-9][A-F]
    十六进制转换成二进制只需将每个十六进制数字替换为相对应的四个二进制位即可.
  

• 八进制

    Java 中八进制数据要以 0 开头。
    八进制转换成二进制：只需将每个八进制数字替换为相对应的三个二进制位即可。
  

方法

也称函数，Java中方法返回的参数只能有一个

• 方法返回多个小技巧：

// 将多个参数封装成一个对象，定义方法传入对象，方法体内修改属性参数值
public static void main(String[] args) {
        int a = 0;
        String s = "11";
        Params p = new Params(a, s);
        System.out.println(p);

        returnParams(p);

        System.out.println(p);
    }

方法：

    public static void returnParams(Params p) {
        p.a = 10;
        p.s = "aaaaaaaaa";
    }

控制台输出：

    Params{a=0, s='11'}
    Params{a=10, s='aaaaaaaaa'}

封装类：

    class Params {
        public Params(int a, String s) {
            this.a = a;
            this.s = s;
        }

        public Params() {
        }

        int a;
        String s;

        @Override
        public String toString() {
            return "Params{" +
                    "a=" + a +
                    ", s='" + s + '\'' +
                    '}';
        }
    }

算术运算符

++：    如果是变量前缀：先对此变量加 1，再执行其他的操作。
        如果是变量后缀：先执行当前语句的其他操作，再对此变量加 1

--：    如果是变量前缀：先对此变量减 1，再执行其他的操作。
        如果是变量后缀：先执行当前语句的其他操作，再对此变量减 

关系运算符

返回的结果是布尔值

赋值运算符

将数值赋给一个变量，运算顺序从右到左

逻辑运算符

计算机中默认1为真，实际是只要非零即真，0为假。

单个与和两个与的区别:

&   与      ：[运算1 & 运算2] ，1 和 2 不管结果如何都要执行运算过程
&&  短路与  : [运算1 && 运算2] ，1 只要为false，不再运算2的结果直接返回false

| 和 || 同理

字符串连接符

"+"，实际复杂循环应用中尽量少用这个"+"，因为这个字符串连接符会耗用大量的内存空间，而应使用StringBuffer或StringBuild 的append方法。

三目运算符

condition ? 表达式1 : 表达式2

尽量保持':'前后两个数据的类型的一致性，否则数据自动转型（自动拆箱）过程中会产生空指针异常

以下两种场景会触发类型对齐的拆箱操作
1)表达式1或表达式2的值只要有一个是原始类型
2)表达式1或表达式2的值的类型不一致，会强制拆箱升级成表示范围更大的那个类型

异常示例：

Integer m = 1;
Integer n = 2;
Integer k = null;
Boolean flag = false;
Integer res = flag ? m * n : k;

编程规范

转义字符

转义字符	意义	ASCII码值（十进制）
\n	换行，将当前位置移到下一行开头	010
\r	回车 ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\\	代表一个反斜线字符’’’	092
\ ’	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034

换行里面/r/n一起使用的原因：早期为了兼容windows和linux系统而应用的一种格式

流程控制

顺序结构

按代码顺序从上往下执行。

分支结构

小提示

if使用小提示:为了代码的可阅读性的提高，一般在if语句里面尽量不使用else if 或 else 语句。

switch 表达式的返回值必须是下述几种类型之一：int, byte, char, short, String;  如果 case 后面没有写 break 则直接往下面执行！

循环结构

while 循环：先判断，再执行
do-while 循环：先执行，再判断

跳出多层循环使用循环标记 
在循环前面添加标记 xx: for(){}
中断循环 break xx;

数组

存储相同数据类型的容器。数组一旦创建不可改变，是由final修饰的。

冒泡排序

原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

int[] arr = { 11, 9, 56, 23, 16, 28, 64, 19, 20, 16 };
// 排序次数=长度-1
int temp = arr[0];
for (int i = 0; i < arr.length - 1; i++) {
    // 大小比较，位置调换
    for (int j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

二分查找法

int[] nums = {10, 20, 30, 40, 50, 60, 70, 80, 90};

public static int binarySearch(int num, int[] nums) {
    if (nums == null || nums.length < 0) {
        return -1;
    }
    // 最小范围下标
    int minIndex = 0;
    // 最大范围下标
    int maxIndex = nums.length - 1;
    // 中间数据下标
    int centerIndex = (minIndex + maxIndex) / 2;

    while (true) {
        if (minIndex >= maxIndex) {
            return -1;
        }
        if (nums[centerIndex] > num) {
            // 中间数据较大
            maxIndex = centerIndex - 1;
        } else if (nums[centerIndex] < num) {
            // 中间数据较小
            minIndex = centerIndex + 1;
        } else {
            // 找到了数据，数据位置：centerIndex
            break;
        }
        // 当边界发生变化，需要更新中间下标
        centerIndex = (minIndex + maxIndex) / 2;
    }
    return centerIndex;
}