说我有一个无限的流:
Stream<Socket> stream = Stream.generate(() -> {
try {
return serverSocket.accept();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
我希望能够使用它像这样:
stream.forEach(socket -> {
new Thread(() -> {
socket.getOutputStream().write("Hi there, client.");
});
});
但这似乎不起作用,这可能是因为我误解了Java 8 Streams的一个关键方面.我究竟做错了什么？
在Java 8中,看起来类的lambda保存在数组中.例如,假设我们有这个类:
public class LambdaFactory {
public Supplier<Integer> getOne(){
return () -> 42;
}
public Supplier<Integer> getTwo(){
return () -> 128;
}
public Supplier<Integer> getThree(){
return () -> 3;
}
}
然后我这样打印出来:
System.out.println(factory.getOne());
System.out.println(factory.getOne());
System.out.println(factory.getTwo());
System.out.println(factory.getThree());
输出将是这样的
examples.LambdaFactory$$Lambda$1@4e515669
examples.LambdaFactory$$Lambda$1@4e515669
examples.LambdaFactory$$Lambda$2@1b9e1916
examples.LambdaFactory$$Lambda$3@ba8a1dc
所以我们在这里可以看到两件事.两次调用的lambda给了我们相同的lambda对象(这与我们每次都可以得到一个新的内部类不同).我们也看到他们看起来像是被保留在某种类型的"Lambda"结构中
我的问题是,我可以在课堂上看到lambdas吗？我没有任何理由这样做,我只是喜欢解剖一些东西
我有
Function<String, String> myFunction;
是否有任何其他预定义的签名表示将对象"转换"为相同类型的对象的函数？
我相信应该有专门的一个.
谢谢!
我正在测试在Java中的列表中搜索低值和高值的不同方法,我意识到使用stream()和parallelStream()方法的结果更慢且性能更差,而不仅仅是遍历列表......
这可能吗？这怎么可能？
这是我的代码:
迭代整个数组:
private HighLowTuple calculateIteratingWholeArray( List<Integer> arrayWithNumbers, int from, int to )
{
// long start = System.currentTimeMillis();
HighLowTuple result = new HighLowTuple( -1, Integer.MAX_VALUE );
for( int i = from; i < to; i++ )
{
int value = arrayWithNumbers.get( i );
if( value > result.high )
{
result.high = value;
}
if( value < result.low )
{
result.low = value;
}
}
// long end = System.currentTimeMillis();
// System.out.println( "duration internal calculateIteratingWholeArray from " + from …我试图做的可能是使用一个例子更容易解释.我们假设我必须遵循两个数组:
int firstArray[] = {1, 2, 3, 4, 5};
int secArray[] = {1, 2, 3, 4, 5};
我想要的是将i第二个数组的每个元素添加到i第一个数组的每个元素.当然,创建第三个数组也没关系.
在这个例子中,结果将是: 2, 4, 6, 8, 10
我可以在Java 8中使用ParallelStream以某种方式执行此操作吗？我只能想到使用至少一个索引的解决方案,并且由于并行性(这也违背了目的)它们并不真正起作用.
这种单线程方法有效:
AtomicInteger i = new AtomicInteger(0);
int resultArray[] = Arrays.stream(firstArray)
.map(a -> a + secArray[i.getAndIncrement()]).toArray();
但是如果我使用并行流尝试这个,结果(当然它们是)随机的,程序真的很慢.有任何想法吗？
我使用Apache Commons lib有以下代码:
public static List<Address> addressesHasType(final List<Address> addresses, final AddressType... types) {
return (List<Address>) CollectionUtils.select(addresses, new Predicate() {
@Override
public boolean evaluate(final Object object) {
boolean isContains = false;
for (int i = 0; i < types.length && !isContains; i++) {
isContains = ((Address) object).getTypes().contains(types[i]);
}
return isContains;
}
});
}
我试图重构它只使用没有Apache Commons lib的lambda和Java 8,如下所示:
List<Address> addressList = addresses.stream()
.filter(a -> a.getTypes().contains(types)).collect(Collectors.toList());
但这份名单最终变得空洞.我尝试使用findFirst()但它不返回List而是返回Optional对象.
addressList2 = addresses.stream()
.filter(a -> a.getTypes().contains(types)).findFirst();
我怎么能这样做？
我们注意到java 8使用了参考透明度 :
我测试了很多代码来检测这个RT,例如:
public class ReferentialTransparency {
public static int triple(int number) {
System.out.println(number);
try {
Thread.sleep(500);
} catch (Exception e) {
}
return number* 3;
}
public static void main(String[] args) {
List<Integer> vals=Arrays.asList(1,2,3,4,3);
System.out.println(vals.parallelStream()
.mapToInt(ReferentialTransparency::triple)
.sum());
}
}
安慰 :
3
4
2
1
3
39
我注意到Java 8运行三重方法,即使有一个元素出现了两次3.
正如Istvan解释的那样,我的问题是:
如果三重引用透明,为什么编译器不会优化重复调用三元组(3)？
我是Java 8 Streams的新手.请指教,如何将流转换Stream<HashMap<String, Object>>为HashMap数组HashMap<String, Object>[]？
例如,我在代码中有一些流:
Stream<String> previewImagesURLsList = fileNames.stream();
Stream<HashMap<String, Object>> imagesStream = previewImagesURLsList
.map(new Function<String, HashMap<String, Object>>() {
@Override
public HashMap<String, Object> apply(String person) {
HashMap<String, Object> m = new HashMap<>();
m.put("dfsd", person);
return m;
}
});
我怎么能这样做
HashMap<String, Object>[] arr = imagesStream.toArray();
？
抱歉,我的英语不好.
有没有办法监控执行resp.在Java 8中收集/减少并行Stream？我想知道,已经处理了多少元素.
在顺序编程中,我可以用for循环完成整个任务并添加一些计数器,我可以不时地打印到stdout,看看需要多长时间.但对于并行流,我没有看到任何简单直接的方法来做同样的事情.
我试图解决代码中给出的问题.我想要一个能够接受任何函数的lambda表达式
interface ExecuteAnyCode{
void execute(Object... args);
}
void entry(){
ExecuteAnyCode a = Math::sin;
ExecuteAnyCode b = System.out::println;
a.execute(5);
b.execute("Hello World")
}
但它让我对传递给功能接口的函数中的参数有误.有没有办法做到这一点？