java基础要点（3)数组

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
  
需求：想定义一个可以存储3个整数的容器。
  int[] x = new int[3];
打印数组中角标为0的元素的值。
  System.out.println(x[0]);

class ArrayDemo2
{
	public static void main(String[] args)
	{
		int[] arr=new int[3];
		//int arr[]=new int[]{234,32,29,34};
		//int arr[]={23,32,98};
		
		
		//System.out.println(arr[3]);
		//错误：ArrayIndexOutOfBoundsException:3
		//操作数组时，访问到了数组中不存在的角标

		arr=null;
		System.out.println(arr[1]);
		//NullPointerException:空指针异常
		//当引用没有任何指向，值为null的情况，该引用还在用于操作实体

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

数组的操作：
获取数组中的元素，通常会用到遍历

int arr[]={32,24,12,45,78,73,56};

数组中有一个属性可以直接获取到数组元素个数
使用方式：数组名称.length

                System.out.println("length:"+arr.length);

需求：求数组中的元素的和
求和思想

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

需求：遍历数组，打印数组中的每个数

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

需求：给定一个数组，判断数组元素中的最大值和最小值

class ArrayTest
{

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

 步骤：
 1、定义一个变量，初始化为数组中的任意一个值
 2、通过循环语句对数组进行遍历
 3、在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。
 
 需要定义一个功能来完成，以便提高复用性
 1、明确结果，数组中的最大元素，返回类型int
 2、未知内容参与运算：一个数组 int[] arr

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

  获取最大值的两种方式
  初始化为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];
	}
	public static void main(String[] args)
	{
		int arr[]={34,12,32,97,34,2,99};
		int max=getMax(arr);
		int min=getMin(arr);
		System.out.println("max="+max);
		System.out.println("min="+min);
		
	}
}

需求：对指定的数组进行排序

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])
				{
					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])
				{
					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={2,1,0,3,8};
		print(arr);
		//selectSort(arr);
		bubbleSort(arr);
		print(arr);
	}
	public static void print(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]+"]");
		}
		
	}
}

对给定的数组进行反转

class ArrayTest3
{
	public static void main(String[] args)
	{
		int arr[]={23,123,45,97,32,34};
		print(arr);
		reverseArray(arr);
		print(arr);
	}
	public static void print(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]+"]");
		}
	}
	public static void reverseArray(int[] arr)
	{
		for (int start=0,end=arr.length-1;start<end ;start++,end-- )
		{
			swap(arr,start,end);
		}
		
	}
	public static void swap(int[]arr,int x,int y)
	{
		int temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;
	}
	
}

数组的查找功能

需求：有一个有序的数组想要讲一个元素插入到该数组中，
还要保证该数组是有序的，如何获取该元素在数组长的位置

class ArrayTest4
{

定义功能，获取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;

	}
	public static void main(String[] args)
	{
		int[] arr={12,23,31,34};
		int index=getIndex(arr,9);
		//查找位置
		System.out.println(index);
		//查找位置，如果没有,返回放入该数组中的位置
		System.out.println(halfSearch(arr,34));
		//查找位置，如果没有,返回放入该数组中的位置
		System.out.println(halfSearch_2(arr,26));

	}
	public static void print(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]+"]");
		}
	}

折半查找。提高效率，但是必须要保证该数组是有序的数组。

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

	}

折半查找的第二种方式

	public static int halfSearch_2(int[] arr,int key)
	{
		int max,min,mid;
		max=arr.length-1;
		min=0;
		mid=(max+min)/2;
		while (arr[mid]!=key)
		{
			
			if(arr[mid]<key)
				min=mid+1;
			else if(arr[mid]>key)
				max=mid-1;
			 if(min>max)
				 return min;
			 mid=(max+min)/2;
		}
		return mid;
	}
}
class ArrayTest5
{
	public static void main(String[] args)
	{
		toBin(6);
		toHex(60);
	}

十进制转二进制

	public static void toBin(int num)
	{
		while (num>0)
		{
			System.out.println(num%2);
			num=num/2;
		}
	}

十进制转十六进制

	public static void toHex(int num)
	{
		StringBuffer sb=new StringBuffer();
		for (int x=0;x<8 ;x++ )//int数据类型占用4个字节，4位移动一次，最多移动8次
		{
		
		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());
	}
}
class ArrayTest6
{
	public static void main(String[] args)
	{
		toHex(60);
		toBin(6);
	}

  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'简单多了

  这个表怎么建立呢？
  可以通过数组的形式来定义

  结果是反着的，想要正过来，可以通过遍历数组
  ，从最后一位遍历。

	public static void toHex(int num)
	{
		char[] ch={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

		char[] arr=new char[8];//循环8次，最多有8个数
								//字符串数组默认'\u0000'代表空格
			
		int pos=arr.length;//定义指针
		while (num!=0)
		{
			int temp=num&15;

			arr[--pos]=ch[temp];
			num=num>>>4;
		}
		System.out.println("pos="+pos);

存储数据的arr数组遍历

		System.out.print("[");
		for (int x=pos; x<arr.length;x++ )
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}

	}
	public static void toBin(int num)
	{

定义一个二进制的表

		char[] ch={'0','1'};

定义一个存储的数组

		char[] arr=new char[32];

定义一个指针

		int pos=arr.length;

		while (num!=0)
		{
			int temp=num&1;
			arr[--pos]=ch[temp];
			num=num>>>1;

		}
		System.out.println("pos="+pos);
		//存储数据的arr数组遍历
		System.out.print("[");
		for (int x=pos; x<arr.length;x++ )
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}

	}
}

优化

class ArrayTest7
{
	public static void main(String[] args)
	{
		toBin(6);
		System.out.println();
		toHex(60);
		System.out.println();
		toBa(34);
		System.out.println();
	}
	//十进制转二进制
	public static void toBin(int num)
	{
		trans(num,1,1);
	}
	//十进制转十六进制
	public static void toHex(int num)
	{
		trans(num,15,4);
	}
	//十进制转八进制
	public static void toBa(int num)
	{
		trans(num,7,3);
	}
	public static void trans(int num,int base,int offset)
	{
		if(num==0)
			System.out.println(0);
		char[] ch={'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]=ch[temp];
			num=num>>>offset;
		}
		
		
		for (int x=pos; x<arr.length;x++ )
		{
			
				System.out.print(arr[x]);
			
		}




	}
}

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

int[][] arr=new int[2][5];//定义了名称为arr的二维数组。
该二维数组中有2个一维数组，每个一位数组中有5个元素
System.out.println(arr);//[[I@de6ced 二维数组的地址值
System.out.println(arr[0]);//[I@c17164 一维数组的地址值
System.out.println(arr[0][0]);//二维数组中第一个一维数组第一个元素的值
System.out.println(arr.length);//二维数组的长度2
System.out.println(arr[0].length);//第一个一维数组的长度

		int arr[][]={{12,23,4,2,5},{122,223,34,24,15}};
		
		getSum(arr);
	}

需求：计算二维数组中元素的和

	public static void getSum(int[][] arr)
	{
		int sum=0;
		for (int a=0;a<arr.length ;a++ )
		{
			for (int b=0;b<arr[a].length ;b++ )
			{
				sum=sum+arr[a][b];
			}
		}
		System.out.println(sum);//打印和
	}
}