JavaSE之数组Array

package com.shuhuadream.array;

import java.util.Arrays;

/*
 * 
 * 数组的定义：
 * 概念：同一个数组的数据的集合，其实数组就是容器
 *
 * 一个变量只能存储一个数据，如果想要存储多个数据，使用数组来完成
 * 数组的作用：存储多个数据
 * 特点：1.必须是同一种数据类型的数据
 * 		2.存储数据时，必须要明确元素的个数
 * 
 * 数组是存储固定个数并且是同一种类型的元素的容器
 * 
 * 数据一旦多了，存储的地方就是容器，数组是容器的一种体现形式
 * 
 * 数组的好处：可以对存储在数组当中的元素进行编号，并且是从0开始
 * 
 * 这个编号从专业角度来讲，叫做索引或者角标或者下标 	index
 * 
 * 索引的作用：制定了一些编号，存储和查找数据更加的方便
 * 
 * 编号和数据之间存在着对应关系
 * 通过编号可以添加和查找元素
 * 	
 * 数组的语法格式：
 * 	格式一：
 * 元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]
 * 
 * 数组是引用数据类型的变量
 * 数组当中存储的元素可以是任何数据类型（基本数据类型和引用数据类型）
 * 
 * 数组创建之后数组的容量是不能改变的，但是数组的元素是可以改变的
 * 
 * Java内存区域的划分：
 * 1.寄存器：属于硬件部分的内容，是cpu做处理的，程序员并不能过多的干涉
 * 2.栈内存：存储运行时的方法，局部变量。变量运算区域一结束就会被释放
 * 			局部变量：方法当中的形参，方法内声明的变量，语句当中定义的变量
 * 3.堆内存：存储数组和对象，简单来说堆内存当中存储的都是实体
 * 			实体：能存放多个数据的地方，就称为实体
 * 			只要使用new关键字创建的都存储在堆内存当中
 * 	 堆内存特点：
 * 		1.任何实体存储在堆内存当中时，都有内存地址值，使用首地址值表示该实体
 * 		2.堆内存当中的变量，都有默认的初始化值
 * 4.方法区:存储方法（函数）的地方
 * 5.本地方法区：是和操作系统相关的代码存储的区域。
 */
public class Demo01 {
	public static void main(String[] args) {
		
		int[] arr = new int[3];	//格式一
		arr[0] = 12;
		arr[1] = 23;
		System.out.println(Arrays.toString(arr));
		//数组当中的每一个元素都有初始化默认值，而他的默认值就是数组类型对应的默认值
		
		int[] arr2 = arr;//将数组arr的地址赋值给arr2了
		arr2[1] = 40;
		System.out.println(arr2[0]);	//12
		System.out.println(arr[1]);		//40
	}
}

package com.shuhuadream.array;
/*
 * 数组常见的问题：
 * 1.java.lang.ArrayIndexOutOfBoundsException: 数组角标越界异常
 * 2.java.lang.NullPointerException    :空指针异常
 * 
 * 共同的特点：都是在运行时发生的异常
 */
public class Demo02 {
	
	public static void main(String[] args) {
		int[] arr = new int[3];
		
		System.out.println(arr[0]);
		//System.out.println(arr[3]);
		//java.lang.ArrayIndexOutOfBoundsException: 数组角标越界异常
		//语法上并不能校验错误，在程序编译过程中没有问题，运行时才会出现错误。
		//产生的原因：当程序中访问的数组不存在的角标时，就会出现数组角标越界异常
		
		int arr2[] = new int[4];
		//这种写法也是正确的，[]既可以写在类型后面，也可以写在名称的后面
		
		arr = null;
		//System.out.println(arr[0]);
		//java.lang.NullPointerException    :空指针异常
		
		//产生的原因：当引用数据类型的变量没有任何实体指向时，还要对其进行具体的操作
		//就会出现空指针异常
	}
}

package com.shuhuadream.array;
/*
 * 
 * 数组的第二种语法格式
 * 格式二：
 * 元素类型[] 数组名 = new 元素类型[]{元素，元素，元素，.....}
 * 简写格式：
 * 元素类型[] 数组名 = new 元素类型[]{元素，元素，元素，.....}
 * 
 * 操作数组的核心思想就是角标，通过角标实现对于数组当中数据的访问
 * 有设置和获取两种操作，通常对于数组的操作就是数组的遍历
 * 
 * 何为遍历：
 * 通过循环的方式，取出数组当中的每一个元素
 * 
 * 存储数据到数组当中的目的
 */
public class Demo03 {
	public static void main(String[] args) {
		//数组的动态初始化
		int[] arr = new int[3];
		
		//数组的静态初始化
		//格式二
		int[] arr2 = new int[]{23,18,7};
		//简写格式
		int[] arr3 = {23,2,45,67,3,2};
		
		//数组的遍历：打印数组当中的每一个角标对应的元素，就称之为数组的遍历
		for(int i=0;i<arr3.length;i++){
			System.out.println(arr3[i]);
		}
		
		//倒序遍历
		for(int i=arr3.length-1;i>=0;i--){
			System.out.println(arr3[i]);
		}
		
	}
}

package com.shuhuadream.array;
//增强for循环遍历数组
public class Demo04 {
	/*
	 * 增强for循环 jdk在5.0后引入
	 * for(循环变量类型 循环变量名称：要求被遍历的容器名称){
	 * 		循环内容;	
	 * }
	 * 
	 * 1.要求被遍历的容器名称：增强for循环的作用通常用于容器的遍历：比如集合和数组
	 * 2.循环变量的类型：数组当中的元素的类型
	 * 循环变量的名称：程序员可以自己定义，表示正在被遍历的元素
	 */
	public static void main(String[] args) {
		
		int[] arr={1,2,4,6,8};
		
		//增强for循环的遍历
		//弊端：遍历过程中不能拿出数组元素进行操作，不能输出数组角标
		//好处：主要针对容器使用，遍历的过程交给编译器处理
		//		速度比普通for循环块，
		//		元素少则不明显，可以任意选择
		for(int a:arr){
			System.out.println(a);
		}
	}
}

package com.shuhuadream.array;
//定义一个功能，要求返回一个数组中的最大值
public class Test01 {
	public static void main(String[] args){
		int[] arr = {1,3,5,21,4,6,80};
		int max = arrMax(arr);
		System.out.println(max);
	}
	
	public static int  arrMax(int[] arr){
		int max = arr[0];
		for(int i=1;i<arr.length;i++){
			if(max <= arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
	
	public static int getMax(int[] arr){
		int maxIndex = 0;
		for(int i=1;i<arr.length;i++){
			if(arr[i]>arr[maxIndex]){
				maxIndex = i;
			}
		}
		return arr[maxIndex];		
	}
}

package com.shuhuadream.array;
/**
 * 二维数组：
 * 数组中存放的元素依然是数组，那么就称之为二维数组。
 * 
 * */
public class Demo01 {

	public static void main(String[] args) {
//		定义一维数组第一种方式
		int[] arr = new int[3];
//		定义二维数组的第一种方式：
		int[][] brr = new int[3][2];
//		右边： 创建了一个二维数组的实体，那么这个二维数组当中包含了3个一维数组对象。
//		然后每一个一维数组当中包含了2个int类型的数据
		
		System.out.println(arr[0]); //0
		System.out.println(arr); //[I@334dcfad
		//  以@为分隔符，@的左边表示实体的引用类型：存放int类型元素的数组。
		//  @的右边其实是哈希码值，其实就是这个实体在堆内存当中的存储位置。
		
		System.out.println(brr[0]);  //[I@334dcfad
		System.out.println(brr);  //[[I@5eab4b89
		System.out.println(brr[0][0]);  //0
		System.out.println(brr[0][1]);  //0
		
		int [][] brr2 = new int[3][];
		System.out.println(brr2[0]);  //null
		int[] arr2 = new int[2];
		brr2[0] = arr2;
		//System.out.println(brr2[0]); //[I@2f590164
		brr2[1] = new int[5];
		//上面两种写法都是正确的，因为二维数组存储的是一维数组的地址值，
//		所以一维数组的元素个数改变了，对于二维数组没有影响。
		
		int[] a = new int[5];
		int[] b = new int[10];
		int[] c = a;
		c = b;
	
		//二维数组当中的一维数组中元素的个数，是可以不确定的。
		
		
	}
}

package com.shuhuadream.array;
//二维数组的第二种定义格式
public class Demo02 {
	public static void main(String[] args) {
		
		//定义二维数组的两种语法格式
		int[][] brr1 = new int[3][2];
		//二维数组的第二种定义的语法格式，既明确了一维数组的个数，也明确了一维数组中元素的内容
		int[][] brr2 = {{0,0},{0,0},{0,0}};
		//以上brr1和brr2在内存中的体现完全相同
		
		int[][] brr3 = {{1,2,3,5},{3,5,7},{5,3,21},{1,2,4,6}};
		
		//如何获取二维数组当中有几个一维数组
		System.out.println(brr3.length);
		//如何获取二维数组当中某一个一维数组的元素的个数
		System.out.println(brr3[0].length);
		
		//如何去遍历二维数组每一个一维数组的元素
		//遍历二维数组当中的一维数组
		for(int i=0;i<brr3.length;i++){
			for(int j=0;j<brr3[i].length;j++){
				System.out.print(brr3[i][j]+"\t");
			}
			System.out.println();
		}
	}
}