黑马程序员--Java学习06--数组_arr = *getintarr(num);-优快云博客

本文链接：https://blog.youkuaiyun.com/weiye_csdn/article/details/25690243

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

一、数组的概念

所谓数组就是指相同数据类型的元素按照一定的顺序排列的集合，其实数组就是一个容器。

由唯一确定摸个数组元素所需的下标个数可以将数组分为一维数组、二维数组、及多维数组。由于一位数组的使用频率最高，其次是二维数组，而多维数组的定义与使用可以通过二维数组导出，因此，下面仅介绍一维数组和二维数组的定义、创建、初始化和访问的基本方式。

1、一维数组

所谓一维数组是指每个元素由一个下标值唯一确定的数组类型。

一维数组的定义：

数组元素类型[] 数组型变量名;
数组元素类型数组型变量名[];

其中，“数组元素类型”为组成一维数组的元素类型，“数组型变量名”为定义的数组型变量名称，它应符合Java语言的标识符命名规则，建议遵守Java语言的标识符命名规范；例如

int[] intArray; 或者 int intArray[];
float[] floatArray; 或者 float floatArray[];

一维数组的创建

数组型变量属于引用类型，即内部存储的是与引用数组有关的信息，而数组本省需要利用new运算符创建。下面是利用new 运算符创建数组的语法格式：

new 数组元素类型[数组元素数目];

例如：

intArray = new int[100];
floatArray = new float[50];

也可以将数组的定义与创建合并在一起。例如：

char[] name = new char[30];
int[] intArray = new int[50];
float floatArray = new float[50];

需要注意的是：Java语言与C/C++语言就数组类型的实现而言有一个根本的区别，就是Java中的数组只能动态的创建且动态分配内存空间，这是人们最初使用Java语言时经常容易忽略的一个问题。另外，数组一旦被创建就无法改变其长度，如果经常需要在程序运行过程中扩展数组的长度，就应该使用数组列表（ArrayList）。

一维数组的初始化

在创建数组的同时，为数组元素赋予初始值的过程被称为数组的初始化。在Java语言中，为一维数组初始化的基本格式为：

int[] intArray = {10,20,30,40,50,60,70,80,90,100};

这句话的操作过程是：首先为intArray数组分配10个int型元素所需要占用的存储空间，然后将初始值 10，20，30，40，50，60，70，80，90，100依次赋给intArray[0]~intArray[9]。

一维数组的访问

与C/C++语言相同，Java访问数组元素的格式为：

arrayname[下标表达式]

2、二维数组

二维数组的定义有以下几种方式：

数组元素类型数组名字[][];例如 int arr[][];
数组元素类型[][] 数组名字;例如 int[][] arr;

二维数组的创建如下：

//定义一个4行，5列的整型数组
int[][] intArray = new int[][]{{1,6,5,4,2},{7,8,2,4,6},{-1,5,2,4,9},{4,2,3,6,-9}};
或者
int[][] arr ={{1,6,5,4,2},{7,8,2,4,6},{-1,5,2,4,9},{4,2,3,6,-9}};

二、数组的应用

例：数组的遍历

//定义功能：输出数组中每个元素
方法一
class PrintArray {
 PrintArray(int[] arr){
  for (int i=0;i<arr.length ;i++ ) {
   System.out.print(arr[i]);
  }
 }
}
方法二
class PrintArray {
 PrintArray(int[] arr){
  for (int x：arr) {
   System.out.print(x);
  }
 }
}

例：定义一个二维int数组，编写代码获取最小元素。

/**
 * 例：定义一个二维int数组，编写代码获取最小元素。
 * @author wy_heima
 * 解题思路：
 * 1、定义一个二维数组。
 * 2、定义一个容器用于存放最小值。
 * 3、将数组中的一个值先放到容器内，然后将数组中的其它值依次和容器中的值进行比较，若比容器中的值小，则覆盖容器中的值。
 * 4、输出结果。
 * */
public class Test {
	
