相关疑难解决方法(0)

NoClassDefFoundError当我运行我的Java应用程序时,我得到了一个.这通常是什么原因？

我在这个问题上看到了这个引用:什么是构建Web服务的好函数语言？

特别是Scala不支持尾调用消除,除了自递归函数,这限制了你可以做的组合种类(这是JVM的一个基本限制).

这是真的？如果是这样,那么创建这个基本限制的JVM是什么呢？

出于教育目的,我想使用Java-8创建素数流.这是我的方法.x如果没有不超过的主要除数,则该数字为素数sqrt(x).所以假设我已经有一个素数流我可以使用以下谓词来检查:

x -> Seq.seq(primes()).limitWhile(p -> p <= Math.sqrt(x)).allMatch(p -> x % p != 0)

在这里,我使用jOOλ库(0.9.10,如果重要的话)仅用于limitWhile标准Stream API中不存在的操作.所以现在知道一些先前的素数prev我可以生成下一个素数迭代数字,直到找到与该谓词匹配的那个:

prev -> LongStream.iterate(prev + 1, i -> i + 1)
                  .filter(x -> Seq.seq(primes()).limitWhile(p -> p <= Math.sqrt(x))
                                                .allMatch(p -> x % p != 0))
                  .findFirst()
                  .getAsLong()

把所有东西放在一起我写了以下primes()方法:

