blocks|key|45616|text|由于方法调用开销和调用堆栈的使用，递归将变得更慢。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45617|Java也没有执行尾部调用优化，所以不要指望它。(尽管JVM上有一些语言具有尾部调用优化功能，包括Clojure和Kotlin)|45618|另一个缺点可能是在堆栈被填满的情况下存在StackOverflowError的风险。|offset|length|style|CODE|45619|如果您这样做只是为了尝试一下，我建议使用VisualVM，它可以在java+JDK中找到。它是一个分析器，可以用来对这种情况进行基准测试(或者，如果您使用的是操作系统，则可以要求一个开源的YourKit许可证)。|45620|请注意，，我不推荐使用递归，只是为了花哨。如果你真的需要它，就使用它(例如，遍历树)。|BOLD|45621|entityMap^0|0|0|K|I|0|0|0|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|W|8|@$F|X|G|Y|H|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|P|$]]

Recursion will be slower because of the method call overhead and call stack usage.

Java isn't performing tail call optimization either so don't count on it. (Although there are languages on the JVM which do have tail call optimization including Clojure and Kotlin)

Another drawback might be the risk of a <code>StackOverflowError</code> in case you are filling up the stack.

If you are doing this just to try things out I suggest using VisualVM which can be found in the java JDK. It is a profiler which can be used to benchmark this kind of situation (or you can ask for an open source YourKit license if you're working on OSS).

Please note that I do not recommend using recursion just to be fancy. Use it if you really need it (traversing trees for example).

blocks|key|2522307|text|在java中，与while循环相比，递归的开销很小，因为它需要分配一个新的栈帧。如果另一种选择是显式管理堆栈，则递归可能会更快|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2522308|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In java, recursion is little expensive compared to while loop because it requires the allocation of a new stack frame. Recursion may well be faster where the alternative is to explicitly manage a stack

blocks|key|45651|text|递归调用将堆栈帧添加到调用堆栈。循环则不会。循环通常比递归更快，除非递归是分而治之算法的一部分(您的示例不是)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45652|您应该能够对每个方法的执行进行计时，并找出其中一个方法比另一个方法快多少。|45653|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Recursive calls add stack frames to the call stack. Loops do not. Loops are generally faster than recursion, unless the recursion is part of an algorithm like divide and conquer (which your example is not).

You should be able to time the execution of each of your methods and find out how much faster one is than the other.

blocks|key|45673|text|我不建议使用递归，因为每个递归都存储在堆栈中。因此，您需要为每个递归调用存储方法参数、局部变量等，以维护该调用之前的方法状态。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45674|而且，你显然不应该在这种问题上使用递归。它应该留给一些特定的任务，只有当你真的无法避免使用它们的时候。|45675|此外，您还可以对您的代码进行基准测试，看看哪一个运行得更快。你将会有一个想法。|45676|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I would not suggest using Recursion, as each recursion is stored on stack. So, you need to store method parameters, local variables, etc, for each recursive call, to maintain the state of method before that call.

Also, you should obviously not go with recursion with this kind of problem. It should be left for some specific task, only when you really can't avoid using them.

Further, you can also benchmark your code to see which one runs faster. You will get an idea.

blocks|key|45447|text|一般来说，我更喜欢迭代(例如while或for循环)而不是递归，因为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45448|45449|Iteration+is+simpler|unordered-list-item|45450|如果递归太深，可能会出现stackoverflow异常。迭代时不会发生这种情况。|45451|45452|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|M|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

In general, I favour iteration (e.g. a while or for loop) over recursion because:

<ul>
<li>Iteration is simpler</li>
<li>If you recurse too deeply, you can get a stackoverflow exception. This cannot happen with iteration.</li>
</ul>

blocks|key|45503|text|一般来说，如果可能的话，递归被优化为循环，这意味着由于各种原因，如果两种解决方案相等，那么迭代比递归更有利。请参阅Tail+Recursion|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|45504|所以忽略Java没有优化尾递归这一事实，循环应该更快。|45505|还可以看看this|45506|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Tail_call|1|https://stackoverflow.com/questions/11853459/java-recursion-and-performance^0|1L|E|0|0|0|5|4|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

In general, recursion is optimized to loops if possible, meaning that for various reasons, including stack frame allocation and stack frame overflows iteration is favorable over recursion if the two solutions are otherwise equal. See <a href="https://en.wikipedia.org/wiki/Tail_call" rel="nofollow noreferrer">Tail Recursion</a> 
So ignoring the fact that Java doesn't optimize Tail Recursion, loops should be faster.

Also take a look at <a href="https://stackoverflow.com/questions/11853459/java-recursion-and-performance">this</a>

blocks|key|45513|text|您应该使用时间度量来运行代码。下面是我对100个递归/+100个while循环的输出：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45514|Recursive+time:+90941
While+time:+5180|code-block|syntax|javascript|45515|这清楚地表明，while循环比递归更快。|45516|您可以通过运行以下代码来检查我的测量结果：|45517|public+class+Process+{

++++public+Process()+{
++++}

++++public+static+void+countRecursive(int+num)+{
++++++++num%2B%2B;
++++++++if+(num+<=+100)+countRecursive(num);
++++++++else+return;
++++}

++++public+static+void+countWhile(int+num)+{
++++++++do
++++++++++++num%2B%2B;
++++++++while+(num+<=+100);
++++}

++++public+static+void+main(String[]+args)+{
++++++++Long+start+=+System.nanoTime();++++++++
++++++++Process.countRecursive(0);
++++++++System.out.println("Recursive+time:+"+%2B+(System.nanoTime()+-+start));
++++++++Long+startWhile+=+System.nanoTime();
++++++++Process.countWhile(0);
++++++++System.out.println("While+time:+"+%2B+(System.nanoTime()+-+startWhile));

++++}

}|45518|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You should run code with time measurement. Here you have my output for 100 recursions/ 100 while loops: 

<pre><code>Recursive time: 90941
While time: 5180
</code></pre>

This clearly shows that while loop is faster than recursion.

You can check my measurements by running this code:

<pre><code>public class Process {

 public Process() {
 }

 public static void countRecursive(int num) {
 num++;
 if (num &lt;= 100) countRecursive(num);
 else return;
 }

 public static void countWhile(int num) {
 do
 num++;
 while (num &lt;= 100);
 }

 public static void main(String[] args) {
 Long start = System.nanoTime(); 
 Process.countRecursive(0);
 System.out.println("Recursive time: " + (System.nanoTime() - start));
 Long startWhile = System.nanoTime();
 Process.countWhile(0);
 System.out.println("While time: " + (System.nanoTime() - startWhile));

 }

}
</code></pre>

blocks|key|2522468|text|其他人说的都是真的。我想再补充一点:对于你发布的问题，从1数到10，使用递归或迭代都可以，因为它们都只需要很少的时间。通常，在现代计算机系统上，您不需要过多地担心一个进程需要多长时间才能完成(除非您正在处理大型数据集)，因为内存非常便宜，而CPU又非常强大。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2522469|通常，您可以使用良好的编程实践，首先以您觉得最舒服的方式编写程序。如果在此之后运行时间太长，您可以对其进行优化。|2522470|并不是说，在这个层次上研究迭代和递归的比较是一件坏事。同样，迭代通常比递归更可取。我的观点是要学到的教训是，虽然有一些方法可以让您的代码快速运行，但在处理小数据集时，您通常不需要担心这些方法:)|2522471|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

What everyone else said is true. I'd like to add one more thing: For the problem you posted, counting 1 to 10, using recursion or iteration will be fine either way because they both take a negligible amount of time to run. In general, on modern computer systems, you don't need to worry too much about how long a process will take to complete (unless you're dealing with large data sets) because memory is so cheap and CPUs are so powerful.

Usually, you write a program however you feel the most comfortable first, using good programming practices. If it takes too long to run after that, you optimize it then.

Not that looking into how iteration and recursion compare at this level is a bad thing. Again, iteration is usually preferable to recursion. My point is the lesson to learn is that while there are ways to make your code run quickly, you often don't need to worry about them when you're working with small data sets :)

I have the following sample <code>class</code> with these two methods:

Process.java:

<pre><code>public class Process {

 public Process() {
 }

 public static void countRecursive(int num) {
 System.out.println("countRecursive: " + num++);
 if (num &lt;= 10) countRecursive(num);
 else return;
 }

 public static void countWhile(int num) {
 do System.out.println("countWhile: " + num++);
 while (num &lt;= 10);
 }

}
</code></pre>

Main class:

<pre><code>public static void main(String[] args) { 

 Process.countRecursive(0);
 Process.countWhile(0);

}
</code></pre>

Output:

<pre><code>countRecursive: 0
countRecursive: 1
countRecursive: 2
countRecursive: 3
countRecursive: 4
countRecursive: 5
countRecursive: 6
countRecursive: 7
countRecursive: 8
countRecursive: 9
countRecursive: 10

countWhile: 0
countWhile: 1
countWhile: 2
countWhile: 3
countWhile: 4
countWhile: 5
countWhile: 6
countWhile: 7
countWhile: 8
countWhile: 9
countWhile: 10
</code></pre>

But I want to know which "technique" is recommended to use and why.

Thanks in advance.

Which is faster in Java, while or using recursive method?

5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有以下包含这两种方法的示例class：Process.java:public class Process {    public Process() {    }    public static void countRecursive(int num) {        System.out.println("co...

问在Java中，while和使用递归方法哪个更快？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，while和使用递归方法哪个更快？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，while和使用递归方法哪个更快？
EN