Java--05

数组
1.数组是一种引用类型
2.数组是一种简单的数据结构，线性的结构
3.数组是一个容器，可以用来存储其他元素，数组可以存储任意数据类型的元素
4.数组分为：一维数组、二维数组和多维数组
5.数组中存储的元素类型是统一的
6.数组长度不可改变，数组一旦创建长度是固定的，不可变的
7.数组的查找和修改元素效率较高，增删效率较低，具体分析如下：
数组中的每一个元素在内存中所占的空间大小是相同的，知道数组的首元素内存地址，要查找的元素只要知道下标就可以快速地计算出偏移量，通过首元素内存地址加上偏移量，快速计算出要查找的元素的内存地址，通过内存地址快速定位该元素，如果是修改，首先快速定位该元素，然后给该元素重新赋值，所以查找和修改元素的效率较高，而随机对数组进行增删元素，当增加的时候，为了保证数组中元素在空间存储上是有序的，所以被添加元素位置后面的所有元素都要向后移动。删除元素也是，后面所有的元素要向前移动，所以数组的增删效率较低
初始化一维数组的两种方式
1.静态初始化 格式：数据类型 [] 引用 = {该数据类型对应的元素，多个元素用”,”隔开};
例如： int [] arry = {3,4,1,6};
2.动态初始化 格式：数据类型 [] 引用 = new [能存储的该数据类型元素的个数];
例如： int [] arry = [4];
动态初始化一维数组，会先在内存中分配这个数组，并且数组中每一个元素都采用默认值
byte,short,int,long 0
float,double 0.0
boolean false
char \u0000
引用 null
如何预防空指针异常？

public  String m1(Object obj){
        return (obj==null)?"null":obj.toString();
    }

什么时候用静态初始化，什么时候用动态初始化？
1.无论是静态初始化还是动态初始化，最终的内存分布是一致的
2.如果在创建数组的时候，知道数组中应该存储什么数据，这个时候采用静态初始化方式
如果在创建数组的时候，无法预测到数组中要存储什么数据，只是先开辟空间，则使用动态初始化方式
传递数组参数的两种方式

public class Test{
        public static void main(String [] args){
            int [] arry = {2,5,6,8};//第一种方式
            m1(arry);               //第一种方式

            m1(new int [] {4,3,7,8,9});//第二种方式
        }
        public void m1(int [] a){
            for(int i=0;i<a.length;i++){
                System.out.println(a[i]);
            }

        }
    }

关于main方法中的参数列表String [] args
String [] args是专门用来接受命令行参数的
例如：java Test aa bb cc
JVM在调用Test类的main方法之前，先将”aa bb cc”这个字符串以”空格”的方式分割，
然后存储在String数组中
“admin”.equals(username)还是username.equals(“admin”)？
正常情况下两种都可用，但按照经验来说用”admin”.equals(username)
因为这种方式可以避免空指针异常
关于数组的拷贝
在JDK的java.lang.System 里有系统自定义的数组拷贝方法
arraycopy(源数组,源数组的开始下标,目标数组，目标数组的开始下标，拷贝的长度);
二维数组
1.二维数组是一个特殊的一维数组
2.特殊在这个一维数组中每一个元素都是”一维数组”

关于数组的排序
冒泡排序：比较相邻两个元素的关键字值，如果反序，则交换。若按升序排列，每一趟将被扫描的数据序列中的最大元素交换到最后位置，就像气泡从水里冒出一样。
冒泡排序(升序)算法实现如下，外层for循环控制最多n-1趟扫描，内层for循环进行一趟扫描的比较和交换。其中，布尔变量exchange用做本趟扫描是否交换的标记。
示例代码如下：

public class BubbleSort{
    public static void main(String [] args){
        int [] a={3,5,7,2,4,1};
        boolean exchange=true;//是否交换的标记
        //有交换时再进行下一趟，最多n-1趟
        for(int i=a.length-1;i>0&&exchange;i--){
            //假定元素未交换
            exchange=false;
            //一趟比较、交换
            for(int j=0;j<i;j++){
            //反序时，交换
                if(a[j]>a[j+1]){
                    int temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                    exchange=true;//有交换
                }

            }
        }
            for(int i=0;i<a.length;i++){
                System.out.print(a[i]);
            }

    }
}

选择排序：第一趟从n个元素的数据序列中选出关键字最小(或最大) 的元素并放到最前(或最后)位置，下一趟再从n-1个元素中选出最小 （大）的元素并放到次前（后）位置。以此类推，经过n-1趟完成排序。
示例代码如下：

public class SelectSort{
    public static void main(String [] args){
        int [] a={3,5,7,2,4,1};
        //n-1趟排序
        for(int i=0;i<a.length-1;i++){
        //每趟在从i开始的子序列中寻找最小元素
        //设第i个数据元素最小
            int min = i;
            //在子序列中查找最小值
            for(int j=i+1;j<a.length;j++){
                if(a[min]>a[j])
                    min=j;  //记住最小下标
            }
            //将本趟最小元素交换到前边
            if(min!=i){
                int temp=a[i];
                a[i]=a[min];
                a[min]=temp;
            }
        }
        //遍历输出
            for(int i=0;i<a.length;i++){
                System.out.print(a[i]);
            }

    }
}

数组的搜索
查找数组中的元素我们可以遍历数组中的所有元素，这种方式称为线性查找。线性查找适合 与小型数组，大型数组效率太低。如果一个数组已经排好序，那么我们可以采用效率比较高的二分查找或叫折半查找算法。
折半查找：假定数组已按升序排列，从数组的中间位置开始比较，如果当前元素的关键字等于给定值，则查找成功;否则，若给定值小于当前元素的关键字，则在数组的前半段继续查找;反之，在后半段继续查找，依次重复，直到获得查找元素(成功或不成功)
示例代码如下：

public class MyArrays {
    public static void main(String[] args) {
        int[] a = { 1, 2, 4, 7, 9 };
        int desElement = 3;
        int index = binarySearch(a, desElement);
        System.out.println((index == -1) ? desElement + "该元素不存在" : "该元素在数组中的下标是:" + index);
    }

    public static int binarySearch(int[] a, int desElement) {
        int begin = 0;
        int end = a.length - 1;

        while (begin <= end) {
            int mid = (begin + end) / 2;//中间位置，当前比较元素位置
            if (a[mid] == desElement) {
                return mid;            //比较成功
            }
            if (a[mid] > desElement) {//给定元素小
                end = mid - 1;        //查找范围缩小到前半段
            } else {
                begin = mid + 1;      //查找范围缩小到后半段
            }
        }

        return -1;                    //查找不成功
    }
}

关于Arrays工具类
Arrays是SUN提供的一个工具类
该工具主要针对的是数组的操作：排序、二分查找等
Arrays.sort();
Arrays.binarySearch();