2. 流程控制|方法|数组|二维数组|递归

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量211 收藏 1
点赞数
分类专栏： 个人java流程向 文章标签： java python 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Micoreal/article/details/134515421
版权

文章目录

流程控制

代码块

在深入学习选择结构和循环结构前，我们还需要了解块（block）的概念。

什么是代码块？代码块的定义是：由若干条Java语句组成，并且用一对大括号括起来的结构，叫做代码块。

很显然，我们写的main方法就是一个代码块。

那么代码块有什么用处呢？主要是：

  1. 代码块决定了块中的变量的作用域，也就是块中的变量只在当前块中生效。这意味着同一个代码块中，不可能有同名的变量。
  2. 定义在块中的变量，被块限制了作用域，称之为局部变量。这是一个非常重要的概念

最后谈两点注意事项：

  1. 代码块是可以嵌套定义的。
  2. 关于代码块，我们后面会专门讲解，这里先暂且不谈。

选择结构

其实和c++写的差不多，个人感觉上没有区别：

选择结构有两种实现方式，if 和 switch：

  1. if的使用场景
    1. 针对结果是布尔类型的判断。
    2. 多分支if结构，可以使用多个判断条件。
    3. if的判断条件可以是一个连续的取值范围
  2. switch的使用场景
    1. 针对结果是固定类型、固定值的判断，尤其注意不能是boolean类型。
    2. switch始终只能对一个条件进行选择
    3. 每个分支的取值，只能是固定的且离散的。这是switch和if最本质的区别。
  3. 如果碰到if和switch都可以的情况，建议选择if，因为if语法简单不容易出错。而如果是针对离散值的判断，那就选择switch，因为它更加就简洁。实际开发中，99%以上的情况都在使用if而不是switch。

还有就是不管if后面有几条语句，都需要进行大括号括起来（规范）。

循环结构

看着语法来说，也和C++一样，这边就不细说了。

while、for和do…while之间的异同：

  1. while和for都要先判断条件是否成立，再决定是否执行循环体语句。
  2. do…while先执行循环体语句，再执行判断条件。所以无论如何，do…while都要执行一次循环体语句。
  3. while、for是先判断再干，do…while是干了再说。

跳转控制关键字

还是和C++一致，break，continue，return，至于goto（爬）

提到C/C++当中的循环控制关键字，还有一个非常著名的绕不过去，那就是goto

goto关键字，可以帮助我们在循环的过程中跳转到循环任何地方，极大增强了循环的灵活性。但是goto的缺点也是显而易见的，它破坏了程序的结构，使得循环的逻辑被打破，循环的结果容易变得不可控。

到了现在，虽然C++中依然保留goto，但实际上也是不推荐使用的。Java语法更直接摒弃了它，没有将它作为一个关键字，而是作为一个没有任何意义的保留字。

作为保留字，也是提醒程序员：这东西没用，你也不要定义一个东西叫goto。

方法

方法的概述

对于方法来说，实际上和C++的函数相类似，只是java当中每一个东西都被当作是一个类，所以我们需要加上public static 作为前面的标识，实际上就是，原本的方法的意识，这边给出样例:

[修饰符列表] 返回值类型 方法名 (形式参数列表){
	//方法体
}

例子：

public static void main(String[] args) {
 // Result of 'NewDemo.sum()' is ignored
 // 方法既然有返回值,那么建议去接收或者使用这个返回值
 int sumValue = sum(10, 20);
 System.out.println(sumValue);

 int num1 = 100;
 int num2 = 200;
		// 操作方法调用就是操作方法的返回值
 System.out.println(sum(num1, num2));
 System.out.println(sum(num1, num2) + 100);
}

// 定义一个方法,来完成求两个int类型数值的和
public static int sum(int num1, int num2) {
 return num1 + num2;
}

然后就是概念向的：

  1. 我们把[修饰符列表] 返回值类型 方法名 (形式参数列表)称作方法头，或者方法的声明
  2. 我们把方法名 (形式参数列表)称作方法的签名，而对于方法的签名来说，在一个类当中必须是唯一的。

其他的细节：

  1. Java中的一个类中的方法,是平行的关系,位置不同,不会影响方法调用的结果
  2. 同类中的static和static修饰的方法之间可以互相调用,直接用方法名调用即可

以及和C++当中一样实参与返回值实际上会进行自动类型转换（由小变大）。

小技巧：

  1. 提取方法的快捷键 Ctrl+Alt+M.
    在这里插入图片描述
    在这里插入图片描述

  2. 快速生成方法：直接写方法调用，编译报错后使用 alt+enter 快速生成方法
    在这里插入图片描述
    在这里插入图片描述

