小编new*_*cct的帖子

我想知道以下两个方法声明之间的区别是什么:

public Object doSomething(Object obj) {....}

public <T> T doSomething(T t) {....}

有什么东西可以/可以用一个而不是另一个吗？我在本网站的其他地方找不到这个问题.

我正面临一个似乎没有直接解决方案的问题.

我正在使用java.util.Map,我想更新键值对中的值.

现在,我正在这样做:

private Map<String,int> table = new HashMap<String,int>();
public void update(String key, int val) {
    if( !table.containsKey(key) ) return;
    Entry<String,int> entry;
    for( entry : table.entrySet() ) {
        if( entry.getKey().equals(key) ) {
            entry.setValue(val);
            break;
        }
    }
}

那么有没有任何方法,以便我可以获得所需的Entry对象,而不必遍历整个Map？或者有没有办法更新条目的价值？在一些方法Map一样setValue(String key, int val)？

JRH

我有这样的方法:

public static <T> boolean isMemberOf(T item, T[] set)
{
    for (T t : set) {
        if (t.equals(item)) {
            return true;
        }
    }
    return false;
}

现在我尝试使用charfor 调用此方法T:

char ch = 'a';
char[] chars = new char[] { 'a', 'b', 'c' };
boolean member = isMemberOf(ch, chars);

这不起作用.我期望char,并char[]得到autoboxed至Character和Character[],但是这似乎并没有发生.

任何见解？

我似乎只能在C#而不是Java中找到如何做到这一点.

我有一个,List<TypeX>但我知道该列表中的每个元素实际上都是TypeXCalled 的子类TypeY.

如何编写接受List<TypeX>并返回的Lambda表达式List<TypeY>？

我的意思是定义一个类型类的实例,它应用于函数的本地(let或where)范围.更重要的是,我希望在这个实例中的函数是闭包,即能够关闭定义实例的词法范围中的变量(这意味着实例在下次调用它的函数时可能会有不同的工作方式).

我可以为您提供一个简化的用例.假设我有一个基于类型类操作的函数.在这个例子中,我使用平方,它可以在任何类型的实例上运行Num(是的,平方非常简单,可以很容易地重新实现,但它代表的是一些可能更复杂的东西).我需要能够按原样使用现有功能(无需更改或重新实现).

square :: Num a => a -> a
square x = x * x

现在,假设我希望在模运算中使用此操作,即加法,乘法等等.这对于任何固定的模数基都很容易实现,但是我希望有一些通用的东西,我可以为不同的模数基重复使用.我希望能够定义这样的东西:

newtype ModN = ModN Integer deriving (Eq, Show)

-- computes (x * x) mod n
squareModN :: 
squareModN x n =
  let instance Num ModN where
    ModN x * ModN y = ModN ((x * y) `mod` n) -- modular multiplication
    _ + _ = undefined         -- the rest are unimplemented for simplicity
    negate _ = undefined …

std::function<int()> void f1()
{
    int a, b, c, d, ..., x, y, z;

    return [=] { return a + b + c; };
}

与

std::function<int()> void f2()
{
    int a, b, c, d, ..., x, y, z;

    return [a, b, c] { return a + b + c; };
}

毋庸置疑,前者比后者更短,更方便,更优雅.

但是,我仍然担心:

从性能的角度来看,后者总是优于前者吗？

标准是否保证lambda表达式仅捕获必要的变量？即,在前一示例中,仅捕获a,b,c,未使用的变量d,...,x,y,z不是.

我见过lambda函数,参数为*x.它是一种放入列表或元组的方式,如果它是一个元组,你如何将列表作为参数参数,反之亦然.

如果你能把我链接到一些文档,我将不胜感激.

有问题的lambda函数:

import os
add_to_place = lambda *x : os.path.abspath(os.path.join(os.path.dirname(__file__), *x))

提前致谢.我推断它是一个元组,但我想要一些文档,只是为了确定.

如果我有以下对象:

@interface Simple : NSObject

@end

@interface Complex : Simple

@end

另一个对象如:

@interface Test : NSObject 

+(void) doSomething:(void (^)(Simple*)) obj;

@end

如果我调用这样的方法,一切都有效:

[Test doSomething:^(Simple * obj) {

}];

