小编Gon*_*n I的帖子

我的目标是防止所有者以外的其他用户修改/读取权限。在ubuntu论坛上，对两种方法都给出了评论。

例：

sudo useradd -d /home/newuser -m newuser;
sudo chmod 700 /home/newuser # or # chmod go-rwx /home/newuser

=> chmod go-rwx和/ chmod 700或两者完成相同的事情之间是否有区别？如果存在差异，建议使用哪一个？

嗨，下面的语句会引发错误。它说“不是声明”

map.containsKey(1)? someObject.setFlag(true) : map.put(1,"hello");

是否需要将返回值存储在语句左侧的某个变量中？

我在紧密循环中有两个不同步的线程，将全局变量递增 X 次 (x=100000)。

全局的正确最终值应该是 2*X，但由于它们不同步，所以它会更少，根据经验，它通常只是略高于 X

然而，在所有测试运行中， global 的值从未低于 X 。

最终结果有可能小于x（小于100000）吗？

public class TestClass {
    static int global;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread( () -> {  for(int i=0; i < 100000; ++i) {     TestClass.global++;  }  });
        Thread t2 = new Thread( () -> { for(int i=0; i < 100000; ++i) {     TestClass.global++;  }  });
        t.start(); t2.start();
        t.join(); t2.join();
        System.out.println("global = " + global);
    }
}

为什么Stream.of()需要强制转换才能采用内联 lambda 表达式或方法引用？

考虑一下：

 Function<String,String> f = String::toUpperCase; // works without cast
 Stream.of(f); // works without cast
 //Stream.of(String::toUpperCase); // Error - target type must be functional interface
 Stream.of((Function<String,String>) String::toUpperCase); //OK

对变量 f 的赋值不需要强制转换，但当用作 Stream.of 的内联参数时，需要强制转换。为什么？

Arrays.asList(..)返回数组的列表包装器。此包装具有固定的大小，并直接由数组支持，因此，对add（）或试图修改列表的其他函数的调用将引发UnsupportedOperationException。

从堆栈溢出中的问题可以明显看出，开发人员常常对此感到惊讶。

但是，根据Liskov替换原理（LSP），List接口具有add（）方法，该方法对于List的所有派生类都应该正常工作

Arrays.asList（）返回的类型是否是违反Liskov替代原理的示例？

为了更好地理解C++ lambdas的实现,我欺骗了编译器将lambda视为一个对象,似乎它们在内存中的布局相同.

注意:这只是为了澄清,我不是在提倡在生产中编写这些类型的黑客

这是由语言规范还是编译器实现细节保证的？

struct F
{
    int a;  int b;  int c;
    void printLambdaMembers()
    {
        cout << this << endl; // presumably the lambda 'this'
        cout << a << endl; // prints 5   
        cout << b << endl;
        cout << c << endl;
    }
};

void demo()
{
    int a = 5;
    int b = 6;
    int c = 7;
    auto lambda = [a,b,c]() { cout << "In lambda!\n";  };
    // hard cast the object member function pointer …

我喜欢java中热切单身的简单性,大多数关于它的文章称它的创建线程是安全的.

class Singleton {

public static final Singleton instance = new Singleton ();

    private Singleton (){};

    public static Singleton getInstance(){

        return instance;

    }
}

但是我听到一些声称它的创建可能毕竟不是线程安全的.例如,一个消息来源声称如果使用多于1个类加载器或App域则不安全.

由JVM保证的Eager Singleton的创建是否是线程安全的,例如,2个线程不会意外地同时创建单例？

编辑:对象创建的线程安全性是否需要关键字final？如果该字段不是最终的,它不是线程吗？

我试图了解函数类型<void()>和函数指针类型之间的区别<void (*)()>

stl::function可以通过 指向函数<void()>，但我似乎需要<void (*)()>在我自己的模板类中使用：

void f1() {
    std::cout << "hi!\n";
}
template<class T> struct X
{
    T t;
};
int main()
{
    std::function<void()> f = f1;  // stl handles this, and f is callable
    f(); // OK

    // X<void()> x; // compilation error - a member of a class template cannot aquire a function type

    X<void (*)()> x2;  // OK
    x2.t = f1;  // OK
    x2.t();  // OK

    return 0;
} …

我在 Windows 上使用 Eclipse 连接到 wsl 上的文件，并且遇到了明显的 Eclipse 错误，该错误导致 \wsl$\folder1\pom.xml 等文件名被破坏。 https://bugs.eclipse.org/bugs/show_bug.cgi?id=577938

错误报告中的评论提出了可能的解决方法

A workaround is to map the UNC path to a drive letter, but this shouldn't be necessary

我该怎么做呢？

当使用带有类级别注释的 spring AOP 时，spring context.getBean 似乎总是为每个类创建并返回一个代理或拦截器，无论它们是否有注释。

此行为仅适用于类级别注释。对于方法级注解，或者执行切入点，如果不需要拦截，getBean 返回一个POJO。

这是一个错误吗？按设计？还是我做错了什么？

@Component
@Aspect
public class AspectA {

    @Around("@target(myAnnotation)")
    public Object process(ProceedingJoinPoint jointPoint, MyAnnotation myAnnotation) throws Throwable {
        System.out.println(
                "AspectA: myAnnotation target:" + jointPoint.getTarget().getClass().getSimpleName());
        System.out.println(" condition:" + myAnnotation.condition());
        System.out.println(" key:" + myAnnotation.key());
        System.out.println(" value:" + myAnnotation.value());
        return jointPoint.proceed();
    }
}




@Component("myBean2")
//@MyAnnotation(value="valtest-classLevel2", key="keytest-classLevel2", condition="contest-classLevel2")
 public class MyBean2 {
     public Integer testAspectCallInt(int i){
    System.out.println("MyBean2.testAspectCallInt(i=" + i + ")");
    return i+1000;
    }
}








@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation {
  String value()      default "";
  String …