方法的重载

语法要求：
一个类中的多个方法，可以具有相同的方法名，但是它们的形参列表必须不同。

形参列表不同意味着：

  1. 形参数量不同
  2. 形参数量相同时，形参的数据类型不同
  3. 形参数量和数据类型都相同时，形参的数据类型的顺序不同

而具体使用什么函数则和C++一样满足的是就近原则，但此时就有人会这么做：

// 方法1
public static void test(int a,double b){}
// 方法2
public static void test(double a,int b){}

调用：

test(10, 10);

那么此时调用的是啥呢？

显然不好确定，无论是1还是2都需要类型转换才能匹配，既然都转换，并且都是int—>double，那么到底谁"近"呢？实际上这个方法的调用，是一个模糊的调用，会编译报错。这一点在开发中，多个方法组成方法重载时，要格外注意。

Junit单元测试初识

Junit就是用来做单元测试的，而这一部分存在于编译器当中，也属于第三方库，导入过程就需要alt + Enter进行操作

通俗点说,junit可以实现在一个类中实现多个main方法的效果

Junit的使用:

  1. 首先要创建一个类,而且这个类最好不要叫Test
  2. 然后在这个类的类体中,方法外面,写注解@Test
    注解: annotation,它是一种和class同等级别的数据类型,是一种引用数据类型
    "@Test"当中,其中Test是这个注解的名字,相当于类名
    "@"加上这个注解名,表示创建这个注解的对象(这是一种比较独特的创建对象方式)
    "@Test"注解是Junit的一个基本注解,它表示创建一个测试方法,这个测试方法类似于main方法
  3. 直接写注解肯定会报错,原因和直接在代码中写Scanner类似,是因为缺少导包的步骤，需要导包，但是注解@Test和Scanner导包还有所不同，Scanner是JDK中原本就存在的类,可以直接导包，注解@Test不是JDK中已经存在的注解,而是第三方开发出来的工具当中的注解。 这时需要一个将三方工具包导入当前工程的过程,称之为"导入依赖" 正常情况下,依赖导入需要通过依赖管理工具(maven)去导入,或者手动下载,手动导入，但是Junit这个第三方依赖很特殊,它的依赖包已经存在于IDEA本地文件当中，可以直接通过"alt+回车"导入依赖,并完成导包。
  4. 写完注解后,还需要写测试方法,格式如下:
 public void 方法名(){
 	// 方法体
 }

注意事项：

  1. Junit单元测试的格式上：
    1. public void 是固定格式，不可修改，修改会报错。
    2. 并且测试方法正常情况下，不能添加形参，必须是空参方法。
  2. 做单元测试的类中，不要写main方法，没有太大意义。

具体的导入依赖的操作：
在对应标红色的位置
在这里插入图片描述
我这边由于自己已经导入了，所以就不再次进行尝试了，这边就讲个操作方式。

全限定类名

为什么Junit的使用最好不要在一个Test类中呢?

因为由于Junit的测试方法需要使用注解@Test,其中Test是注解的名字,相当于类名，而注解和类是同等级别的数据类型，所以如果直接在Test类中,写注解@Test,会优先选择使用自身类Test作为一个注解，但是Test类本身就不是注解,而且也不是我们想要的那个注解Test，这肯定是不可行的!这也是一种就近原则.

如何解决?如果非要在Test类中使用注解Test咋办呢?
因为我要使用的注解Test是org.junit包下的Test注解,而不是自身的类Test，所以在写注解时,就不能简单写注解的名字了，要带上包名，由于在Java中,同包下绝不可能存在同名类(注解)，所以包名+类名(注解名)是可以唯一的确定一个类(注解)的，我们把直接写"类名"的形式,称之为"简单类名"，而把"包名+类名"的形式,称之为"全限定类名",全限定类名的作用是唯一确定一个类 。

例子：

public class Test {
    // 这里不能使用简单类名,要使用全限定类名
    @org.junit.Test
    public void test() {
        System.out.println("hello world!");
    }
}

Debug 小技巧

  1. 如果想要进入查看源代码（类或者方法等）时，可以按快捷键： CTRL + 左键。
  2. 查看代码时：从A—> B —> C —> D，我把D看完了,想继续看C的代码,怎么办呢?使用快捷键 ctrl + alt + 左右键 回到上一次鼠标的位置(左键) 去到下一次鼠标的位置(右键)

