我知道密钥库通常会保存私钥/公钥,信任存储只保存公钥(并代表您打算与之通信的可信方列表).嗯,这是我的第一个假设,所以如果这不正确,我可能还没有开始......
我对使用keytool时如何/何时区分商店感兴趣.
所以,到目前为止,我已经创建了一个密钥库
keytool -import -alias bob -file bob.crt -keystore keystore.ks
这将创建我的keystore.ks文件.我回答yes问题我是否相信bob但是我不清楚这是否创建了密钥库文件或信任库文件？我可以设置我的应用程序以使用该文件.
-Djavax.net.ssl.keyStore=keystore.ks -Djavax.net.ssl.keyStorePassword=x
-Djavax.net.ssl.trustStore=keystore.ks -Djavax.net.ssl.trustStorePassword=x
并且使用System.setProperty( "javax.net.debug", "ssl")set,我可以在受信任的证书下看到证书(但不在密钥库部分下).我导入的特定证书只有一个公钥,我打算用它通过SSL连接向Bob发送内容(但也许最好留给另一个问题!).
任何指示或澄清都将非常感激.无论你导入什么,keytool的输出都是相同的,它的惯例是一个是密钥库而另一个是信任存储？使用SSL等时的关系是什么？
我想复制Java 8流,以便我可以处理它两次.我可以collect作为一个列表并从中获得新的流;
// doSomething() returns a stream
List<A> thing = doSomething().collect(toList());
thing.stream()... // do stuff
thing.stream()... // do other stuff
但我认为应该有一种更有效/更优雅的方式.
有没有办法复制流而不将其转换为集合？
我实际上正在使用Eithers 流,所以想要在移动到正确的投影之前以一种方式处理左投影并以另一种方式处理.有点像这样(到目前为止,我被迫使用这个toList技巧).
List<Either<Pair<A, Throwable>, A>> results = doSomething().collect(toList());
Stream<Pair<A, Throwable>> failures = results.stream().flatMap(either -> either.left());
failures.forEach(failure -> ... );
Stream<A> successes = results.stream().flatMap(either -> either.right());
successes.forEach(success -> ... );
这样做的时候
Stream.of(1, 32, 12, 15, 23).map(Integer::toString);
我得到一个模糊的类型错误.可以理解的是,编译器无法分辨我的意思toString(int)或toString()来自Integer.
当不使用方法引用时,我可能已经通过显式转换或者写出泛型的长手程来解决这个问题,但是如何让编译器知道我的意思呢？我可以使用什么语法(如果有的话)来明确？
这里的其他答案指的是Joda API.我想用它来做java.time.
假设今天的日期是2015年11月26日 - 星期四,当我增加2个工作日时,我希望结果为2015年11月30日星期一.
我正在开发自己的实现,但如果已经存在的话会很棒!
编辑:
除了循环之外,有没有办法做到这一点？
我试图得到一个像这样的函数:
Y = f(X1,X2) where
Y is actual number of days to add,
X1 is number of business days to add,
X2 is day of the week (1-Monday to 7-Sunday)
然后给出X1和X2(从日期的星期几得出),我们可以找到Y然后使用plusDays()方法LocalDate.
到目前为止,我还没有得出它,它不一致.任何人都可以确认循环,直到添加所需的工作日数是唯一的方法吗？
我对按顺序关闭调度的线程的想法很满意ExectuorService; 也就是说,调用shutdown或shutdownNow将导致池上创建的线程正常退出.如果他们回复interrupt你,你可以确定最终会被调用等等,你会得到一个干净,可预测的退出(你可以清理任何资源等).
但是,如果您已将线程设置为守护程序(通过执行程序ThreadFactory),如下所示.
ExecutorService pool = Executors.newSingleThreadExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable runnable) {
Thread thread = Executors.defaultThreadFactory().newThread(runnable);
thread.setDaemon(true);
return thread;
}
});
主线程终止后,VM将突然终止任何守护程序线程.在上面的示例中,调度然后突然终止的(守护进程)线程将绕过任何finally块,并且任何可中断的方法都不会抛出InterruptedException.
所以,我倾向于认为,这标志着一个使用线程ThreadPoolExecutor的池守护进程是不好的做法...我的问题是真的请他帮我练声曲为什么.
为什么在ExecutorService线程池中使用守护程序线程是不好的做法(或者如果你不同意)？特别是我有兴趣通过正常关闭(具有中断策略并且运行良好的线程)与守护程序线程来描述VM关闭的生命周期.
扩展最后一点,finalizeon ThreadPoolExecutor将调用shutdown自身,但是当它使用守护程序线程时,如果finalizeVM调用它们,它们可能已经终止.那么线程池的行为是什么呢？如果底层线程突然终止,它是否可以被欺骗以保持活着(因此不会退出VM)？
我问的部分原因是因为我已经看到它曾经绕过了关闭实际的ExectorService的需要.您能想到绕过其关闭生命周期会产生不良影响的情况吗？到目前为止,我可以提出使用守护进程的唯一原因是采取捷径,我想欣赏它可能导致的任何意外的副作用.
所以Java 8引入了方法引用,文档描述了这四种类型.
我的问题是两种实例类型之间的区别是什么？
- 引用特定对象的实例方法.
- 引用特定类型的任意对象的实例方法.
两者都参考参考但有什么显着不同？用于解决它们的类型推断是不同的吗？重要的是(在他们的例子中)一个是闭包而另一个是lambda？它与方法的参数数量有关吗？
对于servlet生命周期的东西,你们建议做什么来回应异常......
例如,
public class Foo implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent event) {
try {
// something nasty
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void contextDestroyed(ServletContextEvent event) {
try {
// something nasty
} catch (Exception e) {
throw new RuntimeException(e);
}
}
我不完全确定将处理上面的运行时异常.我的想法是,如果抛出异常,它们就足以严重破坏系统,因此(未处理的)运行时异常可能没问题.
我想我在问什么处理来自servlet上下文侦听器的未经检查的异常？
我不能在unapply提取器的方法上使用泛型以及隐式"转换器"来支持特定于参数化类型的模式匹配吗？
我想这样做(注意使用[T]就unapply行),
trait StringDecoder[A] {
def fromString(string: String): Option[A]
}
object ExampleExtractor {
def unapply[T](a: String)(implicit evidence: StringDecoder[T]): Option[T] = {
evidence.fromString(a)
}
}
object Example extends App {
implicit val stringDecoder = new StringDecoder[String] {
def fromString(string: String): Option[String] = Some(string)
}
implicit val intDecoder = new StringDecoder[Int] {
def fromString(string: String): Option[Int] = Some(string.charAt(0).toInt)
}
val result = "hello" match {
case ExampleExtractor[String](x) => x // <- type hint barfs …在很多Java源代码中,(例如LinkedBlockingDeque)我看到了这样的东西;
final ReentrantLock lock = new ReentrantLock();
public void putLast(E e) throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// do stuff
} finally {
lock.unlock();
}
}
我理解基本模式(最后锁定,解锁)但我的问题是为什么在使用之前对本地范围的Lock变量进行赋值？为什么这样做而不是以下？
final ReentrantLock lock = new ReentrantLock();
public void putLast(E e) throws InterruptedException {
this.lock.lock();
try {
// do stuff
} finally {
lock.unlock();
}
}
它会影响优化吗？第一个例子可以防止锁定粗化吗？
评论后编辑:如果你真的不知道为什么会这样,请不要添加答案.这是来自Java源码,@ author标签是Doug Lea所以我很确定它是有原因的.请不要指出代码只是等价的.
谢谢
如果我有收藏集：
List<Long> numbers = asList(2, 2, 4, 5);
我该如何映射/处理这些以建立运行总计。产生类似：
List<Long> runningTotals = asList(2, 4, 8, 13);
更好的是，我该如何构建某物（例如元组）的列表，以便保留原始物：
((2 -> 2), (2 -> 4), (4 -> 8), (5 -> 13));