Java数组

1.数组
比如我要统计每位员工的工资，我得定义多个变量去分开存储，因为一个变量只能保存一个数据，如果过多的员工， 太麻烦，那么我怎么用一个变量去存储多个员工工资呢？
可以使用数组，数组就是一个大的容器，他可以存储多个值
数组的概念：数组和变量差不多，都是存放数据的，不同的是变量只能保存一条数据，而数组可以保存多条数据，前提是这个多条数据必须是同一类型的。
数组既可以存储基本数据类型，也可以存储引用数据类型
2.一维数组的定义
数组类型[] 数组名；
如果定义好数组以后，必须要给数组进行初始化。
数组一旦初始化，长度不可变。长度确定下来了。
3.数组的初始化
(1)动态初始化：指定数组的长度，一旦长度指定，就是数组中只能存放多少数据
两种格式：
①数组类型[] 数组名=new 数组类型[数组长度];
int[] array=new int[9];
②数组类型[] 数组名；
数组名=new 数组类型[数组长度]；
double[] array1;
array1=new double[10];
(2)静态初始化:不是指定数组长度，而是直接在初始化数组的同时给数组赋值
两种格式：
①数组类型[] 数组名=new 数组类型[]{数据1，数据2……};
int[] array2=new int[]{8,9,45,20,19};
②数组类型[] 数组名；
数组名=new 数组类型[]{数据1，数据2……};
int[] array3;
array3=new int[]{67,89,90,1,34};
(3)还有一种最简单的方式：
数组类型[] 数组名={数据1，数据2……};
int[] array4={12,3,4,6,2};
4.数组常见问题
(1)//数组越界异常：ArrayIndexOutOfBoundsException
int[] a=new int[2];
//System.out.println(a[2]=10);//错误的
(2)//空指针异常：NullPointerException
int[] b=null;
System.out.println(b[0]);
5.数组遍历
（1）for循环
（2）foreach(for循环的增强版)
6.数组的分类
（1）基本数据类型的数组
动态初始化数组以后，数组的元素都会赋予一个默认值
byte 0
short 0
int 0
long 0
double0.0
float 0.0
char 空格
boolean false
（2）引用数据类型的数组
String 接口 自己定义的类
引用数据类型的默认值为null
7.java中内存的分配
内存的申请和释放都是jvm进行管理的，java程序要运行，jvm会自动的向电脑申请一块内存，
把这块内存分为5部分：
①栈(Stack):主要存放局部变量(重点)
②堆(Heap):凡是new出来的东西都在堆里面，堆里面的数据都有默认原则：(重点) 整数:0，小数:0.0，布尔:false，char:空格，引用数据类型：null
③方法区(Method Area):存放的是与.class相关的信息
④本地方法区(Native Method Area):与操作系统有关
⑤寄存器(Register):与cpu有关
8.数组获取最值

public static void main(String[] args) {
		//1.求出学生成绩的总分、平均分、最高分、最低分
		int[] score=new int[]{90,89,56,87,98};
		//总分
		int sum=0;
		for(int i=0;i<score.length;i++){
			sum+=score[i];
		}
		System.out.println("总分："+sum);
		//平均分
		int avg=sum/score.length;
		System.out.println("平均分："+avg);
		//最高分
		int max=score[0];
		for(int i=0;i<score.length;i++){
			if(max<score[i]){
				max=score[i];
			}
		}
		System.out.println("最高分："+max);
		//最低分
		int min=score[0];
		for(int i=0;i<score.length;i++){
			if(min>score[i]){
				min=score[i];
			}
		}
		System.out.println("最低分："+min);
   }

9.数组元素逆序

public static void main(String[] args) {
//2.{"C语言","C++","C#","Java","Python"};逆序输出
String[] str=new String[]{"C语言","C++","C#","Java","Python"};
	for(int i=0;i<str.length/2;i++){
		String temp=str[i];
		str[i]=str[str.length-1-i];
		str[str.length-1-i]=temp;
	}
	for(String s:str){
		System.out.println(s);
	}
 }

10.冒泡排序（重点）
口诀（升序）
n个数字来排队，两两想比小靠前，外层循环n-1，内层循环n-1-i

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 num:array){
			System.out.println(num);
		}
	}

11.二维数组
数组中的数组
（1）声明二维数组：
数据类型[][] 数组名；
第一个中括号：二维数组中有几个一维数组 行
第二个中括号：每个一维数组有多少元素 列
（2）初始化二维数组
①动态初始化
int[][] arr= new int[3][2];
int[][] arr= new int[3][];（不建议这样写）
注：int[][]arr= new int[][3]; //非法
②静态初始化
int[][] arr= new int[][]{{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式。

public static void main(String[] args) {
		//1.创建一个二维数组，并动态初始化
		//5代表5行或者表示包含5个一维数组
		//7代表7列或者表示每个一维数组的长度是7
		int[][] array=new int[5][7];
		
		//2.如何赋值
		//第一个一维数组的第一个元素值为10
		array[0][0]=10;
		//第四个一维数组的第七个元素值为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]);//89
	    
	    //简写
	    int[][] array2={{4,90},{23,12},{12,23,45}};
	    System.out.println("获取二维数组的长度："+array2.length);
	    
	    //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 a:i){
        		System.out.print(a+" ");
        	}
        	System.out.println();
        }
	}