数组

数组的基本概念

数组最显著的特征是支持随机访问。

随机访问：指的是在访问某个元素时，无需经过其它元素，直接定位访问它

非随机访问：指的是访向某个元素时，需要先访问其它元素。

显然随机访问的效率很高，时间复杂度是常数级别的O(1)。

而数组的随机访问实现方式是：根据数组的首地址和下标，通过寻址公式直接计算出对应的内存地址，最终找出数据。要想使用这种方式实现随机访问，显然数组对数据结构和数组中的元素都是有要求的：

  1. 存储结构必须是连续的（有序），这样才能连续计算。
  2. 存储的元素必须数据类型相同，这样每个存储单元的地址偏移量都是相同的。

综上，数组是用一段连续的内存空间，来存储一组具有相同类型的数据的结构。

数组的基本使用

数组的声明

要想使用数组，首先要声明（declaration）数组，类似于变量的声明。

声明数组的两种语法格式：

  1. 格式一
数据类型[] 数组名;
  1. 格式二
数据类型 数组名[];
  1. 第一种格式具有更好的可读性，可以直观的看到这个数组是一个什么数据类型的数组。
  2. 第二种格式，是Java沿袭自C语言的一种声明方式。我们都知道，早期很多Java开发者都是C转过来的，所以很多开发者在开发Java时，一时改不了使用习惯。我们在Java早期的源代码中，可以发现很多格式二的使用案例。Java为了代码的兼容性考虑，不太可能会取消这一声明格式。（但是像C#这种和Java同源的设计语言，已经取消了数组的声明格式二）
  3. 但是，我们毕竟不是开发者，而几乎所以Java规范中都禁止使用格式二定义数组。规范的Java代码应该永远采用格式一。

数组的初始化

  1. 静态初始化
    由程序员显式的，指定数组中每个元素的初始值，数组的长度由系统决定（实际上也是由程序员给出的）
// 和数组的声明写在一起，语法格式就是：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

// 静态初始化有简写的形式，可以省略new关键字,但省略使用必须和声明一起写，而带new的，实际上可以自己放在外面进行使用，自己本身就已经是一个数组了。
数据类型[] 数组名 = {元素1,元素2,元素3...};
  1. 动态初始化
    动态初始化指的是：程序员只是指定数组的长度，数组中每个元素的初始值由系统（实际上是JVM）决定。
数据类型[] 数组名 = new 数据类型[数组长度];

注意事项：

  1. 动态初始化没有给出具体元素的赋值，但仍然能够初始化完成，这是因为数组中的元素具有默认值。
  2. 数组的长度必须是一个int范围内的非负数。
  3. 动态初始化数组相对更灵活，是更常用的方式。
  4. 数组的初始化一旦完成，它的长度就不能改变了！一般来说都会使用集合类中ArrayList（ArrayList底层实现仍然是数组，它有下标，能够随机访问，具有数组的优点，但是它没有长度的限制。它是通过将元素放入更长的数组中实现扩容的。这点我们后面会学习。)

还有就是小的tips：

int a = 10;
int[] arr = new int[3];

// 直接输出数组名
	/*
	首先arr是数组名，同时它更是一个局部变量
	我们可以输出数组名，看一下这个局部变量中到底存放了什么
	输出的结果是：[I@6d6f6e28
	解释：
	[ 一个左中括号表示这是一个一维数组。（[[就表示二维数组）
	I 表示这个一维数组是int类型的
	@后面跟的是一个十六进制的数，这个十六进制的数表示的是地址
	所以arr中存储的是地址
*/
System.out.println(arr);

输出：

