小编kou*_*sen的帖子

IDEA文档中有一个关于如何在PyCharm中添加Python解释器的教程,其中涉及访问"Project Interpreter"页面.即使在安装Python插件之后,我也没有看到任何设置.

我错过了一些明显的东西吗

在对JavaDoc中findFirst说,如果流有一个邂逅的命令,那么第一个元素总是会返回,但如果流没有遭遇订单,可以返回的任何元素.

我试图演示它如何在没有遭遇顺序的流上工作,但我不能让它返回除了实际的第一个元素之外的任何东西.

我尝试将元素添加到a Set,它没有定义的遭遇顺序:

    Set<String> words = new HashSet<>();
    words.addAll(Arrays.asList("this", "is", "a", "stream", "of", "strings"));
    Optional<String> firstString = words.stream()
            .findFirst();
    System.out.println(firstString);

每次我跑,我得到a第一个字符串.然后我试图做一个Collections.shuffle关于List它添加到之前Set,但这并没有改变任何东西.

    List<String> wordList = Arrays.asList("this", "is", "a", "stream", "of", "strings");
    words = new HashSet<>();
    words.addAll(wordList);
    firstString = words.stream()
            .findFirst();
    System.out.println(firstString);

我a每次都会回复这个词.

然后我尝试使用unorderedfrom方法BaseStream,声称返回没有遇到顺序的流,但没有区别:

    firstString = Stream.of("this", "is", "a", "stream", "of", "strings")
            .unordered()
            .findFirst();
    System.out.println(firstString);

现在我this每次都得到这个词.我错过了什么吗？有没有办法证明findFirst在无序流上返回不同的值？

我有两张桌子,乐队和投票.Band有一个名字和一个id,Votes有一个total_votes列和一个名为band_id的外键,指向band.id.

我有很多选票,在不同日期保存.我想要做的是找到每个波段的total_votes列的最大值.以下SQL查询有效:

select b.name,max(v.total_votes) as total from band b, votes v 
    where b.id=v.band_id
    group by b.name order by total desc;

不过,我正在使用的系统使用Hibernate.我想将SQL查询重写为HQL或Hibernate条件查询.

这很容易,我只是错过了吗？谢谢你的帮助.

我一直在使用Grails 3.0.1交互式控制台,当我输入"run-app"命令时,我希望它启动服务器并返回提示符.相反,它做了类似的事情:

grails> run-app
> Configuring > 1/1 projects > Resolving dependencies ':agent' > Resolving dependencies ':versio
:compileJava UP-TO-DATE
> Building 16% > :compileGroovy > Resolving dependencies ':compile' > Resolving dependencies 'de
:compileGroovy UP-TO-DATE
:processResources
:classes
:findMainClass
> Building 83% > :bootRun > Resolving dependencies ':runtime' > Resolving dependencies 'detached:bootRun
Grails application running at http://localhost:8080
> Building 83% > :bootRun

系统在此时等待,直到我按下Ctrl-C.我以为系统会启动然后返回提示符.我错过了一些明显的东西吗 我只需要等待吗？

(这可能与/sf/answers/2121852421/有关,但我恐怕还是没有得到它.所以我这样问我的问题,希望它能够得出一个我可以更容易理解的答案.)

通常,当我有一个Stream时,我可以使用Collectors类中的一个静态方法将其转换为集合:

List<String> strings = Stream.of("this", "is", "a", "list", "of", "strings")
    .collect(Collectors.toList());

然而,类似的过程不适用于原始流,正如其他人注意到的那样:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(Collectors.toList());  // doesn't compile

我可以这样做:

IntStream.of(3, 1, 4, 1, 5, 9)
    .boxed()
    .collect(Collectors.toList());

或者我可以这样做:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(ArrayList<Integer>::new, ArrayList::add, ArrayList::addAll);

问题是,为什么Collectors.toList()只为原始流做这个？难道没有办法指定包装类型吗？如果是这样,为什么这不起作用:

IntStream.of(3, 1, 4, 1, 5, 9)
    .collect(Collectors.toCollection(ArrayList<Integer>::new)); // nope

任何见解将不胜感激.

这是一个非常简单的问题，但这里的某个人必须知道，所以这里有一个让他们获得分数的简单方法。

在Java 8，有四类的功能接口在java.util.function包：Consumer，Supplier，Function，和Predicate。AFunction将单个输入转换为单个输出。APredicate将输入转换为boolean.

Consumer和Supplier中的单个抽象方法的签名本质上是相反的：

对于Consumer<T>：

void accept(T t)

而对于Supplier<T>：

