array数组_array[integer]-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43819419/article/details/112357948

本文介绍了Java中的数组，包括定义、初始化和操作数组的基本示例。文章中还详细讲解了数组越界异常，并通过一个具体的例子展示了如何引发此类异常。此外，还探讨了冒泡排序算法，解释了其工作原理并提供了相关的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组

程序 = 算法 + 数据结构

算法：解决程序的流程步骤（顺序、分支、循环）数据结构：

将数据按照某种特定的结构来存储设计良好的数据结构会导致良好的算法。

ArrayList、LinkedList

数组是最简单的数据结构。

数组：存在同一种类型的数据的集合

实例

int num = 3; 定义一个整形

int[] array = new int[4] 定义了一个长度为4的整型数组

	int[] array1 = new int[4];
	double[] array2 = new double[4];
	String[] array3 = new String[4];

存放的数组是整型
存放长度是4
只能存放整数

array[1] = 2 对数组进行赋值

int length = array.length 读取数组的长度

array[i] 读取第i个数组的数据

    //数组定义方式
    //定义一：先定义后赋值
    int[] array = new int[4];
    array[0] = 1;
    array[1] = 2;
    array[2] = 3;
    array[3] = 4;
    //定义二：直接赋值
    int[] array = {1, 2, 3, 4}
    int[] array = new int[]{1, 2, 3, 4}

    //数组遍历
    for(int i = 0; i < array.length(); i++)
        System.out.println(array[i]);

数组越界异常

public void test3() {
		int array[] = new int[4];
		array[0] = 2;
		array[1] = 21;
		array[2] = 32;
		array[3] = 34;
		for (int i = 0; i <= array.length; i++) {
			System.out.println(array[i]);
		}
	}

显示异常：

java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
at java01.ArrayDemo.test3(ArrayDemo.java:78)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:64)
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.base/java.lang.reflect.Method.invoke(Method.java:564)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:89)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:41)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:541)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:763)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:463)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:209)

冒泡排序

数组的排序：冒泡排序int[] array = {40, 17, 21, 1}; // 1, 17,21,40

第一轮：40冒到最右边17,40,21,117,21,40,117,21,1,40 ------- 40 冒出来

第二轮：21冒出来17,21,1,4017,1,21,40 ------- 21冒出来

第三轮：17冒出来1,17,21,40 ------- 17冒出来
4个数只要比较3轮就可以，剩下那个数不要要排序就是最小的

第一轮：比较3次

第二轮：比较2次

第三轮：比较1次

i+x =4=array.length

x=array.length-i

@Test
	public void test4() {
		//冒泡排序
		int[] array = {14, 43, 31, 2, 3};
		for(int i = 1; i <= array.length - 1; i++) {
			for(int j = 0; j < array.length - i; j++) {
				if(array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}

代码

package java01;

import org.junit.Test;

public class ArrayDemo {
	
	//数组
	
	public static void main(String[] args) {
		System.out.println();
	}
	
	@Test
	public void test1() {
		//assign 赋值
		int num = 5;
		
		int[] array = new int[4];
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		array[3] = 4;
		
		//1.存放整数类型的数组
		//2.只能存放整数
		//4.长度是4
		
		//求数组长
		int length = array.length;
		System.out.println(length);
		
		//正序遍历
		for(int i = 0; i < length; i ++) {
			System.out.print(array[i] + " ");
		}
		
		System.out.println();
		
		//逆序遍历
		for(int i = length - 1; i >= 0; i--)
			System.out.print(array[i] + " ");
	}
	
	@Test
	public void test2() {
		int[] array1 = new int[4];
		double[] array2 = new double[4];
		String[] array3 = new String[4];
		
		int[] array = new int[4];
		array[0] = 23;
		array[1] = 45;
		array[2] = 3;
		array[3] = 14;
		
		int max = array[0];
		int min = array[0];
		
		for(int i = 1; i < array.length; i++) {
			if(min > array[i])
				min = array[i];
			if(max < array[i])
				max = array[i];
		}
		
		System.out.println("The max is " + max);
		System.out.println("The min is " + min);
	}
    
    @Test
	public void test3() {
		int array[] = new int[4];
		array[0] = 2;
		array[1] = 21;
		array[2] = 32;
		array[3] = 34;
		for (int i = 0; i <= array.length - 1; i++) {
			System.out.println(array[i]);
		}
	}
	
	@Test
	public void test4() {
		//冒泡排序
		int[] array = {14, 43, 31, 2, 3};
		for(int i = 1; i <= array.length - 1; i++) {
			for(int j = 0; j < array.length - i; j++) {
				if(array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}
}