数组

数组是有序的元素序列。若将有限个类型相同的变量的集合命名。那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便，把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。
数组是用来存放相同数据类型的一种容器，这些相同的数据在容器中是有序排列的。在容器中数据使用下标来标记。数组是在程序运行期间存放数据的容器。
变量：在程序运行期间其值可以改变 存储一个值
数组：在程序运行期间内部数据可以改变 存储多个值

一、数组的声明

• 数组的长度：数组中元素的个数称为数组的长度
• 元素：数组中的每一个数据称为元素
• 数组中的元素都使用下标来确定他在元素中的位置 0------数组的长度-1
  数组的声明代码演示如下:

package com.xingyun.Array;
/**
   * 数组的创建，声明和赋值
 * @author langlang
 * 2020年10月10日下午4:59:51
 * 
 * 
 */
public class ArrayDemo {
	
	public static void main(String[] args) {
		
		//声明一个数组
		//数组的长度一旦声明，在运行期间无法改变
		int  []  nums = new  int [6];
		
		//赋值
		nums[0] = 6;//第一个元素
		nums[1] = 13;//第二个元素
		nums[2] = 56;//第三个元素
		nums[5] = 20;//第六个元素
		
		System.out.println("第"+1+"个元素是"+nums[0]);
		System.out.println("第"+2+"个元素是"+nums[1]);
		
		System.out.println("数组的长度是"+nums.length);
		
		
		//遍历数组
		System.out.println("------元素的遍历------");
//		int  index = 0;
//		for(int i=0;i<6;i++) {
//			System.out.println("第"+(index+1)+"个数字是"+nums[index]);
//			index++;
//		}
		
		
		for(int i=0;i<6;i++) {
			System.out.println("第"+(i+1)+"个元素是"+nums[i]);
		}
		
		
		//第i个元素为nums[i-1],元素的下标从0开始
//		for (int i = 0; i < nums.length; i++) {
//			System.out.println("第"+(i+1)+"个元素是"+nums[i]);
//		}
	}
}

二、数组的具体使用

• 数组不能一次给所有元素赋值，只能挨个赋值
• 数组中可以根据元素的下标给指定位置的元素赋值
• 数组一旦创建其长度不能改变
• 数组的默认值是null 数组元素的默认值是根据数组的类型而定
  1、赋值
  挨个赋值，根据下标
  
  2.查询
  根据下标查询
  
  使用循环一次性查询所有的数据，
  
  
  注意：当要查询的数组元素下标的值超过数组的元素下标最大值，就会报异常，数组元素下标越界异常。
  
  增强型for循环：
  优点：写法简单，不考虑下标，不会出现下标越界的问题
  缺点：无法获取带指定下标位置的元素，只能一次遍历所有
  

三：二维数组和多维数组

• 数组中的元素是数组，称为二维数组

• 语法：
  一维：数据类型 [] 数组名称 = new 数据类型 [];
  二维：数据类型 [][] 数组名称 = new 数据类型 [][];

• 二维数组的子数组的长度是可以发生变化，子数组的实际表示的数组是可以重新赋值的。数组长度不可变是指你当前所引用的数组的长度不可变，一旦引用发生改变，数组的长度就改变了。
  1.声明
  
  2.赋值
  
  
  3.遍历
  

• 小例子，通过多维数组实现经济管理学院，代码实现如下

package com.xingyun.Array;
/**
 * 多维数组
 * @author langlang
 * 2020年10月14日下午4:13:35
 *
 */