[I@6d6f6e28

JVM内存模型

在这里插入图片描述

JVM的五大区域：

  1. JVM栈（以后简称栈，stack）：描述的是Java的（普通）方法执行时的所占内存的内存模型。程序运行时调用方法的代价是：方法中有局部变量需要开辟空间存储，方法的执行过程会产生中间变量，方法执行完毕还需要存储返回地址等等。JVM栈正是Java的（普通）方法执行时所占用的内存空间，局部变量会直接存储在栈帧中。

    于是，方法的执行流程，在JVM内存中，就变成下面这样：

    1. 每当Java程序执行一个方法，都会在栈上分配一块只属于该方法的内存区域，称之为栈帧
    2. 每当Java程序执行一个方法，都会将一个存储该方法信息的栈帧压入栈中，称之为方法进栈
    3. 方法进栈的同时局部变量开辟内存空间存储值，局部变量生效。
    4. 当方法执行完毕后，该方法的栈帧随之销毁，称之为方法的出栈
    5. 方法栈帧被销毁的同时，局部变量也被销毁，局部变量失效。

    注：栈中只有处于栈顶的栈帧才会生效，表示正在执行的方法。称之为当前栈帧，当前方法。

  2. 堆（heap）：堆是JVM内存中最大的一块，new出来的东西（称之为对象或者实例）都在堆上。所以new关键字的语义就是：在堆上开辟一片空间给相应的对象。而这片空间（对象）是有内存地址的，这个内存地址是留给外界访问用的。

    注：引用数据用比较运算符比较的地址就是这个地址，即比较对象的内存地址。

  3. 方法区（method area）：面向对象详细讲。

  4. 本地方法栈：和JVM栈类似，区别是本地方法栈是给本地（native）方法使用的，而不是普通方法。

  5. 程序计数器：JVM执行代码解释执行的，即是一行一行执行字节码的，程序计数器用来记录当前执行的行数。

很明显，在JVM内存模型中，相对比较重要的，和程序的执行联系更紧密的是：堆和JVM栈。堆内存用来存储对象，由于Java是面向对象语言，Java面向对象程序中将会有非常多的对象，所以 堆内存主要决定了Java程序的数据如何存储的问题。而JVM栈用来表示方法的执行流程， 它决定了程序如何执行，或者说如何处理数据。

或者举个例子，当我们在写了一个函数：

public static void test()
{
	int a = 1;
	double[] b = new Double[]{0.1,0.2,0.3};
	String[] arr3 = {"hello", "abc", "666"};
}

对于上面的东西，我们进行分析，首先明白test函数是放在栈区的，然后栈区当中的这个函数内部又会存储局部变量a 的值，以及b的引用（由于b是数组属于引用数据类型，所以实际上存储了一个b的地址，引用），然后这些0.1啊什么的是存储在堆区当中，相同的arr3这些也是一样的arr3也是把引用存在栈区当中，当函数的具体调用的时候，会拿着这个引用（地址）来去堆区拿数据来使用。

而需要注意的是，我们讨论中，在堆区创建的数据（也就是在main下创建的数据）是有默认值的，比如我们可以直接在main下int[] a = new Double[3]，这让内部的值都为0，但是在局部变量当中这是没有默认值的 ，这需要十分的注意。

什么是引用数据类型

引用数据类型是Java的两大数据类型之一，通过数组初始化的内存分配过程来一窥引用数据类型的特点。

引用数据类型的创建分为两部分：

  1. 首先是在栈上分配一片空间给引用数据类型的引用，简称引用，它是一个局部变量，直接存储在栈帧中。
  2. 在堆上开辟一片空间，用于存放引用数据类型的实际信息，称之为对象或者实例

虽然有两个部分，但对象才是引用数据类型的实质，栈上的引用通过存储对象的地址，指向了堆上对象，这样就可以通过引用间接访问堆上的对象。总结来说就是：对象是实质，但我们不能直接访问堆上的对象，而是通过栈上的引用间接访问。

基本数据类型和引用数据类型的区别

基本数据类型的变量必然都是局部变量，你可能会疑惑，数组的元素也可以是基本数据类型，那它们不是局部变量啊。实际上我们不应该这么去思考，数组中的元素其实已经是（数组）对象的一部分了，它不应该单独拎出来看。所以它们的区别在于：

  1. 存储位置（本质区别）
    1. 基本数据类型不存在引用的概念，数据都是直接存储在栈上的栈帧里；
    2. 引用数据类型在栈帧中存储引用，引用作为一个局部变量，存储的只是该引用类型在堆上对象的内存地址。 存储在堆上的对象存储具体信息，才是引用数据类型的实质。引申出，打印变量名区别：
      1. 基本数据类型，打印变量名就是该变量具体的数值
      2. 引用数据类型，没有办法直接访问对象，打印变量名（引用）会显示该引用存储的堆上的对象的内存地址。

堆和栈中内容的区别

我们从以下三个角度来分析这个问题：

  1. 从存储的类型来看：
    1. 堆上存储的是new出来的东西，是引用数据类型的实质——对象。
    2. 栈上存储的是局部变量（基本数据类型和引用类型的引用）
  2. 从默认值来看：

    1. 堆上的变量具有默认值

      1. 整形（byte、short、int、long）默认值为0
      2. 浮点类型（float、double）默认值为0.0
      3. 字符类型（char）默认值是’\u0000’ 表示编码值为0的字符，一个绝对空字符。
      4. 布尔类型（boolean）默认值是false
      5. 引用数据类型默认值是null ,null既不是对象也不是任何一种数据类型，它仅是一个特殊的值,任何引用数据类型的引用都可以指向null，指向null并不意味着没有初始化，可以认为引用指向了虚无，反正没有指向任何一个对象。
      6. 对象才是引用数据类型的实质，没有指向对象的引用实际上没有任何意义，指向null的引用是无法正常使用的
      7. 基本数据类型不能等于null

    2. 栈上的局部变量没有默认值，声明局部变量后必须显式的初始化，否则无法使用。

  3. 生命周期来看：
    1. 堆上的对象使用完毕后，随着方法的出栈，对象的引用就会被销毁。这个时候对象就没有引用指向它，而是孤零零的单独存在于堆上，这种对象意味着我们就无法再次使用它了，这种对象没有意义了。在Java中，我们把这种对象称之为垃圾或者垃圾对象，它们会等待垃圾回收器进行内存回收。
    2. 关于Java的垃圾回收机制（Garbage Collection简称GC）：
      堆上的对象变成垃圾后，并不是立刻就会被回收，而是需要GC通过一系列的算法来决定它是否被回收。Java的GC机制是全自动的，程序员几乎无法干涉和主动回收垃圾。这一方面为Java程序员的开发节省了大量的精力（无需花费大量精力来管理堆内存），相比于C++的全手动回收垃圾对象，Java在GC机制上的创新是Java能够如此流行的重要原因之一。但另一方面，一旦GC这种机制出现问题，对Java而言将会是非常难以解决的问题。垃圾回收是Java和C++之间的一道围墙，墙外的人想进来，墙内的人却想出去。
    3. 栈上的局部变量的生命周期和栈帧保持一致。方法栈帧进栈后，局部变量开辟空间生效了，方法出栈后，局部变量就被销毁了。

数组异常

在数组当中比较常见的异常名称：

  1. 数组下标越界异常：ArrayIndexOutOfBoundsException
  2. 空指针异常：NullPointerException

长度为0的数组 和 数组是null

对于下面的需要进行相关的理解：

  1. 数组未初始化： 这个数组完全是不可用的，没有初始化的数组毫无意义，一旦使用会编译报错。
  2. 数组长度为0和数组为null都是可以使用的，可以认为是经过初始化的，但它们都不是正常数组：
    1. 长度为0的数组，只在内存中存在结构但没有存储单元，不能存储任何数据。它的操作中：
      • 直接打印数组名可以获取数组对象的地址。
      • 不能访问任何数组下标，否则都会抛出数组下标越界异常。
      • 输出数组的长度为0
    2. 数组为null，表示数组的引用指向了null，数组（对象）无法进行任何操作。
      • 直接打印数组名得到一个null字符串。
      • 不能访问任何数组下标，也不能打印数组长度，都会报空指针异常。

一个长度为0的数组的经典用途：

假如方法的返回值是一个数组，而又有无返回数据的需求，这个时候普遍有两种做法 ：

  1. 返回一个长度为0的数组
  2. 返回一个为null的数组

以上两种方式皆可，但是建议优先选装返回长度为0的数组，避免空指针异常

遍历数组多种操作

Arrays.toString(数组)

数组遍历并输出值，是非常常见的操作。所以如果你仅仅是想看一下数组里的元素长啥样，完全不需要自己手写实现。而是直接使用下面的方式

范围for 或者叫 增强for操作：

for(数据类型 变量名 : 要遍历的数组或者集合){
	System.out.println(变量名);
}

这边补充一下，可以直接快捷键，输入iter，直接输出，而java当中的引用采用的都是值引用，不论是函数传参还是什么别的方法，采用的都是值引用。

可变参数

这个… 实际上就是数组，我们实际上按照数组来进行使用即可。 区别在于: 原先的数组是程序员自己创建的，可变参数的数组是编译器帮助创建的，像这种实现原理不变,但是简化了程序员的操作,让代码更灵活的语言特性就是可变参数。

public static int sum(int... var) {
        // 遍历数组求和
        int sumValue = 0;
        for (int ele : var) {
            sumValue += ele;
        }
        return sumValue;
    }

注意事项：

  1. 调用方法时，如果有一个固定参数的方法匹配的同时，也可以与可变参数的方法匹配，则选择固定参数的方法。
  2. 调用方法时，如果出现两个可变参数的方法都能匹配，则报错，这两个方法都无法调用了
  3. 一个方法只能有一个可变长参数，并且这个可变长参数必须是该方法的最后一个参数。
  4. 可变参数的书写格式,推荐"数据类型… 变量名"
  5. 带有可变参数的方法本质上是带有数组形参的一个方法,所以它也是可以和其他方法构成方法重载的!
    1. 尤其是当可变参数和固定参数的方法组成方法重载时,优先匹配固定参数的方法
    2. 当两个可变参数的方法构成方法重载时,要千万小心
    3. 很容易导致两个方法同时无法调用的情况

方法的传参问题

在java当中的所有的传参所传递的都是值传递，java当中没有引用传递这种说法，（值传递，传递值，或者说传递拷贝，引用传递，传递的是别名，也即自己的值的别名）

常见误解：
认为当传递数组的时候，是引用传递：

    public static void doubleElementValue(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;
        }
    }

