数组

最新推荐文章于 2025-09-16 09:40:26 发布

原创最新推荐文章于 2025-09-16 09:40:26 发布 · 310 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

笔记专栏收录该内容

99 篇文章

订阅专栏

1.数组的概念

1.1数组的定义

基本格式

数据类型[] 数组名 = new 数据类型[容量

2.数组的声明与赋值

赋值左侧

数据类型：

告知编译器，当前数组中能保存的数据类型到底是什么？并且在确定数据类型之后，整个数组中保存的数据类型无法更改

[]：

1.告知编译器这里定义的是一个数组类型数据

2.告知编译器，数组是一个【引用数据类型】

数组名：

1.操作数据非常重要的数据

2.数组是一个【引用数据类型】

赋值号右侧：

new：

申请【XX】内存空间，并且清空整个内存空间中所有二进制位，所有的二进制位都是0

数据类型：

前后呼应，告知编译器这里支持的存储的数据到底是什么

[容量]：

容量==>capacity

代码

int [] arr= new int [10];

3.数组的下标

数组中的下标是从0开始；到数组的容量-1

例如：数组容量为10。有效下标范围为0-9

超出有效下标范围，都是无效下标。

容易出现的问题

1.数组下标越界：

ArrayIndexOutOfBoundsException

package day04;

public class Demo1 {
	public static void main(String[] args) {
		//定义一个int类型的数组
		int [] arr= new int [10];
		//首先赋值数组中下标位0的元素
		arr[0]=10;
		arr[2]=20;
		//可以取值也可以赋值
		System.out.println(arr[0]);
		System.out.println(arr[2]);
	}

}

堆区和栈区区别

堆区可以由程序员分配，栈区只能有系统分配。

引用数据类型是什么

开发中引用数据类型，用于保存其他内存空间的首地址，保存地址后，cpu可以通过对应的引用数据类型，得到对应的地址，从而访问对应的内存空间

数组和循环之间的联系

获取数组容量的方式：数组名.length 属性当前的数组属性length是要占用一定的数组空间的，属于数组中的内容。

package day04;

public class Demo2 {
	public static void main(String[] args) {
		int arr[] = new int [10];
		
		//使用for循环对数组每一个进行赋值
		for(int i =0;i<arr.length;i++){
			arr[i] = i+1;
			
			
		}
		//使用for循环对数组中元素进行取值展示
		for(int i =0;i<arr.length;i++){
			System.out.println("arr"+"["+i+"]"+arr[i]);
			
			
		}
	}

}

数组和方法之间的关系

java中如何让数组成为方法的参数，已经使用使用方式

package day04;

public class Demo3 {
	 
	public static void main(String[] args) {
		int arr[]=new int[10];
		m1(arr);
		m2(arr);
		
	}
	public static void m1(int[] arr){
		for(int i =0;i<arr.length;i++){
			arr[i] = i+1;
		}
	}
	public static void m2(int[] arr){
		for(int i =0;i<arr.length;i++){
			System.out.println("arr"+"["+i+"]"+arr);
			
		}
	}

}

4.数组的遍历

数组的算法

完成一个数组的逆序过程

1，3，5，7，9，2，4，6，8==>8,6,4,2,9,7,5,3,1

package day04;

import java.util.Arrays;

public class Demo4 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8};
		reverse(arr);
		System.out.println(Arrays.toString(arr));
	}
	public static void reverse(int[] arr){
		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;
			
		}
	}

}

找出数组中最大值所在下标的位置

package day04;

public class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8};
		int index = maxIndexOf(arr);
		System.out.println(index);
		
	}
	public static int maxIndexOf(int[] arr){
		//假定下标为0的元素是数组中最大值
		int maxIndex =0;
		for(int i =0;i<arr.length;i++){
			if(arr[maxIndex]<arr[i]){
				maxIndex =i;
				
			}
			
		}
		return maxIndex;
	}

}

找出数组中指定元素所在的下标位置

package day04;

public class Demo6 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,1,3,5,7,9};
		int index =indexOf(arr, 5);
		if(index>=0){
			System.out.println(index);
			
		}else{
			System.out.println("no");
		}
		
		
	}
	/**
	 * 找出数组中指定元素出现的下标位置
	 */
	public static int indexOf(int[] arr,int find){
		
		//假定对应查询数据是不存在的
		int index = -1;
		//利用循环，从下标为0的元素开始到最大下标，对比是否存在find
		for(int i =0;i<arr.length;i++){
			//发现指定find元素和下标为i的元素一致
			if(find == arr[i]){
				//使用index保留对应的下标i
				
				index = i;
				//终止循环
				break;
				
			}
			
		}
		
		return find;
		
	}

}

获取数组中指定下标的元素

package day04;

public class Demo7 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,1,3,5,7,9};
		System.out.println(get(arr,5));
		
		
	}
	/**
	 * 找出指定下标的元素
	 */
	public static int get(int [] arr,int index){
		
		//用户指定的index不能超出有效下标范围
		
		if(index<0|| index>arr.length-1){
			/**
			 * 返回任何的数据类型都不合适，可以考虑终止方法，并告诉用户错误是什么
			 */
			System.out.println("input Paramter is Invaliad");
			//当前方法退出
			System.exit(0);
			
		}
		return arr[index];
		
	}

}

找出元素最小的下标

package day04;

public class Demo8 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8,19};
		int min =minIndexOf(arr);
		System.out.println(min);
		
	}
	public static int minIndexOf(int[] arr){
		int min =0;
		for(int i =1;i<arr.length;i++){
			if(arr[min]>arr[i]){
				min = i;
				
			}
			
		}
		
		return min;
		
	}

}

找出元素最后一次出现的位置

