有人告诉我,我误解了final.的影响.final关键字有什么影响？

以下简要概述了我的想法,我知道:

Java final修饰符(又称聚合关系)

原始变量:只能设置一次.(内存和性能增益)
对象变量:可以修改,最终适用于对象引用.
字段:只能设置一次.
方法:不能被覆盖,隐藏.
课程:不能扩展.
垃圾收集:将强制Java世代垃圾收集标记扫描双扫.

Can's和Cant's

• 可以使克隆失败(这既好又坏)
• 可以使不可变的原语aka const
• 可以使空白不可变 - 在创建时初始化也称为readonly
• 可以使对象浅不可变
• 可以使范围/可见性不可变
• 可以使方法调用开销更小(因为它不需要虚拟表)
• 可以使方法参数用作final(即使你不是)
• 可以使对象线程安全(如果对象被定义为final,它不会使方法参数最终)
• 可以进行模拟测试(不是你可以对它做任何事情 - 你可以说错误是有意的)
• 不能交朋友(与其他朋友互相变化,休息不变)
• 以后不能将变为不可变的变量(但可以像工厂模式一样修复)
• 无法使数组元素成为不可变的,也是不可变的
• 无法创建对象的新实例(这既好又坏)
• 无法进行序列化工作

没有替代品final,但有包装+私人和枚举.

在开始写这个问题之前,我试图解决以下问题

// 1. navigate to page
// 2. wait until page is downloaded
// 3. read and write some data from/to iframe 
// 4. submit (post) form

问题是,如果网页上存在iframe,则DocumentCompleted事件将被触发多次(在每个文档完成之后).程序很可能试图从DOM中读取未完成且自然失败的数据.

