JAVA的条件判断，循环注意事项，方法的使用，数组的定义和使用 , 二维数组的定义和使用

原创已于 2024-10-13 15:38:23 修改 · 791 阅读

22 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #开发语言 #数据结构 #eclipse #汇编

于 2024-10-12 21:24:14 首次发布

JAVA基础专栏收录该内容

8 篇文章

订阅专栏

一.Switch的判断参数注意事项：

switch的判断参数不能是：

long float double boolean 类型。

二.条件语句else注意事项：

else 总是与最近的 if 相匹配，所以为了避免出现错误，我们最好加上括号。

三.循环语句注意事项：

Java 的循环判断条件必须是布尔表达式，即其结果只能是 true 或者 false ，不存在什么非零表示真.

四：方法的使用

从某种意义上说，Java 中的方法可以被看作是函数。

如何定义个方法？

像这样：

public static + 方法返回值类型 + 方法名 + （参数类型 + 形参名......） {

}

注意：1. 现阶段直接使用public static 固定搭配。

2.如果没有返回值，则把 “方法返回值类型” 写成 void

3.方法必须写在类当中

4. 方法不能嵌套定义

5. 这里是传值调用。

比如：想交换a与b的参数;

public class asda {



        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            swap(a, b);
            System.out.println("main: a = " + a + " b = " + b);
        }

        public static void swap(int x, int y) {
            int tmp = x;
            x = y;
            y = tmp;
        System.out.println("swap: x = " + x + " y = " + y);
        }

运行结果：

可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，没有交换成功。（这里需要用到数组来实现交换）

1.方法重载：

比如我们要实现浮点数相加，整数相加，多个整数相加，我们都要实现一边其功能的方法，取方法的名字就困难了，所以，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

比如：

可以看到，这三个方法名字都是add，参数列表不同，可以说这三种方法重载了。

注意：

1. 方法名必须相同

2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)

3. 与返回值类型是否相同无关

2.递归：

假如我们想要求 1758 每一项相加，即1+7+5+8，可以用递归实现：

把1758拆分成：

175+8 ---> 17+5+8 ---> 1+7+5+8

五.数组的定义和使用：

1.数组的定义：

数组是相同类型元素的一个集合。在内存中是一段连续的空间。

2.数组的创建和初始化：

数组有三种初始化方式：

（1）数组中存放元素的类型 + [ ] + 数组名 = new + 数组中存放元素的类型 + [ n ] ;

注意：

( 数组中存放元素的类型 + [ ] ) ---> 数组的类型。

n表示数组的长度。

例如：创建一个可以容纳10个int类型元素的数组

int[] arr = new int[10];

数组的类型是 int [ ]

（2）数组中存放元素的类型 + [ ] + 数组名 = new + 数组中存放元素的类型 + [ ] + { (元素) } ；

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};

(3)数组中存放元素的类型 + [ ] + 数组名 = { (元素) } ;

 int[] arr2 = {1,2,3,4};

数组的初始化主要分为动态初始化以及静态初始化:

动态初始化：

在创建数组时，直接指定数组中元素的个数,比如上述代码中的（1）。

静态初始化：

在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定比如上述代码中的（2）（3）。

因为静态初始化可以简写，省去后面的 new int[ ] ; 所以（3）也是静态初始化。

注意：

静态和动态初始化也可以分为两步，但是省略格式（new int [ ] ）不可以。

动态初始化分两步：

int[] array1;
array1 = new int[10];

静态初始化分两步：

int[] array2;
array2 = new int[]{10, 20, 30};

如果数组没有初始化，则会按照下表储存值：

如果数组中存储元素类型为引用类型（比如：String），默认值为null

String[] arr = new String[10];  //默认值是 null

3.访问数组内容：

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标。

java中有三种方式访问数组方式：

在此我们先知道一个重要知识点：

在数组中可以通过数组对象.length 来获取数组的长度。

（1）

利用 for 循环数组下标遍历数组：

运行结果：

（2）利用 for each 方法来遍历数组：

for 后面的括号里面的 int 是数组元素类型，a是自己随便写的，用来接收数组元素，arr 是要遍历的数组名。

运行结果：

(3)利用java官方提供的给我们操作数组的工具：

Arrays就是 java官方提供的给我们操作数组的工具，它可以把传入的数组转化为字符串的形式输出。

运行结果：

4.数组是引用类型：

1. 虚拟机栈：也就是我们说所的栈，局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。

2. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。

所以：

arr 是引用变量，存储的是对象数组在堆上的地址。

他们的关系:

引用变量 arr 存储的是堆上数组对象的地址。可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。

空引用：

int[] arr = null;
System.out.println(arr[0]);

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.

六.参数传数组类型(引用数据类型)

1. 利用引用变量修改堆上的数组对象：

（1）比如：

public class asda {

