JAVA一维数组

妖狐艹你老母 2022-05-17 23:57 265阅读 0赞

### 数组的定义： ###

在Java中，数组是指一组数据的集合。

在数组中能存放任意类型的元素，但同一个数组里面的元素类型必须一致。

**格式：**数据类型\[ \] 数组名 = new 数据类型\[ 数组容量 \] ； （推荐这种写法）

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

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    
    	//下面这些数组定义都是合法的
    	int[] arr1 =new int[10];
    	//素组arr2和arr1是一样的,没有区别,推荐使用第一种写法
    	int arr2[] =new int[10];
    	
    	double[] arr3 =new double[5];
    	float[] arr4 =new float[5];
    	String[] arr5 =new String[5];
    	short[] arr6 =new short[5];
    	long[] arr7 =new long[5];
    	
        }
    }

### 数组的使用： ###

数组中的每个数据被称为元素。

所有数组中的都有一个序号（索引、下标、角标......），都是从0开始，连续递增到数组容量减一。 （建议采用“索引”这一叫法）

数组元素的存取，都是通过数组的索引完成的。

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    	// 声明一个名叫arr的整形数组,容量为10
    	int[] arr = new int[10];
    
    	arr[1] = 100;// 将100赋值给 arr[1],可以理解为把100放到了arr数组的第二个位置.
    	System.out.println("arr[1]的值:" + arr[1]);// 打印arr[1]的值
    
    	arr[2] = 36;
    	System.out.println("arr[2]的值:" + arr[2]);
    
    	arr[0] = arr[1] + arr[2];// 取出arr[2]和arr[1]的值后,将其和放到arr[0]
    	System.out.println("arr[0]的值:" + arr[0]);// 打印arr[0]的值
        }
    }

运行结果：

![运行结果][70]

数组值的初始化分为：动态初始化和静态初始化。

上图源码的初始化是动态初始化，动态初始化是指在定义数组时只指定数组的长度，由系统自动为数组元素赋值的方式。

静态初始化，就是在定义数组的同时就为数组的每个元素赋值。

静态初始化有两种方式，格式如下：

数据类型\[ \] 数组名 = new 数据类型\[ \] \{ 元素，元素，元素 ......\}；

数据类型\[ \] 数组名 = \{ 元素，元素，元素 ......\}；

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    	// 动态初始化
    	int[] arr = new int[10];
    
    	//静态初始化,这个时候数组容量不能指定了
    	char[] arr2 = new  char[] {'a','S','T','v','k','0'};
    	
    	//字符数组arr3和arr2是等价的
    	char[] arr3 = {'a','S','T','v','k','0'};
    	
        }
    }

### 数组的常见操作： ###

**数组的遍历**

在操作数组时，经常需要依次访问数组中的每个元素，这种操作被称为数组的遍历。

数组的遍历常用for循环语句来实现，其他循环语句也可实现，for循环语句使用更方便。

每个数组都具有一个属性length，表示数组的长度，数组一旦建立，数组的容量就确定了，也就是length的值确定。

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    
    	// 静态初始化一个字符数组,一共有6个字符,索引号012345,length的值为6
    	char[] arr = new char[] { 'a', 'S', 'T', 'v', 'k', '0' };
    
    	System.out.println("数组arr的长度为:" + arr.length);
    
    	for (int i = 0; i < arr.length; i++) {
    	    System.out.println("arr数组里索引(下标)为 " + i + " 的元素值是 " + arr[i]);
    	}
    	System.out.println("==========================");
    
    	// JDK1.8之后的foreach语句
    	for (char c : arr) {
    	    System.out.println("arr数组的元素值依次是 " + c);
    	}
        }
    }

运行结果：

![运行结果][70 1]

**数组的最值**

在操作数组时，有时候需要得到数组中最值，一般利用数组的遍历来得到最值。

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    
    	int[] arr = new int[] { 98, 55, 32, 61, 97, 8, 13 };
    	System.out.println("==========================");
    	System.out.println("数组arr的长度为:\t" + arr.length);
    
    	int min = arr[0];// 声明一个变量,用来存储数组的最小值,假设数组的首个元素即是最小值
    	int max = arr[0];
    
    	for (int i = 0; i < arr.length; i++) {
    	    if (arr[i] < min)// 比最小值还小,保存这个值为最小值
    	    {
    		min = arr[i];
    	    }
    	    if (arr[i] > max)// 比最大值还大,保存这个值为最大值
    	    {
    		max = arr[i];
    	    }
    	} // for
    	System.out.println("数组arr里的最小值为:\t" + min);
    	System.out.println("数组arr里的最大值为:\t" + max);
    	System.out.println("==========================");
    
        }
    }

运行结果：

![运行结果][70 2]

**数组的排序：**

数组的排序算法比较多，这里介绍一种常用的排序算法，叫冒泡排序。后面学过封装类之后，直接调用Arryas类里面封装好的方法即可实现数组的排序。

示例：

public class Test_No_Sava {
    
        public static void main(String[] args) {
    
    	int[] arr = new int[] { 98, 55, 32, 61, 97, 8, 13 };
    
    	System.out.println("=====================================================");
    	// 采用升序排序
    	System.out.print("冒泡排序前,数组arr的元素为:\t");
    
    	printfArr(arr);// 打印数组
    
    	// 外层循环
    	for (int i = 0; i < arr.length - 1; i++) {
    	    // 内层循环
    	    for (int j = 0; j < arr.length - 1 - i; j++) {
    		// 比较相邻的两个元素
    		if (arr[j] > arr[j + 1]) {
    		    // 前大后小,交换两个元素
    		    int num = arr[j];
    		    arr[j] = arr[j + 1];
    		    arr[j + 1] = num;
    		}
    	    } // for
    
    	    System.out.print("冒泡排序中,第 " + (i + 1) + " 轮排序后:\t");
    	    printfArr(arr);
    	} // for
    	System.out.println("冒泡排序完成!");
    	System.out.println("=====================================================");
    
        }// main
    
        private static void printfArr(int[] arr) {
    	// 输出数组元素开头的符号{
    	System.out.print("{ ");
    	for (int i = 0; i < arr.length; i++) {
    	    // 中间的元素输出格式为 值,
    	    // 最后一个元素后为} 前面没有,号
    	    if (i < arr.length - 1) {
    		System.out.print(arr[i] + ", ");
    	    } else {
    		// 最后一个元素输出
    		System.out.print(arr[i] + " }");
    	    }
    	} // for
    	System.out.println();
        }// void
    }

运行结果：

![运行结果][70 3]

# 多维数组是在一维数组上的拓展，这里不再详细介绍。 #

[70]: /images/20220518/74f0f708fc8041dda20337273a8e0be4.png
[70 1]: /images/20220518/dba56333166543e8a268e07d516f66a2.png
[70 2]: /images/20220518/85e749d89319448f9298ed3aea155b1f.png
[70 3]: /images/20220518/14b64acc7fa54da08c55b78ad3202302.png