在阅读了关于流的内容后,我现在尝试使用它们,并且已经通过简单的示例出现了第一个问题.我想实现一个非常简单的加密算法,它使用替换.有一些文本需要加密:
static List<Integer> text = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
有一些密码:
private List<Integer> password = Arrays.asList(1, 5, 7, 3);
现在的想法是将密码值添加到文本值.结果应该是
1 + 1,2 + 5,3 + 7,4 + 3,5 + 1,6 + 5 ......
所以我必须从密码创建一个流,它从到达上面列表末尾的开头开始.这部分我已经设法做到了.
现在我不得不将2个流合并为1个流.任何想法,如何实现？
我正在使用转换Grails Joda-Time插件到JavaTime.
我有这样的旧Joda时间码:
def style
switch (type) {
case LocalTime:
style = '-S'
break
case LocalDate:
style = 'S-'
break
default:
style = 'SS'
}
Locale locale = LocaleContextHolder.locale
return DateTimeFormatter.ofPattern(style, locale).withResolverStyle(ResolverStyle.LENIENT)
我怎样才能将它转换为JSR 310？我找不到任何类似于接受样式的方法forStyle(String style).
UPD 我找到了解决方法:
Locale locale = LocaleContextHolder.locale
DateTimeFormatter formatter
switch (type) {
case LocalTime:
formatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
break
case LocalDate:
formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).withLocale(locale)
break
default:
formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT).withLocale(locale)
}
return formatter
但它失败的Instant类型.Spock规范重现:
def 'Instant locale formatting'() {
given:
Instant inst …我正在使用TreeTableView，并且我想根据所选行内的数据更改与上下文菜单关联的菜单项。
假设我有一个结构如下的表：
访客
不休
在此表中，我们可以比喻说我们有两个根节点，分别是“访问者”和“ Chatters”。现在，我想有两个带有不同选项的上下文菜单。可以说，针对访问者的上下文菜单有一个项目是“邀请聊天”，另一个上下文菜单处理聊天者，并且具有不同的选项，例如：“踢”，“禁止”等。我的问题是如何实现这种情况？我应该在哪里使用这些上下文菜单？我应该将它们用于单元格，行还是表格？
Java泛型是否有办法告诉编译器类型T必须是类型U？例如
public class Whatever<T, U> {
T specific;
U moreGeneral;
}
现在,我想确保T是其子类U.有没有办法指定这个？
在stream().filter().map()列表上有一个类似的数据结构,List<List<Object>>如下所示:
[["1","a",20],
["1","b",10],
["2","a",10],
["2","b",30]]
我想要的是按内部列表的第一个元素的值进行分组,保留中间元素,最后将每个"组"的最后元素相加.
[["1", 30],
["2", 40]]
对不起,如果这对你们中的一些人来说很明显,但我还没有找到如何实现这一目标的任何例子.我假设它可以通过Stream.reduce(U身份,BiFunction累加器,BinaryOperator组合器)来完成,但到目前为止我还没有成功.如果有人可以为此提供一些示例代码,我相信它也会受到许多其他人的赞赏.
想象一下,通过回调或InputStream您需要不断转换为Java 8的某种传入数据Stream.我们不知道传入的数据流何时停止,但我们知道它可以停止.
到目前为止,我已经看到了解决这个问题的两种方法,我对如何实现这一目标的最佳实践感兴趣.主要是因为我必须是某人以前面对的事情.必须有比下面的想法更简单的方法.
1)最简单的方法是将源视为a Supplier并仅用于Stream.generate提供数据:
Stream.generate(() -> blockCallToGetData());
然而,这具有缺点,即流永远不会结束.因此,只要输入源停止发送,流就会一直调用该方法.除非我们自然地抛出一个Runtime异常,但这可能会变得很难看.
2)第二个想法是使用a Iterator(转换为a Spliterator)next方法阻塞,直到我们找到下一个元素.作为一个粗略的例子:
class BlockingIterator implements Iterator<Data> {
@Override void boolean hasNext() {
return true;
}
@Override Data next() {
return blockCallToGetData();
}
}
这样做的好处是,我可以通过返回停止流false的hasNext方法.但是,在我们不控制传入数据速度的情况下(例如在回调中),我们需要为迭代器保留一个就绪元素的缓冲区.在有人调用next迭代器之前,这个缓冲区可能会变得无限大.
所以,我的问题是; 将阻塞输入提供给流的最佳做法是什么？
在阅读Java 8中引入的新功能的同时,我发现了Predicates的概念.我注意到互联网和书籍中提供的大多数示例都使用静态函数来创建谓词.
以下面的Apple类为例:
public class Apple {
private String color;
private int weight;
private static final int SMALL_APPLE_MAX_WEIGHT = 150;
public Apple(String color, int weight) {
this.color = color;
this.weight = weight;
}
public static boolean isGreenApple(Apple apple) {
return null!=apple && null!=apple.getColor() && "green".equals(apple.getColor());
}
public boolean isBigApple() {
return this.getWeight() > SMALL_APPLE_MAX_WEIGHT;
}
}
我现在可以创建一个新的谓词如下:
Predicate<Apple> isGreenApple = Apple::isGreenApple;
Predicate<Apple> isBigApple = Apple::isBigApple;
如上所示,我可以使用静态和实例方法创建谓词.哪种方法是首选方法,为什么？
我面临以下问题:我有一个类作为数据成员java.util.Optional对象,我需要将变换放入json.代码看起来像这样的通用方式:
public class MyClass{
public java.util.Optional<MyCustomObject> object;
public Myclass(java.util.Optional<MyCustomObject> object){
this.object = object;
}
public java.util.Optional<MyCustomObject> getObject(){
return this.object;
}
public void setObject(java.util.Optional<MyCustomObject> object){
return this.object = object;
}
}
当我把它变成一个json我得到这样的东西:
Optional[
object
]
我想摆脱json中的Optional部分.我能这样做吗？
我需要一个函数,它返回一个包含{XXX11, XXX12, XXX13, XXX14, XXX21, ... , XXX43, XXX44}where XXX是函数的整数参数的集合.什么是Java 8风格的优雅方式？我已经完成了前缀是一位数如下:
/**
* I need to get {<base>11, <base>12, ..., <base>44} but can't...
* @return {<base>1, <base>2, <base>3, <base>4}
*/
Set<Integer> addOnlyOnePrefix(int base){
return IntStream.range(1, 4).map(prefix -> base*10 + prefix)
.boxed().collect(Collectors.toSet());
}
我知道已经有一个与此相关的问题,在Java 8中使用默认方法与抽象类的接口,但是在Java 8发布之前问了这个问题,它只是一个关于抽象类和接口之间有什么区别的要点.默认方法,它根本没有提供任何实际的例子,而是充满了冗长的解释.
我发布这个问题是因为我对一个实用的例子更感兴趣,它用Java 8中的默认方法清除了抽象类和接口之间的区别.
看看这个例子,
抽象类,
abstract class AbstractClass {
public int var = 0;
// These methods must be Overridden
abstract int x();
abstract int y();
// This method is optional
int z() {
return 0;
}
}
接口(Java 8)
interface Interface {
public int var = 0;
// These methods must be Overridden
int x();
int y();
// This method is optional
default int z(){
return 0;
}
}
如果我想向一个新手Java程序员(比如我自己)解释它的实际区别,我怎么能区分上面两个？
这篇文章说,
默认方法带来的好处是,现在可以向接口添加新的默认方法,并且不会破坏实现.
这可能不是默认方法接口的唯一好处,或者是它？