数组的特点与使用

数组的四个基本特点

1. 其他长度是确定的，数组一旦被创建，它的大小就是不可以改变的

2. 其元素必须是相同类型，不允许出现混合类型

3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型

4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

   数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型

   数组对象本身是在堆中的。

    

数组边界

1. 下标的合法区间：【0，length-1】,如果越界就会报错：

   

    

    

    

2. ArrayIndexOutOfBoundsException : 数组下标越界异常！

3. 小结：

   • 数组是相同数据类型（数据类型可以为任意类型）的有序集合

   • 数组也是对象。数组元素相当于对象的成员变量

   • 数组长度的确定，不可变的。如果越界，则报：ArrayIndexOutOfBounds

数组的使用

1. foreach 循环

   • 案例

     int[] arrays = {1,2,3,4,5};
     //JDK1.5 ,没有下标
     //foreach显而易见，没有for循环的繁琐，直接能够把数组的内容给遍历出来
     //唯一的缺点取不到下标
     for (int array : arrays) {
         //foreach的使用方法
         System.out.println(array);
     }
     总结：有点：foreach可以直接把数组里的内容遍历出来
          缺点：取不到数组下标

   结果：

    

    

    

2. 数组方法入参

   • 案例，通过循环数组，序号，来得到数组的和，最大值

     public static void main(String[] args) {
         int[] arrays = {1,2,3,4,5};
     ​
         //打印全部的数组元素
         for (int i =0; i<arrays.length ; i++){
             System.out.println(arrays[i]);
         }
         System.out.println("==========");
         //计算所有元素的和
         int sum =0;
         for (int i =0; i<arrays.length; i++){
              sum += arrays[i];
     ​
         }
         System.out.println("sum="+sum);
         System.out.println("===========");
         int max = arrays[0];
         //定义最大值
         for (int i=0; i<arrays.length; i++){
             if(arrays[i]>max){
                 max=arrays[i];
             }
         }
         System.out.println("max="+max);
     ​
     }

   结果：

    

    

3. 数组作返回值

• 案例

• public static void main(String[] args) {
          int[] arrays = {1,2,3,4,5};
      //定义数组
          
           printarray(arrays);
      //调用数组函数
          System.out.println("============");
          reverse(arrays);
      //输出反转数组函数
  ​
  //        int [] reverse = reverse(arrays);
           //定义变量reverse
  //        printarray(reverse);
           //第三种方法的，函数调用
     }
  ​
         //打印一个数组
      public  static  void  printarray(int[] arrays){
          for (int i = 0; i <arrays.length ; i++) {
              System.out.println(arrays[i]+ " ");
              //输出遍历出数组i的值
          }
      }
  ​
  ​
  ​
      //反转数组  要求数组反序
        public  static  int[] reverse( int[] arrays){
               int [] result = new int [arrays.length];
           //定义一个数据结果，把新的数组长度赋值上去，保证前后长度一致
   
            
    //1.第一种方法
  //
  //          for (int i = result.length-1; i >=0 ; i--) {
              //for循环遍历
  //              System.out.println(arrays[i]+ " ");
              //输出数组i
  //          }
            
            
            
     //2.第二种方法
  //          for (int i = 0; i <arrays.length ;i++ ) {
              
  //               for (int j=arrays.length-1;j>=i;j--){
  //                   System.out.print(arrays[j]+ " ");
  //              }
  //              break;
                //退出最外的循环，只循环一次
  //          }
  ​
            
      //3，第三种方法
  ​
  //               for (int i=0,j=result.length-1;i<arrays.length; i++,j--){
  //
  //                   result[j] = arrays[i];
                      
  //               }
                     return result;
               //返回result
  ​
        }

结果：

 

 

 

 

 

多维数组

1. 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

2. 二维数组

   • int a[][] =new int [3][2]

3. 解释：以上二维数组a可以看成一个三行两列数组

   • 

      

      

   int [][] array = {{1,2},{2,3},{4,5},{6,7}};
   //二维数组
   /*
   [4][2]
   1,2   array[0]
   3,4   array[1]
   4,5   array[2]
   6,7   array[3]
   ​
    */

4. 思考：多维数组的使用

   • 案例用for循环来遍历出数组

   • public static void main(String[] args) {
         int [][] array = {{1,2},{2,3},{4,5},{6,7}};
         //二维数组
         /*
         [4][2]
         1,2   array[0]
         3,4   array[1]
         4,5   array[2]
         6,7   array[3]
     ​
          */
     ​
         //用for循环来遍历二位数组2层for循环
         for(int i= 0; i<array.length;i++){
             for (int j=0;j<array[i].length;j++){
                 System.out.println(array[i][j]);
     ​
             }
         }

结果：