相关疑难解决方法(0)

如果你有一个java.io.InputStream对象,你应该如何处理该对象并产生一个String？

假设我有一个InputStream包含文本数据,并且我想将其转换为a String,所以例如我可以将其写入日志文件.

采取InputStream并将其转换为最简单的方法是String什么？

public String convertStreamToString(InputStream is) {
    // ???
}

以下Java程序平均需要在0.50到0.55之间运行:

public static void main(String[] args) {
    long startTime = System.nanoTime();
    int n = 0;
    for (int i = 0; i < 1000000000; i++) {
        n += 2 * (i * i);
    }
    System.out.println((double) (System.nanoTime() - startTime) / 1000000000 + " s");
    System.out.println("n = " + n);
}

如果我更换2 * (i * i)用2 * i * i,它需要0.60〜0.65s之间运行.怎么会？

我运行了每个版本的程序15次,在两者之间交替.结果如下:

 2*(i*i)  |  2*i*i
----------+----------
0.5183738 | 0.6246434
0.5298337 | 0.6049722
0.5308647 | 0.6603363
0.5133458 | 0.6243328
0.5003011 | …

如何获得方法的执行时间？是否有Timer实用程序类用于计算任务需要多长时间等等？

Google上的大多数搜索会返回计划线程和任务的计时器的结果,这不是我想要的.

有时java困惑我.
我有大量的int初始化.

什么是真正的差异？

1. Integer.toString(i)
2. new Integer(i).toString()

我正在用Java编写一些代码,在某些时候,程序的流程是由两个int变量"a"和"b"是否为非零来确定的(注意:a和b从不是负数,并且从不在整数溢出范围内).

我可以评估它

if (a != 0 && b != 0) { /* Some code */ }

或者

if (a*b != 0) { /* Some code */ }

因为我希望每段代码运行数百万次,所以我想知道哪一段会更快.我通过在一个巨大的随机生成的数组上进行比较来做实验,我也很想知道数组的稀疏性(数据的分数= 0)会如何影响结果:

long time;
final int len = 50000000;
int arbitrary = 0;
int[][] nums = new int[2][len];

for (double fraction = 0 ; fraction <= 0.9 ; fraction += 0.0078125) {
    for(int i = 0 ; i < 2 ; i++) {
        for(int j = 0 ; j < len ; j++) …

在Java中,当实际上没有错误时使用throw/catch作为逻辑的一部分通常是一个坏主意(部分)因为抛出和捕获异常是昂贵的,并且在循环中多次执行它通常比其他更慢控制结构,不涉及抛出异常.

我的问题是,抛出/捕获本身或创建Exception对象时产生的成本(因为它获得了很多运行时信息,包括执行堆栈)？

换句话说,如果我这样做

Exception e = new Exception();

但是不要扔它,是投掷的大部分成本,还是投掷+捕获处理成本高昂？

我不是在将代码放入try/catch块中是否会增加执行代码的成本,我问的是,捕获Exception是否是昂贵的部分,或者创建(调用构造函数)Exception是否是昂贵的部分.

另一种问这个问题的方法是,如果我创建了一个Exception实例并且一遍又一遍地抛出它,那么每次抛出时创建一个新的Exception会明快得多吗？

在Java中,使用的性能和资源含义是什么

System.currentTimeMillis() 

与

new Date() 

与

Calendar.getInstance().getTime()

据我了解,System.currentTimeMillis()是最有效的.但是,在大多数应用程序中,需要将该长值转换为Date或某些类似对象,以对人类执行任何有意义的操作.

我目前正在开发一个性能非常关键的程序,我决定探索的一条路径可能有助于减少资源消耗,增加了我的工作线程的堆栈大小,因此我可以移动float[]我将要访问的大部分数据堆栈(使用stackalloc).

我已经读过一个线程的默认堆栈大小是1 MB,所以为了移动我所有的float[]s,我必须将堆栈扩展大约50倍(到50 MB~).

我知道这通常被认为是"不安全的"并且不推荐,但在对我的当前代码进行基准测试后,我发现处理速度提高了530%!因此,我不能简单地通过这个选项而不进一步调查,这导致我的问题; 将堆叠增加到如此大的尺寸(可能出现什么问题)有什么危险,我应该采取什么预防措施来减少这种危险？

我的测试代码,

public static unsafe void TestMethod1()
{
    float* samples = stackalloc float[12500000];

    for (var ii = 0; ii < 12500000; ii++)
    {
        samples[ii] = 32768;
    }
}

public static void TestMethod2()
{
    var samples = new float[12500000];

    for (var i = 0; i < 12500000; i++)
    {
        samples[i] = 32768;
    }
}

我们必须一直为日志输出构建字符串等等.在JDK版本中,我们学会了何时使用StringBuffer(许多追加,线程安全)和StringBuilder(许多追加,非线程安全).

有什么建议使用String.format()？它是否有效,或者我们是否被迫坚持连接性能很重要的单线？

例如丑陋的旧式,

String s = "What do you get if you multiply " + varSix + " by " + varNine + "?";

与整洁的新风格(可能很慢),

String s = String.format("What do you get if you multiply %d by %d?", varSix, varNine);

注意:我的具体用例是我的代码中的数百个"单行"日志字符串.它们不涉及循环,所以StringBuilder太重量级了.我String.format()特别感兴趣.

我们知道捕获异常是昂贵的.但是,即使从未抛出异常,在Java中使用try-catch块也是昂贵的吗？

我发现Stack Overflow问题/答案为什么尝试块昂贵？,但它适用于.NET.