<Java SE> 5道递归计算,创建数组,数组遍历,JVM内存分配...

简介: <Java SE> 5道递归计算,创建数组,数组遍历,JVM内存分配

一.递归


1.递归计算N!

public class TestDemo {
    public static int fuc(int n){
        if(n==1){
            return 1;
        }else{
            int tmp = n*fuc(n-1);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = fuc(5);
        System.out.println(ret);
    }
}

结束条件其实是归的其实条件(什么时候开始归)

2.按顺序打印一个数字的每个数

public class TestDemo {
    public static void fuc(int n){
        if(n<10){
            System.out.print(n+" ");
        }else{
            fuc(n/10);
            System.out.print(n%10+" ");
        }
    }
    public static void main(String[] args) {
        fuc(1234);
    }
}

3.递归求1+2+3+...+10

public class TestDemo {
    public static int fuc(int n){
        if(n==1){
            return 1;
        }else{
            int tmp = n+fuc(n-1);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = fuc(10);
        System.out.println(ret);
    }
}

4.递归返回一个数的每位的和

public class TestDemo {
    public static int fuc(int n){
        if(n<10){
            return n;
        }else{
            int tmp = n%10+fuc(n/10);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = fuc(12345);
        System.out.println(ret);
    }
}

5.递归求斐波那契数列

public class TestDemo {
    public static int fuc(int n){
        if(n==1||n==2){
            return 1;
        }else{
            int tmp = fuc(n-1)+fuc(n-2);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = fuc(51);
        System.out.println(ret);
    }
}

6.迭代版本的斐波那契

public class TestDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int f1=1;
        int f2=1;
        int f3=1;
        for (int i = 0; i <n-2 ; i++) {
            f3=f1+f2;
            f1=f2;
            f2=f3;
        }
        System.out.println(f3);
    }
}

二.数组


1.定义数组的三种方式

        int[] array = {1,2,3,4,5};
        int[] array2= new int[]{1,2,3,4,5};
        int[] array3= new int [5];

array是一个引用变量,创建在栈上,存放的是堆上的一个地址

如果没有初始化,默认值是0

boolean类型的默认值是false

2.遍历数组的三种方法

1.下标遍历

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

2.for each 遍历(加强for循环)

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int x:array){
            System.out.print(x+" ");
        }
    }
}

3.Array.toString遍历(需要导包,输出自动补中括号)

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
}

三种输出结果

3.数组是引用类型

1.引用指向(引用)一个对象的内存分布

4.array1=array2

其意思就是把array2的值赋给array1,因为array2的值是其指向的地址,所以array1现在的值变成了array2所指向的地址,则array1与array2共同指向这一块地址。

当没有人引用array1这个对象时,其就会被JVM的垃圾回收器回收了。

5.思考题

下面这段代码会输出什么??

public class TestDemo {
    public static void fuc1(int[]array){
        array = new int[]{1,2,3};
    }
    public static void fuc2(int[]array){
        array[0]=99;
    }
    public static void main(String[] args) {
        int[] array={5,6,7};
        fuc1(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
 
        fuc2(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}


目录
相关文章
|
5月前
|
存储 缓存 Java
我们来说一说 JVM 的内存模型
我是小假 期待与你的下一次相遇 ~
449 5
|
5月前
|
Java 大数据 Go
从混沌到秩序:Java共享内存模型如何通过显式约束驯服并发?
并发编程旨在混乱中建立秩序。本文对比Java共享内存模型与Golang消息传递模型,剖析显式同步与隐式因果的哲学差异,揭示happens-before等机制如何保障内存可见性与数据一致性,展现两大范式的深层分野。(238字)
174 4
|
5月前
|
存储 缓存 算法
深入理解JVM《JVM内存区域详解 - 世界的基石》
Java代码从编译到执行需经javac编译为.class字节码,再由JVM加载运行。JVM内存分为线程私有(程序计数器、虚拟机栈、本地方法栈)和线程共享(堆、方法区)区域,其中堆是GC主战场,方法区在JDK 8+演变为使用本地内存的元空间,直接内存则用于提升NIO性能,但可能引发OOM。
|
5月前
|
存储 缓存 Java
【深入浅出】揭秘Java内存模型(JMM):并发编程的基石
本文深入解析Java内存模型(JMM),揭示synchronized与volatile的底层原理,剖析主内存与工作内存、可见性、有序性等核心概念,助你理解并发编程三大难题及Happens-Before、内存屏障等解决方案,掌握多线程编程基石。
|
6月前
|
安全 Java 应用服务中间件
Spring Boot + Java 21:内存减少 60%,启动速度提高 30% — 零代码
通过调整三个JVM和Spring Boot配置开关,无需重写代码即可显著优化Java应用性能:内存减少60%,启动速度提升30%。适用于所有在JVM上运行API的生产团队,低成本实现高效能。
770 3
|
6月前
|
Java
Java 数组学习笔记
本文整理Java数组常用操作:遍历、求和、查找、最值及二维数组行求和等典型练习,涵盖静态初始化、元素翻倍、去极值求平均等实例,帮助掌握数组基础与应用。
|
6月前
|
缓存 监控 Kubernetes
Java虚拟机内存溢出(Java Heap Space)问题处理方案
综上所述, 解决Java Heap Space溢出需从多角度综合施策; 包括但不限于配置调整、代码审查与优化以及系统设计层面改进; 同样也不能忽视运行期监控与预警设置之重要性; 及早发现潜在风险点并采取相应补救手段至关重要.
890 17
|
7月前
|
存储 监控 算法
Java垃圾回收机制(GC)与内存模型
本文主要讲述JVM的内存模型和基本调优机制。
|
7月前
|
存储 缓存 Java
Java数组全解析:一维、多维与内存模型
本文深入解析Java数组的内存布局与操作技巧,涵盖一维及多维数组的声明、初始化、内存模型,以及数组常见陷阱和性能优化。通过图文结合的方式帮助开发者彻底理解数组本质,并提供Arrays工具类的实用方法与面试高频问题解析,助你掌握数组核心知识,避免常见错误。