Java后端_4

eclipse创建java程序：

1.new java project
2.在src下面创建包(package)
3.在包下面创建类(class)

Contact是一个project项目，下面的scr下面有不同的包（package），
包下面有不同的类（class）

数组

数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型。
创建数组对象会在内存中开辟整块的内存空间，而数组名中引用的是首地址。
数组的长度一旦确定，就不能修改。

一维数组

1.数组的初始化

//1.数组的初始化
        int[] ids;//声明
        ids = new int[] {1,2,3,4}; //静态初始化：数组的初始化和数组元素的赋值操作同时进行
	    int[] arr2 = new int[] {1,2,3};
        int[] arr3 = {1,2,3}; //静态初始化的new int 可以省略
        String[] name = new String[5]; //动态初始化：数组的初始化和数组元素的赋值操作分开进行
	    String name2[] = new String[5];//中括号放后面也可以
        
        //注意：
        //int[] arr = new int[];   后面的int[]要么指明数组长度，要么直接赋值.不能都没有，也不能都有

2.调用数组指定位置的元素:通过索引方式

//2.调用数组指定位置的元素:通过索引方式
        name[0] = "小明";
        name[1] = "小红";
        name[2] = "小刚";
        name[3] = "阿伟";
        name[4] = "杰哥";

3.获取数组的长度

System.out.println(name.length);

4.遍历数组元素

	    for(int i=0;i<name.length;i++) {
            System.out.println(name[i]);
        }

5.数组元素的默认初始化

