Java-数组

一.一维数组

定义：同一种类型的数据的集合，或者说容器。

格式：

1.元素类型 [ ] 数组名 = new 元素类型 [ 元素个数 ]

eg：int [ ] arr = new int [ 5 ]；

2.元素类型 [ ] 数组名 = new 元素类型 [ ] { 元素1、元素2、元素3... }

eg：int [ ] arr = new int [ ] { 1,3,5,7 }  或者  int [ ] arr =  { 1,3,5,7 }

二.常见数组的操作

1.获取数组中的元素：遍历

实现方式：for循环

public class ArrayTest1 {

	public static void main(String[] args) {
		//遍历数组
		int[] arr = new int[]{1,3,5,7,9};
		for(int i=0;i<arr.length;i++){
			if(i != arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.print(arr[i]);
		}
	}

}

2.获取数组的最大值和最小值

public class ArrayTest2 {

	public static void main(String[] args) {
		int[] arr = {9,5,7,6,8,2,14,3};
		int max = arr[0];
		int min = arr[0];
		
		//获取最大值
		for(int x=0;x<arr.length;x++){
			if(arr[x]>max){
				max = arr[x];
			}
		}
		System.out.println("最大值是："+max);
		
		//获取最小值
		for(int x=0;x<arr.length;x++){
			if(arr[x]<min){
				min = arr[x];
			}
		}
		System.out.println("最小值是："+min);
	}
}

3.对数组进行排序

①选择排序（升序）

定义：从第0位开始，依次把其与后面的每一位相比较，如果比后面的值大，则交换位置。

特点：内循环结束一次，最小值出现在头角标位置。

public class ArrayTest3 {

	public static void main(String[] args) {
		//对数组进行排序，选择排序
		int[] arr = {9,5,7,6,8,2,14,3};
		
		for(int x=0;x<arr.length-1;x++){
			for(int y=x+1;y<arr.length;y++){
				if(arr[x]>arr[y]){
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		
		//遍历数组
		for(int i=0;i<arr.length;i++){
			if(i != arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.print(arr[i]);
		}
	}
}

②冒泡排序（升序）

定义：依次把相邻的两个元素进行比较，如果符合条件，则交换位置。

特点：内循环结束一次，最大值出现在了尾角标位置。

public class ArrayTest4 {

	public static void main(String[] args) {
		//对数组进行排序，冒泡排序
		int[] arr = {9,5,7,6,8,2,14,3};
		
		for(int x=0;x<arr.length-1;x++){
			for(int y=0;y<arr.length-x-1;y++){
				if(arr[y]>arr[y+1]){
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
		
		//遍历数组
		for(int i=0;i<arr.length;i++){
			if(i != arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.print(arr[i]);
		}
	}
}

排序中最快的是希尔排序。

③利用jdk自带的数组类的功能进行排序。

Array.sort()；即可搞定。

4.查找一个元素在数组中是否存在

①普通查找法

特点：不管数组是否有序，都可以进行查找，但是效率低

public class ArrayTest5 {

	public static void main(String[] args) {
		//普通查找法查找元素
		int num = 3;
		int[] arr = {9,5,7,6,8,2,14,3};
		for(int x=0;x<arr.length;x++){
			if(num==arr[x]){
				System.out.println("元素存在，角标值为："+x);
				break;
			}
		}
		System.out.println("该元素不存在！");
	}
}

②二分查找法

特点：数组必须有序，才能使用此查找法

public class ArrayTest6 {

	public static void main(String[] args) {
		//二分查找法
		int num = 5;
		int[] arr = {2,3,5,6,7,8,9,14};
		
		int min = 0;
		int max = arr.length-1;
		int mid = (min+max)/2;
		
		while(num!=arr[mid]){
			if(num>arr[mid]){
				min = mid+1;
			}else{
				max = mid-1;
			}
			mid = (min+max)/2;
			if(min>max){
				System.out.println("该数不存在");
				return;
			}
		}
		System.out.println("该元素存在，角标为："+mid);
	}
}

5.进制转换

三.二维数组

定义：在一个数组中包含多个一维数组，即被称为二维数组。

格式：

①数据类型 [ ] [ ] 变量名 = new 数据类型 [ 二维数组的长度 ] [ 一维数组的长度 ] ；

eg：int [] [] arr = new int [ 3 ][ 2 ];  这表示这是一个存储着3个长度为2的一维数组的二维数组。

②int [ ] [ ] arr = { { 1,2,3 }，{ 4,5,5 }，{ 8,4,6 } }；

 这表示这是一个存储着3个长度为3的一维数组的二维数组。

四.由数组引出的内存结构问题

Java内存区域的划分：1.寄存器，2.本地方法区，3.方法区，4.栈内存，5.堆内存

为什么划分这么多区域？因为每一个内存区域对数据处理的方式都不同。

我们先来说一说堆和栈：

1.栈内存的特点：存储的都是局部变量

包括函数的参数、函数内定义的变量、语句中定义的变量，变量一旦使用完，就会在栈内存中自定释放。

2.堆内存的特点：存储的是实体

堆内存中的实体都有首内存地址值

堆内存中的变量都有默认初始化值

对于没有任何引用变量指向的实体，会视为垃圾，被垃圾回收机制所回收。