Java 内部类中布尔标志的final数组而不是非final变量的模式

当我需要在内部类中设置布尔标志时，我的Java代码中经常出现这样的情况。不可能使用原始布尔类型，因为内部类只能处理来自外部的最终变量，所以我使用如下模式：

// class from gnu.trove is not of big importance, just to have an example
private final TIntIntHashMap team = new TIntIntHashMap();
// ....... code ............
final boolean[] flag = new boolean[]{false};
team.forEachValue(new TIntProcedure() {
    @Override
    public boolean execute(int score) {
        if(score >= VICTORY_SCORE) {
            flag[0] = true;
        } 
        return true; // to continue iteration over hash map values
    }
});
//  ....... code ..............

---

final数组而不是非final变量的模式工作得很好，只是在我看来不够漂亮。有人知道Java中更好的模式吗？

在某些情况下，这是最好的模式

---

我能建议的唯一改进是，当您找到匹配项时，返回false。

在某些情况下，这是最好的模式

---

我能建议的唯一改进是，当您找到匹配项时，返回false。

使用一个包含任何类型对象的泛型holder类怎么样。在您的情况下，它可以保存

布尔类型。比如：

class Holder<T> {        
    private T genericObj;

    public Holder(T genericObj) {
        this.genericObj = genericObj;
    }

    public T getGenericObj() {
        return genericObj;
    }

    public void setGenericObj(T genericObj) {
        this.genericObj = genericObj;
    }    
}

abstract class TIntProcedureWithValue<T> implements TIntProcedure {
    private T accumulator;
    public T getValue() {return accumulator;}
}

类持有者{
私人T genericObj；
公共持有人（T genericObj）{
this.genericObj=genericObj；
}
公共T getGenericObj（）{
返回genericObj；
}
公共无效setGenericObj（T genericObj）{
this.genericObj=genericObj；
}    
}

并将其用作：

public class Test {
    public static void main(String[] args) throws Exception {        
        final Holder<Boolean> boolHolder = new Holder<Boolean>(Boolean.TRUE);
        new Runnable() {            
            @Override
            public void run() {
                boolHolder.setGenericObj(Boolean.FALSE);
            }
        };
    }
}

公共类测试{
公共静态void main（字符串[]args）引发异常{
最终持有者boolHolder=新持有者（Boolean.TRUE）；
新的Runnable（）{
@凌驾
公开募捐{
boolHolder.setGenericObj（Boolean.FALSE）；
}
};
}
}

当然，在线程间共享的可变对象中会出现一些常见的问题，但您已经明白了这一点。另外，对于内存需求很紧的应用程序，如果您有很多这样的方法调用，那么在进行优化时可能会忽略这一点。另外，使用
AtomicReference
交换/设置引用时应该注意多线程的使用，尽管跨线程使用它仍然有点可疑。
拥有一个包含任何类型对象的泛型holder类怎么样。在您的情况下，它可以保存
布尔类型。比如：

class Holder<T> {        
    private T genericObj;

    public Holder(T genericObj) {
        this.genericObj = genericObj;
    }

    public T getGenericObj() {
        return genericObj;
    }

    public void setGenericObj(T genericObj) {
        this.genericObj = genericObj;
    }    
}

abstract class TIntProcedureWithValue<T> implements TIntProcedure {
    private T accumulator;
    public T getValue() {return accumulator;}
}

类持有者{
私人T genericObj；
公共持有人（T genericObj）{
this.genericObj=genericObj；
}
公共T getGenericObj（）{
返回genericObj；
}
公共无效setGenericObj（T genericObj）{
this.genericObj=genericObj；
}    
}

并将其用作：

public class Test {
    public static void main(String[] args) throws Exception {        
        final Holder<Boolean> boolHolder = new Holder<Boolean>(Boolean.TRUE);
        new Runnable() {            
            @Override
            public void run() {
                boolHolder.setGenericObj(Boolean.FALSE);
            }
        };
    }
}

