Java基本语法2-数组、二分法、冒泡排序

数组

一维数组的声明与初始化

声明：int num
初始化：num = 10
声明 + 初始化：int id = 1001
声明：int[] ids

静态初始化:数组的初始化和数组元素的赋值操作同时进行

ids = new int[]{1001,1002,1003,1004};

动态初始化:数组的初始化和数组元素的赋值操作分开进行

String[] names = new String[5];
int[] arr4 = {1,2,3,4,5};//类型推断

一维数组元素的默认初始化值

数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’，而非’0’
数组元素是boolean型：false
数组元素是引用数据类型：null

二维数组的声明与初始化

一维数组int[] arr = new int[]{1,2,3};

静态初始化int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};

动态初始化1String[][] arr2 = new String[3][2];

动态初始化2String[][] arr3 = new String[3][];
也是正确的写法：
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};

int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

遍历二维数组元素

for(int i = 0;i < arr4.length;i++){
			
	for(int j = 0;j < arr4[i].length;j++){
		System.out.print(arr4[i][j] + "  ");
	}
	System.out.println();
}

二维数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素
  		int[][] arr = new int[4][3];
  		外层元素：arr[0],arr[1]等
  		内层元素：arr[0][0],arr[1][2]等
  
    ⑤ 数组元素的默认初始化值 
   针对于初始化方式一：比如：int[][] arr = new int[4][3];
       外层元素的初始化值为：地址值
      内层元素的初始化值为：与一维数组初始化情况相同
       
   针对于初始化方式二：比如：int[][] arr = new int[4][];
    	外层元素的初始化值为：null
       内层元素的初始化值为：不能调用，否则报错。

杨辉三角

// 1.新建二位数组，动态初始化
int[][] yangHui = new int[10][];
// 2.为二维数组赋值
for (int i = 0; i < yangHui.length; i++) {
    yangHui[i] = new int[i + 1];
    // 2.1为首末元素赋值
    yangHui[i][0] = yangHui[i][i] = 1;
    // 2.2为其余元素赋值
    for (int j = 1; j < yangHui[i].length - 1; j++) {//
        yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
    }

}
// 3.打印输出二维数组
for (int i = 0; i < yangHui.length; i++) {
    for (int j = 1; j < yangHui[i].length; j++) {// 第0个位置没有元素
        System.out.print(yangHui[i][j] + " ");
    }
    System.out.println();
}

运行结果：

最大值、最小值、总和、平均数等

// 1.找到数组中的最大值
int maxArr = arr[0];
for (int i = 0; i < arr.length; i++) {
    if (maxArr < arr[i]) {
        maxArr = arr[i];
    }
}
System.out.println("数组中的最大值为：" + maxArr);

// 2.找到数组中的最小值

int minArr = arr[0];
for (int i = 0; i < arr.length; i++) {
    if (minArr > arr[i]) {
        minArr = arr[i];
    }
}
System.out.println("数组中的最小值为：" + minArr);

// 3.找到数组中的平均数
int num = 0;
for (int i = 0; i < arr.length; i++) {
    num += arr[i];
}
System.out.println("数组的平均数为：" + (num / arr.length));

// 4.求总和
int num1 = 0;
for (int i = 0; i < arr.length; i++) {
    num1 += arr[i];
}
System.out.println("数组的总和为：" + num1);

数组的赋值

赋值就像快捷方式一样，不开辟新的内存空间。
如何理解：如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

// 1.数组的赋值
String[] str1 = new String[5];
str1 = str;
str1[2] = "AA";
for (int i = 0; i < str1.length; i++) {
    System.out.print(str[i] + " ");
}
System.out.println();

数组的复制

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

// 1.1数组的复制
for (int i = 0; i < str1.length; i++) {
    str1[i] = str[i];
    System.out.print(str1[i] + " ");
}

数组元素反转

//方法一：
for(int i = 0;i < arr.length / 2;i++){
    String temp = arr[i];
    arr[i] = arr[arr.length - i -1];
    arr[arr.length - i -1] = temp;
}

//方法二：
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    String temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

二分法

二分法的思想必须要用在已经排好序的数组上，通过不断更改左右端点的位置找到目标。

          boolean isflag=true;
          int[] arr2 = new int[]{-90,-55,4,12,34,56,78,98};
          int dest1=-1;
          int head = 0;
          int end = arr2.length-1;
          while (head<=end){
              int middle = (head+end)/2;
              if(dest1 == arr2[middle]){
                  System.out.println("right");
                  isflag=false;
                  break;
              }
              else if (arr2[middle]>dest1){
                  end = middle -1;
              }
              else {
                  head = middle+1;
              }
          }
          if (isflag){
              System.out.println("wrong");
          }

冒泡排序

	int[] arr = new int[] { 21, 43, 64, 76, 878, 432, 21 };
        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 = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }