基础知识二

运算符

算术运算符

PS ：
整数与整数相除时，结果为整数。
负数对正数取模结果为负数
正数对负数取模结果为正数

赋值运算符

符号：= , +=, -=, *=, /=, %=

public static void main(String[] args) {
        short s = 4;
        s =（short）s+4;
        s +=4;

    }

在执行s+=4;语句时，编译器在编译的时候，默认进行了强制类型转换，也就是将int类型的数据转换成short类型的数据。
在执行s = s + 4;语句时，编译器在编译的时候，默认并没有强制类型转换。 所以，s是short类型，4是int类型，s会自动提升为int类型，相加的和也是int类型，赋值给short类型的变量肯定会损失精度。 这时候就需要进行强制类型转换：s = (short)(s + 4);。

比较运算符

逻辑运算符

位运算符

三元运算符

格式：
(条件表达式) ? 表达式1 : 表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2。

程序流程控制

判断结构

格式：
if(条件表达式){
执行语句；
}

if(条件表达式){
执行语句；//表达式为true执行
}else{
执行语句；//表达式为false执行
}

warmming：由于if( false );语句后面加了分号，因此不执行任何操作。 { System.out.println(“Hello World”); }为局部代码块。
局部代码块：局部代码块可以定义局部变量的生命周期。

选择结构

格式：

switch(表达式）{
   case 取值1：
   执行语句
   break;
   case 取值2：
   执行语句
   break;
   `````
   default:
   执行语句
   break;
 }

s
witch语句特点：
1. switch语句选择的类型只有四种：byte，short，int，char。
2. case与default没有顺序。 先执行第一个case，没有匹配的case执行default。
3. 结束switch语句的两种情况：①遇到break，②执行到switch语句结束。
4. 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
5. 进入switch语句后，执行顺序是先执行case，然后从上到下，最后再执行default。 即使default放在case上面，执行顺序也不变。

if和switch语句的应用：
if：
1. 对具体的值进行判断。
2. 对区间判断。
3. 对运算结果是boolean类型的表达式进行判断。
switch：
1. 对具体的值进行判断。
2. 值的个数通常是固定的。
对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率相对高。

循环结构

格式：

while(条件表达式){
  执行语句;
} 

do{
  执行语句;
  }while(条件表达式);

while和do while的区别：
do while语句的特点：无论条件是否满足，循环体至少执行一次。
while如果条件不满足，循环体一次都不会执行。

for(初始化表达式;循环条件表达式;循环后的操作表达式一,循环后的操作表达式二){
  执行语句;
  }

for里面的三个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
while和for的区别：
1. while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
2.最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
3.在使用循环时候，一定要明确哪些语句需要参与循环，哪些不需要。 循环通常情况下，需要定义条件，需要控制次数。

数组

常见操作一：获取最值

public class ArrayMax {
    public static void main(String[] args) {
        int[] arr ={24,43,-35,3,223};
        System.out.println("max = "+getArrayMax(arr));

    }

    public static int getArrayMax(int[] arr){
        //存储最大值的地方
        int maxElement = arr[0];
        //循环遍历
        for(int x = 1;x<arr.length;x++){
            if(arr[x]>maxElement){//判断若比较值比存储值大，则刷新存储值
                maxElement = arr[x];
            }
        }
        return maxElement;
    }
    public static getMaxByIndex(){

    }
}

常见操作二
选择排序：

public class ArrayDemo {

    public static void main(String[] args) {
        int[] arr = {89,34,-24,-89,25};
        System.out.println("排序前数组：");
        printArray(arr);
        System.out.println("排序后数组");
        selectSort(arr);
        printArray(arr);
    }

    public static void selectSort(int[] arr){
        for(int x = 0;x<arr.length-1;x++){
            for(int y = x+1;y<arr.length;y++){
                if(arr[x]>arr[y]){
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
    public static void printArray(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int x = 0;x<arr.length;x++){
            if(x!=arr.length-1){
                sb.append(arr[x]+",");
            }else{
                sb.append(arr[x]+"]");
            }
        }
        System.out.println(sb.toString());
    }
}

结果：

冒泡排序：
1. 首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
2. 经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3. 第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
4. 依照此方式，一直到只有第一和第二个元素互相比较而结束。

public class ArrayDemo {

    public static void main(String[] args) {
        int[] arr = {89,34,-24,-89,25};
        System.out.println("排序前数组：");
        printArray(arr);
        System.out.println("排序后数组");
        bubbleSort(arr);
        printArray(arr);
    }
    public static void bubbleSort(int[] arr){
        for(int x = 0;x<arr.length-1;x++){
            for(int y = 0;y<arr.length-1-x;y++){
                if(arr[y]>arr[y+1]){
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }
    public static void printArray(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int x = 0;x<arr.length;x++){
            if(x!=arr.length-1){
                sb.append(arr[x]+",");
            }else{
                sb.append(arr[x]+"]");
            }
        }
        System.out.println(sb.toString());
    }

}

常见操作三：折半查找（二分法）
1. 设置三个变量记录角标：min、 max、 mid。 min初始值为0，max为数组最大角标，mid为
（max+min）/2。
2. 查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3. 如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。 设置max = mid - 1，mid = (max + min)/2，重复第1、 2步的操作。
4. 如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。 设置min = mid + 1，mid = (max + min)/2，重复第1、 2步的操作。
5. 如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。

public class ArrayDemo {

    public static void main(String[] args) {
        int[] arr = {89,34,-24,-89,25};
        Arrays.sort(arr);
        printArray(arr);
        System.out.println("结果是="+binarySearch(arr,89));

    }

    public static int binarySearch(int[] arr, int key){
        int max,mid,min=0;
        max= arr.length-1;
        mid=(max+min)/2;
        while(arr[mid]!=key){
            if(key>arr[mid]){
                min=mid+1;
            }else if(key<arr[mid]){
                max=mid-1;
            }
            if(max<min)
                return -1;
            mid = (max+min)/2;
        }
        return mid;

    }


    public static void printArray(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int x = 0;x<arr.length;x++){
            if(x!=arr.length-1){
                sb.append(arr[x]+",");
            }else{
                sb.append(arr[x]+"]");
            }
        }
        System.out.println(sb.toString());
    }

}