Java数组的基础

数组

声明数组的语法

数组下标是从0开始的

ArrayIndexOutOfBoundsException 数组下标越界异常

        //动态初始化：包含默认初始化  没有赋值初始值都是0
        int [ ]nums;//1.声明数组
        //类型  [ ] 数组名 
        int [ ] num1=new int[10];  //2.创建数组
        //这里可以存放10个int类型的数字  
        //给数组元素赋值
        nums[0]=10;
        nums[1]=11;
        nums[2]=12;
        nums[3]=13;
        nums[4]=14;
        nums[5]=15;
        nums[6]=16;
        nums[7]=17;
        nums[8]=18;
        nums[9]=19;
        //数组元素值的和
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum +nums[i];
        }
        System.out.println(sum);


        //静态初始化：  创建+赋值
        int [ ] a = {1,2,3,4,5,6,7,8,9}

数组的四个基本特点

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

• 数组元素的类型必须是相同类型的，不可以出现混合类型

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

数组的使用

int [ ]nums = {1,2,3,4,5,6,7,8,9};
//打印全部元素
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
System.out.println("=============================");
//增强for遍历   没有下标
for(int num : nums){
    System.out.println(num);
}
System.out.println("=============================");
//计算所有元素的和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
    sum = sum +nums[i];
}
System.out.println(sum);

System.out.println("============================");
//查找最大元素
int max = nums[0];
for (int i = 0; i < nums.length; i++) {
    if (nums[i]>max){
        max = nums[i];
    }
}
System.out.println(max);


//反转数组
       int [ ]nums = {1,2,3,4,5,6,7,8,9};
       int[ ]reverse= reverse(nums);
       printArray(reverse);
    }
    public static int [ ] reverse(int [ ] nums){
        int [ ] result = new int[nums.length];
        for(int i = 0, j = result.length-1;i < nums.length;i++,j--){
            result[j]=nums[i];
        }
        return  result;
    }
    public static void printArray(int [ ]nums){
       for (int i = 0; i < nums.length; i++) {
           System.out.print(nums[i]+" ");
        }

    }

多维数组

可以看出数组的数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZ1jfIgF-1597385041270)(C:\Users\big熊\Desktop\markDown\photo\数组.png)]

    //[5][3]
    /**
     * 1,2,3
     * 2,3,4
     * 3,4,5
     * 4,5,6
     * 5,6,7
     */
     int [ ][ ]array = {{1,2,3},{2,3,4},{3,4,5},{4,5,6},{5,6,7}};
    System.out.println(array.length);
    System.out.println(array[1][2]);
}

//遍历二维数组
    public static void main(String[] args) {
        //[5][3]
        /**
         * 1,2,3
         * 2,3,4
         * 3,4,5
         * 4,5,6
         * 5,6,7
         */
         int [ ][ ]array = {{1,2,3},{2,3,4},{3,4,5},{4,5,6},{5,6,7}};
         printArray( array);
    }
    public static void printArray(int[][] array) {
      for (int i = 0; i < array.length; i++) {
          for (int i1 = 0; i1 < array[i].length; i1++) {
              System.out.println(array[i][i1]+" ");
          }

        }
    }

Arrays类

int [ ]a = {1,2,3,4,555,99,77,88,66,3};
//打印数组元素
Arrays.sort(a);//数组排序：升序
System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);//填充
        System.out.println(Arrays.toString(a));

冒泡排序

时间复杂度O(n^2)

  //临时变量
    int [ ] a={1,24,56,2,4,84,33,6,54,};
    int [ ] sort =sort(a);
    System.out.println(Arrays.toString(sort(a)));
}
//冒泡排序
//1. 比较数组中两相邻的元素，如果一个数比第二个数大，我们就交换他们的位置
//2. 每一次比较，都会产生出一个最大，或者最小的数字
//3. 下一次则可以少一次排序
//4. 依次循环，直到结束
public static int[] sort(int [ ]array){
    int temp = 0;
    //外层循环，判断我们这个要走多少步
    for (int i = 0; i < array.length-1; i++) {
        //内层循环判断两个数，如果第一个数比第二个数大，则交换位置
        for (int j = 0; j < array.length-1-i ; j++) {
            if (array[j+1]<array[j]){
             temp=array[j];
             array[j]=array[j+1];
             array[j+1]=temp;
            }
        }
    }
    return array;
}