	public static void main(String[] args) {
		
		//定义一个4行，5列的二维数组
		int[][] arr ={{1,6,5,4,2},{7,8,2,4,6},{-1,5,2,4,9},{4,2,3,6,-9}};
		
		//输出二维数组
		System.out.println("二维数组arr是：");
		printArray(arr);
		
		//输出二维数组最小值
		System.out.println("二维数组arr的最小值是："+getMin(arr));
	}
	
	
	//定义int型方法用于返回数组arr的最小值
	private static int getMin(int[][] arr) {
		
		//定义int变量用于存放最小值
		int temp;
		
		//将二维数组的第一个数赋给temp
		temp=arr[0][0];
		
		//定义for循环，将数组中其它值和temp值相比较，最后得出最小值
		for(int i=1;i<arr.length;i++) {
			
			for(int j=0;j<arr[i].length;j++) {
			
				if(temp>arr[i][j]) temp=arr[i][j];
				}							
		}	
		//返回最小值
		return temp;		
	}
	
	//定义一个方法用于输出数组各元素
	static void printArray(int[][] arr) {
		
		System.out.print("{");
		
		for(int i=0;i<arr.length;i++) {
			
			System.out.print("{");
			
			for(int j=0;j<arr[i].length-1;j++) {
			
				System.out.print(arr[i][j]+",");		
				}
			
			System.out.print(arr[i][arr[i].length-1]+"}");
		}
		System.out.println("}");
	}
}

输出结果是：-9

例：获取数组中重要元素的下标

class ArraySreach_1 {

	public static void main(String[] args) {

		int[] arr={1,3,5,6,7,8,9};
		int index=getIndex(arr,9);//获取元素9的下标
		System.out.println("index="+index);
	}

	/**
		定义功能：获取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;
	}

}

上面这种查找方法效率低，对于含有较多元素的数组就显得慢了，下面介绍折半查找法：

class ArraySreach_2 {

	public static void main(String[] args) {

		int[] arr={1,3,5,6,7,8,9};
		int index_1=halfSearch_1(arr,9);
		int index_2=halfSearch_2(arr,9);//获取元素9的下标
		System.out.println("index_1="+index_1);
		System.out.println("index_2="+index_2);
	}

	/*
	折半查找，提高效率，但是必须要求原数组有序;
	折半查找的基本思路：
	1、设arr[min .... max]是当前的查找区间，首先确定该区间的中间位置mid=(min+max)/2;
	2、然后将待查的key值与arr[mid]比较，若相等，则查找成功，并返回该位置；否则需确定新的查找区间。
	3、若arr[mid]>key,则由表的有序性可知arr[mid....max]均大于key，因此若表中存在关键字等于key的记录，则该记录必定是在mid左边的
	   字表arr[min....mid-1]中，故新的查找区间是左子表
	4、类似的，若arr[mid]<key,则要查找的key必在mid的右子表arr[mid+1.....max]中，即新的查找区间是右子表arr[mid+1...max].
	5、循环以上步骤，直到子区间的长度小于1时查找结束。
	*/
	public static int halfsearch_1(int[] arr,int key) {

		int min=0,max=arr.length-1,mid;
		mid=(min+max)/2;
		while(arr[mid]!=key) {

			if(arr[mid]>key) max=mid-1;
				
			if(arr[mid]<key) min=mid+1;
				
			if(min>max) return -1;
				
			mid=(min+max)/2;
			
		}
		return mid;
	}

	/**
	折半查找的另一种方法
	*/
	public static int halfsearch_2(int[] arr,int key) {

		int min=0,max=arr.length,mid;
		mid=(min+max)/2;
		while (min<=max) {//与上一个的不同之处，此处的约束条件不同
		
			if(arr[mid]>key) max=mid-1;
				
			if(arr[mid]<key) min=mid+1;
				
			if(arr[mid]==key) return mid;
				
			mid=(min+max)/2;
		}
		return -1;
	}

}

下面介绍排序选择排序和冒泡排序法：

/**
选择排序思想：从头至尾顺序扫描序列，找出最小的一个记录，和第一个记录交换，接着从剩下的记录中继续这种选择和交换，最终使序列有序。
*/
import java.util.Arrays;
class ArraySort {
	
