javase:java数组

一丶数据概述

1.数组是相同类型数据的有序集合
2.数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
3.每一个数据称作每一个数组元素，每个数组元素可以通过一个下标访问

二丶数组声明创建

①声明数组变量

	dataType[] arrayRefVar;//首选方法
	
	dataType arratRefVar;//效果相同，但不是首选方法

②使用new操作符来创建数组

dataType[] arratRefVar  new dataType[arraySize];

③数组的元素时通过索引访问的，数组索引从0开始

//变量的类型 变量的名字 = 变量的值；
	//数组类型
	public static void main(String[] args) {
		int[] nums;//1.声明一个数组
		
		nums = new int[10];//2.创建一个数组
		//等价于  int[] nums = new int[10];
		
		
		//3.给数组元素中赋值
		nums[0] = 1;
		nums[1] = 2;
		nums[2] = 3;
		nums[3] = 4;
		nums[4] = 5;
		nums[5] = 6;
		nums[6] = 7;
		nums[7] = 8;
		nums[8] = 9;
		nums[9] = 10;
		
		//计算所有元素和
		
		int sum = 0;
		
		//获取数组长度：arrays.length
		for(int i = 0;i < nums.length;i++) {
			sum = sum + nums[i];
		}
		System.out.println(sum);
	}

三丶数组使用

1.for-each循环

//打印全部的和数组元素
		for(int i = 0 ;i < arrays.length;i++) {
			System.out.println(arrays[i]);
		}
		
		//计算所有元素的和
		int sum = 0;
		for(int i = 0 ;i < arrays.length;i++) {
			sum = sum + arrays[i];
		}
		System.out.println(sum);
		
		//查找最大元素
		int max = arrays[0];
		
		for(int i = 0 ;i < arrays.length;i++) {
			if(arrays[i] > max) {
				max = arrays[i];
			}
		}
		System.out.println(max);

2.数组作方法入参

int[] arrays = {1,2,3,4,5};
		
		printArray(arrays);
		System.out.println();
//		int[] result = reverse(arrays);
//		printArray(result);
//		//JDK1.5,没有下标
//		for(int array : arrays) {
//			System.out.println(array);
//		}
	}
	
	//打印数组元素
	public static void printArray(int[] arrays) {
		for(int i = 0 ;i < arrays.length;i++) {
			System.out.print(arrays[i]+" ");
		}
	}

3.数组作返回值

int[] arrays = {1,2,3,4,5};
		
		printArray(arrays);
		System.out.println();
		int[] result = reverse(arrays);
		printArray(result);
		
	//打印数组元素
	public static void printArray(int[] arrays) {
		for(int i = 0 ;i < arrays.length;i++) {
			System.out.print(arrays[i]+" ");
		}
	}
	
	//反转数组
	public static int[] reverse(int[] arrays) {
		int[] result = new int[arrays.length];
		
		for(int i = 0 ;i < arrays.length;i++) {
			result[i] = arrays[arrays.length-i-1]; 
		}
		
		return result;
	}

四丶多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

//[4][2]
		int[][] array = {{1,2},{3,4},{5,6},{7,8}};
		
		for(int i = 0;i < array.length;i++) {
			for(int j = 0; j< array[i].length;j++) {
				System.out.print(array[i][j]+" ");
			}
			System.out.println("");
		}

五丶Arrays类

1.数组的工具类java.untl.Arrays
2.由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
3.查看JDK帮助文档
4.Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（也可以使用对象调用）
5.常用功能：①通过fill给数组赋值②通过sort方法对数组升序排序③通过equals方法比较数组中元素值是否相等④通过binarySerach方法能对排序好的数组进行二分查找法操作。
Arrays类例子。

int[] a = {1,2,3,4,9090,31231,543,21,3,23};
		
		//打印数组元素Arrays.toString
		System.out.println(Arrays.toString(a));
		
		//排序后打印
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		
		//fill的使用
		//数组用8填充
		Arrays.fill(a, 8);
		System.out.println(Arrays.toString(a));
		
		//数组中2-4用0填充
		Arrays.fill(a,2,4,0);
		System.out.println(Arrays.toString(a));

