Java语法基础之数组

------- android培训、java培训、期待与您交流！ ----------

数组的定义

数组的内存分配及特点

数组操作常见问题

数组常见操作

数组中的数组

1，数组的定义

概念：用于存储同一种类型数据的集合。其实数组就是一个容器

好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。

如何在java中表现一个数组呢？两种表现形式。

1）、元素类型[] 变量名 = new 元素类型[元素的个数]；

示例： int [] arr=new int[3]

2）、元素类型[] 变量名 = {元素1，元素2...}；

    示例：int [] arr={3,4,5}

元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；

        int [] arr=new int[]{3,4,5}

如：需求：定义一个可以存储3个整数的容器

Int[] a=new int[3]{1,2,3}

2，数组的内存分配及特点

java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

Java程序在运行时，需要在内存中的分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；

    只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。通过new建立的实例都存放在堆内存中

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。实体不在被使用，会在不确定的时间内被垃圾回收器回收

3，数组操作常见问题

数组脚标越界异常（ArrayIndexOutofBoundsException）

int[] arr =newint[2];

System.out.println(arr[3]);

访问到了数组中的不存在的脚标时发生。操作数组时，访问到了数组中不存在的角标。

空指针异常（NullPointerException:）

int[] arr =newint[3];

       arr = null;

System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时。空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

4,数组常见操作

获取最值（最大值，最小值）

排序（选择排序，冒泡排序）

折半查找（二分查找）

4.1获取最值（最大值，最小值）

给定一个数组{5,1,6,4,2,8,9}。

1，获取数组中的最大值，以及最小值。

    获取数组中的最大值。

    思路：

    1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。

    通过一个变量进行临储。

    2，让数组中的每一个元素都和这个变量中的值进行比较。

    如果大于了变量中的值，就用该该变量记录较大值。

    3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

 

    步骤：

    1，定义变量。初始化为数组中任意一个元素即可。

    2，通过循环语句对数组进行遍历。

    3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

   

    需要定义一个功能来完成。以便提高复用性。

    1，明确结果，数组中的最大元素int。、

    2，未知内容：一个数组。int[]

class ArrayTest 
{
	
	public static int getMax(int[] arr)
	{
		int max = arr[0];
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}
	/*
	获取最大值的另一种方式。
	可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。
	*/
	public static int getMax_2(int[] arr)
	{
		int max = 0;
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[max])
				max = x;
		}
		return arr[max];
	}
	/*
	获取最小值。
	*/
	public static int getMin(int[] arr)
	{
		int min = 0;
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]<arr[min])
				min = x;
		}
		return arr[min];
	}
	//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。
	/*
	public static double getMax(double[] arr)
	{
	}
	*/
	public static void main(String[] args)
	{
		int[] arr ={5,1,6,4,2,8,9};
		int max = getMax_2(arr);
		int min = getMin(arr);
		System.out.println("max="+max);
		System.out.println("min="+min);
//		boolean[] ar = new boolean[3];
//		System.out.println(ar[1]);
	}
}

4.2排序（选择排序，冒泡排序）

对给定数组进行排序。

{5,1,6,4,2,8,9}

import java.util.*;
class ArrayTest2 
{
	/*
	选择排序。
	内循环结束一次，最值出现头角标位置上。
	*/
	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;
					*/
					swap(arr,x,y);
				}
			}
		}
	}
	/*
	冒泡排序：相邻的两个元素进行比较，如果符合条件换位
第一圈：最值出现在最后位。
	*/
	public static void bubbleSort(int[] arr)
	{
		for(int x=0; x<arr.length-1; x++)
		{									
			for(int y=0; y<arr.length-x-1; y++)
//-x:让每一次比较的元素减少，-1：避免角标越界。
			{
				if(arr[y]<arr[y+1])
				{
					/*
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
					*/
					swap(arr,y,y+1);
				}
			}
		}
	}
	/*
	发现无论什么排序。都需要对满足条件的元素进行位置置换。
	所以可以把这部分相同的代码提取出来，单独封装成一个函数。
	*/
	public static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void main(String[] args)
	{
		int[] arr = {5,1,6,4,2,8,9};
		//排序前；
		printArray(arr);
		//排序
		//selectSort(arr);
		//bubbleSort(arr);

		//Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
		//排序后：
		printArray(arr);
	}
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}
	}
}

选择排序图解：

冒泡排序图解：

4.3折半查找（二分查找）