public static LongStream primes() {
    return LongStream.iterate(2L, 
            prev -> LongStream.iterate(prev + 1, i -> i + 1)
                              .filter(x -> Seq.seq(primes())
                                              .limitWhile(p -> p <= Math.sqrt(x)) …

我是java的新手.我在regex strHindiText中得到java Stack overflow Exception.我该怎么办？

try {
     // This regex convert the pattern "{\fldrslt {\fcs1 \ab\af24 \fcs0 ऩ}{"
     // into "{\fldrslt {\fcs1 \ab\af24 \fcs0 ऩ}}}{"
     // strHindiText = strHindiText.replaceAll("\\{(\\\\fldrslt[ ])\\{((\\\\\\S+[ ])+)((\\s*&#\\d+;\\s*(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*)+)\\}\\{","{$1{$2$4}}}{");

     // This regex convert the pattern "{\fcs0 \af0 &#2345;{ or {\fcs0 \af0 *\tab &#2345;{" 
     // into "{\fcs0 \af0 &#2345; }{"
     strHindiText = strHindiText.replaceAll("\\{\\s*((\\\\\\S+[ ](\\*)?)+\\s*)(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*[ ]*(((&#\\d+;)[ ]*(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*[ ]*)+)\\{", "{$1 $4$5 }{");

     // This regex convert the pattern "{&#2345; \fcs0 \af0 {" 
     // into "{&#2345; \fcs0 \af0 }{"
     strHindiText = strHindiText.replaceAll("\\{\\s*(((&#\\d+;)[ …

这是我的计划的背景.

一个函数有50%的机会什么都不做,50%自称两次.该计划完成的概率是多少？

我写了这段代码,显然效果很好.对每个人来说可能并不明显的答案是,该计划有100%的机会完成.但是当我运行这个程序时,会出现一个StackOverflowError(有多方便;)),在Math.Random()中出现.有人能指出我从哪里来,并告诉我,如果我的代码可能是错的？

static int bestDepth =0;
static int numberOfPrograms =0;
@Test
public void testProba(){
   for(int i = 0; i <1000; i++){
       long time = System.currentTimeMillis();
       bestDepth = 0;
       numberOfPrograms = 0;
       loop(0);
       LOGGER.info("Best depth:"+ bestDepth +" in "+(System.currentTimeMillis()-time)+"ms");
   }
}

public boolean loop(int depth){
    numberOfPrograms++;
    if(depth> bestDepth){
        bestDepth = depth;
    }
    if(proba()){
        return true;
    }
    else{
        return loop(depth + 1) && loop(depth + 1);
    }
}

public boolean proba(){
    return Math.random()>0.5;
}

.

java.lang.StackOverflowError
at java.util.Random.nextDouble(Random.java:394)
at java.lang.Math.random(Math.java:695)

.我怀疑堆栈及其中的功能数量是有限的,但我真的没有看到这里的问题. …

据Oracle称,StackOverflowError是:

在发生堆栈溢出时抛出,因为应用程序过于严重.

我知道递归是什么,通常递归函数,如果没有正确终止,会导致StackOverflowError.为了检查StackOverflowError抛出之前发生的递归调用的数量,我写了这段代码:

package ErrorCases;

public class StackOverFlowError {
static int i=0;
void a()
{

    //System.out.println("called "+(++i));
    try{
        ++i;
    a();
    }catch(Error e)
    {
        System.out.println(e.getClass());
        System.out.println(i);
    }
}

public static void main(String[] args) {

       new StackOverFlowError().a();

   }

}

在JVM抛出StackOverflowError之前,i给出递归调用计数的值a().每次运行
的价值i都不同,如:

output 1: class java.lang.StackOverflowError
           10466
Output 2: class java.lang.StackOverflowError
           10470

我的疑问是？

1. 在JVM抛出之前递归有多深 StackOverflowError？

2. 一旦StackOverflowError投掷,我们可以恢复吗？

我们从Java的序列化库中获取StackOverflowErrors.问题是默认的序列化实现是递归的,其深度仅受通过引用网络的最长路径的限制.

我们意识到我们可以覆盖默认方法,但是我们在项目中有数百个连接丰富的类,所以我们对覆盖方法并不热衷.如果存在非递归的通用解决方案(或者至少将递归从堆栈移动到堆),我们会更感兴趣.

我搜索了这个话题,发现只有很多人痛苦地抱怨同样的事情,但大多数这些抱怨来自很多年前.情况有所改善吗？如果没有,我们写一个通用的实现,你有什么建议吗？我们假设有一些原因(对我们来说还不明显)为什么没有人破解这个坚果.从理论上讲,做"正确"听起来应该是可行的.

我理解单一责任原则的重要性,但从技术上讲,我们对每个java方法中的局部变量(存储在堆栈帧中)的数量有任何上限.并且上限是否等于最大堆栈大小,即,我可以使用大小等于配置的最大堆栈大小的堆栈帧吗？

我目前正在用Java编写快速排序算法来对随机的整数数组进行排序,然后使用System.nanoTime()对它们进行计时.这些数组的大小是10的幂,从10 ^ 3开始到10 ^ 7结束.此外,随机列表具有不同的属性.我正在整理纯粹的随机列表,列表中包含一些相同的值(很少),反向排序列表,排序列表和几乎排序的列表.

排序有效.它在数组上递归执行快速排序,直到它需要排序30个元素或更少的数组,在这种情况下,它执行插入排序.

一切都很好10 ^ 3和10 ^ 4但是一旦我达到10 ^ 5的值,它只会对随机,几个独特和随机列表进行排序,但在排序几乎排序和排序的列表时会产生堆栈溢出错误.

我不相信问题在于生成列表的方式,因为堆栈溢出发生在排序算法中(编译器引用的行是findPivot()方法中的第一行).此外,它通常会在崩溃之前对1到6个列表进行排序.因此,必须以某种方式使算法本身与几乎排序和排序的列表进行交互.此外,反向列表的生成涉及调用用于创建排序列表的代码(然后将其反转).

另外,我觉得不太可能,这个问题仅仅是不必,因为某些原因,通过递归在近分类和排序列表显著多次调用该分区关闭阵列的部分,而不是其他列表类型的算法,如它可以对10 ^ 7值的随机列表进行排序,这将需要比具有10 ^ 5值的近似排序列表更多的分区.

我意识到它必须与这些列表类型如何与我的快速排序的递归相互作用有关,但如果有人可以阐明它会很棒.我把代码放到了完整的快速排序算法和下面的随机列表生成器中.

快速排序算法

/**
 * Performs a quick sort given the indexes of the bounds of an integer array
 * @param arr The array to be sorted
 * @param highE The index of the upper element
 * @param lowE The index of the lower element
 */
public static void quickSort(int[] arr, int highE, int lowE)
{       
    //Only perform an action if arr.length …

我在sun solaris 中托管的weblogic server 10g 中的 xml 转换中收到以下 java stackoverflow 错误。这仅发生在特定的 xml 转换中，其余所有 xml 转换都可以正常工作。使用的 xsl 文件也不是很大。

Caused by: java.lang.StackOverflowError
    at com.sun.org.apache.xalan.internal.xsltc.dom.SimpleResultTreeImpl.characters(SimpleResultTreeImpl.java)
    at com.sun.org.apache.xalan.internal.xsltc.dom.SimpleResultTreeImpl.copy(SimpleResultTreeImpl.java:438)
    at com.sun.org.apache.xalan.internal.xsltc.runtime.BasisLibrary.copy(BasisLibrary.java:1317)
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace()
    at GregorSamsa.replace() …