Java数组详解

数组

概念：同一种类型的数据集合
优点：自动给数组中元素从0开始编号，方便操作这些元素。

格式1(需要一个容器存放未知的具体数据)
//元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度];
int[ ] arr = new int[5];
格式2(需要一个容器存储已知的具体数据)
//元素类型[ ] 数组名 = new 元素类型[ ]{元素,元素,...};
int[ ] arr = new int[ ]{3,5,1,7};
int[ ] arr = {3,5,1,7};

堆内存

内存的划分

1寄存器
2本地方法区
3方法区
4栈内存：存储局部变量，变量所属的作用域一旦结束，该变量就自动释放
5堆内存：存储数组和对象，凡是new都建立在堆中
堆内存特点:
1.每一个实体都有首地址值。
2.堆内村中每一个变量都有一个初始化值，根据类型，整数是0，小数是0.0或0.0f，boolean是f’alse,char是’\u0000’。
3.垃圾回收机制。

运行异常情况
1.当访问数组中不存在的角标时
2.当引用的变量没有任何实体指向时还在操作实体
3.直接打印数组名称会输出例子：[I@c17164 @左边表示 实体类型，右边为数组哈希值

数组常见操作

遍历

###一维数组：

int arr[]; //定义一个一维数组
int arr2[] = {1,2,3,4,5}; //静态初始化一个数组
arr1 = new int[5]; //动态初始化数组

arr1[3]=10; //给intArrayOne的第4个元素赋值为10
System.out.println(arr1[0]);//引用arr1数组中的第1个元素并进行输出,因为此时第1个元素还被赋值，所以其值为整型的默认值0，输出为0
System.out.println(arr1[3]);//引用arr1数组中的第4个元素并进行输出
System.out.println(arr2[4]);//引用arr1数组中的第5个元素并进行输出
/*
    静态初始化在声明一个数组变量的同时，进行赋值；动态初始化给一个已存在的数组类型的变量赋一个空的数组，两种方法在初始化后，
    变量所存储的数组的元素数目都是确定的，使用下标进行引用时不能超过其范围
*/

一维数组遍历

语法：
for(元素类型 临时变量名:遍历对象)
{
    引用了临时变量的语句(临时变量存入的是遍历对象中的元素，而非元素对应的下标)
}

//for循环输出一个数组中的所有元素
for(int i=0;i<=arr2.length-1;i++)  //数组名.length=数组长度
{
    System.out.println(arr2[i]);
}
//可以使用便利循环进行简化
for(int num:arr2)
{
    System.out.println(num);
}

获取最值

定义变量记录较大的值

public static int getMax(int[] arr)
{	//定义变量记录较大的值(元素)
	int maxElement = arr[0];
	for(int x=1;x<arr.length;x++)
	{
	if(arr[x]>maxElement)
	maxElement = arr[x];
	}
	return maxElement;
}

定义角标记录较大的值

public static int getMax(int[] arr)
{	//定义变量记录较大的值(角标)
	int maxIndx = 0;
	for(int x=1;x<arr.length;x++)
	{
	if(arr[x]>arr[maxIndx])
	maxIndx = x;
	}
	return arr[maxIndx];
}

排序

选择排序

public static void selectSort(int[] arr)
{
	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;
			}
		}
	}
}
//操作是同一数组，返回值不需要，

冒泡排序

public static void bubbleSort(int[] arr)
{
	for(int x=0;x<arr.length-1;x++)
	{  //内循环：减一避免角标越界，减x让外循环增加一次内循环参数与比较的元素个数递减
		for(int y=0;y=arr.length-1-x;y++)
		{
			if(arr[y]>arr[y+1])
			{
				int temp=arr[y];
				arr[y]=arr[y+1];
				arr[y+1]=temp;
			}
		}
	}
}

//for循环也可换为
for(int x=length;x>0;x--)
{  //内循环：减一避免角标越界，减x让外循环增加一次内循环参数与比较的元素个数递减
	for(int y=0;y<x;y++)
	{
	}
}

排序位置代码提取

	public static void swap(int[] arr,int a,int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

排序性能优化

//用变量储存最小值及其角标，再交换位置
public static void selectSort_2(int[] arr)
	for(int x=0;x<arr.length-1;x++) {
		int num = arr[x];
		int index = x;
		for(int i=0;i<arr.length;i++) {
			if(num>arr[i]) {
				num = arr[i];
				index = i;
			}
		if(index!=x)	
			swap(arr,x,index);
		}
	}
}

