JavaSE:数组

1.数组

元素的数据类型[] 数据名;

数据类型[]

1.动态初始化

char[] 数组名 = new char[长度];

数组存储的元素的数据类型[] 数组名 = new 数组储存的元素的数据类型[长度]；

int [] name = new int [长度];

数组名【下标】 = 值；

name[下标] = 值；

2.静态初始化

声明和初始化分开

((1)数组的数据类型 数组名；

int name;

数组名 = new 元素的数据类型【长度】{元素内容}

name = new int[]{元素内容1、元素的内容2}

(2)素组的声明和初始化在一起

元素的数据类型【】数组名 = {

元素内容1、元素内容2}

}

int[] name = {元素的内容1、元素的内容2

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0WVX5tda-1599662931151)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1598411732645.png)]

1.数组：从字面上理解，表示一组数据；

  1.所谓“数组”(array)，就是相同数据类型的元素按一定顺序排列的集合，
就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，
然后用编号区分他们，这个名字称为"数组名"，
2.编号成为"下标或索引”（index）。
组成数组的各个变量成为数组的“元素”(element).
组成中元素的个数成为“数组的长度”（length）.
术语：数组名、下标/索引，元素，数组的长度。
	
要求和特点：
（1）数组的长度一旦确定就不能修改，除非重新创建一个数组
（2）数组的元素是连续存储的，即一个数组需要开辟一整块连续的存储空间；
（3）数组的结构，访问速度是很快的
可以通过[下标]快速定位到某个元素的位置

2.数组的初始化格式：

（1）动态化数组

数据类型[] 变量名= new 数据类型[长度]；

数组名[下标] = 元素的实际值；

（2）静态初始化

在编译期间数组的长度、元素的实际值是已知的，

格式：

元素的数据类型【】 数组名= { 元素1、元素2.。。 }

/*

当我们把数据存到数组中之后，我们会基于数组这个结构对数据进行管理，

这些管理的操作的步骤，我们称为算法：
（1）求数组中所有数的总和、平均值、统计某个值满足xx条件的个数
（2）找数组中的最大/小值
（3）找数组中的最大/小值及其下标
（4）数组元素的查找
最最基本的查找算法：顺序查找
（5）冒泡排序
最最基本的排序算法，也是最经典的排序算，几乎所有程序员都要学的入门排序算法。
冒泡排序虽然不是最优，即效率不是最高的。
过程：
（1）相邻元素做比较，如果它们现有的顺序不符合最终的要求，就交换
例如： array[0]与array[1]
array[1]与array[2]
array[2]与array[3]
例如：从小到大
array[2]与array[3]，8和1不符合从小到大，就要交换
（2）经过多轮的比较才能实现最终的排序
n个元素，需要比较n-1轮。每一轮只能保证本轮最大/小到达它正确的位置。
*/
class Test17ArrayUse5{
public static void main(String[] args){
int[] array = {3,5,8,1,2};

		/*
	从小到大
	第一轮：
		第一次：array[0]<array[1]?3<5?成立，不交换
		第二次：array[1]<array[2]?5<8?成立，不交换
		第三次：array[2]<array[3]?8<1?不成立，交换array[2]与array[3]，结果{3,5,1,8,2}
		第四次：array[3]<array[4]?8<2?不成立，交换array[3]与array[4]，结果{3,5,1,2,8}
	
	结果：最大的跑到最后，下一轮array[4]就不需要参与了
	
	第二轮：
		第一次：array[0]<array[1]?3<5?成立，不交换
		第二次：array[1]<array[2]?5<1?不成立，交换array[1]与array[2]，结果{3,1,5,2,8}
		第三次：array[2]<array[3]?5<2?不成立，交换array[2]与array[3]，结果{3,1,2,5,8}
		
	第三轮：
		第一次：array[0]<array[1]?3<1?不成立，交换array[0]与array[1]，结果{1,3,2,5,8}
		第二次：array[1]<array[2]?3<2?不成立，交换array[1]与array[2]，结果{1,2,3,5,8}
		
	第四轮：
		第一次：array[0]<array[1]?1<2?成立，不交换
	*/
	//重复比较很多轮，很多次，需要用到双重循环
	for(int i=1; i<array.length; i++){//外循环控制轮数  array.length是5，i=1,2,3,4
		/*
		当i=1，
			array[0]与array[1]
			array[1]与array[2]
			array[2]与array[3]
			array[3]与array[4] 
		假设array[j]与array[j+1]	j的范围：0,1,2,3  j<array.length-i
		当i=2，
			array[0]与array[1]
			array[1]与array[2]
			array[2]与array[3]
		假设array[j]与array[j+1]	j的范围：0,1,2	j<array.length-i
		当i=3，
			array[0]与array[1]
			array[1]与array[2]
		假设array[j]与array[j+1]	j的范围：0,1	j<array.length-i
		当i=4，
			array[0]与array[1]
		假设array[j]与array[j+1]	j的范围：0	j<array.length-i
		*/
		for(int j=0; j<array.length-i; j++){
			if(array[j]>array[j+1]){
				//交换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.println(array[i]);
	}
}

}

/*

数组是分为一维、二维、多维数组，但是一般情况下到二维就很复杂。

一维数组：[]，一组（行）数据
二维数组：[][]，多组（行）数据

1、如何声明二维数组？
元素的数据类型[][] 数组名;

2、如何初始化呢？
（1）静态初始化
数组名 = new 元素的数据类型[][]{{第一行的数据},{第二行的数据}。。。};
简化：当声明和静态初始化在一句完成时
元素的数据类型[][] 数组名 = {{第一行的数据},{第二行的数据}。。。};

（2）动态初始化

3、如何遍历数组？
（1）总行数：数组名.length
（2）每一行的长度：
行.length
行：数组名[i]
数组名[i].length
（3）元素：数组名[i][j]

下标越界的异常：ArrayIndexOutOfBoundsException
/
class Test18Two{
public static void main(String[] args){
/
需求：存储咱们班3个小组的学员的成绩
*/
//int[][] scores ;
//scores = new int[][]{{78,56,90},{88,99,100,90},{77,56,98,90}};

	int[][] scores = {{78,56,90},{88,99,100,90},{77,56,98,90}};
	for(int i=0; i<scores.length; i++){
		//(1)打印本行的元素
		for(int j=0; j<scores[i].length; j++){
			System.out.print(scores[i][j]+"\t");
		}
		//(2)换行
		System.out.println();
	}
}

6,90},{88,99,100,90},{77,56,98,90}};
for(int i=0; i<scores.length; i++){
//(1)打印本行的元素
for(int j=0; j<scores[i].length; j++){
System.out.print(scores[i][j]+"\t");
}
//(2)换行
System.out.println();
}
}
}