T get()

由于 aConsumer接受输入并且不返回任何内容而 a 不Supplier接受任何内容并返回值，因此它们感觉像是对立的。如果有人问我 a 的反义词是什么Consumer，我自然会想到Producer，就像生产者-消费者问题一样。

所以我（诚然有些愚蠢）的问题是，为什么不Supplier叫Producer？我失踪有明显的原因吗？

我经常推荐使用Groovy的@ImmutableAST转换作为一种简单的方法来创建类,这是不可变的.这总是适用于其他Groovy类,但有人最近问我是否可以将这些类混合到Java代码中.我一直认为答案是肯定的,但我遇到了麻烦.

说我有一个不可变的User类:

import groovy.transform.Immutable

@Immutable
class User {
    int id
    String name
}

如果我使用Groovy编写的JUnit测试来测试它,一切都按预期工作:

import org.junit.Test

class UserGroovyTest {

    @Test
    void testMapConstructor() {
        assert new User(name: 'name', id: 3)
    }

    @Test
    void testTupleConstructor() {
        assert new User(3, 'name')
    }

    @Test
    void testDefaultConstructor() {
        assert new User()
    }

    @Test(expected = ReadOnlyPropertyException)
    void testImmutableName() {
        User u = new User(id: 3, name: 'name')
        u.name = 'other'
    }
}

我可以用Java编写的JUnit测试做同样的事情:

import static org.junit.Assert.*;

import org.junit.Test;

public class UserJavaTest { …

我一直看到flatMap用于1对1操作的示例,例如:

Flux.just("a", "b", "c")
    .flatMap(s -> Mono.just(s.toUpperCase())

当我想到的时候

Flux.just("a", "b", "c")
    .map(String::toUpperCase)

(注意:我知道我没有添加订阅者;假设我打印它们或者其他东西)

flatMap这里的用法是为了压扁退货Mono吧？但为什么不直接使用map如图所示的操作？是因为map操作是同步的吗？我错过了什么用例？

我有一个简单的网站(http://www.kousenit.com/twitterfollowervalue),根据一个人的Twitter粉丝计算数量.由于Twitter API一次仅返回关注者100,因此完整的过程可能涉及大量呼叫.

目前,我对运行Twitter循环的方法进行了Ajax调用.该方法看起来像(Groovy):

def updateFollowers() {
    def slurper = new XmlSlurper()
    followers = []
    def next = -1
    while (next) {
        def url = "http://api.twitter.com/1/statuses/followers.xml?id=$id&cursor=$next"
        def response = slurper.parse(url)
        response.users.user.each { u ->
           followers << new TwitterUser(... process data ...)
        }
        next = response.next_cursor.toBigInteger()
    }
    return followers
}

这是从一个名为renderTTFV.groovy的控制器调用的.我使用原型库通过Ajax调用来调用控制器:

在我的网页上,在标题部分(JavaScript)中:

function displayTTFV() {
    new Ajax.Updater('ttfv','renderTTFV.groovy', {});
}

并且在呼叫完成时,页面正文中有一个div更新.

一切正常,但updateFollowers方法可能需要相当长的时间.有什么方法可以返回进度值吗？例如,我想在每次迭代时更新网页.我提前知道会有多少次迭代.我只是无法弄清楚在该循环中间更新页面的方法.

任何建议,将不胜感激.

在博客文章Flight of the Flux 3中，作者建议将同步阻塞调用包装在Monowith a subscribeOncall 中，如文章中的以下代码片段所示：

final Flux<String> betterFetchUrls(List<String> urls) {
  return Flux.fromIterable(urls)
    .flatMap(url -> 
             //wrap the blocking call in a Mono
             Mono.fromCallable(() -> blockingWebClient.get(url))
             //ensure that Mono is subscribed in an boundedElastic Worker
             .subscribeOn(Schedulers.boundedElastic())
    ); //each individual URL fetch runs in its own thread!
}

但在同一篇文章的前面，他们表明您可以使用它publishOn来确保在单独的线程上完成阻塞调用：

Flux.fromIterable(firstListOfUrls) //contains A, B and C
    .publishOn(Schedulers.boundedElastic())
    .map(url -> blockingWebClient.get(url))
    .subscribe(body -> System.out.println(Thread.currentThread().getName + " from first list, got " + body));

既然如此，为什么不直接betterFetchUrls …

自从这个方法

Stream.of(T... values)

包括单个元素的情况,为什么方法:

Stream.of(T t)

还包括在API中？它的目的是什么？什么时候被调用？它与varargs版本有什么不同吗？