注： java可用内置函数Arrays.sort(arr)进行排序

查找

public static int getIndex(int[] arr;int key){
	//先遍历
	for(int i=0;i<arr.length;x++){
		if(arr[x]==key)
			return x;
	}
	//如果查找元素不存在，返回-1
	return -1;
}

折半查找（二分查找）

为了提高效率，前提被查找的数要有序

public static int binarySearch(int[] arr,int key) {
		int max,min,mid;
		min=0;
		max = arr.length-1;
		mid = (min+max)/2;
		
		while(arr[mid]!=key) {
			if(key>arr[mid])
				min=mid+1;
			else if(key<arr[mid])
				max=mid-1;
			if(max<min)
				return -1;
			mid = (min+max)/2;
		}
		return mid;
	}

public static int binarySearch_2(){
	int max,min,mid;
	min=0;
	max=arr.length-1;
	while(min<=max){
		mid=(max+min)>>1;//相当于除以2
		if(key>arr[mid])
			min = mid +1;
		else if(key<arr[mid])
			max = mid -1;
		else
			return mid;
	}
	return -1;
}

java有内置折半方法binarySearch()//如果数据存在返回具体角标，如果不存在返回（-插入点-1）

进制转换

十进制转为十六进制：

public static void toHex(int num) {
		for(int x=0;x<8;x++) {
			int temp = num & 15;
			if(temp>9)
				System.out.print((char)(temp-10+'A'));
			else 
				System.out.print(temp);
			num =num >>> 4;
		}
	}

查表法

public class VarDemo {
	public static void main(String[] args) {
		toBinary(6);
	}
	//查表法
	public static void trans(int num,int base,int offset ) {
		if(num==0) {
			System.out.println("0");
			return;//如果num=0就返回，不再向下执行
		}
		//定义关系表
		char[] chs = {'0','1','2','3','4',
				'5','6','7','8','9',
				'A','B','C','D','E','F'};
		//查表查到的数据比较多，先定义一个数组，临时容器
		char[] arr = new char[32]; 
		int pos = arr.length;
		while(num!=0) {
			int temp = num & base;
			arr[--pos] = chs[temp];			
			num = num >>> offset;
		}
		System.out.println("pos="+pos);
		for(int x=pos;x<arr.length;x++) {
			System.out.print(arr[x]);
		}
	}
	public static void toHex(int num) {
		trans(num,15,4);
	}
	public static void toOctal(int num) {
		trans(num,7,3);
	}
	public static void toBinary(int num) {
		trans(num,1,1);
	}
}

二维数组

定义格式

int [][] arr = new int [x][y];//x表示数组个数，y表示每个数组中元素个数
int [][] arr = new int[x][];//只定义数组个数未定义每个数组的元素个数
int [][] arr = {{1,2}{3,4,5}{}}

二维数组遍历

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

class  ArrayDemo
{
	public static void main(String[] args) 
	{

//		int[] arr = new int[3];  
//		System.out.println(arr);//[I@1fb8ee3  @左边是实体的类型。 @右边是实体的哈希值。

//		int[][] arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
//		System.out.println(arr);//直接打印二维数组。   [[I@c17164
//		System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。 [I@1fb8ee3
//		System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 0

//		int[][] arr = new int[3][];
//		System.out.println(arr);//直接打印二维数组。   [[I@c17164
//		System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。null
//		System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 NullPointerException

//		int[][] arr = new int[3][2];
//		System.out.println(arr.length);//打印二维数组的长度。其实就是一维数组的个数。
//		System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。

		int sum = 0;
		int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};
		for(int x=0; x<arr.length; x++)
		{
			for(int y=0; y<arr[x].length; y++)
			{
				System.out.print(arr[x][y]+",");
				sum += arr[x][y];
			}
		}
		System.out.println("sum="+sum);
//		甲：30 59 28 17
//		乙；37 60 22 19
//		int[] arr = {{30,59,28,17},{37,60,22,19}};

		int[][][] arr = new int[3][2][4];
	}
}

/*
int[] x,y[];
int[] x;
int[] y[];

a
x = y;
b
x = y[0];
c
x[0] = y[0];
d
x[0] = y[0][0];
e
x[0] = y;
*/

arraycopy(src,srcPos,dest,destPos,length)
参数src原数组srcPos起始位置dest目标数组destPos目标起始位置length复制长度
从下标为srcPos开始，复制length个数据到下标为desPos开始的位置上去