公共类测试{
公共静态void main（字符串[]args）引发异常{
最终持有者boolHolder=新持有者（Boolean.TRUE）；
新的Runnable（）{
@凌驾
公开募捐{
boolHolder.setGenericObj（Boolean.FALSE）；
}
};
}
}

当然，在线程间共享的可变对象中会出现一些常见的问题，但您已经明白了这一点。另外，对于内存需求很紧的应用程序，如果您有很多这样的方法调用，那么在进行优化时可能会忽略这一点。另外，使用
AtomicReference
交换/设置引用时应注意多线程的使用，尽管跨线程使用它仍然有点可疑。
一个问题是，TIntIntHashMap没有方法，因此必须使用foreach模拟它。您可以尝试编写自己的类，通过添加reduce方法来扩展TIntIntHashMap

另一种解决方案是仅扩展TIntProcedure以获得一个值。比如：

class Holder<T> {        
    private T genericObj;

    public Holder(T genericObj) {
        this.genericObj = genericObj;
    }

    public T getGenericObj() {
        return genericObj;
    }

    public void setGenericObj(T genericObj) {
        this.genericObj = genericObj;
    }    
}

abstract class TIntProcedureWithValue<T> implements TIntProcedure {
    private T accumulator;
    public T getValue() {return accumulator;}
}

抽象类TIntProcedureWithValue实现了TIntProcedure{
私人T型蓄能器；
公共T getValue（）{返回累加器；}
}

然后，您可以将该类的实例传递给foreach，设置内部累加器而不是外部标志数组，然后获取结果值。
一个问题是TIntIntHashMap没有方法，因此您必须使用foreach对其进行模拟。您可以尝试编写自己的类，通过添加reduce方法来扩展TIntIntHashMap

另一种解决方案是仅扩展TIntProcedure以获得一个值。比如：

class Holder<T> {        
    private T genericObj;

    public Holder(T genericObj) {
        this.genericObj = genericObj;
    }

    public T getGenericObj() {
        return genericObj;
    }

    public void setGenericObj(T genericObj) {
        this.genericObj = genericObj;
    }    
}

abstract class TIntProcedureWithValue<T> implements TIntProcedure {
    private T accumulator;
    public T getValue() {return accumulator;}
}

抽象类TIntProcedureWithValue实现了TIntProcedure{
私人T型蓄能器；
公共T getValue（）{返回累加器；}
}

然后，您可以将该类的一个实例传递给foreach，设置内部累加器而不是外部标志数组，然后获取结果值。
可能是这样的吗？（实现或扩展…不幸的是，我不知道什么是程序）：

也许是那样的？（实现或扩展…不幸的是，我不知道什么是程序）：

使用

关于这个问题，这里有一个流行的StackOverflow问题：
使用

关于这个问题，这里有一个流行的StackOverflow问题：
我不熟悉gnu.trove，但一般来说，“algortim”函数最好更具体一些，在这里留下更少的代码

private final IntIntHashMap team = new IntIntHashMap();

boolean found = team.value().containsMatch(new IntPredicate() {
    public boolean is(int score) {
        return score >= VICTORY_SCORE;
    }
});

（Java SE 8中应该有更简洁的语法。）
我不熟悉gnu.trove，但一般来说，“algortim”函数最好更具体，这里的代码更少

private final IntIntHashMap team = new IntIntHashMap();

boolean found = team.value().containsMatch(new IntPredicate() {
    public boolean is(int score) {
        return score >= VICTORY_SCORE;
    }
});

（Java SE 8中应该提供更简洁的语法。）
您可以使用现有方法或编写更适合您的用例的方法，而不是使用非常通用的
forEachValue
。当然，您可以让它非常通用，比如
exists（迭代器it，谓词p）
或
count（迭代器it，谓词p）
。我认为函数式方法而不是命令式方法会更简洁，在Java中尝试使用FP构造相当长的时间后，我终于放弃了。它只是不能提高可读性、正确性或任何其他可取的东西