//二分查找法。必须有前提：数组中的元素要有序。

	public static int halfSearch(int[] arr,int key)
	{
		int min,max,mid;
		min = 0;
		max = arr.length-1;
		mid = (max+min)/2;//(max+min)>>1

		while(arr[mid]!=key)
		{
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;

			if(min>max)
				return -1;
			mid = (max+min)/2;
		}
		return mid;
	}

4.4其他操作：获取数组中元素、获取数组元素个数。

class ArrayDemo3 
{
	public static void main(String[] args) 
	{
//数组的操作：
		//获取数组中的元素。通常会用到遍历。
		int[] arr = {3,6,5,1,8,9,67};
		//int sum = 0;
		for(int x=0; x<arr.length; x++)
		{
			//sum += arr[x];
			System.out.println("arr["+x+"]="+arr[x]+";");//arr[0]=0;
		}
		//数组中有一个属性可以直接获取到数组元素个数。length.
		//使用方式：数组名称.length = 
		System.out.println("length:"+arr.length);
		printArray(arr);
	}
	//定义功能，用于打印数组中的元素。元素间用逗号隔开。
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}
	}
}

5、数组中的数组

二维数组[][]

格式1：int[][]arr=new int[3][4];

a)       定义了名称为arr的二维数组

b)       二维数组中有3个一维数组

c)       每一个一维数组中有2个元素。

d)       一维数组的名称分别为arr[0],arr[1],arr[2]

e)       给第一个一维数组1角标位赋值为78写法是：arr[0][1]=78;

格式2：int[][]arr=new int[3][];

a)       二维数组中有3个一维数组

b)       每个一维数组都是默认初始化值null

c)       可以对这个三个一维数组分别进行初始化。

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

格式3：int[][]arr={{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组

二维数组中有三个一维数组

每一个一维数组中具体元素也都已初始化

第一个一维数组arr[]={3,8,2};

第二个一维数组arr[]={2,7};

第三个一维数组arr[]={9,0,1,6};

二维数组的图解：

练习：获取arr数组中所有元素的和，使用for的嵌套循环即可。

注意特殊写法情况：int[]x,y[];x是一维数组，y是二维数组。

class Array2Demo 
{
	public static void main(String[] args) 
	{
//		int[] arr = new int[3];//一维数组。
		//int[][] arr = new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
							//每一个一维数组中有四个元素。
		//System.out.println(arr[0][1]);
		/*
		int[][] arr  = new int[3][];
		arr[0] = new int[3];
		arr[1] = new int[1];
		arr[2] = new int[2];
		System.out.println(arr.length);//打印是二维数组的长度 3；
		System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
		*/
		int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
		int sum = 0;
		for(int x=0; x<arr.length;x++)
		{
			for(int y=0; y<arr[x].length; y++)
			{
				sum = sum + arr[x][y];
			}
		}
		System.out.println("sum="+sum);
	}
}
/*
int[] x; int x[];
int[][] y; int y[][]; int[] y[];
int[] x,y[];//x一维，y二维。
int[] x;
int[] y[];
a.
x[0] = y;//error
b.
y[0] = x;//yes
c.
y[0][0] = x;//error
d.
x[0][0] = y;//error
e.
y[0][0] = x[0];//yes
f.
x=y;//error
*/

6、数组练习

6.1对给定的数组进行反转。

对给定的数组进行反转。

{3,1,5,6,2} --->

{2,6,5,1,3}

class  ArrayTest3
{
	public static void main(String[] args) 
	{
		int[] arr = {3,1,5,6,2};
		printArray(arr);
		//反转后;
		reverseArray(arr);
		printArray(arr);
	}
	public static void reverseArray(int[] arr)
	{
		for(int start=0,end=arr.length-1; start<end ; start++,end--)
		{
			/*
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
			*/
			swap(arr,start,end);
		}
	}
	public static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}		
	}
}

6.2 数组的查找操作。

练习：有一个有序的数组，想要将一个元素插入到该数组中，

还要保证该数组是有序的。如何获取该元素在数组中的位置。

