黑马程序员——Java基础——数组

     点击打开链接 点击打开链接 点击打开链接 android培训、<a">点击打开链接 点击打开链接 java培训、期待与您交流！">点击打开链接 点击打开链接

数组是同一种类型的数据的集合，其实数组就是一个容器。

Java中出现了数组，数组有些什么用处呢？可以自动给数组中的元素从0开始编号，方便操作这些元素

定义数组的两种格式：

格式1：元素类型[] 数组名=new 元素类型[元素个数或数组长度]；

     示例：int[] i=new int[5];

     也有程序员这么写：int arr[]=new int[2];

 

格式2：元素类型[] 数组名=new 元素类型[]{元素，元素，元素。。。}

        示例：int arr=new int[]{2,5.6,8};

        也有这么写的：int arr={2,5,6,7,1};

数组的内存分配:

    Java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一个区域都有特定的处理数据方式和内存管理方式。下面简单介绍几种内存区：

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存：数组和对象，通过new建立的实例都会存放在对内存中。

l 每一个实例都有内存地

l 实例中的变量都有默认初始化值

l 实体不再被使用，会在不确定的时间内被垃圾回收器回收。

此外还有方法区、本地方法区、寄存器。

程序员在使用数组时最容易发生的两个异常：

ArrayIndexOutOfBoundsException:数组角标越界异常，加入我们定义一个数组长度为10，如果你操作角标为10的元素，就会发生此异常，这是数组中最容易犯的错误，原因是数组角标是从0开始的，如果你定义的数组长度为10，最大角标应该是9，也就是说，定义数组的最大角标应是arr[arr.length-1],length是数组的一个属性，可以直接获取到数组元素个数。

NullPointerException:空指针异常。当应用程序在需要对象的地方使用null时，则抛出该异常。在数组里如果我们定义了一个数组，让arr=null,然后操作数组里的元素，就会发生此异常。

这两个异常都是在编译时不被检测，在运行时出现的异常，他们都是RuntimeException的子类。

数组常见的操作：

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

②获取数组的最大值和最小值

③数组的排序。有冒泡排序，选择排序，快速排序

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

因其种类繁多，所以特意写一个数组工具类，以便更加深入了解数组的常见操作，代码如下：

class ArrayTools
{
	//遍历打印数组中所有元素
	public static void arrayPrint(int[] arr)
	{
		System.out.print("[");
		for(int i=0;i<arr.length;i++)
		{
			if(i!=arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.println(arr[i]+"]");
		}
	}

   //数组两元素值进行交换
    private static void exchange(int[] arr,int a,int b) 
	{
		int temp;
		temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
   //获取数组的最大值
   public static int getMax(int[] arr)
   {
	   int max=0;
	   for(int i=1;i<arr.length;i++)
	   {
		   if(arr[max]<arr[i])
			   exchange(arr,max,i);
	   }
	   return arr[max];
   }

   //获取数组的最小值
    public static int getMin(int[] arr)
   {
	   int min=0;
	   for(int i=1;i<arr.length;i++)
	   {
		   if(arr[min]>arr[i])
			   exchange(arr,min,i);
	   }
	   return arr[min];
   }

   //选择排序法，简单来说就是先找出最小值（或最大值），
   //放在角标为0（或最大角标）的元素下，再找出第二小（或大）的值放在角标为1的元素下，
   //以此类推，直到找出最大值
   public static void sort_1(int[] arr)
   {
       for(int i=0;i<arr.length-1;i++)
	   {	   
		   for(int j=i+1;j<arr.length;j++)
	       {
			   if(arr[i]>arr[j])
				   exchange(arr,i,j);
		   }
	   }
   }

   //冒泡排序，已知一个数组，如果升序排列，比较相邻两个元素，如果角标小的元素值大，则两者交换，
   //这样就把最大值放在最末尾，然后再重复上一过程，直到所有元素都排列好。
   public static void sort_2(int[] arr)
   {
	   for(int i=0;i<arr.length-1;i++)
	   {
		   for(int j=0;j<arr.length-i-1;j++)
		   {
			   if(arr[j]>arr[j+1])
				   exchange(arr,j,j+1);
		   }
	   }
   }

   
   //折半查找,第一种方法,必须保证数组是有序的
   public static int halfSearch_1(int[] arr,int key)
   {
        int min,max,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;
           mid=(max+min)/2;
		   if(min>max)
			   return -1;
	   }
	   return mid;
   }

  //折半查找第二种方法，必须保证数组时有序的。
  public static int halfSearch_2(int[] arr,int key)
   {
        int min,max,mid;
		min=0;
		max=arr.length-1;

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

   //在一个有序数组中利用折半查找法，插入元素
   public static int[] insert(int[] arr,int el)
	{
		
		int index=halfSearch_1(arr,el);
		if(index!=-1)
			return insert(arr,index,el);
		else
		{
			int min,max,mid;
			min=0;
			max=arr.length-1;
            
		    while(min<=max)
	        {
               mid=(min+max)/2;
		       if(el>arr[mid])
			       min=mid+1;
		       else if(el<arr[mid])
			       max=mid-1;
	        }

            return insert(arr,min,el);
		}

	}

   //在一个数组中的指定位置插入一个元素，
	private static int[] insert(int[] arr,int index,int el)
	{
          int[] arr2=new int[arr.length+1];
		  for(int i=0;i<arr2.length;i++)
		    { 
			   if(i<index)
				   arr2[i]=arr[i];
			   else if(i==index)
				   arr2[i]=el;
			   else
				   arr2[i]=arr[i-1];
		    }
			return arr2;
	}
}

 

 

  其实对于数组的这些操作，java早就封装成了类，在java。Util包中，Arrays类包含了用来操作数组（比如排序和搜索）的各种方法，下面介绍常用的几种：

static void  /sort(),参数可传各种数据类型的数组，还可以指定范围。

static void /fill(arr,val),将val值分配给指定的数组的每个元素，也可指定范围，分配给范围内的元素。

static boolean/equals(arr1,arr2),判断两个数组是否相等，条件是两个

数组中的数组以相同顺序包含相同元素，则返回true。

static arr/copyOfRange(arr,int from,int to):将指定数组的指定范围复制到一个新数组。

static arr/copyOf(arr,int newLength),复制指定的数组，截取或用0填充。

static int/binarySearch(arr,key):使用二分法搜索指定的数组，以获得指定值的角标。

 

二维数组[][]

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

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

l 二维数组中有3个一维数组

l 每一个一维数组中有2个元素

l 一维数组的名称分别为arr[0]、arr[1]、arr[2]

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

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

l 二维数组中有3个一维数组

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

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