//5.数组元素的默认初始化
        /* byte,short,int:0
         * long:0L
         * float:0.0f
         * double:0.0
         * char:0或'\u0000',而非'0'，显示出来的效果是空格
         * 引用数据类型（如String）：null
         * /

内存简化结构：
栈（stack）：存放局部变量
堆（heap）：存放new出来的结构：对象、数组
方法区（method area）：包括常量池、静态域
数组中的元素值存放在堆中（因为是new出来的），数组首元素的地址存放在栈中（因为是局部变量），首元素的地址起了个名，叫做数组名（如arr），即栈的数组名指向堆中数组的首元素（类似C中的指针）。如果堆中的数组没有被栈中的变量所指向，则会在某一个时间段被垃圾回收。

二维数组

其实，从底层看，没有所谓的二维数组，只不过是一维数组的每一个元素都一个数组

二维数组基本操作

//1.二维数组的声明和初始化
        int[][] arr1 = new int[][] {{1,2,3},{4,5},{6,7,8}};//静态初始化
        int arr4[][] = new int[][] {{1,2},{3}};//中括号放后面也可以
        String[][] arr2 = new String[3][2];//动态初始化
        String[][] arr3 = new String[3][];//动态初始化
        //注意：String[][] arr3 = new String[][2];  这是不对的。并且[][]的长度赋值和数组的元素赋值不能同时存在
        
        //2.如何调用数组指定位置的元素
        System.out.println(arr1[0][1]);
        arr3[0] = new String[4];//说明arr3的第一个元素是一个有4个元素的数组
        System.out.println(arr3[0][1]);//输出null
        //System.out.println(arr3[1][1]);//异常，因为arr3的第二行不知道存的是什么。“空指针异常”
        
        //3.获取数组的长度
        System.out.println(arr1.length);//输出3
        System.out.println(arr1[1].length);//输出2
        
        //4.如何遍历二维数组
        for(int i=0;i<arr1.length;i++) {
            for(int j=0;j<arr1[i].length;j++) {
                System.out.print(arr1[i][j]+" ");
            }
            System.out.println();
        }
        
        //5.数组元素的默认初始化
        System.out.println(arr2[0]);//一个地址（存arr2[0][0],arr2[0][1],arr2[0][2]组成的数组的首元素的地址）
        System.out.println(arr2[0][0]);//null
        double[][] arr = new double[2][];
        System.out.println(arr[0]);//null（因为arr[0]存放的是一个还未定义的数组，属于引用数据类型，所以是null）
        //针对初始化方法一：String[][] arr2 = new String[3][2];
        //    外层初始化是：地址
        //    内层初始化是：与一维数组的初始化情况相同
        //针对初始化方法二：String[][] arr3 = new String[3][];
        //    外层初始化是：null
        //    内层初始化是：空指针异常

二维数组注意：

int[][] arr = new int[5][]; //声明二维数组
arr[0][0] = 1;//要想访问arr[0][0]，必须先new出这一行：arr[0] = new int[5]; 否则会出现空指针异常

二维数组复制：

int[] arr = new int[]{2,3,5,7,4,5,6};
int[] arr2 = arr;//这个不叫把arr复制给arr2，因为arr2和arr都指向同一个内存，arr2变了，arr相应的也变
//若想把arr复制给arr3：
int[] arr3 = new int[arr.length];
for(int i=0;i<arr.length;i++){
    arr3[i]=arr[i];
}

二维数组反转：

for(int i=0;i<arr.length/2;i++) {
            temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
//或如下算法：
for(int i=0,j=arr.length-1;i<j;i++,j--) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

数组的查找算法

线性查找

		String[] arr = new String[]{"宝宝","宝贝","my","姐姐","亲爱的"};
        String dest = "姐姐";//要查找的值
        boolean isFind = false;//定义是否找到的标识，方便未找到的时候输出
        for(int i=0;i<arr.length;i++) {
            if(dest.equals(arr[i])) {
                System.out.println("姐姐在第"+(i+1)+"个位置");
                isFind = true;
                break;
            }
        }
        if(!isFind) {
            System.out.println("未找到");
        }

二分查找

		int[] arr = new int[] {-88,-56,-12,0,2,8,56,78,101};
        int dest = -56;//要查找的值
        int head = 0;//初始首索引
        int end = arr.length-1;//初始尾索引
        int index = 0;//初始索引值
        boolean isFind = false;
        
        while(head<=end) {
            index = (head+end)/2;
            if(arr[index]==dest) {
                System.out.println("找到了"+arr[index]);
                isFind = true;
                break;
            }else {
                if(dest>arr[index]) {
                    head = index+1;
                }
                else {
                    end = index-1;
                }
            }
        }
        if(!isFind) {
            System.out.println("未找到");
        }

数组排序算法

排序算法要求具有稳定性：即数组中两个元素arr[i]和arr[j]是相等的，并且arr[i]在arr[j]前面，则排序过后要求arr[i]仍在arr[j]前面.
有10种排序算符：选择排序（直接选择排序、堆排序），交换排序（冒泡排序、快速排序），插入排序（直接插入排序、折半插入排序、shell排序），归并排序，桶式排序，基数排序

冒泡排序: (时间复杂读：O(n^2)）

int[] arr = new int[] {43,56,78,23,55,89,54,-52,-59,0,77};
        //冒泡排序
        for(int i=0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-1-i;j++) {
                if(arr[j+1]<arr[j]) {
                    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]+" ");
        }

快速排序：（之后再看，涉及的知识有点多）（时间复杂度：O(nlog2n)）

数组调包实现操作

//java.util.Arrays:操作数组的类，里面定义了很多操作数组的方法
import java.util.Arrays;
public class ArrayTest {
    public static void main(String[] args) {
        //1.boolean equals(int[] a, int[] b):判断两个数组是否相等
        int[] arr1 = new int[] {1,2,3,4};
        int[] arr2 = new int[] {1,2,4,3};
        boolean isEquals = Arrays.equals(arr1,arr2);
        System.out.println(isEquals);
        
        //2.String toString(int[] a):输出数组信息
        System.out.println(Arrays.toString(arr1));
        
        //3.void fill(int[] a, int val):将指定的值填充到数组当中
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1)); //输出[10,10,10,10],即把所有的值替换成10
        
        //4.void sort(int[] a):排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        
        //5.int binarySearch(int[] a,int key):二分查找
        int[] arr = new int[] {43,56,78,79,89,103};
        int index = Arrays.binarySearch(arr, 56);
        System.out.println(index);//输出1。若未找到，则返回负数
    }
}

数组中常见异常

1.数组角标越界异常：ArrayIndexOutBoundsException
2.空指针异常：NullPointerExcption