当我们在main当中调用这个函数，传递一个arr给他，我们会发现arr内部的数据是会进行修改的，但此时我们把其当作是引用传递，这是很有问题的，事实上值传递，也即传递引用数据类型的地址，我们也能根据这个地址去改变堆中数据的大小的。

看下面的例子进行分辨：

	public static void swapReference(int[] arr1, int[] arr2) {
        int[] temp = arr1;
        arr1 = arr2;
        arr2 = temp;
        System.out.println("交换的方法中arr1"+Arrays.toString(arr1));
        System.out.println("交换的方法中arr2"+Arrays.toString(arr2));
    }

当调用这个函数的时候，我们会发现在main函数中arr1和arr2并没有发生变化，怎么理解呢？我们先假设如果是引用传递会发生什么？

  1. 当发生引用传递的时候：我们传入的是main当中数组的别名，也即两个对应的是同一个东西，所以最后在arr1和arr2会发生变化，arr1和arr2相互交换。
  2. 当发生值传递的时候：传入的是main的值，也即拷贝，所以我们交换的只是jvm栈当中的arr1和arr2，外面的并没有进行调换。

总结，由于java值传递的特性，可以得到以下结论：

  1. 不能修改基本数据类型的实参的值，也不能修改引用数据类型实参引用的取值，一个方法不能修改其它方法中局部变量的取值。一旦违反上述原则，那么局部变量就不"局部"了。
  2. 可以改变引用数据类型中对象里的数据（称之为改变对象的状态，改变对象的属性值）
  3. 换句话来说，就是没办法改变引用数据类型的值，但可以改变引用数据类型内部数据的值。

