Java 数组定义和相关操作

一、数组定义：所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。

二、核心概念：
（1）数组有一个名字，称为数组名。
（2）数组中存放的数据叫做元素（element）每个元素在数组中都有确切的位置，这个位置用下标或者索引来表示。请注意：下标从0开始的。
（3）数组个数=元素最大index+1；数组中元素的个数，常被称为数组的长度（length）;请注意：数组的长度一但确定就不能修改。
（4）数组中存放的元素是有序的。

三、简单了解一维数组和二维数组：
（1）定义：
一维数组定义：type[] arraynam`e。type可以是基本类型和对象类型
如int[] arr;
二维数组定义：可以简单理解为在数组中又存储了数组

（2）初始化方式：
一维数组：

• 静态初始化：如 int[] arr= {1,2,3,4,5,89,87};
• 动态初始化：type[] arr=new type[size] 通过new为数组分配空间 。如 int[] arr=new int[7]这里的7是数组的长度。
  错误写法：
  int[] arr=new int(3);
  int[] arr=new int[];
  int[] arr=new int[3]{1,2,3};

二维数组：

• 静态初始化:int [][] arr={{1,2},{3,4},{5,6}};
• 动态初始化:int [][] arr=new int[3][2];

四、数组操作：

(1)一维数组一些简单操作

package com.etime;

public class Teat01 {

	public static void main(String[] args) {

		int[] intArray1 = { 1, 2, 3, 4, 5, 89, 87 }; // 一维数组静态定义
		int[] intArray2 = new int[3]; // 一维数组动态定义
		intArray2[0] = 1; // 一维数组根据索引赋值
		intArray2[1] = 2;
		intArray2[2] = 3;
		int a = intArray1[2];
		System.out.println(a); // 根据索引得到数组中单个元素
		int i = 15;
		if (i < 0 || i >= intArray1.length) { // 通过if方法判断要取的下标是否正确
			System.out.println("数据有误");
		} else {
			System.out.println(intArray1[i]);
		}
		int len = intArray1.length; // 数组名.length得到数组长度
		System.out.println(len);
	}
}

(2)二维数组的简单操作

package com.etime;

public class Test04 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 二维数组静态定义
		int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
		// 动态定义
		int[][] array1 = new int[3][2];

		array1[0][0] = 1; // 给动态定义数组array1赋值
		int b = array1[0][0]; // 根据下标取出二维数组array1中元素
		System.out.println(b);

		int a = array[1][1]; // 注意两个坐标都是从0开始的 取出来的是4
		System.out.println("根据两个下标取值" + a);

		// 二维数组长度
		int len = array.length;
		System.out.println("二维数组长度:" + len);  // 第一维的数组长度
		int[] arr = array[0];
		int length = arr.length;
		System.out.println(length);  // 第二维的数组长度

		for (int i = 0; i < arr.length; i++) { // 打印第一维下标为0的数组中的元素 结果应为 1 2
			System.out.println(arr[i]);

		}
	}
}

注意：1）二维数组中每一个元素是一个一维数组，所以对二维数组取值时，两个下标都应该标注索引值，这样才能取出单个元素。2）二维数组的长度分为两个部分，即第一位数组的长度和第二维数组的长度。如int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 } };第一维数组长度为3，第二维数组长度为2。

(3)数组的遍历，逆置

package com.etime;

public class Test02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] array1 = { 2, 3, 4, 5 };   // 定义一个一维数组
		int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 } };   // 定义一个二维数组

		// 一维 数组顺序遍历
		for (int i = 0; i < array1.length; i++) {
			System.out.println(array1[i]);
		}
		// 增强型for循环 for(数据类型 遍历的元素：数组名){} 只顺序打印
		for (int element : array1) {
			System.out.println(element);
		}

		// 一维数组逆序遍历 定义元素的下标i从array1.length-1，i--
		for (int i = array1.length - 1; i >= 0; i--) {
			System.out.println(array1[i]);
		}

		// 一维数组逆置1 数组逆置，即将数组元素的位置交换。
		// 两两交换，所以交换次数array1.length/2，下标为0和下标length-1交换，下标为1和length-1-1交换，存在i和length-1-i关系
		for (int i = 0; i < array1.length / 2; i++) {
			int temp = array1[i];
			array1[i] = array1[array1.length - 1 - i];
			array1[array1.length - 1 - i] = temp;
		}
		for (int i = 0; i < array1.length; i++) { // 逆置后顺序打印 5 4 3 2
			System.out.println(array1[i]);
		}
		
// 一维数组逆置2 strat代表下标为0,end代表下标为length-1;start++,end--依次交换。
//		for (int start = 0, end = array1.length - 1; start < end; start++, end--) {
//			int temp = array1[start];
//			array1[start] = array1[end];
//			array1[end] = temp;
//		}
//		for (int i = 0; i < array1.length; i++) { // 逆置后顺序打印
//			System.out.println(array1[i]);
//		}

		// 二维数组遍历 使用两个for循环 i是第一维的遍历 j是第二维的遍历
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				System.out.print(array[i][j] + "\t");
			}
		}
		
		// 二维数组逆序打印 i和j都逆序打印即可
		for (int i = array.length - 1; i >= 0; i--) {
			for (int j = array[i].length - 1; j >= 0; j--) {
				System.out.print(array[i][j] + "\t");
			}
		}
	}
}

（4）简单算法

    	//取出一维数组最大值
		int[] array1= {2,4,6,8,1,3,7};
		int max=array1[0];
		for(int i=0;i<array1.length;i++) {
			if(max<array1[i]) {
				max=array1[i];
			}
		}
		System.out.println(max);
		
		//取出一维数组最小值ֵ
		int min=array1[0];
		for(int i=1;i<array1.length;i++) {
			if(min>array1[i]) {
				min=array1[i];
			}
		}
		System.out.println(min);
		
	// 二维数组{{1,2},{3,4}{5,6}{7,8}}找出最大值ֵ
		int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
		int max = array[0][0];
		for (int i = 0; i < array.length; i++) {
			int[] arr = array[i];
			for (int j = 0; j < arr.length; j++) {
				if (max < arr[j]) {
					max = arr[j];
				}
			}
		}
		System.out.println(max);
	
	
	// 二维数组{{1,2},{3,4}{5,6}{7,8}}找出最小值ֵ
		int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
		int min = array[0][0];
		for (int i = 0; i < array.length; i++) {
			int[] arr = array[i];
			for (int j = 0; j < arr.length; j++) {
				if (min >arr[j]) {
					min = arr[j];
				}
			}
		}
		System.out.println(min);
	
		// 求二维数组中每个元素中的第一个的平均值
		int[][] array1 = { { 100, 100, 100 }, { 45, 23, 98 }, { 65, 69, 87 }, { 74, 78, 79 } };
		float sum = 0f;
		int i = 0;
		while (i < array1.length) {
			sum += array1[i][0];  //每个一维数组中的第一个数
			i++;
		}
		System.out.println(sum / array1.length);  //一维长度

		// 求单个元素总和  如求70 80 80 总和
		int[][] array = { { 95, 90, 80 }, { 90, 90, 90 }, { 70, 80, 80 }, { 100, 100, 100 } };
		int[] arr = array[2];
		int sum = 0;
		for (int j = 0; j < arr.length; j++) {
			sum = arr[j] + sum;
		}
		System.out.println(sum);