我看到了我考试的代码片段,我的第一个提示是它会抛出StackOverFlowError
for (int i = 10; i > 5; i++) {
if(i == 1000) i = 10;
System.out.println(i);
}
碰巧不是这样的。请从代码示例中解释为什么而不是将抛出StackOverFlowError。
首先,代码: public class StackSOF {
private int deep = 0;
public void stackLeak() {
deep++;
stackLeak();
}
public static void main(String[] args) {
StackSOF sof = new StackSOF();
try {
sof.stackLeak();
} catch (Throwable e)
我感到惊讶的是,即使在Java中出现了之后,仍然能够继续执行。
我知道StackOverflowError是类错误的子类。类错误被称为“Throwable的子类,它指示一个合理的应用程序不应该试图捕捉的严重问题”。
这听起来更像是一条建议,而不是一条规则,支持像StackOverflowError这样捕获错误实际上是允许的,这取决于程序员不这样做的合理性。看,我测试了这段代码,它正常终止。
public class Test
{
public static void main(String[] args)
{
try {
foo();
列出了关于组合函数如何导致StackOverflowError的以下示例。
scala> val f = (x: Int) => x
f: Int => Int = <function1>
scala> val g = List.fill(100000)(f).foldLeft(f)(_ compose _)
g: Int => Int = <function1>
scala> g(42)
java.lang.StackOverflowError
正如书中所解释的那样,g是一个复合函数,它有10万个函数,每个函数都调用下一个函数。
以下代码的输出为9123:9158
import java.util.concurrent.atomic.AtomicInteger;
public class StackOverflow {
private static AtomicInteger atomicInteger = new AtomicInteger(0);
private static int staticInt = 0;
public static void main(String args[]) {
int atomicInt = atomicInteger.increme
我从和的答案中了解到,在可能的情况下,您的代码可能会进入一个无限循环,从而进入stackOverFlowError,但我不明白如何在这里复制相同的场景,
public class A {
private B b = new B();
@Override
public String toString() {
return "b "+b;
}
}
public class B {
private A a = new A();
@Override
public String toString() {
return "
我无法理解,为什么我的代码会使java.lang.StackOverflowError异常?谁能简单介绍一下为什么会出现java.lang.StackOverflowError异常呢?
public class BasicProg {
BasicProg b = new BasicProg();
int show() {
return (true ? null : 0);
}
public static void main(String[] args) {
BasicProg b = new BasicProg();
请帮助理解为什么下面的代码
public class HeapQn1 {
/**
* @param args
*/
public HeapQn1() {
new HeapQn1();
}
static HeapQn1 n = new HeapQn1();
public static void main(String[] args) {
}
}
结果:
java.lang.StackOverflowError
at com.rg.test.interview.HeapQn1.<init&g
这个隐式val是如何导致StackOverFlowError的?
(削减了我的原始代码,以便仍然导致错误)
object Complicit {
// a class with name, default, and conversion function as implicit val
case class CC[A](name: String, defaultValue: A)(implicit val convert: String => A) {
def getFrom(s: String): A= try {
convert(s)
} ca
我想在java中通过每当我命中StackOverflowError时返回一个thunk来实现一个trampoline。有没有关于StackOverflowError的任何保证,比如,如果在StackOverflowError之后我做的唯一一件事就是在堆上创建对象并从函数返回,那么我就会很好。
如果上面的话听起来很模糊,我已经添加了一些代码,用于以连续传递的方式以尾递归方式计算偶数/奇数,每当堆栈溢出时返回一个延迟的thunk。代码可以在我的机器上运行,但是Java能保证它一直运行吗?
public class CPS {
public static class Thunk {
fina
今天,当我开始eclipse时,它给了我以下错误:
org.eclipse.jst.jsp.core.internal.parser.JSPSourceParser:
input could not be parsed correctly at position 150449
java.lang.StackOverflowError
然后它显示了另一个错误。
An internal error occurred during:
"JSP Index Manager: Processing Resource Events".
java.lang.StackOverflowEr
在使用sbt (Version0.14)编译过程中,有以下具有大量参数(150个)的case类会导致java.lang.StackOverflowError异常:
类别定义:
case class TestClass(Param1:String,Param2:String,Param3:String,...,Param150:String)
sbt编译期间的异常:
[info] Compiling 1 Scala source to C:\spark-2.2.0-bin-hadoop2.7\ImportSyncPuffDataApp\target\scala-2.11\classes...
j
我们能找到包含自身为hashcode的list的element吗?
我知道这是一个糟糕的做法,但这是面试官的要求。
当我运行以下代码时,它会抛出一个StackOverflowError
public class Main {
public static void main(String args[]) {
ArrayList<ArrayList> a = new ArrayList();
a.add(a);
a.hashCode();
}
}
现在我有两个问题:
为什么会有StackOverflowError
在观察StackOverflowError时如何检索完整的调用堆栈?
考虑一下这个简单的例子:
public class Overflow {
public Overflow() {
new Overflow();
}
public static void a() {
new Overflow();
}
public static void main(String[] argv) {
a();
}
}
现在报告的错误是:
Exception in thread "main" jav
我有一个Grails项目,我目前正在使用Jenkins和Grails插件构建该项目。有时它似乎会在启动Grails时抛出一个StackOverflowError。它似乎并不总是这样,如果我重启Jenkins web应用程序,这个错误就会消失。
错误是
Exception: java.lang.StackOverflowError thrown from the UncaughtExceptionHandler in thread "main"
Build step 'Build With Grails' marked build as failure
我能做些什
我在Clojure中定义了以下函数。
; return the input unchanged
(defn same [x] x)
; Recursively call the function on the input N times
(defn recurse-n-times [input function n]
(if (= n 0)
input
(recurse-n-times (function input) function (- n 1))
)
)
下面是递归函数的一些输出:
(recurse-n-times 0 inc 5) ; returns
那么,让我们说:
public class Sample { //main() class
public static void main(String[] args) {
A a = new A();
}
}
public class A {
A aa = new A();
}
So...when,我运行它,...it给出: java.lang.StackOverflowError。因此,我的解释是在第1行生成对象a,然后在2...and行创建对象aa生成,然后进入递归.它不断地创建一个又一个对象,直到堆内存满为止。
如果对象是在Heap...th
我有以下代码,它符合良好。在运行时,它会在线程"main“java.lang.StackOverflowError中给出异常。原因可能是递归对象创建。但我的问题是,在这种情况下,我们应该得到OutOfMemory错误。那么为什么我们要使用StackOverflowError呢?
public class MainClass {
MainClass m = new MainClass();
public static void main(String a[]) throws Exception {
MainClass mc = new MainClass(