Java基础06-数组

超、凢脫俗 2023-10-20 06:10 95阅读 0赞

1.数组的好处

1、同时存储多个数，代码更简洁，提高效率
        2、分类存储，方便查找

2.数组的声明和使用步骤

声明
            数据类型[]  数组名称;  或  数据类型  数组名[];
    创建数组对象
            等价于在堆中申请数组空间
            数组名 = new 数据类型[长度];
            或合二为一：数据类型[]  数组名称 = new 数据类型[长度];
            当创建完数组对象后，数组中的每一个元素有默认值
    初始化/赋值
            静态初始化
                数组的声明，数组对象的创建，数组元素的赋值在一条语句完成
                数据类型[]  数组名 = {元素值1,元素的值2......};
                数据类型[]  数组名 = new  数据类型[]{值1,值2....};
            动态初始化
                适用于一开始不清楚元素的值是什么，赋值比较有规律
                一般使用for循环
    
             例如：int[] arr = new int[5];
            for(int i=0; i<arr.length; i++){
                arr[i] = 值; 或 arr[i] = 键盘输入;
            }
     原生态赋值
                单独各自赋值：数组名[下标] = 值;

3.数组的常见算法

1、循环打印

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

2、求总和和平均值

例如：int[]  arr = {1,2,3,4,5};
    int sum = 0;
    for(int i=0; i < arr.length; i++){
    	sum += arr[i];
    }
    double avg = (double)sum / arr.length;

3、查找  
查找，如果数组中有你要找的元素，就返回下标，如果没有返回-1

例如：int[]  arr = {1,2,3,4,5};
    int index = findElement(arr, 4);
    
    public int findElement(int[] src , int key){
    	for(int i=0; i < src.length; i++){
    		if( key == src[i] ){
    			return i;
    		}
    	}
    	return -1;
    }

4、找最值

例如：int[]  arr = {1,2,3,4,5};
    int index = findElement(arr, 4);
    
    //返回最小值的下标
    public int getMin(int[] src){
    	int min = src[0];
    	int index = 0;
    	for(int i=0; i < src.length; i++){
    		if( min > src[i] ){
    			min = src[i];
    			index = i;
    		}
    	}
    	return index;
    }

5、排序  
冒泡排序  
通过相邻两个元素的比较，如果前一个元素比后一个元素大，然后交换实现把大的元素往后移，通过几轮之后，实现排序

int[] arr = {5,4,3,2,1};//从小到大排序
    //外循环控制轮数
    for(int i = 1; i<arr.length ; i++){
    	//内循环控制每轮的比较的次数
    	for(int j=1 ; j <= arr.length - i ; j++){
    		if(arr[j-1] > arr[j]){
    			int temp = arr[j-1];
    			arr[j-1]=arr[j];
    			arr[j]=temp;
    		}
    	}
    }

选择排序  
先把数组分为未排序和已经排序的两部分，每次从未排序的部分选出最小值，放到已经排序的部分的最后，经过多次，然后实现排序

int[] arr = {5,4,3,2,1};//从小到大
    //外循环控制轮数，每轮负责找出本轮的最小值
    for(int i =0; i< arr.length-1; i++){
    	int min = arr[i];
    	int index = i;
    	//内循环，负责从未排序部分找最小值
    	for(int j=i; j<arr.length; j++){
    		if(min > arr[j]){	
    			min = arr[j];
    			index = j;
    		}
    	}
    	//放到已经排序的部分的最后，通过交换两个元素
    	if(index != i){
    		int temp = arr[i];
    		arr[i]= arr[index];
    		arr[index] =temp;
    	}
    }

6、数组的复制

地址复制，复制的是一个地址值，两个数组引用变量指向同一个地址，相当于指向同一个数组对象，其中一个修改，另一个也跟着变化

int[] arr = {1,2,3,4,5};
    int[] newArr = arr;//地址复制
    newArr[2] = 18;

元素复制  
两个数组对象，互不影响，只不过是新数组的元素与旧数组的元素是一一相等值  
7、反转

方法一：

int[] arr = {1,2,3,4,5};
    for(int  i = 0 ; i< arr.length/2; i++){
    	arr[i] = arr[arr.length-1 -i];
    }

方法二：

int[] arr = {1,2,3,4,5};
    int[] newArr = new int[arr.length];
    for(int i=0;i<arr.length;i++){
    	newArr[i] = arr[arr.length-1-i];
    }
    arr = newArr;

4.Arrays工具类

使用步骤：import java.util.Arrays;
            Arrays.方法名();
        sort()实现数组排序，从小到大
        fill()实现一次性填充整个数组
        copyOf()：复制数组，返回一个全新的数组
        copyOfRange()：从原数组复制一部分[from,to)

5.注意

1、数组的元素的类型可以是任意类型
        2、数组一旦确定大小，长度，就不可以再改变，如果需要改变，只能创建新的数组，然后把旧的数组的元素复制过来
        3、常见的异常
            ArrayIndexOutOfBoundsException
            NullPointerException

6.可变参数

语法：形参部分，最后一个形参：数据类型...  形参名
        一个方法只能有一个可变参数，而且是最后一个，也可是任意类型
        定义方法中，当做数组去使用
        调用的时候，你可以给这个可变参数的位置传递任意个参数0~n个

7.多维数组

声明的格式
            数据类型[][] 数组名;  或  数据类型  数组名[][]  或  数据类型[]  数组名[];
        开辟长度/分配空间
            固定的列数
                数组名 = new  数据类型[行数][列数];
                这个数组中的一维数组已经创建，不为null
                例如：int[][] array = new int[3][5];  array[0]这个一维数组不再为null，array[0].length=5;  array[0][0] = 0;
            不固定列数
                数组名 = new 数据类型[行数][];
                它里面的一维数组现在为null
                例如：int[][] array = new int[3][];  array[0]这个一维数组是null，如果此时你写了array[0].length会报空指针异常NullPointerException
                如果要往这个数组存储数据，需要对每一列单独再分配空间，或者说再创建每一个一维数组才能存数据，例如：array[0]= new int[5];  array[0][0] =0;
        初始化
            动态初始化
                声明、创建数组对象、与给数组的元素赋值是分开的
                int[][] array = new int[3][5];
                for(int i=0;i<array.length; i++){
    	            for(int j=0;j<array[i].length;j++){
    		        array[i][j]=  //从键盘输入  随机产生   根据某种规律计算所得	
    	            }
                }
                array[0][0] = 5;//原生态单独赋值
            静态初始化
                声明、创建数组对象、初始化数组元素是一条语句
                int[][] array = new int[][]{ {值,值} ,{ 值, 值，值}  };
    
                int[][]  array = { {}   ,{}   ,{}};
        使用
            循环赋值，循环打印
            求和

8.对象数组

每一个元素都是对象
        声明：  引用数据类型[]  数组名 = new 引用数据类型[长度];
        赋值：array[i] = 对象;
        使用：array[i].属性   array[i].方法()