java基础-CSDN博客

本文链接：https://blog.csdn.net/qq_32906033/article/details/60969326

java基础回顾（一）

java中boolean类型的长度问题
根据java虚拟机规范里面的解释可知，它的长度是不确定的，单个的boolean类型变量的长度是int类型的长度，为4个字节；boolean类型的数组，每个元素的长度为byte类型，占1字节。
类型转换小细节
float类型定义时后面要加f,long类型定义时后面要加l。小类型转大类型自动向上转型，大转小需要强制转换。float+long=float.(这里指代的都是类型)
原码，反码，补码
1.当原码为正数时，反码，补码都与原码一致。
2.当原码为负数时，反码=原码除符号位取反，补码=反码-1.
例：0000 0011（+3）原码
0000 0011 反码
0000 0011 补码
1000 0011 （-3）原码
1111 1100 反码
1111 1011 补码
计算机操作的是补码的原因：
1.将减法运算变为加法运算，方便做减法运算。A-127=A + (-127)
*引入补码以后，计算机中的加减运算都可以用加法来实现，并且两数的补码之“和”等于两数“和”的补码，在计算机中，所有的加减运算都可以统一化成补码的加法运算，并且其符号位也一起参与运算，结果为补码，这种运算既可靠又方便
如果用原码计算，1-1=1+(-1)=[0000 0001]原+[1000 0001]原=[1000 0010]原=2.如果用原码计算，让符号位也参与运算，显然对于减法来说，结果是不正确的，这也就是为什么计算机内部不用原码表示一个数，为了解决原码做减法的问题出现了反码，如果用反码计算减法，1-1=1+(-1)= [0000 0001]原+ [1000 0001]原=[0000 0001]反+[1111 1110反]=[1111 1111]反=[1000 0000]原=-0，发现用反码计算减法，结果的真值部分是正确的，而唯一的问题其实出现在0这个特殊的数值上，虽然人们理解上+0和-0是一样的，但是0带符号是没有任何意义的，而且会有[0000 0000]原和[1000 0000]原两个编码表示0；于是补码的出现，解决了0的符号以及两个编码的问题：1-1=1+(-1)=[0000 0001]原+[1000 0001]原=[0000 0001]补+[1111 1111]补=[0000 0000]补=[0000 0000]原，这样0用[0000 0000]表示，而以前出现的问题-0则不存在了，而且可以用[1000 0000]表示-128。 (-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]补 + [1000 0001]补 = [1000 0000]补。在用补码运算的结果中, [1000 0000]补就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)。使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-231, 231-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值。
2.无符号及带符号的加法运算可以用同一电路完成。
　　有符号和无符号的加减，其实都是把它们的真值拿过来相加。
位运算符（操作的都是补码）

*进行位运算时，都是先化为补码在进行计算，当运算结果符号位为0（正）时，不用再转回原码；当符号位为1时，需要将补码转回为原码。

**&：两边同时为1，则为1，否则为0.
** | ：两边有一方为1，则为1，否则为0.
** ^ : 两边不一致时结果为1，否则为0.
**~ ：直接取反。
移位运算符（操作补码）
**<< :左移右边补0
**>> :右移正数左边补0，负数左边补1
** >>> :无符号右移不论正负，左边补0.
++，–注意点
1.++在赋值符号（=）后面时，先赋值，再运算
例：int i = 3; i = i++ + i++ ; i = 3 + 4 = 7;
2.++在=前面时，先运算，再赋值
3.在前后混合使用的情况下，遇到++/–在前面的时候，需考虑其前面的++/–在后面的情况也要运算。
例：int i = 3; i = i++ + ++i + i– + –i; i = 3 + 5 +5 +3=16;
*在多重++/- -一起使用时，后者在自增或自减时，会把前一个的值运算出来再根据自己的位置作运算或赋值。

程序的三种结构(流程控制)：

1）顺序结构；
2）分支结构；
if()和else if()的区别：当有多条if语句时，第一条匹配上之后的if语句还是会执行匹配后面的if语句；else if在匹配上一条后，后面的不会再执行。
switch(condition):可以是byte,short,int,char,String(1.7+),Enum(1.5+)
3）循环结构
for(){} for each(1.5+)
do{}while();
while(){}
*return,break,continue的区别：
return:结束方法，后面的代码块不会再执行，在有返回值的情况下，所有分支都需要return。
break:结束当前循环，可以加上标签跳出外层循环。
continue:跳过本次循环，在其后面的代码块不会再执行。
- 方法重载
  方法重载只与方法签名有关，与返回值类型没关系。

数组存储一组相同数据类型的数据(基本,引用)

    //声明数组  初始化长度  长度不可变
    int[] is = new int[10];
    //数组[基本数据类型] 引用（栈）  数据[栈里面]
    //数组[引用数据类型] 引用（栈）  数据[堆里面]
    //插入排序  

public static void insertSort(int[] is){
    int len = is.length;
    for (int i = 0; i < len-1; i++) {
        //每一轮比较次数在增加
        for (int j = i+1; j > 0; j--) {
            if(is[j] < is[j-1]){
                swap(is, j, j-1);
            }
        }
        System.out.println(i+1+"轮:"+Arrays.toString(is));
    }
}
//选择排序  选出一个最小值然后逐个比较 找出真正的最小值

public static void selectSort(int[] is){
    int len = is.length;
    int min = 0;
    //比较多少轮
    for(int i = 0;i<len-1;i++){
        min = i;
        //比较多少次
        for(int j = i;j<len;j++){
            if(is[j]<is[min])
                min=j;
        }
        if(min!=i){
            is[min]=is[min]^is[i];
            is[i]=is[min]^is[i];
            is[min]=is[min]^is[i];
        }
    }
}
//冒泡  两两相比 找出较大的   最大的放最后
public static void bubbleSort(int[] is){
    //决定多少轮
    for (int i = 0; i < is.length-1; i++) {
        //每一轮比较过程
        for (int j = 0; j < (is.length-i-1); j++) {
            if(is[j]>is[j+1]){
                swap(is, j,j+1);
            }
        }
        System.out.println(i+1+"轮:"+Arrays.toString(is));
    }
}
/**
 * i < j
 * @param is
 * @param i
 * @param j
 */
private static void swap(int[] is,int i, int j) {
    int temp = is[i];
    is[i] = is[j];
    is[j] = temp;
}
2.随机数
Random r = new Random();
int i = r.nextInt(10)+1;//1-10

学习心得:
1.插入排序是把一个数插入到前/后面一个有序的序列中；冒泡排序是把一个数与前面或后面的无序序列的元素比较，然后交换；选择排序是选出一个最小值然后逐个比较找出真正的最小值，每一轮交换一次。