java数组（array）

首先先介绍调试方法Dbug，这对于我们日后面对大量代码需要调试某一块代码时更方便

public class Dbug {
    /*
    在idea中进行Dbug调试
      1.断点：程序开始调试的位置
      2.以Dbug模式启动
      3.快捷键  F8
      4.结束调试     释放程序  直接关闭虚拟机

     */
    public static void main(String[] args) {

        int a = 10;

        int b = 5;

        int c = a+b;
    }
}

数组的定义   声明    创建

详细批注在下述的代码段中

 

import java.util.Arrays;

public class demo1 {
    /*
    数组：一组数据
    java中数组：一组相同数据类型元素的集合
               数组就是一个容器
               容器中多个值的空间是连续的
               数组在创建时必须给予长度和容量
         int a,int b,int c    ---->装入到一个数组容器中
     */
    public static void main(String[] args) {
        //int a = 10;
        //int[]b = new int[10];//表示创建了一个数组对象
       // String[] b = new String[10];//引用类型

        /*
        数组声明
        int -->表示数组中存储的数据类型
        []-->表示声明的变量值应该是一个数组
        a-->变量名
                */
     /*   int[] a,d;//一般用第一种(建议使用）,意思是这两个变量表示的都是数组
        String[] b;
        int c[],e;//c是数组，表示的是数组。e表示的是整数变量
*/
        /*
        数组创建
        创建一个指定类型指定容量的数组容器
        new int[5]表示创建了一个容量为5的整数类型数组，默认使用0填充每一个空间

         */
        int[] a = new int[5];
        System.out.println(a);//[I@1b6d3586   数组在内存中的地址
        System.out.println(Arrays.toString(a));//把数组转为字符串形式，便于直观看到数组中值的情况
        float[] b = new float[5];
        System.out.println(Arrays.toString(b));//默认用0.0填充
        String[] c = new String[5];
        System.out.println(Arrays.toString(c));//引用类型默认是null
        boolean[] d = new boolean[5];
        System.out.println(Arrays.toString(d));//布尔型默认用false填充



        int[] e = new int[]{1,2,3,4,5};
        //new int[]{1,2,3,4,5}创建一个数组容器，同时使用12345把每个空间赋值
        System.out.println(Arrays.toString(e));



        //简化！！！
        int [] f = {1,2,3,4,5};
        //隐式的创建一个与{}元素数量相等长度的数组容器
        //Java中的数组，一旦创建时确定容量，就无法更改容量
    }

}

数组中元素的访问

public class demo2 {
    public static void main(String[] args) {
        /*
        数组中元素的访问（1.给每个位置上元素进行赋值，2.获取某个位置上的值）
        a[0]:[0]数组元素的索引，数组中有5个空间，每个空间有一个编号，通过编号可以访问对应位置的元素
        索引（下标），每个空间的编号
        编号始终从0开始，最大的编号时长度减1,是int类型（数组长度有限）
         */
        int [] a = new int[]{1,2,3,4,5};
                      //     0 1 2 3 4（位置）
        a[0]=10;//给数组中某个位置进行赋值
        System.out.println(a[0]);//获取数组中某个位置的值
        System.out.println(a[1]);
        System.out.println(a[4]);
        //System.out.println(a[6]);不能超出数组的正常范围 否则会报错   0-----长度-1


        System.out.println("数组的长度"+a.length);
    }
}

数组元素的遍历迭代（全部列举）

public class demo3 {
    public static void main(String[] args) {
        /*
        数组元素遍历迭代
        取出数组中每个空间的元素，找出数组中有没有某个元素，最大值，最小值

        方式1：使用for循环（已知次数）
               索引：0---数组长度-1     数组名.length
               index
               通过for循环生成有效的数组索引

         */
        int [] a = {1,2,3,4,5,6,7};
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
}


        /*

        方式2：增强for循环
        简化for循环的语句
        for(int t(声明了一个变量，变量类型与数组中数据类型一致）：a（需要遍历的数组名））{
        输出t   每次循环时，从数组中取出一个元素，赋值给变量t，t每次都获取到元素
        }
        主要是对数组中所有元素进行遍历，不是用来替代for循环

         */





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



       int [] a = {1,2,3,4,5,6,7};
        for (int t : a){
            System.out.println(t);
            //只能从头到尾遍历（输出）所有元素
         }



}



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

        //找出数组中的最大值
        int[] b = {1,2,3,4,5,6,7,8};
        int c =b[0];
        for (int i=1;i<b.length;i++){
            if (b[i]>c) {
                c = b[i];
            }
            }
        System.out.println(c);
        }
    }

二维数组

public class demo4 {
    /*
    二维数组（多维数组）：
    数组中的每一个元素都是一个一维数组


    声明：
    int[][]a
    int a[][]

     */
    public static void main(String[] args) {
        /*
        new int[3][4]：    [3]表示二维数组长度是3，（3个一维数组）
                          [4]表示一维数组的长度是4
            {{0，0，0，0}{0，0，0，0}{0，0，0，0}}
              0 1  2  3  0 1  2  3  0 1  2  3
                   0        1         2
         */
       /* int[][]a =new int[3][4];
        System.out.println(a.length);//获取的是二维数组的长度
        System.out.println(a[1][2]);*/


        /*
        [3]表示二维数组长度为3，[]一维数组长度为空，创建二维数组时不会创建一维数组
        {null,null,null,}
         */





/*        int [][]a=new int[3][];
        System.out.println(a.length);
        int[]b = {1,2,3,4,5};
        int[]c = {1,2,3,4};
        int[]d = {1,2,3,4,5,6};
        a[0] = b;
        a[1] = c;
        a[2] = d;
        System.out.println(a[1][2]);
*/
        int[][] a = new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};

        int[][] b = {{1,2,3,4},{1,2,3,4},{1,2,3,4}};//简化版

        b[1][2] = 66;
        System.out.println(b[1][2]);//给二维数组中的一维数组中的元素赋值

    }
}

使用双层循环进行二维数组的遍历

public class demo5 {
    public static void main(String[] args) {
        int[][] a = new int[][]{{1,2,3,4},
                                {1,2,3,4},
                                {1,2,3,4}};
        //int[][] a = {{1,2,3,4},{1,2,3,4},{1,2,3,4}};简化版
        /*
        二维数组遍历
        使用双层循环
         */
        for (int i=0;i<a.length;i++){//遍历二维数组
           for (int j=0;j<a[i].length;j++){//遍历一维数组
               System.out.print(a[i][j]+" ");//取出一维数组中的每一个元素
           }
            System.out.println();
        }
    }
}