package day04;

public class Demo9 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8,19};
		int index=lastIndexOf(arr, 19);
		System.out.println(index);
		
		
	}
	public static int lastIndexOf(int[] arr,int find){
		
		//假定找不到对应的数据
		int index = -1;
		for(int i = arr.length-1;i>=0;i++){
			//找到对应元素保存index，终止循环
			if(find == arr[i]){
				index= i;
				break;
				
			}
			
		}
		return index;
		
	}
	

}

找出指定元素在指定数组中所有的下标位置

a.不允许在方法内打印

b.考虑到多数据情况

c.需要在方法外获取下标数据信息

d.不允许使用数组作为返回值

package day04;

public class Demo10 {
	public static void main(String[] args) {
		int [] arr = {1,3,5,7,9,1,3,5,7,9,10};
		int [] indexArr = new int[arr.length];
		int count = allIndexOf(arr, indexArr, 5);
		//count是查询到的指定元素个数，同时可以利用与循环中，找到对应的元素
		for(int i =0;i<count;i++){
			System.out.println(indexArr[i]);
			
		}
		
		
	}
	public static int allIndexOf(int[] arr,int[] indexArr,int find){
		
		//参数合法性判断 
		if(arr.length>indexArr.length){
			System.out.println("no");
			//参数不合法，没有找到数据
			return 0;
			
			
		}
		/**
		 * 定义一个变量。计数器，记录找到元素个数
		 * 尾插法当中下一次存放元素的位置
		 */
		
		
		int  count =0;
		//利用循环遍历整个数据arr数组
		
		for(int i =0;i<arr.length;i++){
			//找到对应的元素，保存下标i
			if(find == arr[i]){
				//保存到indexArr数组中
				//需要使用尾插法  保存下一次存放数据的位置
				indexArr[count]=i;
				count +=1;
				
			}
			
		}
		return count;
			
		}
	

}

在指定位置插入指定元素

package day04;
//在指定位置插入指定元素

import java.util.Arrays;

public class Demo11 {
	
	public static void main(String[] args) {
		int[] array = {1,3,5,7,9,11,13,15,17,0};
		add(array, 5, 20);
		System.out.println(Arrays.toString(array));

	}
	
	/**
	 * 在指定的数组中插入指定的元素
	 * @param arr 指定的int类型数组
	 * @param index指定的下标位置，必须在合理的区间范围以内
	 * @param insert 指定插入的元素 int类型
	 * @return添加成功返回ture
	 */
	public static boolean add (int[] arr,int index,int insert){
		
		//参数合法性判断
		if(index<0||index>arr.length -1){
			System.out.println("运行失败");
			//方法运行失败
			return false;
			
		}
		for(int i = arr.length -1;i>index;i--){
			arr[i]=arr[i-1];
			
		}
		arr[index] = insert;
		return true;
		
		
		
	}
	


}

删除数组中指定下标的元素

package day04;

import java.util.Arrays;

public class Demo12 {

	public static void main(String[] args) {
		int[] array = {1,3,5,7,9,11,13,15,17,0};
		remove(array, 3);
		System.out.println(Arrays.toString(array));
		
	}
	public static boolean remove(int[] arr,int index){
		//判断合法性判断
		if(index<0||index>arr.length - 1){
			System.out.println("方法错误");
			return false;
		}
		
		for(int i = index;i<arr.length-1;i++){
			arr[i]=arr[i+1];
			
		}
		arr[arr.length - 1]=0;
		return true;
		
		
	}
}

5.数组的排序

选择排序算法：升序排列核心（找换）

package day04;

import java.util.Arrays;

/**
 * 选择排序算法
 * @author 刘朝阳
 *
 */

public class Demo13 {
	public static void main(String[] args) {
		int[] array = {1,3,5,7,9,11,13,15,17,0};
		selectSort(array);
		System.out.println(Arrays.toString(array));
		
	}
	public static void selectSort(int[] arr) {
		//外部循环控制核心算法的循环次数
		for(int i =0;i<arr.length- 1;i++){
			//聪明和index位置开始寻找极值
			int index = i;
			for(int j = i+1;j<arr.length;j++){
				if(arr[index]<arr[j]){
					index = j;
				}
				
			}
			if(index != i){
				int temp = arr[i];
				arr[i] = arr[index];
				arr[index]=temp;
				
			}
			
		}
		
	}

}

冒泡排序：

package 冒泡排序;

import java.util.Arrays;
/**
 * 冒泡排序
 * @author mmz
 *
 */
public class BubbleSort {
    public static void BubbleSort(int[] arr) {
        int temp;//定义一个临时变量
        for(int i=0;i<arr.length-1;i++){//冒泡趟数
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j+1]<arr[j]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int arr[] = new int[]{1,6,2,2,5};
        BubbleSort.BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

6.数组的应用

Arrays数组工具类的使用

数组的工具类：提供了数组操作的基本方法

sort(int[] arr);

快速排序算法

package day04;

import java.util.Arrays;

public class Demo14 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8,10};
		System.out.println(Arrays.toString(arr));
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}

}

binarySearch(int[] arr,int find);

二分法查询，要求数组是有序的

package day04;

import java.util.Arrays;

public class Demo14 {
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8,10};
		System.out.println(Arrays.toString(arr));
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		
		/**
		 * 二分法查找
		 * 1.数据必须有序，无序情况下不保证查询结果情况
		 * 2.数据未找到，返回负数
		 * 3.多个相同数据的情况下，不保证找到数据是第几个数据
		 */
		int index = Arrays.binarySearch(arr, -5);
		System.out.println(index);
	}

}

toString(任何数据类型）；

把数组内容做出一个String类型字符串返回值