小编Phi*_*hil的帖子

当我们将一种类型的对象转换为另一种类型时会有任何开销吗？或者编译器只解析所有内容并且在运行时没有成本？

这是一般事情,还是有不同的情况？

例如,假设我们有一个Object []数组,其中每个元素可能有不同的类型.但我们总是知道,例如,元素0是一个Double,元素1是一个String.(我知道这是一个错误的设计,但我们假设我必须这样做.)

Java的类型信息是否仍然在运行时保留？或者编译后一切都被遗忘了,如果我们做(Double)元素[0],我们只需跟随指针并将这8个字节解释为double,不管是什么？

我不太清楚Java中的类型是如何完成的.如果您对书籍或文章有任何建议,那么也要感谢.

我遇到了这个老问题,并使用scala 2.10.3进行了以下实验.

我重写了Scala版本以使用显式尾递归:

import scala.annotation.tailrec

object ScalaMain {
  private val t = 20

  private def run() {
    var i = 10
    while(!isEvenlyDivisible(2, i, t))
      i += 2
    println(i)
  }

  @tailrec private def isEvenlyDivisible(i: Int, a: Int, b: Int): Boolean = {
    if (i > b) true
    else (a % i == 0) && isEvenlyDivisible(i+1, a, b)
  }

  def main(args: Array[String]) {
    val t1 = System.currentTimeMillis()
    var i = 0
    while (i < 20) {
      run()
      i += 1 …

我最近开始在Scala编程.我正在寻找一个免费的Scala分析器.从该语言的官方网站阅读带我到YourKit,但该程序不是免费的.

谷歌搜索"scala profiler"没有给我任何相关的结果.

那么如何描述用Scala编写的程序呢？我更喜欢Netbeans或Eclipse的图形插件.但如果没有这样的东西,那么一个控制台就可以了.

谢谢 :)

我尝试计算Ackermann(4,1),不同语言/编译器之间的性能差异很大.以下是我的Core i7 3820QM,16G,Ubuntu 12.10 64bit的结果,

C:1.6s,gcc -O3 (gcc 4.7.2)

int ack(int m, int n) {
  if (m == 0) return n+1;
  if (n == 0) return ack(m-1, 1);
  return ack(m-1, ack(m, n-1));
}

int main() {
  printf("%d\n", ack(4,1));
  return 0;
}

OCaml:3.6s,ocamlopt (与ocaml 3.12.1)

let rec ack = function
  | 0,n -> n+1
  | m,0 -> ack (m-1, 1)
  | m,n -> ack (m-1, ack (m, n-1))
in print_int (ack (4, 1)) …

我见过ApiDemos的com.example.android.apis.view.List11示例.在该示例中,每行采用视图android.R.simple_list_item_multiple_choice.每个这样的视图都有a TextView和a CheckBox.

现在我希望每个视图都有2 TextViews和1 CheckBox,有点类似于List3示例.我尝试像这样创建一个自定义布局文件row.xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
    <CheckBox
        android:id="@+id/checkbox"
        android:layout_alignParentRight="true"
        android:layout_width="wrap_content"
        android:layout_height="fill_parent" />
    <TextView
        android:id="@+id/text_name"
        android:textSize="13px"
        android:textStyle="bold"
        android:layout_toLeftOf="@id/checkbox"
        android:layout_alignParentLeft="true"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />
    <TextView
        android:id="@+id/text_phone"
        android:textSize="9px"
        android:layout_toLeftOf="@id/checkbox"
        android:layout_below="@id/text_name"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" /> 
</RelativeLayout>

然后在Activitys中onCreate(),我喜欢这样:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Query the contacts
    mCursor = getContentResolver().query(Phones.CONTENT_URI, null, null, null, null);
    startManagingCursor(mCursor);

    ListAdapter adapter = new SimpleCursorAdapter(this,
            R.layout.row,
            mCursor, 
            new …

这两种做事方式之间的效率(例如执行时间,代码大小等)是否有任何差异？

下面是创建对象并且什么也不做的人为设想的示例,但我的实际场景可能是创建新的线程,监听器等.假设以下代码片段在循环中发生,以便它可能有所作为.

使用匿名对象:

void doSomething() {
    for (/* Assume some loop */) {
        final Object obj1, obj2; // some free variables

        IWorker anonymousWorker = new IWorker() {
            doWork() {
                // do things that refer to obj1 and obj2
            }
        };
    }
}

首先定义一个类:

void doSomething() {
    for (/* Assume some loop */) {
        Object obj1, obj2;
        IWorker worker = new Worker(obj1, obj2);
    }
}

static class Worker implements IWorker {
    private Object obj1, obj2;
    public CustomObject(Object obj1, Object obj2) {/* …

因此,由于纯代码和不纯代码之间的明确分离,纯函数式语言具有自己的潜在类别.我已经看到了几个在Haskell中实现的功能,如嵌套数据并行或流融合.

我的问题是,在可行性/简单性方面但尚未实现的Haskell或多或少独特的其他改进/优化是什么？(我主要关心GHC,但也喜欢听别人的声音)

我认为像这样的表达式会导致Haskell永远评估.但GHCi和编译程序中的行为让我感到惊讶.

例如,在GHCi中,这些表达式被阻塞直到我Control+C,但没有消耗CPU.看起来好像在睡觉.

let loop = loop
let loop = 1 + loop

我尝试用GHC编译这些程序:

main = print loop
  where loop = 1 + loop

main = print loop
  where loop = if True then loop else 1

印刷的是:

Main: <<loop>>

所以我的问题是:显然这些表达式被编译成与命令式语言中的循环或递归调用不同的东西.他们编译的是什么？这是一个特殊的规则来处理自己在右手边的0-arg函数,还是一个我不知道的更普遍的特殊情况？

[编辑]:

还有一个问题:如果这恰好是编译器的特殊处理,那么在无法检查所有无限循环时执行此操作的原因是什么？"熟悉的"语言并不关心像while (true);或者这样的案例int f() { return f();},对吗？

非常感谢.

我遇到了这个问题,它比较了各种编译器在计算斐波那契数字时的表现.

我尝试用Haskell做这个,看看它与C的比较.

C代码:

#include <stdio.h>
#include <stdlib.h>

int fib (int n) {
  if (n < 2) return 1;
  return fib (n-1) + fib (n-2);
}

int main (int argc, char* argv[]) {
  printf ("%i\n", fib (atoi(argv[1])));
  return 0;
}

结果:

> gcc -O3 main.c -o fib
> time ./fib 40
165580141
real    0m0.421s
user    0m0.420s
sys 0m0.000s

哈斯克尔:

module Main where
import System.Environment (getArgs)

fib :: Int -> Int
fib n | n < 2 = 1
      | …

我想知道是否有一个地图的实现是:

• 不可变,因此我可以在函数式编程中使用它,并毫不费力地确保事务和并发.
• 快.我已经检查了二进制搜索树(RB,AVL)和Tries,但它们似乎都没有哈希表那么快.是否有支持更新和检索的固定时间的地图实现？(或至少非常快的对数时间)

简而言之,是否存在可以与Hash Maps进行性能比较的功能数据结构？