黑马程序员——Java（数组）

                                        ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一：数组定义：

               数组是相同类型数据的集合，描述的是相同类型的若干个数据按照一定的先后顺序排列组合而成，其中每一个数据称作为一个数组元素，每个元素可以通过他们的下标来访问它。

二：数组格式：

         （1）格式1：

                      元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

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

           （2）格式2：

                     元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

                      int[] arr = new int[]{1，2，3，4};

                      int[] arr = {1，2，3，4};

三：数组的基本特点：

             （1）长度固定，一旦被创建它的长度就是不可变的；

             （2）数组中的元素类型必须是相同的，不允许出现混合类型；

             （3）数组中的元素数据类型可以是任何的，包括基本数据类型和引用类型；

             （4）数组变量属于引用类型，数组也可以看做是对象，数组中的每一个元素称作 为该对象的成员变量；

四：一维数组的创建及使用：

           （1）创建一维数组：  

                  ①先声明，再用new运算符进行内存分配。

                   先声明：

                   两种格式：数组元素类型 数组名字[]    

                    数组元素类型[]  数组名字（推荐使用）

                   后内存分配：

                    数组名字=new 数组元素类型[数组元素个数]

             例：

                  int arr；

                  arr=new int[5];

             ②声明的同时为数组分配内存

                     格式：数组元素类型 数组名=new 数组元素类型[数组元素个数]

              例：

                 int arr[]=new int[5];

            （2）初始化一维数组

                      两种初始化方式：

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

                      int arr[]={1,2,3,4,5}

五：二维数组的创建及应用：  

          （1）创建二维数组

                 ①先声明，再用new运算符进行内存分配。 

          先声明：

                 两种格式：数组元素类型 数组名字[][]  （常用） 

                 数组元素类型[][]  数组名字 

                例：int arr[][]

        后分配内存

                 两种方法：

                直接为每一位数组分配内存：arr=new int[2][5]

                分别为每一维分配内存：

                arr=new int[2][];

                arr[0]=new int[3];

                arr[1]=new int[5];

                ②声明的同时为数组分配内存。

             格式：

                元素类型[][] 数组名 = new 元素类型[一维数组个数][一维数组元素个数]

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

             （2）初始化二维数组

             例：

                int arr[][]={{1,2,3},{4,5}；

六：数组中常见的问题：

           （1） 数组越界：

                示例：

                    int []arr=new int[2];

                     System.out.println(arr[3])  //访问了数组中不存在的数组脚标；

          （2）定义数组数组为null，而访问了数组；

                    int []arr=null；

                     System.out.println(arr[3]) ;//数组为空访问不存在；

七：数组的一些常见应用：

     示例 （1）给一列数获取最大值：

            思路：

                1、进行比较，并定义变量记录每次比较后的最大值；

                2、对数组中的元素进行遍历输出，和变量中记录的元素进行比较，如果遍历到的元素大于变量中的元素，就用变量记录下该元素；

                3、遍历结果，该变量记录就是最大值，输出变量；         

               

<pre name="code" class="java">class Demo
{
	public static int getMax(int[]arr)
	{
		int max =arr[0];//定义变量并初始化
		for(int x=1;x<arr.length;x++)//遍历数组元素
		{
			if(max<arr[x])
			{
				max=arr[x];//用变量记录下最大值
			}
		}return max;
	}
	public static void main(String[]args)
	{
		int[]arr={1,2,3,4,5};//创建一个数组
		Demo.getMax(arr);//调用getMax方法
		System.out.println(Demo.getMax(arr));
	}
	
}

     示例（2）：二分查找

                        给定一个有序的数组，往该数组中插入一个元素，并保证是有序的。

    思想 ：

               

public class HalfSearch 
{
	{
		int []arr={7,8,9,10,11,12};//定义一个数组并初始化

	public static void main(String[]args)

	    int index =half(arr,12);
	    System.out.println("index="+index);
	}
	public static int  half(int []arr,int key)
	{
		int max ,mid,min;
		min=0;
		max=arr.length-1;
		mid=(max+min)/2;
		/*1>当arr[mid]不等于该元素的时候：
		 *   （1）当key小于arr[mid]时，把mid+1值赋给min继续比较；依次比较知道找到该元素位置；
		 *   （2）当key大于arr[mid]时，把mid-1值赋给max继续比较；依次比较知道找到该元素位置；
		 * */
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
			{
				min=mid+1;
			}else if(key<arr[mid])
				{
				max=mid-1;
				}
			if(max<min)
			{
				return -1;
			}
			mid=(min+max)/2;
		}
		return mid;	
	}

}

示例（3）

              冒泡排序：

                       

public class Maopao 
{
	public static void Arry(int []arr)
	{
		for(int i=0;i<arr.length-1;i++)
		{
			for(int j=1;j<arr.length-1-i;j++)
			{
				if (arr[j]>arr[j+1])
				{
				swap(arr, j, j);
				}
			}
		}
	}
	public static void swap( int []arr,int i,int j)
	{
		int temp=arr[j];
		arr[j]=arr[j+1];
		arr[j+1]=temp;
		
	}
	public static void main(String[]args)
	{
		int [] arr={34,56,67,78,90};
		 Arry(arr);
		 for(int i=0;i<arr.length;i++)
		 {
			 System.out.print(arr[i]+" ");
		 }
	}
}

示例（4）

        选择排序：

               

public class test {  
  
    public static void main(String[] args) {  
        int arr[]={2,4,5,1,3};  
        int max;  
        //外循环进行元素顺序调换  
        //内循环获得每趟中部分数组中的最大元素下标  
        for(int i=1;i<arr.length;i++){  
            max=0;  
            for(int j=1;j<=arr.length-i;j++){  
                if(arr[j]>arr[max]){  
                    max=j;  
                }  
                int temp=arr[arr.length-i];//将此趟的部分数组的最后一个元素值存入temp  
                arr[arr.length-i]=arr[max];//将此趟的部分数组的最大元素值存入最后元素的位置  
                arr[max]=temp;//将temp中的值放入之前最大元素的位置上。  
            }  
        }  
        //遍历输出  
        for(int i:arr){  
            System.out.println(i);  
        }  
    }  
}  

示例（5）

           将数组进行反转：输入一个数组{3,1,6,5,8,2}将它按{2,8,5，6,1,3}输出：

 分析：
 *     （1）首先将给定的数组分别分成两部分，定义两个变量分别存储前半部分和后半部分，
 *         然后再逐步进行交换最后在遍历 输出结果。

public class ArraryTest 
{
	public static void show(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;
		}
	}
	public static void main(String[]args)
	{
		int []arr={3,1,6,5,8,2};
		   show(arr);//调用show方法
		for(int i=0;i<arr.length;i++)//将交换的元素重新遍历一边输出
		{
		    System.out.println(arr[i]);
		}
	}
}