	public static void main(String[] args) {
		
		//定义一个待排序数组
		int[] arr={1,2,3,3,5,0,6,8,9,2,4,1,6,4,0,6,7,4,3};
		//数组的操作最常见的是获取数组中的元素。
		//数组中有一个属性可以直接获取到数组中元素个数:.length.
		//使用方法：数组名称.length

		//输出排序前数组
		printArray(arr);

		//选择排序
		selectSort(arr);

		//输出排序后数组
		printArray(arr);
	}


	/**
	选择排序
	*/
	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 printArray(int[] arr) {

		for(int x=0;x<arr.length;x++) {

			System.out.print(arr[x]+" ");
		}
		System.out.println();
	}
}

/**
冒泡排序
思想原理：
1、相邻的两个数相比较，经过轮的比较，最大的数据肯定会位于最后；
2、经过循环，若某一轮的比较中没有移动数据说明序列已经有序，此时可以结束循环
步骤：
1、定义变量，进行初始化；
2、通过循环语句对数组进行遍历；
3、在变量的过程中定义判断条件，如果前一个比后一个大，调换两者位置，如果在某一次循环中并未调换，说明数组已经有序，跳出循环。
	
*/
import java.util.Arrays;
class ArraySort {
	
	public static void main(String[] args) {
		
		//定义一个待排序数组
		int[] arr={1,2,3,3,5,0,6,8,9,2,4,1,6,4,0,6,7,4,3};
		

		//输出排序前数组
		printArray(arr);

		//选择排序
		bubbleSort(arr);

		//输出排序后数组
		printArray(arr);
	}

	//冒泡排序
	public static void bubbleSelect(int[] arr)
	{
		
		w:for(int x=arr.length-1;x>0;x--)
		{	
			int cnt=0;
			q:for(int y=0;y<x;y++)
			{
				if(arr[y]>arr[y+1])
				{
					int temp=arr[y];
					arr[y]=arr[y+1];
					arr[y+1]=temp;
					cnt=1;
				}
			}
			if(cnt==0)
				break w;
		}
	}

	//输出数组
	public static void printArray(int[] arr) {

		for(int x=0;x<arr.length;x++) {

			System.out.print(arr[x]+" ");
		}
		System.out.println();
	}
}

下面介绍进制转换：

/**
练习十进制、二进制、八进制、十六进制之间的转换 
*/

class ArrayTest {

	public static void main(String[] args) {
		
		//将-6转化成二进制
		toBin(-6);
		
		//将-19转化成八进制
		toOxx(-19);

		//转化成十六进制
		toHex(-127);
		toHex_(-60);

	}

	//十进制转二进制
	public static void toBin(int num) {

		if(num==0) {

			System.out.print(0);
			return ;
		}
		StringBuffer sb=new StringBuffer();//定义容器存放得出的0，1数据
		while (num!=0) {

			sb.append(num%2);
			//System.out.print(num%2);
			num=num >>> 1;
		}
		System.out.println(sb.reverse());
	}


	//十进制转八进制
	public static void toOxx(int num) {

		if(num==0) {

			System.out.print(0);
			return ;
		}
		StringBuffer sb_=new StringBuffer();

		while (num!=0){//for(int x=0;x<10;x++)
		
			sb_.append(num & 7);
			num=num >>> 3;
		}
		System.out.println(sb_.reverse());
	}

	//十进制转十六进制
	public static void toHex(int num) {

		if(num==0) {

			System.out.print(0);
			return ;
		}
		StringBuffer sb_=new StringBuffer();
		while (num!=0) {

		//for(int x=0;x<8;x++)
			if ((num & 15)>9) {

				sb_.append((char)((num & 15)-10+'A'));
			}
			else 
				sb_.append(num & 15);
			
			num=num >>> 4;
		}
		System.out.println(sb_.reverse());
	}


	//查表法
	public static void toHex_(int num) {
		if(num==0) {

			System.out.print(0);
			return ;
		}
		char[] ch={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		StringBuffer sb_=new StringBuffer();
		while (num!=0) {
		//for(int x=0;x<8;x++)

			sb_.append(ch[num & 15]);
			
			num=num >>> 4;
		}
		System.out.println(sb_.reverse());
	}
}