数组

1.什么是数组？

 * 数组和变量差不多都是用来存放数据的，不同的是变量只能保存一条数据，而数组可以保存多条数据
 * 必须是同一类型
 * 数组是引用数据类型

2.如何定义数组？

 * 数组类型[] 数组名;
 * 如果定义好数组以后，必须要给数组进行初始化
 * 数组是一个引用数据类型
 * 通过new的方式对数组进行初始化
 * 数组的初始化分为两种
 * （1）动态初始化——指定数组的长度——一旦长度指定，就是数组中只能存放多少数据
 * 两种格式：
 * 第一种：
 * 数组类型[] 数组名=new 数组类型[数组长度];
 * 第二种：
 * 数组类型[] 数组名;
 * 数组名=new 数组类型[数组长度]
 * 
 * （2）静态初始化:不是指定数组长度，而是直接在初始化数组的同时给数组赋值
 * 两种：
 * 第一种
 * 数组类型[] 数组名=new 数组类型[]{数据1,数据2....};
 * 第二种：
 * 数组类型[] 数组名;
 * 数组名=new 数组类型[] {数组1,数组2....};
 * 
 * （3）还有一种最简单的方式
 * 数组类型[] 数组名={数据1,数据2.....};
 */

新建 Class Demo01
public static void main(String[] args) {
		
		//1.定义了一个数组，并进行动态初始化
		/**
		 * int：数据类型是int型的，也就代表我这个数组之能存放整数，只能是9个整数
		 * array：数组名（变量的命名规则）
		 */
		int[] array=new int[9];
		
		//2.动态初始化的第二种
		double[] array1;
		array1=new double[10];
		
		//创建好了数组，如何给数组进行赋值，通过数组的索引（下标）,数组的下标从0开始
		array[0]=10;
		array[1]=11;
		array[8]=12;
		//array[5]="aaa";
		//array[9]=20;下标越界了
		System.out.println(array[0]);
		
		//3.静态初始化第一种：
		int[] array2=new int[]{8,9,15,20};
		System.out.println(array2[3]);//20
		
		//4.静态初始化的第二种
		int[] array3;
		array3=new int[]{67,89,90,1,34};
		System.out.println(array3[1]);//89
		
		//5.最简洁的方式创建数组
		int[] array4={12,3,4,6,2};
		System.out.println(array4[4]);//2
		
		//6.获取数组的长度 数组名.length，数组的长度一旦定义不可改变
		System.out.println("array3数组的长度："+array3.length);
		//System.out.println(array3[5]=10);
		
		//7.数组中常见的几种异常
		//数组越界异常： java.lang.ArrayIndexOutOfBoundsException
		int[] a=new int[2];
		//System.out.println(a[2]=10);错误的
		
		//空指针异常： java.lang.NullPointerException
		int[] b=null;
		//System.out.println(b[0]);
	}

3.遍历数组的两种方法

* 第一种：for循环控制输出
* 第二种：foreach循环输出

新建 Class Demo02
public static void main(String[] args) {
		int[] array=new int[]{12,4,6,34,90,89};
		//我想获取数组中的每一元素值
		//System.out.println(array[0]);
		
		//使用循环遍历数组
		//1.使用for循环 i代表的是数组的下标
		for(int i=0;i<array.length;i++){
			System.out.println("数组的第"+i+"个元素："+array[i]);
		}
		
		//2.foreach(for循环的增强版)
		System.out.println("foreach遍历数组");
		/**
		 * for(定义变量接收的数组的每一个元素值：要变量的数组名)
		 * 数组遍历只有两种方式
		 */
		for(int a:array){
			System.out.println("foreach循环数组元素："+a);
		}
	}

4.数组类型的分类

 * 第一种：基本数据类型的数组
 * 动态初始化数组以后，数组元素都会赋予一个默认值
 * byte short int long double float char boolean
 * 0	0	0	0		0.0		0.0	空格		false

 * 第二种：引用数据类型的数组
 * String、自己封装的类
 * 引用数据类型的默认值为null

新建 Class Demo03
public static void main(String[] args) {
		//int类型数组
			int[] num=new int[5];
			num[0]=10;
			num[3]=12;
			for(int n:num){
				System.out.println(n);
			}
		//double类型数组
			double[] d=new double[2];
			System.out.println(d[0]);
			System.out.println("=============");
			
		//char类型数组
			char[] c=new char[3];
			for(int i=0;i<c.length;i++){
				System.out.println("char类型数组："+"-"+c[i]+"-");
			}
			
		//boolean
			boolean[] b=new boolean[5];
			System.out.println("boolean类型数组："+b[2]);//false
			
		//String
			String[] str=new String[4];
			str[0]="张三";
			for(String s:str){
				System.out.println(s);
			}
			
		//数组类型是Student类型
			Student[] stu=new Student[1];
			stu[0]=new Student("张三",18);//创建了一个对象并给这个对象的属性赋值
			for(int i=0;i<stu.length;i++){
				System.out.println("姓名："+stu[i].getName()+"年龄："+stu[i].getAge());
			}
		}

5.java中内存的分配

* java中的内存是怎么进行分配的
 * 内存的申请和释放都是jvm进行管理的
 * java程序要运行，jvm会自动地向电脑申请一块内存，他会把这块内存分为五部分
 
 * 前两部分
 * 1.栈（Stack）:主要存放局部变量
 * 2.堆（Heap）:凡是new出来地东西都在堆里面，堆当中的数据都有默认原则
 * 整数0  小数0.0 布尔：false char:空格 引用数据类型：null
 * 3.方法区（Method Area）：存放的是与.class相关的信息
 * 4.本地方法区（Native Method Area）：与操作系统有关
 * 5.寄存器（Register）：与CPU有关

	public static void main(String[] args) {
		int[] a=new int[]{1,2,3};
		//int[] b=new int[]{1,2,3};
		int[] b=a;
		System.out.println(a==b);
	}

6.冒泡排序

 * 冒泡排序
 * 数组中的元素两两比较
 
 * 口诀
 * n个数字来排队
 * 两两相比小靠前
 * 外层循环n-1
 * 内层循环n-i-1

public static void main(String[] args) {
		//从大到小
		int[] array={76,3,234,90,6,78,1,-1};
		
		//外层循环嵌套控制趟数
		for(int i=0;i<array.length-1;i++){
			//内层控制次数
			for(int j=0;j<array.length-i-1;j++){
				//比较 从大到小用< 小到大>
				if(array[j]<array[j+1]){
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
		for(int a:array){
			System.out.println(a);
		}
	}

7.选择排序

 * 选择排序（了解）：效率低
 * 从小到大排列

public static void main(String[] args) {
		int[] num={25,4,56,122,2};
		for(int i=0;i<num.length;i++){
			for(int j=0;j<num.length;j++){
				if(num[i]<num[j]){
					int temp=num[i];
					num[i]=num[j];
					num[j]=temp;
				}
			}
		}
		for(int a:num){
			System.out.println(a);
		}
	}

8.二维数组

 * 二维数组，数组中的数组
 * 1.声明二维数组：
 * 数据类型[][] 数组名;定义了没有进行初始化
 * 第一个[]：二维数组中有几个一维数组，行
 * 第二个[]：每一个一维数组中有多少个元素，列
 
 * 2.初始化二维数组
 * 第一种：动态初始化
 * 第二种：静态初始化

public static void main(String[] args) {
		//1.创建一个二维数组，并动态初始化
		//5代表5行或者包含五个一维数组
		//7表示7列或者表示每个一维数组的长度是7
		int[][] array=new int[5][7];
		//2.二维数组赋值
		//第一个一维数组的第一个元素值为10
		array[0][0]=10;
		//第四个以为数组的第7个元素值为5
		array[3][6]=5;
		System.out.println(array[0][0]);
		System.out.println(array[2][0]);
		
		//3.静态初始化
		int[][] array1=new int[][]{{1,2},{2,3,4},{5,9,89,1}};
		System.out.println(array1[2][2]);
		
		//简写
		int[][] array2={{4,90},{23,12},{12,23,45}};
		
		//4.遍历二维数组
		//外层循环控制行
		for(int i=0;i<array2.length;i++){
			//内层循环控制的是列
			for(int j=0;j<array2[i].length;j++){
				System.out.print(array2[i][j]+" ");
			}
			System.out.println();
		}
		System.out.println("使用增强for循环==========");
		for(int[] i:array2){
			for(int j:i){
				System.out.print(j+" ");
			}
			System.out.println();
		}
	}

注释

2020.08.03java实训第六次课