标签: java-8

我可以看到闭包的一些好处,例如它们如何在简化现有库和使未来设计更容易和更高效方面占有一席之地.

但是,提案草案(http://www.javac.info/consensus-closures-jsr.html)中提到的一个要点是第2.5节,即e点:

(规范将改进语言)

e)使未来的API设计能够取代扩展Java平台的语言设计.

我很难看到这是怎么回事,语言设计肯定就是 - 语言本身的设计,除非Java使用闭包修改语言打开各种奇怪的API,否则不能被API取代(我非常怀疑会发生这种情况.)

任何人都可以对此有所了解,并且可能提供一些事先需要语言更改的例子,但是,通过添加闭包,不再需要一个？

我在Clojure中使用了许多库,它们生成符合" clojure.lang.IFn "接口的更高阶函数.

它有多个arity重载,即接口看起来像:

public interface IFn extends Callable, Runnable{
  public Object invoke() ;
  public Object invoke(Object arg1) ;
  public Object invoke(Object arg1, Object arg2) ;
  public Object invoke(Object arg1, Object arg2, Object arg3) ;
  .... etc.
  public Object applyTo(ISeq arglist) ;
}

我能否在Java 8中直接使用这种类型的对象作为可调用的lambda函数？

我正在阅读Java 8的功能,我看到它们有方法引用,但我没有看到如何在方法重载时指定哪个方法.有人知道吗？

我正在玩FilteredList他们已经添加到JDK8中的课程,感觉要快得多 - 似乎让性能更接近GlazedLists.但是,当我使用a FilteredList而不是a 时,表列排序似乎根本不起作用ObservableList.

控制台中没有异常/堆栈跟踪.

以下是我的控制器中的实例成员:

    private ObservableList<Film> masterData = FXCollections.observableArrayList();
    private FilteredList<Film> filteredData;

我的控制器init:

@FXML
void initialize() {
   ...   
   filmTable.setItems(filteredData);
   ...
}

构造函数:

public FilmBrowserController() {

   ...
   masterData.addAll(filmRepository.findAllSortedByTitle());
   filteredData = new FilteredList<>(masterData);
   filteredData.setPredicate(film -> true);
}

我一直在通过在更改过滤器TextField时设置新谓词来过滤列表:

filteredData.setPredicate(film ->
     film.getTitle().toLowerCase().contains(filterField.getText().toLowerCase()));

我对JavaFX还很绿 - 我错过了一些非常基本的东西,或者这可能是一个bug？我正在使用下载的JDK 8:https://jdk8.java.net/download.html Build b100.

是否不可能有一个可以过滤但同时按列排序的表？

编辑:

修改了我在stackoverflow上找到的另一个javaFX表示例,我添加了这一行(74):

table.setItems(table.getItems().filtered(p -> p.getFirstName().startsWith("a")));

完整来源:

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.*; …

特定 doSomething(Function foo) { println foo(2) }

Groovy的: doSomething( { it*it } as Function )

Java的: doSomething( (x) -> x*x )

这两者有什么区别吗？

使用新Java 8打印文件中所有行的最优选和简洁方法是什么？

输出必须是文件的副本,行的行如下:

[Line 1 ...]
[Line 2 ...]

问题涉及带有lambdas的Java-8,即使在旧版本中有这样的方法.展示Java-8的全部内容!

我正在尝试通过(映射)进行分组,然后将值列表转换为不同的列表.

我有DistrictDocuments列表:

List<DistrictDocument> docs = new ArrayList<>();

然后我在它上面流式传输并按城市分组:

Map<String, List<DistrictDocument>> collect = docs.stream()
                .collect(Collectors.groupingBy(DistrictDocument::getCity));

我还有一个方法,它采用了DistrictDocument并从中创建了Slugable:

private Fizz createFizz(DistrictDocument doc) {
    return new Fizz().name(doc.getName()).fizz(doc.getFizz());
}

