黑马程序员--Java数组

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1,数组定义

概念:数组是一种数据结构,用来存储统一类型值的集合,简单的来说,就是一个容器,它是引用型类型

好处:可以对该容器中的数据进行编号,从0开始编号方便元素的管理

2,创立数组

创立一维数组有两种表现方式;

1, 元素类型[] 变量名 = new 元素类型[元素的个数];

实例:int[] arr = new int[3];

2, 元素类型[] 变量名 = {元素1,元素2....};

实例:int[] arr = {3,4,5};

当然也可以进行结合

元素类型[] 变量名 = new 元素类型[]{元素1,元素2...};

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

创立二维数组有两种表现方式：

1，元素类型[][] 变量名 = new 元素类型[一维元素个数][二维元素个数] 

示例：int[][] arr = new int[2][3];//定义了一个arr的数组，数组中有两个一维数组，每个一维数组有3个元素，当然可默认不设置

2，元素类型[][] 变量名 ={{元素组1},{元素组2},{元素组3}....}

示例:int[][] arr = {{1,5,7},{2,4},{2,8,4,9}}

3,数组内存分配及特点

对于Java而言,内存的分配和管理是靠JVM来分配的,JVM主要讲内存分为5份:寄存器、本地方法区、方法区、栈、堆

JAVA程序正在运行时

栈：储存的都是局部变量（函数中定义的变量，函数上的参数，语句中的变量）；

只要数据运算完成所在区结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体，每个实体都有内存首地址值，堆内存的变量都有默认值的，因为数据类型不同，值也不一样

Java独有的垃圾回收机制，实体不被使用就会不定时的被垃圾回收器回收

一维数组的内存示意图

二维数组的内存示意图:

4,关于数组程序报错的常见问题:

1 数组脚标越界异常（ArrayIndexOutofBoundsException）

int[] arr =newint[2];
System.out.println(arr[3]);//访问到了数组中的不存在的脚标时发生。操作数组时，访问到了数组中不存在的角标。

2,空指针异常（NullPointerException:）

int[] arr =newint[3];
arr = null;
System.out.println(arr[0]);//arr引用没有指向实体，却在操作实体中的元素时。空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

5,数组的排序和查找

1,获取最大值

/**需求：获取数组中的最大值 
思路：将数组中的元素进行从小到大（或从大到小）的排列，然后取第一个元素为最小值，取最后一个值为最大值 
步骤： 
    1创建类ArrayTextMax 
    2创建一个数组并赋值 
    3用for循环对其进行排序， 
    4打印排序后的数组的第一个元素和最后一个元素 
*/  
  
class ArrayTextMax  
{  
    //定义方法：在数组中取最大值  
    public static int getMax(int[] arry)  
    {  
        int max = arry[0];  
        for (int i=0;i<arry.length;i++)  
        {  
            //用第一个元素的值和后面的比较，大则换值  
            if (max<arry[i])  
            {  
                max = arry[i];  
            }  
        }  
        return max;  
    }  
  
    public static void main(String [] args)  
    {  
        int[] arr = {5,2,4,8,6,1,9};  
        int max = getMax(arr);//只是获取最大值的方法  
        System.out.println("getMax方法：arr数组中最大值为；" + max);  
    }  
}

2,数组的排序

/* 
定义功能： 
获取最大值，先用第一个值和每一个比较， 
再用第二个值和后面的值比较，将小的放前面 
*/  
import java.util.*;  
class ArrayText  
{  
    //第一种排序方法：选择排序  
    public static void getPaixu0(int[] arry)  
    {  
        for (int j=0;j<arry.length;j++)  
        {  
            //i=j，每比较一轮就减少一个数，比较后，再用第二个数获得后面的最小值  
            for (int i=j+1;i<arry.length;i++)  
            {  
                //换值  
                if (arry[j]>arry[i])  
                {  
                    int temp = 0;  
                    temp = arry[j];  
                    arry[j] = arry[i];  
                    arry[i] = temp;  
                }  
            }  
        }  
    }  
  
    //第二种排序方法：冒泡排序--相邻的两个元素比较  
    public static void getPaixu(int[] arr)  
    {  
        for (int j=0;j<arr.length*arr.length;j++)  
        {  
            for (int i=1;i<arr.length;i++)//设置为1是为了防止越界  
            {  
                if (arr[i-1]>arr[i])//若改成<是从大到小排序  
                {  
                    int temp = 0;  
                    temp = arr[i-1];  
                    arr[i-1] = arr[i];  
                    arr[i] = temp;  
                }  
            }  
        }  
    }  
  
