Java-数组篇

数组

什么是数组

数组（Array），是多个相同数据类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

数组的数组类型

数组本身是引用数据类型 ，数组中的元素可以是任何数据类型数组是内存中连续的空间

数组的分类

两种分类方式：

按维数分类：一维数组和二维数组

按数组元素数据类型分类：基本数据类型元素的数组和引用数据类型元素的数组

一维数组

一维数组的声明和初始化

静态初始化

int array = {1,2,3,4,5};//静态

(可以省略new int 前提是等号前面有int)

动态初始化 ：

String [] names = new String[5];//动态

数组一旦初始化 其长度就确定了

如何获取一维数组的长度

name.length（数组的长度即数组中元素的个数）

如何遍历数组元素

for循环

一维数组的默认初始化值

整型byte short int long 数组元素的默认初始化值都是0

浮点型数组元素的默认初始化值都是0.0

char型数组元素的默认初始化值都是0，不是‘0’

布尔型数组元素的默认初始化值都是false

引用数据类型数组元素默认初始化值为null

一维数组的内存解析

栈 存放局部变量（放在方法中的变量）

堆 存放new出的结构

方法区

二维数组

二维数组的初始化

静态初始化

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

动态初始化

String [][]arr2 = new String[3][2];//动态初始化方式一
String [][]arr3 = new String[3][]//动态初始化方式二

获取二维数组的长度

int [] arr1 = new int [] []{{1,2,3},{4,5},{6,7}};
arr1.length = 3；
arr1[1].length = 2

如何遍历二维数组

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

二维数组的默认初始化值

针对初始化方式一：

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

int [][] arr =new int[4][3];
System.out.println(arr[0]);//输出 [I@15db9742 地址值
System.out.println(arr[0][0]);//输出0

float [][] arr1 =new float[4][3];
System.out.println(arr1[0]);//输出 [F@******** 地址值
System.out.println(arr1[0][0]);//输出0.0

String [][] arr2 =new float[4][2];
System.out.println(arr2[1]);//输出 地址值
System.out.println(arr2[1][1]);//输出null

针对初始化方式二：

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错

dounle [][] arr3 =new dounle[4][];
System.out.println(arr1[1);//输出null 因为数组是引用数据类型
System.out.println(arr1[1][0]);//程序报错

二维数组的内存解析

自己画图理解一下

多维数组的使用

int []x,y[];//x是一维数组，y为二维数组
//等同于
int []x;
int[]y[];

同类型才能赋值或者自动类型提升

---

数组中的常见算法

数组元素的赋值

杨辉三角

package com.gmf.java;

public class YangHui {
    public static void main(String[] args){
        int [][]yangHui = new int [10][];
        for (int i=0;i< yangHui.length;i++){
             yangHui[i] = new int [i+1];
            yangHui[i][0]=yangHui[i][i] = 1;
            for(int j = 1;j< yangHui[i].length-1;j++) {
                yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            }
        }
//        for (int i=0;i< yangHui.length;i++){
//            for(int j = 0;j< yangHui[i].length;j++){
//                System.out.print(yangHui[i][j]+"  ");
//            }
//            System.out.println();
//        }
        for (int[] childYangHui:yangHui){
            for(int number:childYangHui){
                System.out.print(number+"  ");
            }
            System.out.println();
        }
    }
}

求数组元素的最大值、最小值、平均数、总和等

数组的复制、反转、查找（线性查找、二分法查找）

int array1,array2;
array1=new int[]{2,3,4,6,7};
array2 =array1；//不算复制，只是地址值一样，都指向了堆空间中唯一的数组实体
for (int i = 0;i<array2.length;i++){
    if(i%2==0){
        array2[i]=i;
    }
}
打印array1，发现元素也变了
修改array2里面的元素值，array1的元素值也随之改变

如何复制？重新new一个等长的数组 通过for循环赋值

数组元素的反转

for (int i = ;i<arrr.length/2;i++){只要进行到一半就行
    String temp =arr[i];
    arr[i]=arr[arr.length-i-1];
    arr[arr.length-i-]=temp;
}

查找

线性查找

String dest = "BB";
boolean isFlag = true;
for (int i = 0;i<arr.legth;i++){
    if(dest.equals(arr[i])){
        System.out.println("找到了指定元素，位置为："+i);
        isFlag = False;
        break;
    }
}
if(isFlag){
    System.out.println("很抱歉，没有找到")；
}

二分法查找：所要查找的数组必须有序

int [] arr2 =new int []{-98,-34,-2,34,54,66,79,105,210,333};
int dest = 34;
int head = 0;//初始首索引
int end = arr.length-1；//初始的末索引
boolean isFlag = true;
while(head<=end){
    int middle = (head+end)/2;
    if(dest == arr2[middle]){
    	System.out.println("找到了指定的元素,位置为"+middle);
        isFlag = false;
    }else if(arr[middle]>dest){
        end = middle - 1;
    }else{
        head = middle + 1;
    }
}
if(isFlag){
    System.out.println("找不到！");
}

数组元素的排序算法

衡量排序算法的优劣：

1：时间复杂度：分析关键字的比较次数和记录的移动次数

2：空间复杂度：分析排序算法中需要多少辅助内存

3：稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的（不影响其他变量的排序）

排序算法的分类：内部排序和外部排序（是否需要借助外部存储设备）

十大内部排序算法

冒泡和快速先掌握

算法的五大特征

1. 输入
2. 输出
3. 有穷性
4. 确定性
5. 可行性

冒泡排序

public class  BubbleSortTest{
    public static void main(String[] args){
        int[] arr = new int[]{42,32,76,-98,0,64,33,-21,32,99};
        for (int i = 0;i<arr.length-1;i++){//8个元素要交换七大轮
            for(int j =0;j<arr.length-1-i;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.println(arr[i]);
        }
    }
}

冒泡排序时间复杂度（平均）：O(n^2) 稳定

快速排序时间复杂度（平均）：O(nlog2n)不稳定

Arrays工具类的使用

1//boolean equals([int[]a,int[]b)
boolean isEquals = Arrays.equals(arr1,arr2);//判断两个数组是否相等

2//String toString(arr1)
Arrays.toString(arr1);//输出数组信息

3//void fill(int[]a,int val)
    Arrays.fill(arr,10);//将数组中所有的元素全部替换成给定参数的值
4// void sort(int[]a)
    Arrays.sort(array2);
5//int binarySearch(int[]a,int key)
Arrays.binarySearch(arr3,21);//返回值为负数则没找到，正数则为被找的数的位置

数组中的常见异常

1 数组角标越界的异常:
ArrayIndexOutOfBoundsException

2 空指针异常：
Null Pointer Exception

Ps:一旦出现异常未处理，程序即终止运行