小编big*_*zer的帖子

下面讨论如何使用lambdas将方法作为参数传递:
Java Pass Method as Parameter

在其他语言中,即C++,可以使用Lambdas将函数绑定到它的参数 - 这里讨论:
Bind Vs Lambda？

在Java中,是否可以使用lambdas绑定方法？

如果是这样,你会如何做到这一点？

编辑>>>>

根据要求,我通常尝试做的一个例子:

请注意,这里有伪代码.

public class DataView {

    private static ArrayList<Float> rectData = new ArrayList<Float>();
    private static ArrayList<Float> textData = new ArrayList<Float>();

    DataView(){

        //Pseudo Code:
        boundFunction mybind  = boundFunction(functionA, 5, 10);
        boundFunction mybind2 = boundFunction(functionB, 10, 12);

        iter(mybind);
        iter(mybind2);

    }

    //Method with pseudo parameter
    private void iter(functionSignature){
        for(Float i : textData){

            //Pseudo call to pseudo parameter
            functionSignature();

        }
    }

    private void functionA(int a, int b){ …

我正在使用JBox2D编写Java程序.我需要找到两个纹理之间的确切碰撞点,如果它们碰撞的话.

我有代码来确定是否发生了碰撞,并且显然可以调用碰撞对象ID来确定哪些纹理发生碰撞.

我似乎无法弄清楚如何抓住碰撞本身的实际坐标.我阅读了文档,但它非常复杂,并没有直接解决这个问题.

这是我的代码:

import org.jbox2d.callbacks.ContactImpulse;
import org.jbox2d.callbacks.ContactListener;
import org.jbox2d.collision.Manifold;
import org.jbox2d.common.Vec2;
import org.jbox2d.dynamics.Fixture;
import org.jbox2d.dynamics.contacts.Contact;


public class MyContactListener implements ContactListener{


    //When they start to collide
    public void beginContact(Contact c) {

    System.out.println("CONTACT");

    Fixture fa = c.getFixtureA();
    Fixture fb = c.getFixtureB();

    Vec2 posA = fa.getBody().getPosition();
    Vec2 posB = fb.getBody().getPosition();



}

public void endContact(Contact c) {

}

public void preSolve(Contact c, Manifold m) {}

public void postSolve(Contact c, ContactImpulse ci){}

}

我正在使用C++进行面向对象编程的课程.

在我们的文中它说,

如果我们不声明复制构造函数,编译器会插入实现浅复制的代码.如果我们不声明赋值运算符,则编译器会插入实现浅赋值的代码.

我想知道的是,这实际上是否真实,实际调用了编译器机制的内容,以及它是如何工作的.

这不是关于复制构造函数的问题,而是关于编译器行为.

编辑>更多背景

按文本定义复制构造函数:

复制构造函数的定义包含逻辑

1. 在所有非资源实例变量上执行浅拷贝
2. 为每个新资源分配内存
3. 将数据从源资源复制到新创建的资源

资源由文本定义

对象在运行时分配的内存表示该对象类的资源.

管理此资源需要额外的逻辑,这对于不访问资源的简单类来说是不必要的.这种额外的逻辑确保了对资源的正确处理,通常称为深度复制和分配.

我正在用Java编写辅助学习算法.

我遇到了一个我可以解决的数学问题,但由于处理过程很重,我需要一个最佳解决方案.

话虽这么说,如果有人知道一个非常棒的优化库,但语言是Java所以需要考虑.

这个想法很简单:

对象将存储变量的组合,例如ABDC,ACDE,DE,AE.

组合的最大数量将取决于我可以在不减慢程序速度的情况下运行的数量,因此理论上可以说100.

决策过程将每次迭代生成一个随机变量.如果生成的变量是其中一个组合的一部分,例如.'A'是ABDC和ACDE的一部分,而不是C和B(或存储的组合中的任何后续字母)的倾向将增加.

为了使事情更加清晰,我们假设'A','B','C','D'和'E'是唯一可能的变量.事实是,会有更多像12或14,但这个最大值还取决于我可以处理多少没有滞后.

由于有五个可能的变量,它将为第一次迭代生成加权1/5随机滚动.如果该滚动结果为'A',则在下一次迭代中'B'和'C'现在将具有2/5倾向而不是1/5.

如果下一次迭代产生'B','D'倾向将增加到3/5.注意:关系是指数关系; 实际上,它不会是1/5,而是像10%那样略微提升,如果它达到序列中的第4个变量,它将滚雪球说50%.

现在,在Java中,我可以通过跟踪每个对象的所有存储组合来实现此功能.我在想通过在每次迭代中以小步骤分配跟踪过程,它不应该太慢.

另一种解决方案是绘制所有可能的组合及其潜在的倾向.这当然只需要一个搜索功能,但也会在计算所有可能性和存储在某个地方时出现问题,可能在文件中.

有人建议我应该使用Markov模型和/或库,尽管我对这种类型的数学并不太熟悉.

如何在Java中快速计算此过程？
.

示例>>>

只有一个序列ABC.

对于三个数字,机会开始相等所以它看起来像兰特(1,3)

如果A是结果,我们增加B的可能性,因为它是序列中的下一个字母.让我们说它加倍.

所以现在机会是:A = 1/4,C = 1/4,B = 2/4

该函数现在看起来像rand(1,4),其中3和4的结果都代表选项B.

如果下一个结果是B,我们希望增加C的可能性,因为它是序列中的下一个字符,但是它是上次增加的两倍(指数)

机会现在类似于:A = 1/6,C = 1/6,B = 4/6

该函数现在为rand(1/6),其中值3,4,5,6表示C.

据我所知,内存池是一个块,或者在运行时在堆栈上分配多个内存块.
相比之下,根据我的理解,从操作系统请求动态内存,然后在运行时分配在堆上.

//编辑//

• 内存池显然不一定在堆栈上分配即.内存池可以与动态内存一起使用.
• 非动态内存显然也未必分配在栈上,按了这个问题的答案.
• 因此,"动态与静态内存"和"内存池"的主题并不真正相关,尽管答案仍然相关.

据我所知,内存池的目的是提供RAM的手动管理,其中内存必须由程序员跟踪和重用.

出于多种原因,这在理论上对性能有利:

1. 随着时间的推移,动态内存变得支离
2. CPU可以比动态块更快地解析静态内存块
3. 当程序员控制内存时,根据具体程序,他们可以选择在最好的情况下释放和重建数据.

4.多线程时,单独的池允许单独的线程独立运行而无需等待共享堆(Davislor)

我对内存池的理解是否正确？如果是这样,为什么看起来内存池不经常使用？

这个问题特别适用于数组。

在许多语言中，我会这样做：

    #This is in python for simplicity:

    def increment(mylist):
        for i in mylist:
            i += 1;
            
        return mylist
    

    mylist = {0,1,2,3}
    mylist = increment(mylist)

我尝试了几种在 C 中返回数组的方法，但没有一个像上面那样工作。看起来 C 根本就不打算以这种方式工作。相反，我必须这样做：

#include <stdio.h>

increment(int *myarray, int size) {
    for(int i = 0; i < size; i++){
        myarray[i] += 1;
        
    }
}

int main(){
    int myarray[4] = {0,1,2,3};
    increment(myarray, 4);

}

不用说，C 函数会更改数组的状态，因此是一个副作用函数。有充分的理由避免这种情况（这不是这个问题的主题）。

C 有没有办法避免这些类型的副作用？

我需要创建一个接受双'参数'的运算符.

myClass myobject();

double mydouble = 10000;

mydouble += myobject;

我的运营商:

double operator+=(double value, const myclass& object)
{
    value += object.value;           
    return  value;
}

即使mydouble初始化为10000,参数值也会传递给operator + = 0.

如何创建一个可以接受左操作数作为参数的运算符？

我遇到了一个有趣的错误,我很确定它与条件语句的上下文中的包含多态性有关.

该示例的亮点如下:

   ClassParent *parentPointer; //Declare pointer to parent

   if(condition){
       ClassChild1   = mychild; //Declare child1 object
       parentPointer = *mychild;//Parent pointer points to child
   }

   if(!condition){
       ClassChild2   = mychild; //Declare child2
       parentPointer = *mychild;//Parent pointer points to child2  
   }

   cout << *parentPointer; //What will this point to???

应该清楚,条件语句在最后一行中生成*parentPointer变量.

我的整个函数看起来像这样:(注意崩溃的地方)

    void PosApp::addItem(bool isPerishable) {
        Item *refitem;

        if (isPerishable) {
            Perishable myitem;
            std::cout   << "Enter the following: "  << std::endl
                        << "Sku: "                  << std::endl
                        << "Name:"                  << std::endl
                        << "Price: "                << std::endl …