JAVASE（二）--分支&循环&数组

运算符

自增自减

int a = 1;
System.out.println(a++);//1---先取值再自增
int b=1;
System.out.println(++b);//2---先自增再取值
int c=1;
int d = c++;
int e = ++c;
System.out.println(d);//1---先取值再自增
System.out.println(e);//3---先自增再取值

&&和&的区别（||和|)

执行效率不同，&&比&的效率更高。
例：（条件1）&&（条件2）
当（条件1）判断完是false时,结果早都注定是false了,（条件2）不会去判断，系统更加高效。

分支结构

if分支

单分支：
if(判断条件){
       代码。。。
}
多分支：
if(判断条件){
       代码1。。。
}else{
       代码2。。。
}
嵌套分支：
if(判断条件1){
       代码1。。。
}else if(条件2){
       代码2。。。
} else if(条件3){
       代码3。。。
}else{
       代码4。。。
}

switch分支

switch(exp)中,exp是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持

switch(变量或者表达式){//jdk1.7后条件新增String
       case 1:
       case 2:
       case 3:  
       case 4:  
       default:
}

case穿透

case穿透就是：当在switch语句中，执行case分支语句，如果满足case1，但是在case1的语句块中，没有加break;即使case1满足条件，程序仍然会向下执行case2，即使case2不满足条件，除非case2语句块中有break;，程序会跳出switch选择结构，否则继续执行case3，一直这样执行下去，直到整个switch语句全部执行完毕，才能结束！

switch (1) {
    case 1:System.out.println(1);
    case 2:System.out.println(2);
    case 3:System.out.println(3);break;
    case 4:System.out.println(4);
    case 5:System.out.println(5);
    }

结果为：

1
2
3

case合并

int i=5;
    switch(i){
    case 1 : case 2 : case 3 :
        System.out.println("Test0！");
    break;
    case 4 : case 5 : case 6 :
        System.out.println("Test1！");
    }

结果为：

Test1！

循环结构

for循环

for(循环的开始位置;循环的判断条件;循环的更改条件){
            要重复干的事情/循环体
        }

嵌套for循环

for(1;2;3){//外循环
            for(1;2;3){//内循环
            }
        }

外循环执行1次,内循环执行n次

for(int  i = 1 ; i <= 5 ; i++) {//外循环--执行5次
        for(int  j = 1 ; j <= 5 ; j++) {//内循环--执行5次
            System.out.print("* ");//同行展示
        }
        System.out.println();//换行
    }

外循环控制行,内循环控制列，结果为：

* * * * * 
* * * * * 
* * * * * 
* * * * * 
* * * * * 

while循环

先判断，再执行

while(执行条件){
       代码…
}

do-while循环

先执行，再判断

do{
       代码…
}while(执行条件);

三种循环结构比较

--for(开始位置;判断条件;更改条件){循环体}
需要知道开始位置,需要知道结束位置,需要知道数据的变化规律
--while(判断条件){循环体}
只需要指定条件--先判断满足了条件就执行
--do{循环体}while(判断条件);
只需要指定条件--先执行再判断条件

break和continue

两者都是终止循环的关键字。
break: 中断当前循环，简单粗暴
continue：跳出本次循环，进入下一轮
例子：接收用户输入的100次数字，如果不是88继续输入，找到88就返回

for(int i=1;i<=100;i++){
         int j = new Scanner(System.in).nextInt();
         if(j!=88){
                continue;//继续输入下一次
         }
         if(j==88){
                System.out.println("找到了88...");
                break;//循环终止
         }
     }

测试：

5
243
88
找到了88...

数组

数组概念

--数组英文名称是Array,标志是[]
--可以存放多个数据,要求数据都是 相同的类型
--为了方便查询数组里存的数据,为每个数据分配了下标
--下标默认从0开始.下标的最大值是 数组的长度-1

数组的创建

动态初始化

动态初始化语法: 数据类型 [] 数组名 = new 数据类型[指定数组长度] ;//为了迎合C开发人员习惯[]放在数组名后也可以

int[] a = new int[5];

静态初始化

int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};

数组长度

length属性获取数组长度

数组一旦创建，长度不可变

允许创建长度为0的数组

数组遍历

使用循环，依次访问数组的位置

int[] a = new int[]{1,2,3,4,5};
    for(int i=0;i<a.length;i++){
           System.out.println(a[i]);
    }

结果为：

1
2
3
4
5

二维数组

二维数组其实就是每一个元素为一维数组的数组

动态初始化

int a [][]=new int[2][3];
int [][] b=new int[2][3];
int[] c []=new int[2][3];
int d [][]=new int[2][ ];

错误初始化：int a[][]=new int [][3];

静态初始化

int [][] arr=new int[][]{{4,5,6,8},{2,3},{1,6,9}};

数组工具类Arrays

Arrays.toString

把数组里的数据用逗号连接成一个字符串

