小编swc*_*wch的帖子

我想知道方法引用和功能接口的所有这些东西如何在较低级别上工作.最简单的例子是我们有一些List

List<String> list = new ArrayList<>();
list.add("b");
list.add("a");
list.add("c"):

现在我们想用Collections类对它进行排序,所以我们可以调用:

Collections.sort(list, String::compareToIgnoreCase);

但是,如果我们定义自定义比较器,它可能是这样的:

Comparator<String> customComp = new MyCustomOrderComparator<>();
Collections.sort(list, customComp::compare);

问题是Collections.sort有两个参数:List和Comparator.由于Comparator是功能接口,因此可以使用具有相同签名(参数和返回类型)的lambda表达式或方法引用替换它.那么它是如何工作的,我们也可以传递compareTo只引用一个参数并且这些方法的签名不匹配？如何在Java8中翻译方法引用？

我尝试在我的应用程序中使用n4j,但我有大日志文件的问题.它们是必要的还是有某种方法可以减少它们的数量和大小？

目前我看到的文件如下:

nioneo_logical.log.v0

nioneo_logical.log.v1

nioneo_logical.log.v2

等等,每个约26MB(超过50%的neo4j文件夹).

我找不到任何示例或文章,当我们使用Spring Boot + Jenkins时,连续交付管道是怎样的.

在Java EE中,我通常这样做:

• 将更改推送到存储库
• 詹金斯每5分钟检查一次更改
• 如果有变化,Jenkins会拉动源并运行maven build
• 使用wildfly maven插件我在服务器上运行redeploy

一般来说,当我使用Spring Boot时,我想知道在最后一点该做什么.应用程序打包到单个JAR中并在单独的进程中运行,因此在Spring Boot中实际上没有像重新部署那样的东西.我是否必须首先编写一些脚本来杀死旧进程,然后运行新工件？或者也许有类似"spring boot cli"的东西,我可以管理所有正在运行的spring boot应用程序？

我有 Spring Data 的简单代码示例：

实体

@Entity
@Table(name = "car")
public class Car {

    @Id
    @GeneratedValue
    private Long id;

    private String name;
//...
}

存储库：

@Repository
public interface CarRepository extends JpaRepository<Car, Long> {
}

服务与示例方法：

@Service
public class CarService {

    @Autowired
    private CarRepository carRepository;

    public void change() {
        Car one = carRepository.findOne(1L);
        one.setName("changed"); //important
    }
}

和控制器：

@RestController("/")
public class CarController {

    @Autowired
    private CarRepository carRepository;

    @Autowired
    private CarService carService;

    @GetMapping
    public List<Car> home() {
        carService.change();
        List<Car> all = carRepository.findAll();

        return …

我试图从我的应用程序(在CSS中)完全删除ListView边框,但没有任何作用.

FXML中有结构,如:HBox> AnchorPane> ListView

我试着申请:

-fx-border-width: 0px;

to .hbox,.anchorpane(应用于节点的类),.list-view和.list-cell但看起来listview中还有更多内容仍然有边框.如何完全删除它？

编辑:问题解决了.它是由默认-fx-padding引起的:1px;

我想知道为什么 Java 中的浮点数在初始化为文字时可以表示精确的值，但是当它们表示某些计算的结果时它们是近似值。例如：

double num1 = 0.3;
double num2 = 0.1 + 0.2;
System.out.println(num1);
System.out.println(num2);

为什么结果是：

0.3
0.30000000000000004

并不是：

0.30000000000000004
0.30000000000000004

当没有 0.3 的精确二进制表示时。我知道 BigDecimal 类，但我不太了解这种原始数字不一致。

我有两个具有@OneToOne关系的实体：

@Entity
public class User implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id_user")
    private Long id;

    @OneToOne(cascade = CascadeType.MERGE, orphanRemoval=true)
    @JoinColumn(name = "id_details")
    private UserDetails details;
//...username, password, email
}

@Entity
public class UserDetails implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id_user_details")
    private Long id;
//...firstname, lastname, address
}

首先，我用UserDetails保存User：

public class Main {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("pu");
        EntityManager em = emf.createEntityManager();

        em.getTransaction().begin();
        UserDetails details = new UserDetails("John", "Doe", "NYC …

JPQL中的示例查询如下所示:

SELECT c FROM Customer c;

我读了JPA规范,书籍,我找不到这个c的含义.在SQL中我们简单地写:

SELECT * FROM customer;

我知道我们可以将此c用作别名,即在WHERE子句中,如下所示:

SELECT c FROM Customer c WHERE c.name = ...

但我仍然不明白这个c究竟是什么,如何调用它(别名？对象？)以及为什么它必须在SELECT之后而不是*.

tl;dr 注入到 servlet 的 CDI bean 怎么可能也在适当的范围内？

在 oracle 官方教程和一些书籍中，我们可以看到一些简单的例子，展示了如何将 CDI bean 注入 servlet。这非常简单，因为我们只需要使用@Inject注释并在 beans.xml 中启用 bean 发现。我不明白的是，注入到 servlet的@RequestScoped 或 @SessionScoped bean怎么可能具有正确的范围。servlet 对象仅由容器创建一次，因此据我所知，注入也应该只发生一次，或者应该发生一些意外行为。但是当我们使用 ie. @RequestScoped 在 bean 类上，注入发生在对这个 servlet 的每个请求之后（很棒）。问题是它是如何深入工作的？

简单的例子

public interface BeanInterface {
    public void beanInfo();
}

——

@RequestScoped
public class BeanImpl implements BeanInterface {
    @Override
    public void beanInfo() {
        System.out.println(this);
    }
}

——

@WebServlet("/bean")
public class BeanServlet extends HttpServlet {
    //how is it injected with every GET/POST/... request
    @Inject
    private BeanInterface bean;

    protected void …

假设我有一些形状，例如：

Shape s1 = new Rectangle(10, 10);
Shape s2 = new Circle(10);

等等。我想在画布上绘制它们。在 Swing 中，可以通过 Graphics2D.draw(Shape shape) 方法，但我在 JavaFX GraphicsContext 中看不到等效项。JavaFX 中有这样的东西吗？

当我们有两个类时：

class Foo {
    void foo() {
        System.out.println("foo");
    }
}

和：

class Bar extends Foo{
    void bar() {
        System.out.println("bar");
    }
}

Bar clazz 对象是否在 vtable 中存储对 foo() 和 bar() 方法的引用，或者仅在 Bar 的 vtable 中存储对 bar() 方法的引用并访问 foo() 方法 jvm 访问 Bar clazz 对象，然后访问 Foo clazz 对象，然后在其 vtable 中找到 foo() 方法？是不是更像这样： 或者那个： 或者也许这没有在规范中描述并且可以依赖于 JVM 实现？

我理解静态是什么,但我找不到信息如何通过对象引用静态字段.

让我们假设我们有两个类:

class Foo {
    static int statValue = 10;
}

class Bar {
    public static void main(String[] args) {
        Foo foo1 = new Foo();
        int valFromObject = foo1.statValue;

        int valFromClass = Foo.statValue;
    }
}

当我们运行这个程序时,我们在堆上有一个对象(foo1),在metaspace中有两个类(简化).

当我们通过类访问静态字段时:

int valFromClass = Foo.statValue;

这很简单,因为我假设我们在元空间中引用了类对象.但是如何通过对象访问静态成员？当我们写:

int valFromObject = foo1.statValue;

是实际涉及的Foo实例还是被绕过的

foo1.statValue;
Foo.statValue

是同义词？