小编i_a*_*ero的帖子

我是Java新手,我真的很困惑iterator和iterable.任何人都可以向我解释并举一些例子吗？

我想知道是否有一种快速/干净的方法来获得两组之间的对称差异？

我有:

Set<String> s1 = new HashSet<String>();
s1.add("a");
s1.add("b");
s1.add("c");

Set<String> s2 = new HashSet<String>();
s2.add("b");

我需要这样的东西:

Set<String> diff = Something.diff(s1, s2);
// diff would contain ["a", "c"]

只是为了澄清我需要对称差异.

我正在阅读有关无国籍状态的文章并在文档中遇到过这个问题:

如果流操作的行为参数是有状态的,则流管道结果可能是不确定的或不正确的.有状态lambda(或实现适当功能接口的其他对象)的结果取决于在流管道执行期间可能发生变化的任何状态.

现在,如果我有一个字符串列表(strList比如说),然后尝试使用并行流从中删除重复的字符串,方法如下:

List<String> resultOne = strList.parallelStream().distinct().collect(Collectors.toList());

或者如果我们想要不区分大小写:

List<String> result2 = strList.parallelStream().map(String::toLowerCase)
                       .distinct().collect(Collectors.toList());

此代码是否有任何问题,因为并行流将分割输入并且在一个块中不同并不一定意味着在整个输入中是不同的？

编辑(以下答案的快速摘要)

这distinct是有状态操作,并且在有状态中间操作的情况下,并行流可能需要多次通过或大量缓冲开销.distinct如果元素的排序不相关,也可以更有效地实现.另外根据文件:

对于有序流,不同元素的选择是稳定的(对于重复元素,保留在遇到顺序中首先出现的元素.)对于无序流,不进行稳定性保证.

但是在有序流并行运行的情况下,不同可能是不稳定的 - 意味着它将在重复的情况下保留任意元素,而不一定是distinct其他情况下预期的第一个元素.

从链接:

在内部,distinct()操作保持一个包含先前已经看到的元素的Set,但它隐藏在操作中,我们无法从应用程序代码中获取它.

因此,在并行流的情况下,它可能会消耗整个流,或者可能使用CHM(类似于ConcurrentHashMap.newKeySet()).对于有序的,很可能是使用LinkedHashSet或类似的结构.

我很难理解何时使用：

while (left < right ) {
}

vs 何时使用：

while (left <= right ) {
}

此外，在设置左右边界时，有时我们会使用：

left = mid 

有时我们使用

left = mid + 1;

相似地

right = mid; vs
right = mid - 1;

我在二分搜索知识中是否缺少任何基础知识？

在Java 8之前,AtomicLong类中CAS的代码是:

public final long incrementAndGet() {
    for (;;) {
        long current = get();
        long next = current + 1;
        if (compareAndSet(current, next))
          return next;
    }
}

但现在它已被改为单一内在线:

public final long incrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}

这段代码比前者有什么优势？这个新代码如何工作？

我在下面有一个类,想要删除包含相同名称的重复者,如何使用Java8 Lambda,预期List包含p1,p3,如下所示.

人:

public class Person {

public int id;
public String name;
public String city;

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getCity() {
    return city;
}

public void setCity(String city) {
    this.city = city;
}

}

测试:

import java.util.ArrayList;
import java.util.List;

public class Testing {

public static void main(String[] args) { …

我需要数据库设计专家提出一些建议.

1. 我有大约六个外键到一个表(缺陷),它都指向用户表中的主键.它像是:

   defect (.....,assigned_to,created_by,updated_by,closed_by...)
   

   Run Code Online (Sandbox Code Playgroud)

   如果我想获得有关缺陷的信息,我可以进行六次连接.我们有更好的方法吗？

2. 另一个是我有一个states表可以存储一个用户定义的值.我有缺陷表和任务表,我希望这两个表共享公共状态表(New,In Progress等).所以我创建了:

   • task (.....,state_id,imp_id,.....)
   • defect(.....,state_id,imp_id,...)
   • state(state_id,state_name,...)
   • importance(imp_id,imp_name,...)

有许多这样的共同属性以及状态如重要性(正常,紧急等),优先级等.对于所有这些,我想使用相同的表.我在每个表中保留一个标志以区分任务和缺陷.在这种情况下,最佳解决方案是什么？

如果有人在健康域中使用此应用程序,他们希望为其缺陷或任务分配不同的类型,状态,重要性.此外,当用户选择任何项目时,我想在配置参数部分下显示所有类型,状态等.

我正在运行java8应用程序,它看起来像一旦主线程退出,进程就会退出.

我正在使用completableFuture来启动异步任务,如下所示

CompletableFuture cf = CompletableFuture.supplyAsync(() -> task.call());

        cf.thenRunAsync(() -> {
            try {
                System.out.println(Thread.currentThread());
                System.out.println((Double)cf.get() * 4.0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

我希望async将作为一个单独的线程运行,因此主线程退出不应该导致进程退出,但事实并非如此.

我猜异步作业是作为deamon线程运行的吗？但无法确认.