六丶稀疏数组

含义：当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数字来保存该数组
处理方式：①记录数组共有几行几列，有多少个不同值②把具有不同值额元素和行列及值记录在一个小规模的数组中，从而缩小程序规模
需求：编写五子棋游戏中，有存盘退出和续上盘的功能
数组和稀疏数组的相互转换

//1.创建一个二维数组 8*8 0：没有棋子  1：黑棋  2：白棋
		int[][] array1 = new int[8][8];
		array1[1][2] = 1;
		array1[2][3] = 2;
		//输出原始数组
		System.out.println("输出原始数组");
		
		for(int[] ints : array1) {
			for(int anInt : ints) {
				System.out.print(anInt+" ");
			}
			System.out.println();
		}
		
		//转换为稀疏数组保存
		//获取有效值个数
		int sum = 0;
		for(int i = 0;i<array1.length;i++) {
			for(int j = 0;j < array1[i].length;j++){
				if(array1[i][j]!=0) {
					sum++;
				}
			}
		}
		System.out.println("有效值个数："+sum);
		
		//2.创建一个稀疏数组
		int[][] array2 = new int[sum+1][3];
		
		array2[0][0] = array1.length;
		array2[0][1] = array1[0].length;
		array2[0][2] = sum;
		
		//3.遍历二维数组，将非0值存放在稀疏数组中
		int count = 0;
		for(int i = 0;i<array1.length;i++) {
			for(int j = 0;j < array1[i].length;j++){
				if(array1[i][j]!=0) {
					count++;
					array2[count][0] = i;
					array2[count][1] = j;	
					array2[count][2] = array1[i][j];	
				}
			}
		}
		
		System.out.println("稀疏数组");
		
		for(int[] ints : array2) {
			for(int anInt : ints) {
				System.out.print(anInt+" ");
			}
			System.out.println();
		}
		
		//还原稀疏数组
		//1.读取稀疏数组
		int[][] array3 = new int[array2[0][0]][array2[0][1]];
		
		//2.给其中的元素还原他的值
		for(int i = 1;i < array2.length;i++) {
			array3[array2[i][0]][array2[i][1]] = array2[i][2];
		}
		
		//3.打印
		System.out.println("还原稀疏数组");
		for(int[] ints : array3) {
			for(int anInt : ints) {
				System.out.print(anInt+" ");
			}
			System.out.println();
		}

内存分析

1.堆

①存放new的对象和数组
②可以被所有的线程共享，不会存放别的对象引用

2.栈

①存放基本变量类型（会包含这个基本类型的具体数值）
②引用对象的变量（会存放这个引用在堆里面的具体地址）

3.方法区

①可以被所有的线程共享
②包含了所有的class和static变量

三种初始化：

1.静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

2.动态初始化

Int[]a a = new int[2];
a[0] = 1;
a[1] = 2;

3.数组的默认初始化

数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组的四个基本特点

1.长度是确定的。数组一旦被创建，他的大小就不可以改变。
2.元素必须是相同的类型，不允许出现混合类型
3.数组中的元素可以是任何数据类型，包括基本类型和引用类型
4.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素想当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

冒泡排序

public static void main(String[] args) {
		int[] a = {2,6,2,7,9,23};
		int[] sort = sort(a);
		System.out.println(Arrays.toString(sort));
	}
	
	//冒泡排序
	//1.比较数组中，两个相邻的元素，如果第一个数逼第二个数打，就交换他们的位置
	//2.每一次比较都会产生一个最大或最下的数字
	//3.下一轮则可以少一次排序！
	//4.依次循环，直到结束
	public static int[] sort(int[] array) {
		
		//临时变量
		int temp = 0;
		
		//外层循环，判断我们这个要走多少次
		for(int i = 0;i < array.length;i++) {
			for(int j = i;j < array.length;j++) {
				if(array[j]>array[i]) {
					temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		return array;
	}