debug模式及数组

debug模式

用来调试程序 ，逐行运行程序

断点: 需要从哪行开始调试,在哪设置断点

以debug模式运行

F8：step over 步调

调试完成 释放程序

Connected 查看运行结果

数组

定义：是一组相同数据类型元素的集合，是一个容器

数组中可以存储基本数据类型，也可以存储引用数据类型

数组创建时必须指定长度，创建后，长度不能改变

数组中每个元素空间是连续的

声明  创建

访问数组中的元素   下标

声明  创建数组

int[] a,d; 定义了两个数组

int b[],c; 定义了数组b与变量c

三种定义方法

1.  int[] a = new int[5];

2.  int []a = new int[]{0,1,2,3,4};

3.  int []a = {0,1,2,3,4};

new创建一个数组，并指定数组的长度(容量)，每个空间会赋予默认值

整数的默认值是0

引用类型的默认值是null

boolean类型的默认值是false

System.out.println(a);//[I@1b6d3586  --  数组在内存中的地址(hash值)

Arrays类，Java语言中提供的用于操作数组的工具类，提供排序，二分查找，数组复制

System.out.println(Arrays.toString(a));[0,0,0,0,0]

Arrays.toString()  把数组以字符串的形式返回,便于调试查看

Arrays.sort()  排序

访问数组中的元素

数组名[索引/下标]

索引/下标(index):从0开始，是整数(int)，数组长度最大值是int的最大值

int[] a = new int[Integer.MAX_VALUE];

Integer.MAX_VALUE int类型最大值

数组最大索引  长度-1

数组长度

数组名.length

数组下标异常  Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 at day1.Demo2.main(Demo2.java:18)

for循环遍历数组

for (int i = 0; i < a.length; i++) {

    System.out.println(a[i]);

}

增强for循环

适合挨个的遍历每一个元素

a--要遍历的数组

int t--声明一个临时遍历,用来接收每次循环时,从数组中取出的元素

优点:写法简单  不足: 不能控制某一区间的遍历

for(int t:a){

    System.out.println(t);

}

二维数组(多维数组)

数组的数组,数组每个元素又是一个一维数组

int[][] a = new int[3][5];

[3]: 表示二维数组的长度是3

[5]: 表示二维数组中,每一个一维数组的长度为5

a[][] = {{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}}

int[][] a = new int[3][]: 只声明了二维数组的长度,并没有声明二维数组中一维数组的长度,也就不会创建一维数组{null,null,null}

二维数组遍历

public class Demo5 {
    public static void main(String[] args) {
        int[][] a={{1,2,3},{4,5,6},{7,8,9}};
        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();//换行
        }*/
        int[][] a = new int[2][3];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = scanner.nextInt();
            }
        }
        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();
        }
    }
}

冒泡排序

每次取出相邻的两个元素进行比较，将较大的向后移，每比较一趟，可以找出一个最大值

                   5，4，3，2，1

第一趟        4，3，2，1，5

第二趟        3，2，1，4，5

第三趟        2，1，3，4，5

第四趟        1，2，3，4，5

import java.util.Arrays;

public class Sort1 {
    public static void main(String[] args) {
        int[] a = {5,4,3,2,1};
        for (int i = 0; i < a.length-1; i++) {//外层循环控制比较趟数
            for (int j = 0; j < a.length-1-i; j++) {//内层循环,相邻两个元素比较 j j+1
                if(a[j] > a[j+1]){//满足条件,交换位置
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

选择排序

从第一个元素开始,与之后的每一个元素进行比较,将较小的移动到第一个位置,以此类推

方法一:

import java.util.Arrays;

public class Sort2 {
    public static void main(String[] args) {
        int a[] = {5,4,3,2,1};
        for (int i = 0; i < a.length-1; i++) {//控制比较的趟数
            for (int j = i+1; j < a.length; j++) {
                if(a[i]>a[j]){
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    System.out.println(Arrays.toString(a));
    }
}

方法二:

       

import java.util.Arrays;

public class Sort2 {
    public static void main(String[] args) {
        int a[] = {5,4,3,2,1};
        for (int i = 0; i < a.length-1; i++) {
            int min = i;
            for (int j = i+1; j < a.length; j++) {
                if(a[min]>a[j]){
                    min = j;//记录最小索引的下标
                }
            }
            int temp = a[i];
            a[i] = a[min];
            a[min] = temp;
        }
        System.out.println(Arrays.toString(a));
    }
}

杨辉三角

public class Project {
    public static void main(String[] args) {
        int row = 10;
        int[][] a = new int[row][row*2+1];
        a[0][row] = 1;
        for (int i = 1; i < a.length; i++) {
            for (int j = 1; j < a[i].length-1; j++) {
                    a[i][j] = a[i-1][j-1]+a[i-1][j+1];
            }
        }
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j]!=0){
                    System.out.print(a[i][j]+"\t");
                }
                else {
                    System.out.print("\t");
                }
            }
            System.out.println();
        }
    }
}