一、Java语言基础（4）_方法和数组——数组

2018-04-25

不悔梦归处，只恨未尽心

 

数组

 

一、一维数组

 

　　

 

1. 数组的含义：具有相同类型的多个变量按有序形式组织起来的数据形式。（数组是用来存储固定大小的同类型元素。）
2. 数组的定义：

　　　　方式1（推荐使用）：数组元素类型[] 数组名称；　　如：int[] ages;　　(可以把 int[] 看成一个整体，看成一种数据类型，int类型的数组)

　　　　方式2：数组元素类型 数组名称[]；　　如：int ages[];

　　　　数组必须初始化才能使用，因为初始化表示在内存存中分配空间。

 

　　3.数组的初始化：

　　　　数组是定长的：一旦初始化完成，数组的长度（数组元素个数）就固定了，不能改变。如果需要更改，只能重新初始化。

 　　

　　　　

 

　　　　

• 静态初始化

　　　　　　　由程序员为每一个数组元素设置初始值，而数组的长度由系统自动分配

　　　　　　　语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素1，元素2，元素3，...}；　　new关键字：在堆空间开辟一块内存区域，用来存储数据。

　　　　　　　　　　举例：int[] num = new int[]{1,3,5,7,9};　　

　　　　　　　　　　简单写法(必须申明的同时并初始化，不能先声明后初始化)：int[] num = {1,3,5,7,9};

• 动态初始化　　　

　　　　　　由程序员设置数组元素个数（数组长度），而每一个数组元素的初始值由系统决定。　　　　　　　　

　　　　　　 语法：数组元素类型[] 数组名 = new 数组元素类型[length]；　　　　　　

　　　　　　 举例：int[] num = new int[100];

 

　　4.静态初始化内存分析

　　

 

　　5.动态初始化内存分析

　　

 

　　6.数组的基本操作

• • 获取数组元素
    

　　　　　　元素类型 变量 = 数组名[index]；　　index表示索引

• • 设置元素

　　　　　　数组名[index] = 值；

• 遍历数组

　　　　　　　建议使用for循环遍历

• 数组长度

　　　　　　　int num = 数组名.length；  （length是属性，不是方法）

• 索引范围　　

　　　　　　　[0，length-1]　　从0开始，逐一递增

 

数组基本操作的代码：

//数组的基本操作

class ArrayDemo
{
    public static void main(String[] args){

        int[] num1 = new int[]{1,3,5,7,9};

        System.out.println("数组的长度=" + num1.length);
        System.out.println("数组第一个元素=" + num1[0]);//获取数组元素

        //修改(设置)num1数组的第一个元素
        num1[0] = 100;
        System.out.println("数组第一个元素=" + num1[0]);//获取数组元素

        System.out.println("----------------------------");

        //遍历数组
        System.out.println("数组第一个元素=" + num1[0]);
        System.out.println("数组第二个元素=" + num1[1]);
        System.out.println("数组第三个元素=" + num1[2]);
        System.out.println("数组第四个元素=" + num1[3]);
        System.out.println("数组第五个元素=" + num1[4]);

        System.out.println("----------------------------");

        //使用for循环遍历数组
        for(int index = 0; index < num1.length; index++){
            System.out.println(num1[index]);
        }
     }
}

输出结果：

　　

　　7. 操作数组常见异常

• NullPointerException：空指针异常（空引用异常）　　

　　　　　　当数组没有初始化，就直接操作数组，就会出现空指针异常　　

　　　　　 如： int[] bs = null;

　　　　　　　　System.out.println(bs.length);  

• ArrayIndexOutOfBoundsException：数组的索引越界异常

　　　　　　如：　int[] a = {100};

　　　　　　　　　System.out.println(a[-1]);

 　　

　　8.获取数组最大和最小元素

　　　　输出结果：10

class ArrayDemo2 
{

    //获取数组最大元素
    public static int getMax(int[] num){
        int max = num[0];//假设第一个元素是最大值
        for(int index = 1; index < num.length; index++){
            if(num[index] > max){
                max = num[index];    //把最大值存储在max变量里
            }
        }
        return max;

    }

    public static void main(String[] args) 
    {
        
        int[] num = new int[]{-3,0,2,1,10};

        int max = ArrayDemo2.getMax(num);
        System.out.println(max);
    }
}

　　9.按格式打印数组元素

class ArrayDemo2 
{



    public static void main(String[] args) 
    {
        
        
        String[] arr = {"A","B","C","D","E"};
        ArrayDemo2.printArrary(arr);
    }
    static void printArrary(String[] arr){
        //如果数组为空,则输出null
        if(arr == null){
            System.out.println("null");
            return;    //结束方法
        }

        String ret = "[";
        //遍历数组
        for(int index = 0; index < arr.length; index++){
            ret = ret + arr[index];
            //如果当前index不是最后一个索引，则拼接“，”
            if(index != arr.length-1){
                ret = ret + ", ";
            }
        }
        ret = ret + "]";
    
    System.out.println(ret);
    }
}

输出结果：

　　10.逆序排列数组元素

class ArrayDemo2 
{

    public static void main(String[] args) 
    {    
        String[] arr = {"A","B","C","D","E"};
        ArrayDemo2.printArrary(arr);
        String[] newArr = ArrayDemo2.reverse(arr);
        ArrayDemo2.printArrary(newArr);
    }
    static void printArrary(String[] arr){
         //如果数组为空,则输出null
         if(arr == null){
             System.out.println("null");
             return;    //结束方法
         }
 
         String ret = "[";
         //遍历数组
        for(int index = 0; index < arr.length; index++){
             ret = ret + arr[index];
             //如果当前index不是最后一个索引，则拼接“，”
             if(index != arr.length-1){
                 ret = ret + ", ";
             }
         }
         ret = ret + "]";
     
     System.out.println(ret);
    }

    static String[] reverse(String[] oldArr){
        
        //创建一个新数组，用来存放就数组逆序之后的元素  
        String[] newArr = new String[oldArr.length];
        for(int index = oldArr.length-1; index >= 0; index--){
            newArr[oldArr.length-1-index] = oldArr[index];
        }
39         return newArr;
    }
}

 输出结果：

 　　11.元素出现索引(线性搜索)

class ArraySearchDemo 
{
    public static void main(String[] args) 
    {
        int[] arr = {10,20,30,10,50,-30,10};

        int beginIndex = ArraySearchDemo.indexOf(arr,10);
        System.out.println(beginIndex);

        int endIndex = ArraySearchDemo.lastIndexOf(arr,10);
        System.out.println(endIndex);
    }
    /*
        查询key元素在arr数组中第一次出现的位置
        参数：
            arr:从哪一个数组中去做查询
            key:当前去查询的元素
        返回：如果key存在于arr数组中，则返回第一次出现的索引
            如果key不存在于arr数组中，则返回-1
    */
    static int indexOf(int[] arr,int key){
        for(int index = 0; index < arr.length; index++){
            if(arr[index] == key){
                return index;
            }
        }
        return -1;
    }
    //获取key参数在arr数组中最后出现的索引位置
    static int lastIndexOf(int[] arr,int key){
        for(int index = arr.length-1; index >= 0; index--){
            if(arr[index] == key){
                return index;
            }
        }
        return -1;
    }
}

输出结果：