数组的定义与运用（Arrays类）

数组

1. 数组定义：是相同类型的有序集合，数据按照一定先后次序排列组合而成，通过每个数组元素的下标来访问。

2. 数组的定义与声明：

   public static void main(String[] args) {
       int[] num;//定义、声明一个数组，还可以：int num[],但是前一种更好
       num = new int[7];//创建一个数组，里面可以存放7个数字
       //赋值
       num[0]=1;
       num[1]=2;
       num[2]=3;
       num[3]=4;
       num[4]=5;
       num[5]=6;
       num[6]=7;
       //计算所有元素的和
       int sum = 0;
       for (int i=0;i<num.length;i++){//计算数组中所有值的和
           sum=sum+num[i];
       }
       System.out.println(sum);
   }
   

3. 数组的初始化

   • 静态初始化：

     //静态初始化，创建+赋值
     int[] num2 = {1,2,3,4,5,6,};
     

   • 动态初始化（包含默认初始化）：

     //动态初始化，包含默认初始化
     int[] num;//定义、声明一个数组，还可以：int num[],但是前一种更好
     num = new int[7];//创建一个数组，里面可以存放7个数字
     //赋值
     num[0]=1;
     num[1]=2;
     num[2]=3;
     num[3]=4;
     num[4]=5;
     num[5]=6;
     num[6]=7;//默认初始化是指在未给数组赋值时，默认值为0
     

4. 数组的基本特点：

   • 长度确定，数组一旦被创建，不他的大小就是不可改变的

   • 数组元素必须是相同类型，不能混合

5. 数组边界：数组长度确定，如果越界会报错数组下标越界

6. 数组的使用：

   • 普通的For循环

   • For-each循环：

     public static void main(String[] args) {
         //静态初始化，创建+赋值
         int[] arrays = {1,2,3,4,5,6};
         //打印全部数组元素：for-each
         for (int array : arrays){
             System.out.println(array);
         }
     }
     

   • 数组作方法渗入：

     public static void main(String[] args) {
         //静态初始化，创建+赋值
         int[] arrays = {1,2,3,4,5,6};
         printArrays(arrays);
     }
     //打印数组元素
     public static void printArrays(int[] arrays){
         for (int i=0;i<arrays.length;i++ ){
             System.out.println(arrays[i]);
         }
     }
     

   • 数组作返回值：

     public static void main(String[] args) {
         //静态初始化，创建+赋值
         int[] arrays = {1,2,3,4,5,6};
         int[] reverse =reverse(arrays) ;
         printArrays(reverse);
     }
     //反转数组
     public static int[] reverse(int[] arrays){
         int[] result = new int[arrays.length];
         //反转操作
         for (int i = 0,j=result.length-1;i<arrays.length;i++,j--){
             result[j] =arrays[i];
         }
         return result;
     }
     //打印数组元素
     public static void printArrays(int[] arrays){
         for (int i=0;i<arrays.length;i++ ){
             System.out.println(arrays[i]);
         }
     }
     

   7. 多维数组：（二维数组，a[][][] [] ,相当于数组的嵌套）

      int[][] array = {{1,2},{2,3},{3,4}};
      
      for (int i = 0 ;i<array.length;i++){//二维数的遍历
          for (int j = 0;j<array[i].length;j++){
              System.out.println(array[i][j]);
          }
      }
      

   8. Arrays类：（java中的数组工具类）

      • 打印数组

        int[] arrays = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(arrays));//使用Arrays数组工具里的toString方法打印输出数组里所有元素
        

      • 排序：Arrays.sort(arrays) //数组进行排序：升序

      • 冒泡排序：最为出名的排序算法之一，总共有八大排序！

          public static void main(String[] args) {
                int[] a = {1,8,5,9,4,6,2,7};
                System.out.println(Arrays.toString(sort(a)));
        
            }
            //冒泡循环
            public static int[] sort(int[] array){
                int count = 0;
                //外层循环，判断需要循环几次
                for (int i = 0;i<array.length;i++){
                    //优化
                    boolean flag =false;
                    //内层循环，比较判断两个数，如果第一个数比第二个数大，那么交换位置
                    for (int j = 0;j<array.length-1-i;j++){
                        if (array[j+1]>array[j]){
                            count =array[j] ;
                            array[j] =array[j+1];
                            array[j+1]= count;
                            flag = true;
                        }
                    }if (flag==false){//如果相等说明本轮没有执行程序，程序已经结束
                        break;
                    }
                }
                return array;
            }