标签: lambdaj

在我的应用程序架构中,我通常通过服务层将对象或对象列表从数据访问层发送到Web层,其中这些对象从DAO对象转换为DTO对象,反之亦然.Web层对DAO对象没有任何访问权限,DAO层不使用DTO.

为了演示,我通常将代码编写为:

@Transactional(readOnly = true)
public List<UserDTO> getAllUserAsUserDTO() {
    List<UserDTO> userDTOs = new ArrayList<UserDTO>();

    for(User user : getAllUser()) {
        userDTOs.add(constructUserDTO(user));
    }

    return userDTOs;
}

private UserDTO constructUserDTO(User user) {
    UserDTO userDTO = new UserDTO();
    userDTO.setFullName(user.getFullName());
    userDTO.setId(user.getId());
    userDTO.setUsername(user.getUsername());
    userDTO.setRole(user.getRole());
    userDTO.setActive(user.isActive());
    userDTO.setActiveText(user.isActive() ? "Active" : "Inactive");
    return userDTO;
}

这里用户是数据库实体:

@javax.persistence.Entity
@Table(name = "USER")
public class User extends Entity {

    @Transient
    private static final long serialVersionUID = -112950002831333869L;

    private String username;
    private String fullName;
    private boolean active;
    private …

我有一个对象列表,我需要转换为一个映射,其中键是每个元素的函数,值是每个元素的另一个函数的列表.实际上,这是通过它们的功能对元素进行分组.

例如,假设一个简单的元素类:

class Element {
    int f1() { ... }
    String f2() { ... }
}

以及这些的清单:

[
    { f1=100, f2="Alice" },
    { f1=200, f2="Bob" },
    { f1=100, f2="Charles" },
    { f1=300, f2="Dave" }
]

那我想要一张地图如下:

{
    {key=100, value=[ "Alice", "Charles" ]},
    {key=200, value=[ "Bob" ]},
    {key=300, value=[ "Dave" ]}
}

任何人都可以建议一种简洁的方式在Java中执行此操作而不进行迭代吗？LambdaJ的group方法与Guava的组合Maps.transform几乎可以实现,但group不生成地图.

有没有人试图在android开发中使用lambdaj库？

当我创建一个简单的小型Java应用程序时,它对我来说很好,但我无法在Android应用程序中使用它.

更新:

我正在添加lambdaj(lambdaj-2.3.2-with-dependencies.jar,从http://code.google.com/p/lambdaj下载),然后在构建我的应用程序时出现以下错误:

Dx warning: Ignoring InnerClasses attribute for an anonymous inner class
(org.hamcrest.generator.qdox.directorywalker.DirectoryScanner$1) that doesn't come with an
associated EnclosingMethod attribute. This class was probably produced by a
compiler that did not target the modern .class file format. The recommended
solution is to recompile the class from source, using an up-to-date compiler
and without specifying any "-target" type options. The consequence of ignoring
this warning is that reflective operations on this class will incorrectly
indicate that …

我们在配置lambdaj以使用Joda Time时遇到问题.由于LocalDate是最终的类,Lambdaj需要初始化如下:( 参见bug 70)

public class LocalDateArgumentCreator implements FinalClassArgumentCreator<LocalDate> {
    private final long MSECS_IN_DAY = 1000L * 60L * 60L * 24L;
    public LocalDate createArgumentPlaceHolder(int seed) {
        return new LocalDate((long)seed * MSECS_IN_DAY);
    }
}
ArgumentsFactory.registerFinalClassArgumentCreator(LocalDate.class, new LocalDateArgumentCreator());

由于我们需要在几乎所有地方应用此配置,因此我们缺乏如何实现此配置的选项.我们的应用程序是基于Spring和Wicket的Web应用程序.

我提出了三种不同的选择:

1.核心maven模块中的静态初始化块

由于核心模块包含在每个其他模块中,因此所有模块都包含该类.剩下的问题是,即使没有对目标类的引用,静态块总是会被初始化吗？

例

public final class LambdajInitializer {
    static {
        // initialize like above
    }
}

2.初始化bean applicationContext.xml

缺点:从未对非Spring测试进行初始化

示例:在applicationContext-core.xml中(包含在每个模块中)

<bean class="...LambdajInitializer" />

public class LambdajInitializer {
    @PostConstruct
    public void init() {
        // Lambdaj initialization
    } …

我最近从C#转到Java [再次].但是我非常想念lambda表达式以及像C#的IEnumerable.Foreach这样的东西.所以我在Java中寻找一个lambda表达式库.

有没有比LambdaJ更好的库？

在Java程序中也可以直接使用clojure吗？那我可以在Java函数中混合使用clojure代码吗？

我想在Java中压缩任意深度嵌套的某些类型T元素的集合/结构,最好用

• 只有实时视图而不是复制的集合;
• 不仅处理集合,而且还有Iterator,任意维度的T数组,Iterable,以及任意混合和嵌套的所有这些结构;
• 静态类型安全.

有没有一个可以处理这个的java库？

番石榴似乎只处理一个嵌套级别,即Collection<Collection<T>>--flatten - > Collection<T>.

lambdaj看起来很有希望:我可以以某种方式结合on(),asIterator()并flattenIterator()实现这一目标吗？以静态类型安全的方式？

我正在寻找替代方法以类型安全的方式获取属性名称.

例如,使用lambdaj,我可以这样做:

propertyName(on(Contract.class).getContractKey())

但这有点冗长,性能也不是很好.

我希望在构建期间生成一些东西.

让我告诉你我的代码:

Foo类

public class Foo {

    String code;
    String value;

    public Foo(String code, String value) {
        super();
        this.code = code;
        this.value = value;
    }
    // getters/setters
}

主要方法(专注于getFooMultiMapCode()方法):

public class FooMain {

public static void main(String[] args) {
    Foo foo1 = new Foo("100","foo1");
    Foo foo2 = new Foo("200","foo2");
    Foo foo3 = new Foo("300","foo3");
    Foo foo4 = new Foo("100","foo4");
    Foo foo5 = new Foo("100","foo5");
    Foo foo6 = new Foo("200","foo6");
    List<Foo> foos = Arrays.asList(foo1,foo2,foo3,foo4,foo5,foo6);  
    Map<String,List<Foo>> fooCodeMap = getFooMultiMapCode(foos);
    System.out.println(fooCodeMap); …

在去年我做的Java集成项目中,我发现了lambdaj,并且很快就能够让我更快地生成更易读的代码.我记得在那段时间里读到关于lambda表达式的1.8,并认为我找到了一个已经为我带来了所有功能的插件.

现在我正在重新审视lambda表达式,看看我可能在lambdaj的目的和范围上犯了错误.我现在看到它的方式,lambdaj并不真正提供lambda表达式,而是一种特定于域的语言,旨在替换集合上的重复循环.它的DSL语法看起来类似于匿名函数,并提供了一些相同的功能,如闭包和curried函数,但最终它受到JLS的限制.

我现在想知道1.8的lambda表达式可以为lambdaj不能的Java项目带来什么.是否只是通过本机支持匿名功能来提高性能？类似于lambdaj的集合操作函数的表达式是否会出现在1.8中？或者1.8中的lambda表达式对我来说是创建我自己的匿名函数.在这种情况下,是否应该为1.8创建一个特定版本的lambdaj,使用真正的匿名函数重新创建函数库？

我是Java 8新功能的新手,这可能是一个愚蠢的问题,但我仍然坚持这一点.

我试图在eclipse中运行以下代码,但它给出了编译时错误.

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;
import ch.lambdaj.Lambda;

public class LambdajTest {

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add(1);
        list.add(3);
        list.add(8);
        list.add(10);
        list.add(16);

        int sum = list.stream().filter(p -> p > 10).mapToInt(p -> p).sum();
    }

}

错误是: - p无法解析为变量.我在classpath中添加了lambdaj 2.3.3 jar.

请提供解决方案.提前致谢.