05-Java数组

数组

所谓数组(Array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

数组的特点：

• 数组的长度一旦确定就不能修改

• 创建数组对象会在内存中开辟一整块连续的空间。而数组名中引用的是这块连续空间的首地址。

• 遍历数组和获取某个元素的速度快，因为可以通过数组名+下标，直接定位到任意一个元素。

数组的分类：

• 数组按照维度分为：一维数组、二维数组、多维数组

• 数组按照元素的数据类型分：基本数据类型元素的数据，引用数据类型元素的数组

1.一维数组

1.1一维数组的声明

数组的声明：

1. 数组类型 数组名; 即 元素数据类型[] 数组名;

例如:

int[] arr1; //格式1
char arr2[];//格式2

1.2一维数组的初始化

初始化的目的：

• 确定数组的长度
• 为元素赋值

1. 静态初始化

当数组的元素是已知的有限个时，可以使用静态初始化。

数据类型[] 数组名 = new 元素的数据类型[]{
    
    值列表};
数据类型[] 数组名 ={
    
    值列表}；//更简洁
int[] arr = {
    
    1,2,3,4};

2. 动态初始化

数据类型 数组名 = new 元素数据类型[数组的长度];
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

动态初始化时数组的长度在[]中指定，而且必须指定

动态初始化时每一个元素有默认值

（1）基本数据类型

​ byte,short,int,long：0

​ float,double：0.0

​ char：\u0000

​ boolean：false

（2）引用数据类型

​ 统统都是null

注意：

• 无论是静态初始化还是动态初始化必须确定数组长度。

• 动态初始化在创建数组对象时，显式指明长度，静态初始化，由列出的元素个数确定数组的长度

1.3一维数组的遍历

for循环遍历数组：

for(int i=0; i<数组名.lenght; i++){
    
    
    //或赋值
    数组名[i] = 值;
    //或显示
    System.out.println(数组名[i])；
    //或其他操作
    //例如：判断是否是偶数
    if(数组名[i]%2==0){
    
    
          //...
    }
}

1.4一维数组的内存分析

int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

1.5一维数组的反转

1. 借助一个新数组

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

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    
    
    newArr[i] = arr[len -1 - i];
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    
    
    System.out.println(arr[i]);
}

2. 首位对应交换

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

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){
    
    //循环的次数就是交换的次数
    //首  与  尾交换
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    
    
    System.out.println(arr[i]);
}

1.6查找

1. 顺序查找：对数组没要求

int[] arr = {
    
    4,5,6,1,9};
int value = 1;
int index = -1;

for(int i=0; i<arr.length; i++){
    
    
    if(arr[i] == value){
    
    
        index = i;
        break;
    }
}

if(index==-1){
    
    
    System.out.println(value + "不存在");
}else{
    
    
    System.out.println(value + "的下标是" + index);
}

2. 二分查找：对折对折再对折

   对数组有要求，元素必须有大小顺序的

class Test{
    
    
	public static void main(String[] args){
    
    
		int[] arr = {
    
    1,2,3,4,5,6,7,8,9};//数组是有序的
		int value = 2;
		
        int index = -1;
		int left = 0;
        int right = arr.length - 1;
        int mid = (left + right)/2;
        while(left<=right){
    
    
            //找到结束
            if(value == arr[mid]){
    
    
                index = mid;
                break;
            }//没找到
            else if(value > arr[mid]){
    
    //往右继续查找
                //移动左边界，使得mid往右移动
                left = mid + 1;
            }else if(value < arr[mid]){
    
    //往左边继续查找
                right = mid - 1;
            }
            
            mid = (left + right)/2;
        }
        
        if(index==-1){
    
    
    		System.out.println(value + "不存在");
		}else{
    
    
    		System.out.println(value + "的下标是" + index);
		}
        
	}
}

1.7冒泡排序

从小到大，从左到右两两比较

int[] arr = {
    
    5,4,6,3,1};
for(int i=1; i<arr.length; i++){
    
    //外循环的次数 = 轮数 = 数组的长度-1
    for(int j=0; j<arr.length-i; j++){
    
    
    	//内循环的次数为length-i
    
        //两两比较
        //从小到大，说明前面的比后面的大，就交换
        if(arr[j] > arr[j+1]){
    
    
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

1.8数组常见异常

• 越界 ArrayIndexOutOfBoundsException

• 空指针 NullPointerException

 

2.二维数组

通俗的理解：

​ 一维数组比喻成平房，就一层楼，有几间房

​ 二维数组比喻成楼房，有几层楼，每层楼各有几间房

2.1二维数组的声明

格式：元素的数据类型[][] 二维数组名;

  //推荐
  元素的数据类型[][] 二维数组的名称;

 //不推荐
 元素的数据类型  二维数组名[][];
 //不推荐
  元素的数据类型[]  二维数组名[];

2.2二维数组的初始化

1. 静态初始化

元素的数据类型[][] 二维数组的名称 = {
    
    
			{
    
    第一行的值列表}, 
			{
    
    第二行的值列表},
			...
			{
    
    第n行的值列表}
		};

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

2. 动态初始化

​ 数组对象的创建与元素的赋值分开进行

//1.每行的列数相等
数据类型[][] 数组名 = new 元素的数据类型[行数][列数];
数组名[行下标][列下标] = 值;

//2.每行的列数不确定
数据类型[][] 数组名 = new 元素的数据类型[行数][];
数组名[行下标] = new 元素的数据类型[该行的总列数];
数组名[行下标][列下标] = 值;

2.3二维数组的遍历

for(int i=0; i<二维数组名.length; i++){
    
    
    for(int j=0; j<二维数组名[i].length; j++){
    
    
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

2.4二维数组的内存分析

int[][] arr = new int[2][];
arr[0] = new int[3];
arr[1] = new int[2];
arr[0][1] = 1;

3.递归

程序调用自身的编程技巧称为递归（ recursion）。

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归求 斐波那契数列： 1、1、2、3、5、8、13、21… 的第n项

import java.util.Scanner;

public class Fibonacci {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("请输入n:");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println(fib(n));

    }
    public static int fib(int n){
    
    
        if(n==1||n==2){
    
    
            return 1;
        }
        return fib(n-2)+fib(n-1);
    }
}