我试图理解负面的前瞻是如何在简单的例子上起作用的.例如,考虑以下正则表达式:
a(?!b)c
我认为负面前瞻符合一个位置.因此,在这种情况下,正则表达式匹配任何严格包含3个字符的字符串,而不是abc.
但这不是真的,正如在这个演示中可以看到的那样.为什么？
以下代码定义了4个gradle任务:
4.times { counter ->
task "task$counter" << {
println "I'm task number $counter"
}
}
但什么是<<运营商？它在groovy中做了什么？
我正在尝试使用mkyong示例编写我的测试弹簧安全应用程序.
Spring Security: 4.0.0.RC1
Spring: 4.1.4.RELEASE
我有以下安全配置:
<http auto-config="true">
<intercept-url pattern="/admin**"
access="hasRole('ADMIN')"/>
<form-login authentication-failure-url="/?auth_error"
username-parameter="user"
password-parameter="password"
login-page="/"
default-target-url="/?OK"/>
<!-- <csrf/> -->
</http>
<authentication-manager>
<authentication-provider>
<user-service>
<user name="mkyong" password="123456" authorities="ADMIN" />
</user-service>
</authentication-provider>
</authentication-manager>
登录页面:
<html>
<body>
<form method="POST">
<label for="user">User: </label>
<input type="text" id="user" name="user" /> </br>
<label for="password">Password: </label>
<input type="text" name="password" id="password" /> </br>
<input type="submit" />
</form>
</body>
</html>
现在,当我尝试登录时,我得到403错误页面:
Invalid CSRF Token 'null' was found on the request parameter
'_csrf' or header 'X-CSRF-TOKEN'.
描述:
Access to …我有一个关于CompletableFuture方法的问题:
public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)
事情是JavaDoc说的就是这样:
返回一个新的CompletionStage,当该阶段正常完成时,将使用此阶段的结果作为所提供函数的参数执行.有关特殊完成的规则,请参阅CompletionStage文档.
线程怎么样？这将在哪个线程中执行？如果未来由线程池完成怎么办？
咨询的JavaDoc和的源代码Thread.interrupt()中的方法Java SE 7,我发现这个:
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0(); //1, Outside of the synchronized block
}
//...
private native void interrupt0();
可以看出,本机方法调用位于//1同步块之外.那么,如果不将interrupt()方法调用到synchronized块中,是否安全？
Thread t;
//something else
t.interrupt(); //Not in a synchronized block
它是线程安全的吗？如果超过1个线程试图同时中断它怎么办？interrupt0那么本机方法将如何表现？
点击提交按钮会发生什么？让我有一个位于http://example.com/URL 上的表单,其中包含两个input元素,如下所示:
<form method="get">
<input type="text" id="field1" name="namefield1"/>
<input type="text" id="field2" name="namefield2"/>
<input type="submit" value="submit"/>
</form>
http在我的特定情况下,实际获得请求的内容将被发送到-server？
我有一个包含对数组的volatile引用的类:
private volatile Object[] objects = new Object[100];
现在,我可以保证,只有一个线程(调用它writer)可以写入数组.例如,
objects[10] = new Object();
所有其他线程只读取线程写入的值writer.
问题:我是否需要同步这样的读写以确保内存一致性？
我认为,是的,我应该.因为从性能角度来看,如果JVM在写入数组时提供某种内存一致性保证,那么它就没有用处.但我不确定.没有找到任何有用的文档.
我有以下示例:
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
A<ConcreteErrorHandler> a = new A<ConcreteErrorHandler>();
a.m(); //Exception here!
}
public static class AbstractErrorHandler {
public static void handle(){
throw new UnsupportedOperationException("Not implemented");
}
}
public static class ConcreteErrorHandler extends AbstractErrorHandler{
public static void handle(){
System.out.println("Concrete handler");
}
}
public static class A<T extends AbstractErrorHandler>{
public void m(){
T.handle();
}
}
}
为什么调用基类的方法,而不是派生的方法？handle()方法的签名完全相同.我知道静态方法不会继承,但是在我的情况下不应该抛出编译时错误吗？
有人可以解释这种行为吗？
我有以下课程:
public class Base{
//fields
public String getStr(){
String str = null;
//Getting str from the fields
return str;
}
}
public class Derived extends Base{
//fields
//some other fileds
public String getStr(){
String str = null;
//Getting str from the fields + some other fields
return str;
}
}
现在,我有一个具有类型参数的方法Derived.
public void makeStr(Derived d){
Base b = null;
//Getting the Base class subobject from d and printing the str
}
但我不能只是做任务b = d;然后调用b.getStr()因为该方法 …
我正在阅读J. Bloch的有效Java,现在我在数组与列表部分.以下是他提供的未经检查的演员的示例:
interface Function<T> {
T apply(T arg1, T arg2);
}
public class Main{
public static void main( String[] args ){
Function<String> f = null;
List<String> str = Arrays.asList("asd");
//staff
reduce(str, f, ""); //E's deduced to String. Where is type-unsafe?
}
static <E> E reduce(List<E> list, Function<E> f, E initVal) {
E[] snapshot = (E[]) list.toArray(); // Unchecked cast
E result = initVal;
for (E e : snapshot)
result = f.apply(result, e);
return result;
}
}
他说这种方法不是类型安全的,我们可以轻松搞定ClassCastException.但我不知道怎么做.哪里是类型不安全的,类型变量E …