黑马程序员---Java基础--04天(数组)

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

0.数组(概述-内存结构)

概念:
同一种类型数据的集合,其实数组就是一个容器.
数组的好处:
可以自动给数组中的元素从0开始编号,方便操作这些元素.
格式1:
元素类型[] 数组名 = new 元素类型[元素个数或者数组长度];
示例:
int[] arr = new int[5];
格式2:
元素类型[] 数组名 = new 元素类型[]{元素,元素...}
int[] arr = new int[]{3,7,8,9};
int[] arr = {3,4,6,8}

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


		//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
		
		//需求：想定义一个可以存储3个整数的容器。
		int[] x = new int[3];






		//打印数组中角标为1的元素的值。
		System.out.println(x[1]);
	}
}

1.数组(静态初始化-常见问题)

class  ArrayDemo2
{
	public static void main(String[] args) 
	{
		int[] arr = new int[2];
		int arr[] = new int[2];


		//int[] arr = {3,1,6,5,4};
		System.out.println(arr[2]);
		int[] arr = new int[5];
		arr[0] = 90;
		arr[1] = 89;


		int[] arr = new int[3];


		arr = null;
		System.out.println(arr[1]);
		//ArrayIndexOutOfBoundsException: 3:
		//操作数组时，访问到了数组中不存在的角标。


		//NullPointerException:空指针异常：
		//当引用没有任何指向值为null的情况，该引用还在用于操作实体。


	}
}

2.数组(常见操作-遍历)

class ArrayDemo3 
{
	public static void main(String[] args) 
	{
		//数组的操作:
		//获取数组中的元素.通常会用到遍历.


		//int[] arr = new int[3];
		int[] arr = {3,9,6,7,8};


		//数组中有一个属性可以直接获取到数组元素个数.length
		//使用方式:数组名称.length =
		//System.out.println("length:"+arr.length);


		//int sum = 0;
		/*
		for(int x=0; x<arr.length; x++)
		{
			//sum += arr[x];
			System.out.println("arr["+x+"]="+arr[x]+";");
		}
		*/
		//System.out.println(arr);


		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]+"]")
		}
	}
}

3.数组(常见操作-获取最值)

/*
给定一个数组{5,1,6,4,2,8,9}.
1.获取数组中的最大值,以及最小值.
*/


class  ArrayTest
{
	
	/*
	获取数组的最大值.
	思路:
	1.获取最值需要进行比较.每一次比较都会有一个较大的值.因为该值不确定.
	通过一个变量进行临储.
	2.让数组中的每一个元素和都和这个变量中的值进行比较.
	如果大于了变量中的值,就用该变量记录较大值.
	3.当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值了.


	步骤:
	1.定义变量.初始化为数组中任意一个元素即可.
	2.通过循环语句对数组进行遍历.
	3.在变量过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量.
	
	需要定义一个功能来完成.以便提高复用性.
	1.明确结果,数组中的最大元素int.
	2.未知内容:一个数组.int[].
	*/


	public static int getMax(int[] arr)
	{
		int max = arr[0];


		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[max])
			{
				max = arr[x];
			}
			return max;
		}
	}


	/*
	获取最大值的另一种形式.
	可不可以将临时变量初始化为0呢?可以,
	这种方式,其实是在初始化为数组中任意一个角标.
	*/
	
	public static int getMax_2(int[] arr)
	{
		int max = 0;


		for(int x=1; x<arr.ength;x++)
		{
			if(arr[max]<arr[x])
			{
				max = x;
			}
			return arr[max];
		}
	}


	/*
	获取最小值.
	*/


	public static int getMin(int[] arr)
	{
		int min = 0;
		for(int x=0; x<arr.length;x++)
		{
			if(arr[min]>arr[x])
			{
				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.数组(排序-选择排序)
5.数组(排序-冒泡排序)

inmport java.util.*;
/*
对给定的数组进行排序
{5,1,6,4,2,8,9}
*/
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:避免角标越界.
			{
				/*
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
					*/
					swap(arr,x,y);
			}
		}
	}


	/*
	发现无论什么排序.都需要对满足条件的元素进行位置置换.
	所以可以把这部分相同的代码提取出来.单独封装成一个函数.
	*/
	public static void swap(int[] arr,int x,int y)
	{
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = 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)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}
	}
}

6.数组(排序-位置置换功能抽取)

/*
给定的数组进行反转
{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[strat];
			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)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}
	}
}

7.数组(折半查找)

/*
数组的查找操作.


练习:有一个有序的数组,想要将一个元素插入到该数组中,
还要保证该数组是有序的.如何获取该元素在数组中的位置.
*/
import java.util.*;
class ArrayTest4 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}


	//定义功能,获取key第一次出现在数组中的位置.如果返回是-1,
	//那么代表该key在数组中不存在.
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0; x<arr.length; x++)
		{
			if(arr[arr[x]==key])
				return x;
		}
		return -1;
	}


	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])
				mid = 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;


		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;
	}
}

8.数组(十进制-二进制)

9.数组(十进制-十六进制)

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());
	}
}

10.数组(查表法十进制-十六进制)

11.数组(查表法十进制-二进制)

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]+",");
		}


	}
}

12.数组(进制转换优化)

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 ;
	}
}

13.数组(二维数组)

14.数组(二维数组练习)

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
*/

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima