黑马程序员——数组

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

一、概念

     1.   同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

     2.   使用数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

 

二、1.一维数组的格式

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

                  如： int []  arr = new int [3];  也可以写成： int arr[] = new int[3];

        格式2：元素类型 []数组名 = new 元素类型 [ ]{元素1,元素2,…};

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

        还有一种简写的静态初始化格式：如： int [] arr={1,2,3,4,5};

        其中：new是用来在堆内存中产生一个容器实体。

 

注：1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

        2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

内存小知识：

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

        栈内存（stack）：在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 栈内存主要存放的是基本类型类型的数据 如、( int, short, long, byte, float, double, boolean, char) 和对象句柄。

        堆内存（heap）：1、数组和对象，通过new建立的实例都存放在堆内存中。

                      2、每一个实体都有内存地址值。

                      3、实体中的变量都有默认初始化值。

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

　　运行最快的内存是cp计数器。（也有说寄存器的。我没有在参考资料上看到过Java中有寄存器。如果有知道的，希望不吝赐教）。

2.二维数组的格式

 也称多维数组，是数组中的数组

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

        解释：以上格式表示定义了名称为arr的二维数组。有3个一维数组，每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为56写法是：arr[0][1] = 56。

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

         注：此种格式中每个一维数组都是默认初始化值null。

         格式3：int[][] arr = {{1,2,5},{6,4},{8,9,3,6}};//每一个一维数组中具体元素都初始化了。

注：一种特殊定义写法：int[]x,y[]; x是一维数组，y是二维数组。

三、数组的练习

数组中容易出现的异常。

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例：

             int[] arr = new int[5];

              System.out.println(arr[8]);

            访问到了数组中的不存在的脚标时发生。

    2、空指针异常(NullPointerException)。例：

            int[]arr = null;

             System.out.println(arr[0]);

             arr引用没有指向实体，却在操作实体中的元素时。

打印最大值和最小值：

/*
 需求：把数组{1,15,35,15,14}打印出来，并打印出最大值和最小值
 思路：1.创建个功能对数组进行遍历；创建个功能求最大值；创建个功能求最小值
        2.对数组进行遍历，需要使用循环。
        3.求最大值，需要定义下标为0的数为初始值的变量，然后用后面的值和初始值比较，如果比初始值大，就把这个数存进去。再和后面的数比较。直到比到最后，这个变量里的
        数就是最大值。
        4.求最小值和求最大值一样。
*/

class  ArrayDemo
{
    public static void main(String[] args) 
    {
        int[]x={1,15,35,15,14};
        //遍历数组
        printarr(x);
        //打印最大值
        getMax(x);
        //打印最小值
        getMin(x);
        
    }
    public static void printarr(int[] x )
    {
        
        for(int i=0;i<x.length;i++)
        {
            if(i!=x.length-1)
                System.out.print(x[i]+", ");
            else
                System.out.println(x[i]+"");
        }
    }
    public static void getMax(int[]x)
    {
        int Max=x[0];
        for (int i=1;i<x.length ;i++ )
        {
            if(x[i]>Max)
                Max=x[i];

        }
        System.out.println("Max="+Max);
    }
    public static void getMin(int[]x)
    {
        int Min=x[0];
        for (int i=1;i<x.length ;i++ )
        {
            if(x[i]<Min)
                Min=x[i];

        }
        System.out.println("Min="+Min);
    }
}

运行结果

排序练习：

/*
    需求：把数组{3,5,6,2,4,8,1}按照从小到大进行排序。（分别使用选择排序和冒泡排序）
    思路：1.可以把数组里的第一个数和后面的数依次比较。如果有比第一个数小的，就和第一个数互换位置。然后继续和后面的数比较。
          2.把第二个数安照上面的方法和后面的数依次进行比较。然后第三个数按照上面的方法和后面进行比较。。。。
          。需要定义一个第三方变量
          3.把数组里的数和后一个数进行比较，如果前一个数大，就进行交换。进行一次循环后，最大的数跑到最后了。
*/
class  PaiXu
{
    public static void main(String[] args) 
    {
        int[] arr={3,5,6,2,4,8,1};
        //排序前
        printarr(arr);
        //选择排序
        xuanze(arr);
        //排序后
        printarr(arr);
        int[] mao={3,5,6,2,4,8,1};
        //排序前
        printarr(mao);
        //冒泡排序
        maopao(mao);
        //排序后
        printarr(mao);
    }
    /*
     选择排序。
     内循环结束一次，最值出现在头角标位置上
    */
    public static void xuanze(int[]a)
    {
        for (int x=0;x<a.length-1 ;x++ )
        {
            for (int y=x+1;y<a.length ;y++ )
            {
                //int temp;
                if(a[x]>a[y])
                {
                    /*
                    temp=a[x];
                    a[x]=a[y];
                    a[y]=temp;
                    */
                    swap(a,x,y);
                }    
            }
        }
    }
    /*
    冒泡排序
    */
    public static void maopao(int[]a)
    {
        for (int x=0;x<a.length-1 ;x++ )
        {
            for (int y=0;y<a.length-1-x ;y++)//-1是避免角标越界，-x是让每次比较的元素减少
            {
                //int temp;
                if(a[y]>a[y+1])
                {
                    /*
                    temp=a[y];
                    a[y]=a[y+1];
                    a[y+1]=temp;
                    */
                    swap(a,y,y+1);
                }

            }
            
        
        }
    }
    //互换方法
    public static void swap(int[]a,int x,int y)
    {
        int temp;
        temp=a[x];
        a[x]=a[y];
        a[y]=temp;
    }
    //遍历数组
    public static void printarr(int[]a)
    {
        System.out.print("[");
        for (int x=0;x<a.length ;x++ )
        {
            if(x!=a.length-1)
                System.out.print(a[x]+", ");
            else
                System.out.println(a[x]+"]");
        }

    }
}

运行结果

注：1、最快的排序方法是希尔排序（Shell Sort）。

　　2、在实际开发中不用自己敲代码。直接调用Arrays.sort();来进行排序。

折半查找：

 

/*
 需求：要求在一个有序数组{1,5,6,7,9,15,35,46}中插入一个数(比如11)，在插入后该数组仍是一个有序数组。
 思路：1、使用折半查找该数在数组中的位置，如果数组中有该数，就在该数存在的位置上把该数插入进去就可以了，如果不存在，返回最小角标的值min就可以得到要插入的位置。
        2、该函数需要返回值，返回值类型 int。有两个变量。（数组和插入的数）。
*/
class  ZheBan
{
    public static void main(String[] args) 
    {
        int[]arr={1,5,6,7,9,15,35,46};
        int index=half(arr,11);
        System.out.println("index="+index);
    }
    public static int half(int[]a,int key)
    {
        int min=0;
        int max=a.length-1;
        int mid=(min+max)>>1;
        while(min<=max)
        {
            if(key>a[mid])
            {
                min=mid+1;
            }
            else if(key<a[mid])
            {
                max=mid-1;
            }
            else
            {
                return mid;
            }
            mid=(min+max)>>1;
        }
        return min;
    }
}

运行结果

 查表法和进制转换练习

/*
 需求：输入一个数，打印出它的二进制，八进制，十六进制；
 思路：无论转换为哪种进制，都需要进行查表，都需要while循环，都需要&，都需要右移。所以可以定义一个功能把这些封装到里面，不管转换哪个进制，只需要调用
        这个功能就行了。因为它们需要转换的数不确定，&的数不一样，右移的位数不同。所以需要三个变量。因为没学String字符串类型。所以直接在功能里打印。
     
      
*/
class  JinZhi
{
    public static void main(String[] args) 
    {
        //定义一个数
        int n=60;
        //转为二进制
        toBin(n);
        //转为八进制
        toOct(n);
        //转为十六进制
        toHox(n);
        
    }
    //十进制转为二进制
    public static void toBin(int num)
    {
        trans(num,1,1);
        
    }
    //十进制转为八进制
    public static void toOct(int num)
    {
        trans(num,7,3);
    
    }
    //十进制转为十六进制
    public static void toHox(int num)
    {
        trans(num,15,4);
        
    }
    public static void trans(int num,int base,int offset)
    {
        //如果输入的数为0，则直接输出0，并返回
        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[] a=new char[32];
        int pos=a.length;
        while(num!=0)
        {
            int temp=num&base;
            a[--pos]=chs[temp];
            num=num>>>offset;
        }
        for (int x=pos;x<a.length ;x++ )
        {
            System.out.print(a[x]);
        }
        System.out.println();
    }
}

运行结果