Java知识总结-数组

说明：刚学数组的时候一直弄不明白为什么对数组进行排序和换位的方法不都需要返回这个数组，这些方法返回值都是void，后面才知道数组里存放的都是引用地址，方法里操作的也是引用，当这些引用被改变了，数组里的元素集会变化。

数组是用于存储相同数据类型的一组数据集合。

一，数组的创建方法，

创建一个数组时一定要明确数组的大小。具体元素可以在定义数组时确定，也可以在以后确定：

下面是创建数组常见的几种方式：

public class Test {
	public static void main(String[] args){
		//数组元素不明确时
		int[] arr1=new int[5];
		int arr2[]=new int[5];
		//数组元素明确时
		int[] arr3=new int[]{1,2,3,4,5};
		int[] arr4={1,2,3,4,5};
	}
}

注意：当数组元素明确时，不需要指定数组大小。

public class Test {
	public static void main(String[] args){
		//错误方式
		int[] arr5=new int[5]{1,2,3,4,5};
	}
}

数组在建立以后，其大小不能改变，但是数组的元素可以改变，

public class Test {
	public static void main(String[] args){
		int[] arr={1,2,3,4,5};
		//为数组指定元素赋值
		arr[4]=9;
	}
}

在创建数组时，会同步明确数组的数据类型，数组就无法添加其他类型的数据。

public class Test {
	public static void main(String[] args){
		int[] arr=new int[5];
		//异常：不能为int型数组添加其他类型数据
		arr[4]="abc";
	}
}

二。数组的遍历

同步循环的方式，依次遍历数组的每个元素，并打印

public class Test {
	public static void main(String[] args){
		int[] arr={5,3,7,9,6,2};
		for (int i = 0; i < arr.length; i++) {
			System.out.println("arr["+i+"]="+arr[i]);
		}
	}
}

运行结果：

arr[0]=5
arr[1]=3
arr[2]=7
arr[3]=9
arr[4]=6
arr[5]=2

三，二维数组的遍历

对多维数组的遍历，可以同步多层循环的嵌套来实现。

public class Test {
	public static void main(String[] args){
		int[][] arr={{5,3,7},{4,9},{2,6,8}};
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				System.out.println("arr["+i+"]["+j+"]="+arr[i][j]);
			}
		}
	}
}

运行结果：

arr[0][0]=5
arr[0][1]=3
arr[0][2]=7
arr[1][0]=4
arr[1][1]=9
arr[2][0]=2
arr[2][1]=6
arr[2][2]=8

四，求数组中元素的最值（最大值，最小值）

public class Test {
	public static void main(String[] args){
		int[] arr={5,3,9,6,2,8};
		System.out.println(Max(arr));
		System.out.println(Min(arr));
	}
	//求数组最大值
	public static int Max(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 Min(int[] arr){
		int min=arr[0];
		for (int i = 1; i < arr.length; i++) {
			if(min>arr[i])
				min=arr[i];
		}
		return min;
	}
}

五，数组的排序

数组的常见排序算法有冒泡排序和选择排序。

冒泡排序：

基本思想：

比较数组中相邻的两个元素，如果前面的元素大于后面的元素，则交换他们的位置。

public class Test {
	public static void main(String[] args){
		int[] arr={5,3,9,6,2,8,1};
		sort(arr);
		print(arr);
	}
	//冒泡排序
	public static void sort(int[] arr){
		int num;
		for (int x = 0; x < arr.length; x++) {
			for (int y = 1; y < arr.length-x; y++) {
				//如果数组相邻两个元素前面大于后面，则交换位置
				if(arr[y-1]>arr[y]){
					num=arr[y-1];
					arr[y-1]=arr[y];
					arr[y]=num;
				}
					
			}
		}
	}
	//遍历数组
	public static void print(int[] arr){
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1)
				System.out.println(arr[i]+"]");
			else
				System.out.print(arr[i]+",");
		}
	}
}

运行结果：

[1,2,3,5,6,8,9]

选择排序：

基本思想：

将制定元素与数组中其他元素分别进行比较，如果满足条件就交换位置。

public class Test {
	public static void main(String[] args){
		int[] arr={5,3,9,6,2,8,1};
		sort(arr);
		print(arr);
	}
	//选择排序
	public static void sort(int[] arr){
		int num;
		//制定元素与其他元素分别比较
		for (int x = 0; x < arr.length-1; x++) {
			for (int y = x+1; y < arr.length; y++) {
				//如果数组相邻两个元素前面大于后面，则交换位置
				if(arr[x]>arr[y]){
					num=arr[x];
					arr[x]=arr[y];
					arr[y]=num;
				}
					
			}
		}
	}
	//遍历数组
	public static void print(int[] arr){
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1)
				System.out.println(arr[i]+"]");
			else
				System.out.print(arr[i]+",");
		}
	}
}

运行结果：

[1,2,3,5,6,8,9]

注：上面两种排序方法中，选择排序的效率相对较高。

六，元素反转

public class Test {
	public static void main(String[] args){
		int[] arr={1,2,3,4,5,6,7};
		sort(arr);
		print(arr);
	}
	//反转排序
	public static void sort(int[] arr){
		int num;
		for (int min = 0,max=arr.length-1; min <=max; min++,max--) {
			num=arr[min];
			arr[min]=arr[max];
			arr[max]=num;
		}
	}
	//遍历数组
	public static void print(int[] arr){
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1)
				System.out.println(arr[i]+"]");
			else
				System.out.print(arr[i]+",");
		}
	}
}

运行结果;

[7,6,5,4,3,2,1]

 七，折半查找

public class Test {
	public static void main(String[] args){
		int[] arr={0,1,2,3,4,5,6,7,8,9};
		System.out.println(sort(arr,6));
	}
	//折半查找
	public static int sort(int[] arr,int key){
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;  //中间角标
		while(arr[mid]!=key){
			if(arr[mid]<key)  //当查找值大于中间角标
				min=mid+1;
			else if(arr[mid]>key) //当查找值小于中间角标
				max=mid-1;
			if(min>max)
				return -1; //如果没有找到则返回-1
			mid=(min+max)/2;
		}
		return mid;
	}
}

运行结果：

6