二维数组

二维数组的基本概念

在这里插入图片描述
二维数组的实质，仍然是一维数组。二维数组的数据类型由其中一维数组的类型决定，只能存储相同类型的一维数组，但值得注意的是和c/c++不一样的是，这个一维数组的大小可以不同，也即二维数组中的每一个一维数组的大小可以不一样，所以java就不存在和c/c++一样的连续存储的情况，他的每一个一维数组的存储都是随机的。

二维数组的基本使用

二维数组的声明：

数据类型[][] 二维数组名;

二维数组的初始化有三种格式：

  1. 静态初始化
   二维数组名 = new 数据类型[][]{{元素1,元素2,元素..},{元素1..}...};
   //可以简写为下面格式
   数据类型[][] 二维数组名 = {{元素1,元素2,元素..},{元素1..}...};
  1. 动态初始化格式一
   二维数组名 = new 数据类型[m][n];

其中：

  1. m表示二维数组的长度，代表二维数组当中，一维数组的个数。
  2. n代表二维数组当中，每个一维数组的长度，即一维数组能存储元素的个数。

注：

  1. 动态初始化格式一创建的二维数组，里面的每个一维数组的长度都相同。
  2. 其中的每一个一维数组相当于动态初始化，里面的元素都具有默认值， 可以直接使用。内存图如下：

在这里插入图片描述

  1. 动态初始化格式二
   二维数组名 = new 数据类型[m][];

其中：
m表示二维数组的长度，代表二维数组当中，一维数组的个数。

注：
这种方式创建的二维数组，实际上只有默认值null，不能直接使用。内存图如下：

除了上述三种三种初始化方式，其它任何方式都是错误的，比如下面：

三种初始化方式中，静态初始化很固定地为元素赋值。动态初始化格式一创建完毕后，一维数组的长度都是一样的，但可以直接使用。而格式二直接使用会空指针异常，还需要手动初始化二维数组中的每一个一维数组，每个一维数组的长度可以自己给出，相对灵活。

二维数组的进阶操作

便利打印：

Arrays.deepToString(某个二维数组)