    public static void func(int[] a) {
        a[0] = 10;
        System.out.println("a[0] = " + a[0]);
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        func(arr);
        System.out.println("arr[0] = " + arr[0]);
    }

结果：

发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变.

刚开始是这样的：

当进入 func 函数后，会在栈上创建另一个引用变量 a 指向堆上的同一个数组对象，a里面也是数组对象的地址。

所以操作引用变量 a 可以修改堆上的数组对象。

（2）比如：

public class asda {

    public static void func(int[] a) {
        a = new int[]{7,8,9,10,11};
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4};

        func(arr);
        System.out.println(Arrays.toString(arr));
    }

结果：

一开始传 arr 过去创建是这样的：

当执行代码 a = new int[]{7,8,9,10,11}; 后是这样：

2.引用变量的交换：

结果：

可以看到，我们把 arr1 和 arr2 的引用变量交换了。

引用变量 arr1 和 arr2 交换前：

引用变量 arr1 和 arr2 交换后：

可以看到，引用变量 arr1 和 arr2 是堆上数组的地址被交换了，而tem是作为为他们交换的“承载器”。

3.引用变量的几个问题：

（1）引用变量可以指向引用吗？----> arr1 = arr2 ;

不可以，说法有错误！！

引用变量只能指向对象，比如指向数组。

arr1 这个引用变量指向的是 arr2 这个引用变量所指向的对象。

（2）int [ ] arr = null ;说明什么？

当前 arr 引用变量不指向任何对象。

（3）一个引用变量可以同时指向多个对象吗？？

int [ ] arr1 = {1,2,3,4} ;

arr1 =new int[ ] {5,6,9,8} ;

arr1 =new int [ ]{60,95,15,41} ;

此时可以说 arr1 同时指向3个对象吗？

不可以！

因为在执行完 arr1 = new int[]{60,95,15,41};后，arr1 指向最后的数组对象new int[]{60,95,15,41};

七.二维数组的定义和使用

1.二维数组的定义：

二维数组有四种创建方式：

（1）：创建并初始化

代表的是2行3列：

int[][] arr1 = {{1,2,3},{4,5,6}};

(2):创建并初始化

代表的是2行3列：

int[][] arr2 = new int[][]{{1,2,3},{4,5,6}};

（3）：创建不初始化

代表的是2行3列：

int[][] arr3 = new int[2][3];

(4) : 创建不初始化

可以省略列，但不能省略行

int[][] arr4 = new int[2][];

注意：

（4）的方法创建的可以实现不规则二维数组。

2.二维数组的理解：

假设我们创建了一个这样的二维数组：

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

        int[][] arr = {{1,2,3},{4,5,6}};

        System.out.println(arr.length);

        System.out.println("===============");

        System.out.println(arr[0]);
        System.out.println(arr[1]);

        System.out.println("===============");

        System.out.println(arr[0].length);
        System.out.println(arr[1].length);

        System.out.println("===============");

        System.out.println(Arrays.toString(arr[0]));
        System.out.println(Arrays.toString(arr[1]));
    }
}

打印结果：

我们应该怎么理解呢？

可以看到，我们打印 arr.length 结果是 2 ，事实上他打印的是二维数组arr 指向的对象在空间 0x99位置的连续数组大小，

再接下来打印 arr[0] 和 arr[1] ，结果是两个地址，这里就回到了一维数组的概念了， arr[0] 和 arr[1] 可以说是堆上数组对象的引用了，他们引用变量分别的是两个数组在堆上的空间地址，对其 arr[0].length 和 arr[1].length 可以得到对应数组的大小。

最后我们利用 Arrays，它可以把传入的数组转化为字符串的形式输出。打印结果如图所示，可以知道在 arr[0] 和 arr[1] 可以作为引用变量 ,回归到了一维数组的理解。

所以，我们可以利用下面这种方式对二维数组进行遍历：

public class test {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }

运行结果：

3. 二维数组不初始化与不规则二维数组：

1.二维数组不初始化：

public class test {
    public static void main(String[] args) {
        int[][] arr = new int[2][];
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }

这样的代码会有什么问题？

结果：

代码执行到 for (int j = 0; j < arr[i].length; j++) 出现了异常，因为我们并没有初始化二维数组，所以它不知道这个 arr [0] 与 arrr[1] 指向哪个对象，所以 arr [0] 与 arrr[1] 会存入 null ,并且null 不能 .length，否则会出现空指针异常。

2.不规则二维数组:

接上面二维数组不初始化，我们可以怎么不规则初始化呢？

public class test {
    public static void main(String[] args) {
        int[][] arr = new int[2][];

        arr[0] = new int[]{1,2,3,4,5,6};
        arr[1] = new int[]{7,8};

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }

结果：

可以看到，这样我们可以初始化成不规则的二维数组并打印，那么，有没有其他方式打印呢？

可以这样：

public class test {
    public static void main(String[] args) {
        int[][] arr = new int[2][];

        arr[0] = new int[]{1,2,3,4,5,6};
        arr[1] = new int[]{7,8};

        System.out.println(Arrays.deepToString(arr));
    }

结果：