鉴于:
import com.google.common.collect.ImmutableMap;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class Testcase
{
public static <T, K, V> MapCollectorBuilder<T, K, V>
toImmutableMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends V> valueMapper)
{
return null;
}
public static final class MapCollectorBuilder<T, K, V>
{
public Collector<T, ?, ImmutableMap<K, V>> build()
{
return null;
}
}
public static <T, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap2(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends …我正在寻找的是一种使用流和地图将一种类型的集合转换为另一种类型的集合的方法WITHOUT具有将对象A转换为对象B的预定义函数/功能接口.Java 6示例:
for (ObjectA objA : collectionA) {
ObjectB objB = new ObjectB();
objB.setId(objA.getId());
collectionB.add(objB);
}
我正在寻找以下内容:
List<ObjectB> collectionB = collectionA.stream().map(objA -> {
ObjectB objB = new ObjectB();
objB.setId(objA.getId());
return objB;
});
这当然不起作用,但你得到了我正在努力做的事情的要点.
在我的应用程序中,我遇到一个问题,当类中的getter仅在接口中默认(Java 8特性)时,结果没有Java Beans属性.即正常方法调用它只是作为一种标准方法,但对于通过"属性"访问它突然表现不同......
这是一个测试用例:
import java.beans.Introspector;
import java.util.Arrays;
import java.util.stream.Collectors;
import org.apache.commons.beanutils.PropertyUtils;
public class test
{
public static void main (String[] arguments) throws Exception
{
// Normal language-level invocation, works fine.
System.out.println (new Bean1 ().getFoo ());
System.out.println (new Bean2 ().getFoo ());
// Printing Java Beans properties; Bean2 doesn't have 'foo' property...
System.out.println (Arrays.stream (Introspector.getBeanInfo (Bean1.class).getPropertyDescriptors ())
.map ((property) -> property.getName ())
.collect (Collectors.joining (", ")));
System.out.println (Arrays.stream (Introspector.getBeanInfo (Bean2.class).getPropertyDescriptors ())
.map ((property) -> property.getName ())
.collect (Collectors.joining (", ")));
// …我一直在研究如何使用Java 8和spring在运行时更改作业的频率.这个问题非常有用,但并没有完全解决我的问题.
我现在可以配置下次执行作业的日期.但是如果将延迟设置为1年,那么我需要在考虑新配置之前等待1年.
我的想法是在配置值发生变化时停止计划任务(所以从另一个类开始).然后在下次执行任务时重新计算.也许有一种更简单的方法可以做到这一点.
这是我到目前为止的代码.
@Configuration
@EnableScheduling
public class RequestSchedulerConfig implements SchedulingConfigurer {
@Autowired
SchedulerConfigService schedulerConfigService;
@Bean
public RequestScheduler myBean() {
return new RequestScheduler();
}
@Bean(destroyMethod = "shutdown")
public Executor taskExecutor() {
return Executors.newScheduledThreadPool(100);
}
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskExecutor());
taskRegistrar.addTriggerTask(
new Runnable() {
@Override public void run() {
myBean().startReplenishmentComputation();
}
},
new Trigger() {
@Override public Date nextExecutionTime(TriggerContext triggerContext) {
Duration d = schedulerConfigService.getIntervalFromDB();
return DateTime.now().plus(d).toDate();
}
}
);
}
}
这就是我想做的事情.
@RestController
@RequestMapping("/api/config/scheduler")
public …有没有办法表示与时区相关的日期(没有时间)？唯一没有时间我能找到的日期表示是LocalDate,我想不允许你指定一个区域.
假设您想要流式迭代器的元素; 让我们使用一个具体的例子Scanner来实现Iterator<String>.
给出一个Iterator,说:
// Scanner implements Iterator<String>
Iterator<String> scanner = new Scanner(System.in);
从中创建的选项Stream<String>很笨重:
StreamSupport.stream(
Spliterators.spliteratorUnknownSize(scanner, Spliterator.ORDERED), false);
或稍微简洁,但迟钝:
StreamSupport.stream(
((Iterable<String>) () -> new Scanner(System.in)).spliterator(), false);
在JDK中的某个地方是否有一个返回Stream<T>给定的工厂方法Iterator<T>？
我正在查看一些代码并遇到这个方法,它采用HTML Header值(即Content-Disposition = inline; filename = foo.bar)并将其解析为由分号分隔成key = value对的映射.起初它看起来像是使用流进行优化的一个很好的候选者,但是在我实现之后,我无法重用计算的String.indexOf('=')值意味着字符串必须被扫描3次,这是实际上不如原来的最佳.我完全清楚有很多实例,Streams不适合这项工作,但我想知道我是否错过了一些技术,可以让Stream比初始代码更高效/更高效.
/**
* Convert a Header Value String into a Map
*
* @param value The Header Value
* @return The data Map
*/
private static Map<String,String> headerMap (String value) {
int eq;
Map<String,String> map = new HashMap<>();
for(String entry : value.split(";")) {
if((eq = entry.indexOf('=')) != -1) {
map.put(entry.substring(0,eq),entry.substring(eq + 1));
}
}
return map;
return Stream.of(value.split(";")).filter(entry -> entry.indexOf('=') != -1).collect(Collectors.));
} //headerMap
我尝试Streaming it:
/**
* Convert a Header Value …我正在寻找最优雅的方式来创建DoubleStream(使用总和,平均等)List<Double>.目前我有这样的代码:
List<Double> doubles = getListOfDoubles();
double sum = doubles.stream()
.mapToDouble(d -> d)
.sum();
也许有人可以建议更短的方式？
我继续学习java 8.
我发现了有趣的行为:
让我们看看代码示例:
// identity value and accumulator and combiner
Integer summaryAge = Person.getPersons().stream()
//.parallel() //will return surprising result
.reduce(1, (intermediateResult, p) -> intermediateResult + p.age,
(ir1, ir2) -> ir1 + ir2);
System.out.println(summaryAge);
和模型类:
public class Person {
String name;
Integer age;
///...
public static Collection<Person> getPersons() {
List<Person> persons = new ArrayList<>();
persons.add(new Person("Vasya", 12));
persons.add(new Person("Petya", 32));
persons.add(new Person("Serj", 10));
persons.add(new Person("Onotole", 18));
return persons;
}
}
12 + 32 + 10 + 18 = 72
对于序列流,此代码始终返回73(72 …
我有一组供应商,它们都有相同的结果,但速度不同(且不同).
我想要一种优雅的方式同时启动供应商,并且只要其中一个产生了价值,就将其退回(丢弃其他结果).
我已经尝试过使用并行流,Stream.findAny()但是它总是会阻塞,直到产生所有结果.
这是一个单元测试,展示了我的问题:
import org.junit.Test;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
import java.util.stream.Stream;
import static org.junit.Assert.*;
public class RaceTest {
@Test
public void testRace() {
// Set up suppliers
Set<Supplier<String>> suppliers = Collections.newSetFromMap(new ConcurrentHashMap<>());
suppliers.add(() -> "fast"); // This supplier returns immediately
suppliers.add(() -> {
try {
Thread.sleep(10_000);
return "slow";
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}); // This supplier takes 10 seconds to produce a value
Stream<Supplier<String>> stream = …java-8 ×10
java ×9
java-stream ×5
collections ×2
iterable ×1
iterator ×1
javabeans ×1
jobs ×1
reduce ×1
spring ×1