有没有办法将该方法放入我的流中,所以我得到了Map<String, List<Fizz>>？我尝试将第二个参数添加到groupingBy但是找不到合适的方法并且总是遇到编译错误.

编辑:如果我的createFizz返回List<Fizz>怎么办？是否可以选择在Collectors.mapping中平展此列表,因为我仍然想要Map<String, List<Fizz>>而不是Map<String, List<List<Fizz>>>

我有一个长期运行的计算,我需要执行一长串输入.计算是独立的,所以我想将它们分配给几个CPU.我使用的是Java 8.

代码的框架如下所示:

ExecutorService executorService = Executors.newFixedThreadPool(numThreads);

MyService myService = new MyService(executorService);

List<MyResult> results =
            myInputList.stream()
                     .map(myService::getResultFuture)
                     .map(CompletableFuture::join)
                     .collect(Collectors.toList());

executorService.shutdown();

负责计算的主要功能如下:

CompletableFuture<MyResult> getResultFuture(MyInput input) {
    return CompletableFuture.supplyAsync(() -> longCalc(input), executor)))
}

长时间运行的计算是无状态的,并且不执行任何IO.

我希望这段代码能够使用所有可用的CPU,但它不会发生.例如,在具有72个CPU和numThreads=72(或甚至例如numThreads=500)的机器上,CPU使用率最多为500-1000%,如htop所示:

根据线程转储,许多计算线程都在等待,即:

"pool-1-thread-34" #55 prio=5 os_prio=0 tid=0x00007fe858597890 nid=0xd66 waiting on condition [0x00007fe7f9cdd000]
   java.lang.Thread.State: WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x0000000381815f20> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
    at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
    at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
    - …

将代码直接传递给线程vs使用CompletableFuture的优势是什么？

Thread thread = new Thread(() -> {do something});
thread.start();

VS

CompletableFuture<Void> cf1 =  
     CompletableFuture.runAsync(() -> {do something}); 

我在编写算法时遇到问题,以帮助我扫描文件系统并查找某个类的所有子类.

细节:

我有一个应用程序扫描外部应用程序时使用nio Files.walk()检索我检查"扩展SuperClass",同时读取文件,如果单词退出,我在列表中添加类名称,如下所示:

List<String> subclasses = new ArrayList<>();
Files.walk(appPath)
     .filter(p->Files.isRegularFile(p) && p.toString()
     .endsWith(".java")).forEach(path -> {
        try {
         List<String> lines = Files.readAllLines(path);
         Pattern pattern = Pattern.compile("\\bextends SuperClass\\b");
         Matcher matcher = pattern
                           .matcher(lines.stream()
                                 .collect(Collectors.joining(" ")));
         boolean isChild = matcher.find();
         if(isChild) subclasses.add(path.getFileName().toString());
        }catch (IOException e){
                //handle IOE
        }

上面的问题是它只获得直接的子类,SuperClass但我需要检索所有直接和间接的子类.我想到递归,因为我不知道有多少子类,SuperClass但我无法实现任何合理的实现.

笔记:

• 扫描超过600,000个文件
• 我不知道有多少直接/间接子类SuperClass有
• 我正在扫描的应用程序是外部的,我不能修改它的代码所以我只能通过读取文件访问它并查看extends存在的位置
• 如果问题的非递归解决方案很好,但如果没有其他办法,我会非常乐意接受递归的解决方案,因为我更关心解决方案而不是性能.

编辑:

我使用以下正则表达式比较名称和导入,以确保即使在相同名称的情况下不同的包输出是正确的:

Pattern pattern = Pattern.compile("("+superClasss.getPackage()+")[\\s\\S]*(\\bextends "+superClass.getName()+"\\b)[\\s\\S]");

我也尝试过:

Pattern pattern = Pattern.compile("\\bextends "+superClass.getName()+"\\b");

但是也有一些缺少的子类,我相信下面的代码会跳过一些检查,并且不能完全发挥作用:

public static List<SuperClass> getAllSubClasses(Path …