int a[] = new int[5];
int b[] = new int[]{1,2,3,4,5};
System.out.println( Arrays.toString(a));//[0, 0, 0, 0, 0]
System.out.println( Arrays.toString(b));//[1, 2, 3, 4, 5]

Arrays.sort

把数组里的数据排序

//1,创建 无序的 数组
int[] a = {10,5,9,1,8};
//2,排序
Arrays.sort(a);
//3,打印
System.out.println(Arrays.toString(a));//[1, 5, 8, 9, 10]

Arrays.copyOf

根据原有数组内容创建新数组

//1,定义原数组
int a[] = {1,3,4,6,7};
//2,完成复制
int[] b = Arrays.copyOf(a, 8);//copyOf(a, 6)--a是原数组的名称,6是新数组的长度
//3,打印数据
System.out.println(Arrays.toString(b));//[1, 3, 4, 6, 7, 0, 0, 0]--把原来的数据复制完,在后面新增位置--扩容
int[] c = Arrays.copyOf(a, 3);
//4,打印数据
System.out.println(Arrays.toString(c));//[1, 3, 4]--把原来的数据截取前面一部分复制,因为位置不够了--缩容

System.arraycopy

更加灵活的复制数组

int a [] = {1,3,4,6,7};
int b [] = new int [10];
System.arraycopy(a, 0, b, 3, 5);//--被复制数组，被复制数组开始下标，新数组，新数组复制开始下标，复制长度
System.out.println(Arrays.toString(b));//--[0, 0, 0, 1, 3, 4, 6, 7, 0, 0]

排序算法

冒泡排序

import java.util.Arrays;
import java.util.Random;

public class Test1_BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int [10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]) {
                    int temp = 0;
                    temp = arr[j] ;
                    arr[j]  = arr[j+1] ;
                    arr[j+1]  = temp ;
                }
            }
        }
        System.out.println(Arrays.toString(arr));//排序完成的数组
    }
}

归并排序

import java.util.Arrays;
import java.util.Random;

public class Test2_MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));//排序完成的数组

    }

    private static void mergeSort(int[] arr) {
        sort(arr, 0, arr.length - 1);

    }

    private static void sort(int[] arr, int i, int j) {
        if (i == j) {
            return;
        }
        int mid = i + (j - i) / 2;
        // 递归拆分数组
        sort(arr, i, mid);
        sort(arr, mid + 1, j);
        merge(arr, i, mid, j);

    }

    private static void merge(int[] arr, int i, int mid, int j) {
        int temp[] = new int[j - i + 1];
        int k = 0;
        int p1 = i;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= j) {
            temp[k++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; // 精髓：将小的数取出，并且移动指针，不取的不移动
        }
        while (p1 <= mid) {
            temp[k++] = arr[p1++];// 没取完时自动排在后面
        }
        while (p2 <= j) {
            temp[k++] = arr[p2++];// 没取完时自动排在后面
        }
        for (int l = 0; l < temp.length; l++) {
            arr[i + l] = temp[l];// 将排好的顺序传递
        }
    }
}

二分排序

import java.util.Arrays;
import java.util.Random;

public class Test3_BinaryInsertSort {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        for (int i = 0; i < arr.length; i++) {
            int start, end, mid;
            start = 0;
            end = i - 1;
            mid = 0;
            int temp = arr[i];
            while (start <= end) {
                mid = (start + end) / 2;
                if (arr[mid] > temp) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            }
            for (int j = i - 1; j > end; j--) {
                arr[j + 1] = arr[j];
            }
            arr[end + 1] = temp;
        }
        System.out.println(Arrays.toString(arr));//排序完成的数组
    }
}

快速排序

import java.util.Arrays;
import java.util.Random;

public class Test4_QuickSort {
    public static void main(String[] args) {
    int[] arr = new int[10];
    Random ran = new Random();
    for (int i = 0; i < arr.length; i++) {
        arr[i] = ran.nextInt(100);
    }
    System.out.println(Arrays.toString(arr));//随机生成的数组
    sort(arr, 0, arr.length - 1);
    System.out.println(Arrays.toString(arr));//排序完成的数组

}

private static void sort(int[] arr, int i, int j) {
    if(i<j) {
    int index = getIndex(arr, i, j);
    sort(arr, i, index - 1);
    sort(arr, index + 1, j);
    }
}

private static int getIndex(int[] arr, int i, int j) {
    int temp = arr[i];
    while (i < j) {
        while (i < j && arr[j] >= temp) {
            j--;
        }
        arr[i] = arr[j];
        while (i < j && arr[i] <= temp) {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = temp;
    return i;
    }
}

总结

条件分支与循环结构都是一种控制代码执行顺序的手段，灵活使用这些结构，就可以控制代码执行的先后顺序与逻辑。
数组是一种数据结构，用来统一创建和管理相同类型的变量。