.Net转Java自学之路—基础巩固篇三（数组）

当要操作的数据较多时，先要想到将数据进行临时存储。

特点：

　　1、数组是一个存储同一类型数据的容器。

　　2、数组一旦初始化，长度是固定的

　　3、数组中的元素都有角标，从0开始进行元素的编号。

数组的定义格式：

　　1、int[] arr = new int[3];　　不明确数组中的元素内容

　　2、int[] arr = new int[3]{1,2,3};　　int[] arr = {1,2,3};　　明确数组中的元素具体内容。

数组实体具有的唯一属性：length

　　通过.length的方式获取指定数组的元素的个数。

数组需要使用new关键字来定义，因为它是一个存储数据的实体。

Java程序运行对内存一共开辟了5片空间：

　　1、寄存器；2、本地方法区；3、方法区；4、堆内存；、栈内存。

栈内存：

　　存储的时局部变量，每个变量要使用都必须进行手动初始化。使用完毕后（执行完变量所在的大括号区间）该变量会自动释放。

堆内存：

　　存储数组和对象，只要是实体或者说是new关键字建立的内容都在堆内存中。

特点：

　　1、每一个实体都有内存地址值，便于引用型变量对其进行使用。

　　2、堆内存中的变量都有默认初始值。

　　3、当实体不再被使用时，就视为垃圾，在不定时的时间内被垃圾回收机制进行自动回收。

public static void main(String[] args)
{
    int[] arr = new int[3];
    /*
    1，在栈内存中创建一个数组类型的变量(引用数据类型的变量)名称叫做arr。
    2，在堆内存中创建了一个数组实体，并分配内存地址。
    3，在该实体中定义了三个元素位置，并进行了编号。
    4，对每一个位置都进行时指定类型的初始化值。
    5，将堆内存中的数组实体的首内存地址值赋值给栈内存中的arr变量。
    6，arr变量就指向了堆内存中的实体。
    */
}

数组常见的问题：

　　1、当访问到数组中不存在的角标时，编辑不会发生异常，因为没有实体，在运行时出现角标出界异常（ArrayIndexOutOfBoundsException）

　　2、当引用类型为null,使其操作具体的实体内容。编辑会通过，但运行时，会发生空指针异常（NullPointerException）

查找：

　　1、折半查找：也称二分查找，只对有序的数组有效。原理：通过头角标和尾角标的不断变化或说中间角标的元素与指定元素进行比较。

    public static int halfSearch(int[] arr,int key)
    {
        int max,min,mid;
        min = 0;
        max = arr.length-1;
        mid = (min+max)>>1;

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

            if(min>max)
                return -1;
        }
        return mid;
    }

    public static int halfSearch(int[] arr,int key)
    {
        int max,min,mid;
        min = 0;
        max = arr.length-1;

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

　　2、对无序的数组查找，获取元素第一次出现的位置就使用基础的遍历和判断。

	public static int getIndex(int[] arr,int key)
	{
		for(int x=0; x<arr.length; x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}

排序：

　　1、选择

　　　　比较方式：选择一个指定位置，使该位置的元素与其他元素进行比较。当出现最值时，存储该元素，然后再对下一个元素的值进行同此操作即可。

        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 selectSort(int[] arr)
        {
            for(int x=0; x<arr.length-1; x++)
            {
                int index = x;
                int num = arr[x];
                
                for(int y=x+1; y<arr.length; y++)
                {
                    if(num>arr[y])
                    {
                        num = arr[y];//记录住小的值
                        index = y;//记录住小的值的角标。
                    }
                }
                
                if(index!=x)
                    swap(arr,index,x);
            }
        }

　　2、冒泡

　　　　比较方式：相邻俩个元素进行比较。

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

        //效率高的。
        for(int x = arr.length-1; x>0; x--)
        {
            int index = x;
            int num = arr[index];

            for(int y=0; y<x; y++)
            {
                if(arr[y]>arr[y+1])
                {
                    if(arr[y]>num)
                    {
                        num = arr[y];
                        index = y;
                    }
                }
            }
            if(index!=x)
                swap(arr,index,x);

        }

        public static void swap(int[] arr,int a,int b)
        {
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }

反转：

	public static void reverseArray(int[] arr)
	{
		for(int start=0,end=arr.length-1; start<end; start++,end--)
		{
			swap(arr,start,end);
		}
	}