public class DuoWeiArray {
	/*
	 * 经济管理学院
	 *         电商                                             信管
	 *           1班                                   2班
	 *      stu01,stu02     stu03,stu04
	 */
	public static void main(String[] args) {
		
		//声明一个三维数组
		String  [][][]  JGY = new  String [2][2][2];
		
		//声明班级     每个专业都有两个班级，所以得声明4个班级
		String  []  class01 = new String [] {"stu01","stu02"};
		String  []  class02 = new String [] {"stu03","stu04"};
		String  []  class03 = new String [] {"stu03","stu04"};
		String  []  class04 = new String [] {"stu03","stu04"};

		//声明每个专业    每个专业下有两个班级，每个班级下又有两个学生，所以专业是一个二维数组
		String  [][]  major01 = new String  [2][2];
		String  [][]  major02 = new String  [2][2];
		//给二维数组赋值
		major01[0] = class01;
		major01[1] = class02;
		major02[0] = class03;
		major02[1] = class04;
		
		
		//给经管院赋值两个专业
		JGY[0] = major01;
		JGY[1] = major02;
		
		
		//遍历多维数组
		for (int i = 0; i < JGY.length; i++) {
			System.out.println("*******专业是*******");
//			System.out.println(JGY[i]);
			for (int j = 0; j < JGY[i].length; j++) {
				System.out.println("*******班级是*******");
//				System.out.println(JGY[i][j]);
				for (int k = 0; k < JGY[i][j].length; k++) {
					System.out.println(JGY[i][j][k]);
				}
			}
		}		
	}
}

四、数组的交换

1、数组与数组之间的元素拷贝

五、数组的排序

排序：正序（从小到大asc）
逆序（从大到小desc）

1. 冒泡排序

• 冒泡排序，是一种计算机科学领域的较为简单地排序算法
• 依次比较两个相邻的元素，如果是正序，第一个比第二个大，交换，否则不交换。每一次比较完数组中最大的那个值后，下一次比较的时候就不需要比较上次最大的那个值。
• 外层循环控制需要比较的次数，内层循环是每一遍具体比较交换的操作。
• 代码如下

	public static void main(String[] args) {

		int[] grade = new int[] { 1,5,8,3 };
		System.out.println("==========排序前==================");
		for (int i : grade) {
			System.out.print(i + "-----");
		}

		System.out.println("==========排序==================");
		
		int count=0;
		for(int i=0;i<grade.length-1;i++) {//循环比较的次数  
			//每一次实际比较交换的操作  每一次都是从第一个元素开始到上一次最大值前一个
			for(int j=0;j<grade.length-1-i;j++) {
				  int temp=0;
				  if(grade[j]>grade[j+1]) {
					  temp=grade[j];
					  grade[j]=grade[j+1];
					  grade[j+1]=temp;
				  }
				  count++;
			}
		}
		System.out.println("总共比较的次数是："+count);
		
		
		
		
		System.out.println("==========排序后==================");
		for (int i : grade) {
			System.out.print(i + "-----");
		}

	}

2.选择排序

• 每一次比较选择一个位置后与后面的每一个元素进行比较，如果当前元素比后面的元素大就交换，每一次比较完将本次的最小值放到当前位置。起始从0开始，以后每一次的比较都从下一个元素开始
• 代码实现如下

		public static void main(String[] args) {

			int[] grade = new int[] { 5,3,84,46,12,10,5 };
			System.out.println("==========排序前==================");
			for (int i : grade) {
				System.out.print(i + "-----");
			}
			System.out.println("==========排序==================");
			int count=0;
			for(int i=0;i<grade.length-1;i++) {//循环比较的次数  
				//i 是用来确定我们每一次的用来比较的元素     j 用来控制我们的i后面的每一元素的 
				//  每一次使用i 位置的元素  与后面的每一个元素进行两两比较   如果i位置元素比后面比较的元素大 进行交换       
				for(int j=i;j<grade.length-1;j++) {
					  int temp=0;
					  if(grade[i]>grade[j+1]) {
						  temp=grade[i];
						  grade[i]=grade[j+1];
						  grade[j+1]=temp;
					  }
					  count++;
				}
			}
			System.out.println("总共比较的次数是："+count);
			
			
			System.out.println("==========排序后==================");
			for (int i : grade) {
				System.out.print(i + "-----");
			}

		}

3.插入排序
4.使用标记进行排序操作