    public static void main(String [] args)  
    {  
        int[] arr0 = {5,2,4,8,6,1,9};  
        System.out.println("arr数组排序前:\n"+ Arrays.toString(arr0));  
        System.out.println();  
        int[] arr1 = {5,2,4,8,6,1,9};  
        getPaixu0(arr1);//第一种排序方法  
        System.out.println("选择排序方法：arr数组排序后:\n"+ Arrays.toString(arr1));//打印排序后的数组  
        System.out.println();  
        int[] arr2 = {5,2,4,8,6,1,9};  
        Arrays.sort(arr2);//java中自带的排序函数  
        System.out.println("java中自带的排序函数sort：arr数组排序后:\n"+Arrays.toString(arr2));  
        System.out.println();  
        int[] arr3 = {5,2,4,8,6,1,9};  
        getPaixu(arr3);//第二种排序方法  
        System.out.println("冒泡排序方法：arr数组排序后:\n"+ Arrays.toString(arr3));  
        System.out.println();  
        System.out.println("arr数组中最小值为；" + arr3[0]);  
        System.out.println("arr数组中最大值为：" + arr3[arr3.length-1]);  
    }  
}

3,元素数组的查找

/**需求|：查找数组中的元素 
思路|：遍历数组中的元素，并与要查找的内容比较，相同，则返回脚标 
步骤 
    1创建类FindArry 
    2用for遍历数组，如果查找到相同内容，记录脚标并返回 
    3如果未找到，就返回-1 
 
    如果要在一个有序数组中插入一个数，之后仍有序 
    就是先查找数组，用折中法：如果查找到有此数，则返回的中间值就是插入的地方，否则将返回的-1改成返回min，即为插入的地方 
    如：{1, 2, 3, 5, 6, 8, 11, 13}插入8，返回mid = 5；插入后为{1, 2, 3, 5, 6, 8, 8, 11, 13} 
    插入10，返回min = 6，插入后为{1, 2, 3, 5, 6, 8, 10, 11, 13} 
*/  
  
import java.util.*;  
class FindArry  
{  
    //方法一：遍历每一个元素查找  
    public static int findarr(int[] arr,int key)  
    {  
        for(int i=0;i<arr.length;i++)  
        {  
            if(arr[i] == key)  
            {  
                return i;  
            }  
        }  
        return -1;  
    }  
  
    //方法二：折半，前提是数组是按大小顺序排列好的，  
    //用查找的值和中间值比较，大则和下一半中间值比依次，小则和上一半中间值比，找到则返回。  
    //        小值的编号在左移或大值的编号在右移。要判断是否大小值的编号相遇，仍若未找到，则不再循环，返回-1  
    public static int FindArry1(int[] arr,int key)  
    {  
        int min,max,mid;  
        min = 0;  
        max = arr.length-1;  
        mid = (min + max)/2;  
          
        //循环，查找中间值与要查找的值比较  
        while(key != arr[mid])  
        {  
            if (key > arr[mid])  
                min = mid +1;  
            else   
                max = mid - 1;  
            if (min > max)  
                return -1;  
            mid = (min + max)/2;  
        }  
        return mid;  
    }  
  
    //方法三：折半第二种  
    //while的条件改变  
    public static int FindArry2(int[] arr,int key)  
    {  
        int min,max,mid;  
        min = 0;  
        max = arr.length-1;  
          
          
        //循环，查找中间值与要查找的值比较  
        while(min <= max)  
        {  
            mid = (min + max)>>1;  
            if (key > arr[mid])  
                min = mid +1;  
            else if(key<arr[mid])  
                max = mid - 1;  
            else  
                return mid;  
        }  
        return -1;  
    }  
  
    public static void main(String [] args)  
    {  
        int[] arr = {1,6,11,2,8,5,3,13};  
        int m = findarr(arr,3);  
        System.out.println("m=" + m);  
        Arrays.sort(arr);  
        System.out.println(Arrays.toString(arr));  
        int x = FindArry1(arr,13);  
        int y = FindArry2(arr,25);  
        System.out.println("查找13的结果x=" + x + "\n查找25的结果y=" + y);  
    }  
}

4,进制的转化

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

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net/heima