import java.util.*;
class ArrayTest4 
{
	public static void main(String[] args) 
	{
//		int[] arr = {3,2,1,5,4,2,9};
//		int index = getIndex(arr,2);
//		System.out.println("index="+index);
		int[] arr = {2,4,5,7,8,19,32,45};//8
		int index = getIndex_2(arr,190);
		System.out.println("index="+index);
		
//		int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
//		System.out.println("x="+x);
	}
	public static int getIndex_2(int[] arr,int key)
	{
		int min = 0,max = arr.length-1,mid;
		while(min<=max)
		{
			mid = (max+min)>>1;
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return min;
	}
	/*
	折半的第二种方式。
	*/
	public static int halfSearch_2(int[] arr,int key)
	{
		int min = 0,max = arr.length-1,mid;
		while(min<=max)
		{
			mid = (max+min)>>1;
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return -1;
	}
	/*
	折半查找。提高效率，但是必须要保证该数组是有序的数组。
	*/
	public static int halfSearch(int[] arr,int key)
	{
		int min,max,mid;
		min = 0;
		max = arr.length-1;
		mid = (max+min)/2;//(max+min)>>1
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;
			if(min>max)
				return -1;
			mid = (max+min)/2;
		}
		return mid;
	}
	//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0; x<arr.length; x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}
}

6.3十进制-->十六进制。十进制-->二进制

class ArrayTest5 
{
	public static void main(String[] args) 
	{
		toBin(6);		
toHex(60);
	}
	
	/*
	十进制-->十六进制。
	*/
	public static void toHex(int num)
	{
		StringBuffer sb = new StringBuffer();
		for(int x=0; x<8; x++)
		{
			int temp = num & 15;
			if(temp>9)
				//System.out.println((char)(temp-10+'A'));
				sb.append((char)(temp-10+'A'));
			else
				//System.out.println(temp);
				sb.append(temp);
			num  = num >>> 4;
		}
		System.out.println(sb.reverse());
	}
	/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		StringBuffer sb = new StringBuffer();
		while(num>0)
		{
			//System.out.println(num%2);
			sb.append(num%2);
			num = num / 2;
		}
		System.out.println(sb.reverse());
	}
}

进制转换用查表法

class ArrayTest6 
{
	public static void main(String[] args) 
	{
//		toHex(60);
		toBin(-6);
	}
	public static void toBin(int num)
	{
		//定义二进制的表。
		char[] chs = {'0','1'};
		//定义一个临时存储容器。
		char[] arr = new char[32];
		//定义一个操作数组的指针
		int pos = arr.length;
		while(num!=0)
		{
			int temp = num & 1;
			arr[--pos] = chs[temp];
			num = num >>> 1;
		}
		for(int x=pos; x<arr.length; x++)
		{
			System.out.print(arr[x]);
		}
	}
	/*
		0 1 2 3 4 5 6 7 8 9 A  B  C   D  E  F  ==十六进制中的元素。
		0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

		查表法：将所有的元素临时存储起来。建立对应关系。
		每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
		这样比 -10+'a'简单的多。

		这个表怎么建立呢？
		可以通过数据的形式来定义。
		发现终于出结果了。但是是反着的。想要正过来呢？可以通过StringBuffer reverse功能来完成。
		但是这个工具还没有学习。
		所以可以使用已经学习过的容器：数组来完成存储。；
	*/
	public static void toHex(int num)
	{
		char[] chs = {'0','1','2','3'
					,'4','5','6','7'
					,'8','9','A','B'
					,'C','D','E','F'};	
		//定义一个临时容器。
		char[] arr = new char[8];
		int pos = arr.length;
		while(num!=0)
		{
			int temp = num & 15;	
			//System.out.println(chs[temp]);
			arr[--pos] = chs[temp];
			num = num >>> 4;
		}
		System.out.println("pos="+pos);
		//存储数据的arr数组遍历。
		for(int x=pos;x<arr.length; x++)
		{
			System.out.print(arr[x]+",");
		}
	}
}

进一步优化:十进制->二进制，十进制->八进制,十进制->十六进制

class ArrayTest7 
{
	public static void main(String[] args) 
	{
		toBin(-6);
		toHex(-60);
		toBa(60);

		System.out.println(Integer.toBinaryString(6));
		System.out.println(Integer.toHexString(6));	}
/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		trans(num,1,1);
	}
	/*
	十进制-->八进制
	*/
	public static void toBa(int num)
	{
		trans(num,7,3);
	}
	/*
	十进制-->十六进制
	*/
	public static void toHex(int num)
	{
		trans(num,15,4);
	}
	public static void trans(int num,int base,int offset)
	{
		if(num==0)
		{
			System.out.println(0);
			return ;
		}
		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;
		}
		for(int x=pos; x<arr.length; x++)
		{
			System.out.print(arr[x]);
		}
		return ;
	}
}

 

-------寄语：成长的季节，静等花开的那天----------                 ——濛濛

------- android培训、java培训、期待与您交流！ ----------