由于他的每一层的数组大小不一样，所以他的遍历有点不一样，理解一下，下面的即可：

import java.util.Arrays;


public class Main {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3, 4}, {2, 3, 4}, {3, 4}};
        System.out.println(Arrays.deepToString(a));
        print(a);

    }

    private static void print(int[][] a) {
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (j==0)
                {
                    System.out.print("["+a[i][j]+",");
                } else if (j==a[i].length-1) {
                    System.out.print(a[i][j]+"],");
                }
                else {
                    System.out.print(a[i][j]+",");
                }
            }
        }
        System.out.print("\b]");
    }
}

输出：

[[1, 2, 3, 4], [2, 3, 4], [3, 4]]
[[1,2,3,4],[2,3,4],[3,4]]

递归

递归注意事项

使用的递归的注意事项:

  1. 首先需要找到方法体中,自身调用自身的代码，这称之为递归体，没有递归体肯定不是递归。
  2. 光有递归体的递归肯定是不行的,方法只进栈不出栈一定会栈溢出,所以需要给出一个条件让方法结束调用出栈,这称之为"递归的出口"， 对于一个正常的递归而言,递归的出口必不可少。
  3. 思考: 一个有递归的出口就一定不会出错吗?一定不会栈溢出?一定安全吗?不一定,递归即便有出口,也需要考虑递归的次数，称之为"递归的深度"，递归的深度不能超过栈的空间大小，否则仍然会栈溢出。

总之: 递归是很危险的,使用递归之前一定要严格考虑递归的出口和递归的深度.递归虽然很好,但是能不用尽量不用

    public static int sum(int num) {
        // 递归需要出口,否则一定栈溢出
        if (num == 0) {
            return 0;
        }
        return num + sum(num - 1);
    }

异常

递归栈溢出错误：
递归是方法自我调用的过程，但是“只递不归”的套娃会导致程序崩溃，报错递归栈溢出错误（StackOverflowError），是一个错误（Error），是比Exception要更加的严重的错误。

产生栈溢出错误的原因在于：

  1. Java程序运行时，调用方法是有代价的：要占用栈（stack）中的内存空间
  2. 方法执行结束后，方法出栈，释放内存，所以一般情况下，栈内存不会溢出，始终够用
  3. 无限制的递归调用方法，会导致方法只进栈不出栈，很快栈内存空间就不够用了
  4. 这种情况就是"栈溢出错误"，对程序而言是致命错误，程序必须停止执行。
Micoreal
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二维数组+递归
Pig-pig-pig的博客
04-10 1697
一.二维数组 1.定义 二维数组其实就是每一个元素为一维数组的数组。 2.定义格式: 数据类型[][] 数组名=new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可写可不写,写与不写有区别 例如: int[][] arr=new int[3][2]; 1.数组名为arr 2.数组长度为3,即存放的一维数组的个数为3, 3.每个一...
二维数组递归算法c语言,JavaScript 递归法排列组合二维数组
weixin_39801075的博客
05-19 302
二维数组排列组合var arrays = [['1-1-雨尘', '1-2-芸芸', '1-3-简一', '1-4-乐乐'], ['2-5-小明', '2-6-花花', '2-7-数数'], ['3-8-静静', '3-9-点点', '3-10-hapday', '3-11-欢欢', '3-12-yuchen']];//debugger;/*** 递归法排列组合二维数组*/function doE...
python输入二维数组_Python输入二维数组方法
weixin_39699746的博客
11-23 4590
Python输入二维数组方法前不久对于Python输入二维数组有些不解，今日成功尝试，记以备忘。这里以输入1-9,3*3矩阵为例n=int(input())line=[[0]*n]*nfor i in range(n):line[i]=input().split(' ')print(line)使用数据转换为int即可！以上这篇Python输入二维数组方法就是小编分享给大家的全部内容了，希望能给大家...
二维数组与递归
xuefeiyuan1995的博客
04-12 557
一、二维数组 1.1、二维数组概述 其实二维数组其实就是每一个元素为一维数组的数组。 1.2、二维数组定义格式及内存图解 二维数组格式1 数据类型[ ] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可选 举例: int [][] arr=new int [3][2]; 定义了一个二维数组arr,这个二维数组有3个一维...
java中用递归遍历二维数组
xunrenbuyu的博客
07-20 2161
    在java中二维数组用到的比较少，对于二维数组的遍历并不难，通过for循环，增强for很简单就可以实现，不过我们知道对于递归可以简单理解为循环，那么有没有想过用递归进行遍历二维数组呢？ 对于递归，个人理解为，自己调用自己的方法，从而实现循环功能，最重要的两点：1 要有出口，避免陷入死循环，2 要注意不要调用的次数过多，防止内存报错； 下面就简单尝试了一下用递归解决二维数组遍历问题，对...