当我尝试改为称之为:

[Test doSomething:^(Complex * obj) {

}];

编译器说:

Incompatible block pointer types sending 'void (^)(Complex *__strong)' to parameter of type 'void (^)(Simple *__strong)'

因为Complex扩展Simple,我认为这会起作用,就像在Java中一样.

有办法以某种方式实现这一目标吗？

我正在开发一个使用dojo的网页,并且有一个项目小部件的数字(在我的测试用例中为6,但一般是变量).我正在调用dojo.addOnLoad(ini​​t),在我的init()函数中我有这些行:

dojo.connect(dijit.byId("project" + 0).InputNode, "onChange",  function() {makeMatch(0);});
dojo.connect(dijit.byId("project" + 1).InputNode, "onChange",  function() {makeMatch(1);});
dojo.connect(dijit.byId("project" + 2).InputNode, "onChange",  function() {makeMatch(2);});
dojo.connect(dijit.byId("project" + 3).InputNode, "onChange",  function() {makeMatch(3);});
dojo.connect(dijit.byId("project" + 4).InputNode, "onChange",  function() {makeMatch(4);});
dojo.connect(dijit.byId("project" + 5).InputNode, "onChange",  function() {makeMatch(5);});

并为我的项目小部件更改事件正确调用makeMatch函数.但如果我用循环替换它们:

for (var i = 0; i < 6; i++) 
    dojo.connect(dijit.byId("project" + i).InputNode, "onChange",  function() {makeMatch(i);});

相同的makeMatch()函数,相同的init()调用,以及其他所有内容 - 只是将我的调用滚动到循环中 - 从不调用makeMatch函数; 对象没有连线.

发生了什么,我该如何解决？我尝试过使用dojo.query,但其行为与for循环案例相同.

我一直在使用块一段时间,但我觉得在ARC和非ARC环境中都有一些我想念的内存管理.我觉得更深刻的理解会让我失去许多内存泄漏.

AFNetworking是我在特定应用程序中主要使用Blocks.大多数情况下,在操作的完成处理程序中,我执行类似"[self.myArray addObject]"的操作.

在ARC和非ARC启用的环境中,根据Apple的这篇文章,将保留"self" .

这意味着每当调用AFNetworking网络操作的完成块时,self将保留在该块内,并在该块超出范围时释放.我相信这适用于ARC和非ARC.我已经运行了泄漏工具和静态分析器,以便我可以发现任何内存泄漏.没有显示任何.

然而,直到最近,我偶然发现了一个我无法弄清楚的警告.我在这个特定的例子中使用ARC.

我有两个实例变量,表明网络操作的完成和失败

@property (nonatomic, readwrite, copy) SFCompletionBlock completionBlock;
@property (nonatomic, readwrite, copy) SFFailureBlock failureBlock;
@synthesize failureBlock = _failureBlock;
@synthesize operation = _operation;

在代码的某处,我这样做:

[self.operation setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id
                                                    responseObject) {
NSError *error = [NSError errorWithDomain:@"com.test" code:100 userInfo:@{@"description": @"zero results"}];
            _failureBlock(error);
        } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
            NSLog(@"nothing");
        }];

.Xcode的抱怨调用failureBlock线,以"捕获'自我’强烈该块的消息很可能导致保留周期,我相信Xcode是正确的:不良区保留自我,自我拥有自己的副本块,所以两者都不会被解除分配.

但是,我有以下问题/意见.

1)如果我将_failureBlock(错误)更改为"self.failureBlock(error)"(不带引号),编译器将停止抱怨.这是为什么？这是编译器错过的内存泄漏吗？

2)通常,在使用作为实例变量的块时,在ARC和非ARC启用的环境中使用块的最佳实践是什么？似乎在AFNetworking中的完成和故障块的情况下,这两个块不是实例变量,因此它们可能不属于我上面描述的保留周期类别.但是当将进度块用于AFNetworking时,可以采取哪些措施来避免像上面那样的保留周期？

我很想听听其他人对ARC和非ARC的看法,包括带有内存管理的块和问题/解决方案.我发现这些情况容易出错,我觉得有必要对此进行一些讨论以便清理.

我不知道它是否重要,但我使用Xcode 4.4和最新的LLVM.