但突然写下这个问题'如果'怪物启发了我,我解决了问题,我试图解决.由于我没有谷歌这个,我觉得在这里发布它会很好.

    private int iframe_counter = 1; // needs to be 1, to pass DCF test
    public bool isLazyMan = default(bool);

    /// <summary>
    /// LOCK to stop inspecting DOM before DCF
    /// </summary>
    public void waitPolice() {
        while (isLazyMan) Application.DoEvents();
    }

    private void webBrowser1_Navigating(object sender, WebBrowserNavigatingEventArgs e) {
        if(!e.TargetFrameName.Equals(""))
            iframe_counter --; …

我不喜欢自动格式弄乱空循环体,如:

之前

for (int i = 0; isTest(i); i++); 

后

for (int i = 0; isTest(i); i++)
    ;

如何配置eclipse不要这样做？

我想存档:

Map2[f,{a,b,c,d}]
{f[a,b], f[b,c], f[c,d]}

但出于某种原因,我只能想到迭代方法.

什么是功能方式？

编辑:

使用这个,就是生成图表示例.如果给出了数字列表,则下面生成它意味着什么的图表,以顺序访问所有节点.

例如:

Map2 = # @@@ Partition[#2, 2, 1] &;
MG[elems_] := Graph[Map2[DirectedEdge, elems]]
nrs = RandomInteger[{1, 15}, 20]
MG[nrs]

{} 10,13,9,7,13,3,5,1,15,10,15,6,14,3,1,2,11,4,8,5

径向布局:

什么时候使用是个好主意AtomicReferenceArray？请举例说明.

我知道默认情况下Java没有所谓的eval(我称之为"邪恶")方法.这听起来像是一件坏事 - 知道你没有其他许多人做的事情.但更糟糕的是,似乎被告知你无法拥有它.

我的问题是:背后有什么可靠的推理？我的意思是,谷歌这个只会返回大量的旧数据和虚假的原因 - 即使有一个我正在寻找的答案,我也无法从那些只是抛出通用标签词的人那里过滤掉它.

我对那些告诉我如何解决问题的答案不感兴趣; 我自己可以这样做:

使用Bean Scripting Framework(BSF)

文件sample.py(py文件夹中)内容:

def factorial(n): 
    return reduce(lambda x, y:x * y, range(1, n + 1))

和Java代码:

ScriptEngine engine = new ScriptEngineManager().getEngineByName("jython");
engine.eval(new FileReader("py" + java.io.File.separator + "sample.py"));
System.out.println(engine.eval("factorial(932)"));

使用像JLink这样的设计桥梁

这相当于:

String expr = "N[Integrate[E^(2 y^5)/(2 x^3), {x, 4, 7}, {y, 2, 3}]]";
System.out.println(MM.Eval(expr));
//Output: 1.5187560850359461*^206 + 4.2210685420287355*^190*I

其他方法

• 使用Dijkstras shunting-yard算法或类似的,并从头开始编写表达式求值程序.
• 使用复杂的正则表达式和字符串操作与委托和HashMultimaps.
• 使用Java表达式库
• 使用Java表达式语言
• 使用类似JRE的脚本语言,如BeanShell.
• 使用Java Assembler和下面的方法或直接字节码操作,如Javaassist.
• 使用Java Compiler API和思考.
• Runtime.getRuntime().exec以root身份使用

我开始使用随Eclipse一起提供的Ant.令我很恼火的是,我得到了数百条警告:

[javac]警告:java\io\BufferedInputStream.class(java\io:BufferedInputStream.class):主要版本51比50更新,这是该编译器支持的最高主要版本.
[javac]建议升级编译器.

如何升级编译器？

可以说我有物品

items : [{id:1,...}, {id:2,...}, {id:3,...}]

并命令:[ 2,3,1 ]得到一个可枚举的

items : [{id:2,...}, {id:3,...}, {id:1,...}]

我希望它能成为符合标准的东西

items.Select(o => new {key = ordering[i++], value = o})
     .OrderBy(k => k.key)
     .Select(o => o.value)

但有更清洁的解决方案吗？

以下我已经确认了这项工作(HimBromBeere,Domysee,qxg)

var expectedOrder = ordering.Select(x => result.First(o => o.Id == x));
var expectedOrder = result.OrderBy(item => Array.FindIndex(ordering,i => i == item.Id));
var expectedOrder = result.OrderBy(item => ordering.ToList().FindIndex(i => i == item.Id));
var expectedOrder = 
  from o in ordering
  join i in result 
    on o equals i.Id
  select …

以下显然有效,但我不喜欢在Tuple中包装项目,

    ImmutableMap<String, Function<Tuple2<Double>, Double>> op = new //
    ImmutableMap.Builder<String, Function<Tuple2<Double>, Double>>()
            .put("+", new Function<Tuple2<Double>, Double>() {
                @Override public Double apply(Tuple2<Double> data) {
                    return data.Val_1 + data.Val_2;
                }
            }).build();
    System.out.println(op.get("+").apply(new Tuple2<Double>(3d, 4d)));

我想写一些类似的东西:

    ImmutableMap<String, Function<Double[], Double>> op = new //
    ImmutableMap.Builder<String, Function<Double[], Double>>()
            .put("+", new Function<Double[], Double>() {
                @Override
                public Double apply(Double... data) {
                    return data[0] + data[1];
                }
            }).build();
    System.out.println(op.get("+").apply(3d, 4d));

ty是最有用的帮助.

编辑:问题解决了,开始使用:

public interface T2Function<T> {
    T apply(T Val_1, T Val_2);
}

之前没有这样做过,所以显然我很沮丧.这里,当前鼠标位置周围的64个像素在表单上绘制得更大.问题是,它有点'缓慢',我不知道从哪里开始修复.

除此之外,我创建了一个线程,它在完成后不断调用更新图形,并且像文本一样点fps,以显示事物的绘制速度.

图像示例:(图像来自Eclipse中的字母'a')

代码示例:

@SuppressWarnings("serial")
public static class AwtZoom extends Frame {
    private BufferedImage image;
    private long timeRef = new Date().getTime();
    Robot robot = null;

    public AwtZoom() {
        super("Image zoom");
        setLocation(new Point(640, 0));
        setSize(400, 400);
        setVisible(true);
        final Ticker t = new Ticker();

        this.image = (BufferedImage) (this.createImage(320, 330));
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                t.done();
                dispose();
            }
        });
        try {
            robot = new Robot();
        } catch (AWTException e) {
            e.printStackTrace();
        }
        t.start();
    }

    private class Ticker extends Thread { …