python一维数组和二维数组_Python numpy实现二维数组和一维数组拼接的方法
weixin_39639919的博客
11-27 4554
Python numpy实现二维数组和一维数组拼接的方法撰写时间：2017.5.23一维数组1.numpy初始化一维数组a = np.array([1,2,3]);print a.shape输出的值应该为（3，）二维数组2.numpy初始化二维数组a = np.array([[1,2,3]]);b = np.array([[1],[2],[3]]);print a.shape//(1，3）prin...
二维数组中的递归算法
L__ear的博客
08-06 1702
这两道题目分别来自爱奇艺 2017 年内推笔试题和 2019 年猿辅导算法题。 第一题 题目描述 Michael 喜欢滑雪这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出，数组的每个数字代表点的高度。下面是一个例子 1 2 3 4 5 16...
php遍历删除二维数组元素,php实现搜索一维数组元素并删除二维数组对应元素的方法...
weixin_35147304的博客
03-11 212
php实现搜索一维数组元素并删除二维数组对应元素的方法发布于 2015-11-15 13:28:07 | 111 次阅读 | 评论: 0 | 来源: 网友投递PHP开源脚本语言PHP(外文名: Hypertext Preprocessor，中文名：“超文本预处理器”)是一种通用开源脚本语言。语法吸收了C语言、Java和Perl的特点，入门门槛较低，易于学习，使用广泛，主要适用于Web开发领域。PH...
JS 二维数组变一维数组的方法
qq_36437172的博客
05-17 5935
方法一： 利用 es5 的 reduce 实现。 var arr1 = [[0, 1], [2, 3], [4, 5]]; var arr2 = arr1.reduce(function (a, b) { return a.concat(b) }); 方法二： 通过 Array.isArray 判断是否为多维数组，如果是，进行递归操作。 var arr1 = [[1,2],3,[[[4], 5]]]; function flatten(arr) { return [].co
二维数组拼接字符串递归
bad_bodyer的博客
02-11 1183
error_reporting(E_ALL ^ E_WARNING ^ E_NOTICE); //显示除去E_WARNING E_NOTICE 之外的所有错误信息  $arr[0] = array(1, 2,3); $arr[1] = array(4, 5,6,7); //$arr[2] = array(7, 8); //$arr[3] = array(10, 11, 12
用递归查找有序二维数组的方法详解
09-05
在本文中，我们将深入探讨如何使用递归方法在一个有序的二维数组中查找特定的整数。有序二维数组是指每行从左到右递增，每列从上到下递增的数组。这样的结构使得我们可以采用一种高效的方式来搜索目标值，而无需遍历...
ccf.rar_ccf_二维数组
09-23
本文将深入探讨如何使用链表动态分配二维数组，以及递归下降语法分析器的相关知识。 首先，让我们关注核心主题——用C++实现使用链表动态分配二维数组。在传统的C++编程中，二维数组通常是静态定义的，这意味着在...
PHP实现判断数组是一维、二维或几维的方法
12-19
二维数组则包含一维数组作为其元素，形成表格状结构。更进一步，多维数组可以包含任意深度的嵌套数组，形成树形或网状结构。 要判断数组的维度，我们可以自定义一个递归函数，如`getmaxdim`，该函数会检查数组中的...
php实现将二维关联数组转换成字符串的方法详解
12-17
这个过程不仅适用于二维关联数组，还可以处理更复杂的多维数组，因为递归可以处理任意深度的嵌套。 在实际开发中，这种数组到字符串的转换功能非常有用，比如在处理用户输入、存储数据到数据库、或者生成CSV格式的...
java旋转二维数组实例
09-04
总的来说，这个Java实例展示了如何使用递归的思想和控制循环来实现二维数组的螺旋填充。这种方法可以扩展到任意大小的二维数组，并且可以灵活地修改填充规则，以适应不同的旋转需求。理解这个例子有助于增强对二维...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1257
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 330
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 242
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
递归求解二维数组路径
07-27
回答: 递归求解二维数组路径可以使用暴力递归的方式。思路是，对于二维数组中的每一个点，记录其到终点（右下角点）的最小路径和。具体做法是，分别查看该点的正下方和右边两个点的值，选择其中较小的一个与数组原...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值