数组的声明与常用方法简述

一维数组

概述

• 顾名思义，数组是数据的组合，不止一个数据，有很多数据，数组是引用类型变量
• 数组的初始化，java中数组必须进行初始化才能使用，为数组中的数组元素分配内存空间，并为每个数组元素赋初始值。

初始化

静态初始化

int[] arr = new int[]{1,2,3};
int[] arr = {1,2,3};

动态初始化

int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

数组的使用

通过下标访问指定元素

注意：
1、java语言的数组索引（下标、角标）是从0开始；
2、不要超出索引的范围，如果超出索引范围会出现java.lang.ArrayIndexOutOfBoundsException

获取数组元素的个数

在java中，所有数组提供length属性，通过这个属性可以访问到数组的长度或者数组中元素的个数

数组的排序

• 冒泡排序

package waking.test.arrays;
/**
 * 数组的排序之冒泡排序
 * @author waking
 *
 */
public class Demo01 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,3,5,7,2,8,9,32,11,45};
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp = arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+",");//1,2,3,5,7,8,9,11,32,45,
		}
	}
}

• 选择排序

package waking.test.arrays;
/**
 * 数组的排序之选择排序
 * @author waking
 *
 */
public class Demo02 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,2,12,4,5,3,7,9,54,56,34};
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[i]>arr[j]) {
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		for (int  i= 0;  i< arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

数组的查找

• 二分查找法

package waking.test.arrays;
/**
 * 数组的二分查找法
 * @author waking
 *
 */
public class Demo03 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,5,6,7,8,9,10,22,56};
		int key = 10;
		int left = -1;
		int right = arr.length-1;
		while(left<right) {
			int middle =(left+right)/2;
			if(key>arr[middle]) {
				left=middle+1;
			}else if(key<arr[middle]){
				right=middle-1;
			}else {
				System.out.println(middle);//6
				break;
			}
		}
	}
}

Arrays工具类

• Arrays工具类有非常多的方法对数组进行操控，可以参考API
• 简单介绍几个常用方法

作用：主要用于对数组进行排序，查找，填充，比较等的操作
Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;

• 常用方法

package waking.test.arrays;

import java.util.Arrays;

/**
 * Arrays工具类
 * Arrays工具类的使用 
 * 1 二分查找 
 * 2 排序 
 * 3 复制 
 * 4 填充 
 * 5 把数组转成字符串
 * @author waking
 *
 */
public class Demo04 {
	public static void main(String[] args) {
		int[] arr = {1,32,5,6,2,7,8,9,10};
		binarySearch(7, arr);
		sort(arr);
		copy(arr);
		fill(arr);
		toStrings(arr);
	}
	/**
	 * 二分查找
	 * @param key
	 * @param arr
	 */
	public static void binarySearch(int key,int[] arr) {
		Arrays.sort(arr);
		int search = Arrays.binarySearch(arr, key);
		System.out.println("您想要查找的数在"+search);//您想要查找的数在4
	}
	/**
	 * 排序
	 * @param arr
	 */
	public static void sort(int[] arr) {
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));//[1, 2, 5, 6, 7, 8, 9, 10, 32]
	}
	
	/**
	 * 复制
	 * @param arr
	 */
	public static void copy(int[] arr) {
		int[] newcopy = Arrays.copyOf(arr, arr.length);
		System.out.println(Arrays.toString(newcopy));//[1, 2, 5, 6, 7, 8, 9, 10, 32]
		
	}
	/**
	 * 填充
	 * @param arr
	 */
	public static void fill(int[] arr) {
		Arrays.fill(arr, 10);
		System.out.println(Arrays.toString(arr));//[10, 10, 10, 10, 10, 10, 10, 10, 10]
	}
	/**
	 * 数组转化为字符串
	 * @param arr
	 */
	public static void toStrings(int[] arr) {
		System.out.println(Arrays.toString(arr));//[10, 10, 10, 10, 10, 10, 10, 10, 10]
	}
}

• Arrays工具类很好用

这里简单介绍方法的传递

根据有没有参数：1.无参方法 	2.有参方法
根据有没有返回值：1.无返回值 2.有返回值
组合成四种方式：无参无返回值，无参有返回值，有参无返回值，有参有返回值

二维数组

• 概念：其实就是数组的嵌套，可以简单理解为二维矩阵
• 二维数组同样有初始化：静态初始化和动态初始化

静态初始化

• 举例

int[][] arr = new int[][]{{1,2,3},{4,5,6}};
int[][] arr = {{1,2,3},{4,5,6}};

动态初始化

int[][] arr = new int[2][2];
arr[0][0] = 1;
arr[0][1] = 2;
arr[1][0] = 3;
arr[1][1] = 4;

• 同样二维数组有length属性来表示数组的长度

package waking.test.arrays;
/**
 * 二维数组的初始化和length属性
 * @author waking
 *
 */
public class Demo05 {
	public static void main(String[] args) {
		int[][] arr = {{1,2},{3,4},{5,6}};
		System.out.println(arr.length);//3
	}
}

• 这里只是简单介绍，感谢您的观看