为什么以下代码在Java 8 + eclipse中成功编译并运行？
package package1;
interface A
{
static void main(String[] args) {
System.out.println("Hi");
}
}
如果将A更改为类,则运行时需要将其作为公共类,但对于接口则不然.这似乎不一致.
编辑:我在发布问题时所做的上述陈述是错误的.(我一定很累,误读了错误).Java不要求托管main的类是公共的,只需要方法.但是,类型托管main不必是公共的,而主要的方法是公共的,这有点不一致.
在关于lambda和匿名类之间差异的一个论点中,在这篇文章中:
我读了一个声称"Lambdas可以拥有状态",就像匿名类实例一样.
据我所知,你不能添加专属于lambda的用户定义状态,因为没有办法在java lambda函数的实现上定义实例成员.
例如:
Runnable r= () -> { int x = 5; }; // defines a local - no way to define instance
Runnable r2 = new Runnable() {
int x; // defines state via instance member
@Override
public void run() {
// TODO Auto-generated method stub
}
};
只是为了澄清,我并不是想将状态引入lambda,因为我认为这违背了意图.我只是想验证或反驳上述堆栈溢出问题上由信誉良好的来源做出的技术性声明.
我想用优雅的java 8流或lambda解决方案替换以下for循环.有什么简洁有效的吗？
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<>( Arrays.asList( 10,-3,5));
// add 1/2 of previous element to each element
for(int i =1 ;i < myList.size(); ++i )
myList.set(i, myList.get(i)+myList.get(i-1)/2);
// myList.skip(1).forEach( e -> e + prevE/2 ); // looking for something in this spirit
}
当使用带有类级别注释的 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 …extern嵌套局部作用域中的此声明是将全局a带回作用域的有效且已定义的方法吗？
int a = 1; // may be in another file
void main() {
int a = 2; // hides the global
{
cout << a << endl; // prints 2
cout << ::a << endl; // obviously 1
extern int a;
cout << a << endl; // also prints 1
}
}
自动占位符类型和显式定义的模板类型参数是否完全等效？
我读到规范指出“占位符类型说明符指定一个占位符类型，稍后将通过从初始值设定项中推导来替换该占位符类型”。
（9.2.8.5 占位符类型说明符 http://eel.is/c++draft/dcl.spec.auto#:auto ）
那么就实例化、常量类型、引用类型等而言，以下内容是否等效？
void f1(auto param) {
using T = decltype(param);
T t1;
}
template <class T> void f2(T param ) {
T t1;
}
我想在以下代码中摆脱变量temp:
type myinterface interface {
f1()
}
type a struct {
val int
}
type b struct {
mi *myinterface
}
func (a) f1() {
}
func demo() {
a1 := a{3}
var temp myinterface = a1
b1 := b{&temp}
fmt.Println(b1)
但如果我试着写
b1 := b{&myinterface(a1)}
我收到了消息
不能取myinterface的地址(a1)(undefined)
这样做的正确方法是什么？
更新:
我没有指向接口的指针,因为接口可以包含结构或指向结构的指针,这也在这个问题中详述:
首先让我说我知道 System.gc() 更像是收集垃圾的建议而不是命令，并且不能保证收集完成、启动或收集特定对象。但是...
使用以下代码，仅当我在引用中显式放置 null 时，才会收集 a1 实例。如果 a1 只是超出范围，则不会被收集。
class A {
@Override
protected void finalize() throws Throwable {
System.out.println("Collecting A");
}
}
public class Example {
public static void main(String[] args) throws InterruptedException {
try {
A a1 = new A();
//a1 = null; // a1 gets collected only if I uncomment this line
}
finally {
System.out.println("Finally executed");
}
System.gc();
Thread.sleep(1000);
}
}
为什么 a1 在没有强引用的情况下只是超出范围而不会被收集？是不是因为这个作用域不构成单独的栈帧？
这是一个后续问题
有很多文章和博客提到 Java 和 JVM 指令重新排序，这可能会导致用户操作中出现反直觉的结果。
当我要求演示 Java 指令重新排序导致意外结果时，有几条评论说，更普遍的关注领域是内存重新排序，并且很难在 x86 CPU 上进行演示。
指令重新排序只是内存重新排序、编译器优化和内存模型等更大问题的一部分吗？这些问题真的是 Java 编译器和 JVM 特有的吗？它们是否特定于某些 CPU 类型？
java cpu-architecture memory-barriers instruction-reordering
假设我有一个使用自定义类加载器加载的类
Class<?> clz = myClassLoader.loadClass("classLoaders.Test");
如何在不创建实例,了解其成员或使用反射的情况下初始化类(运行其静态初始化程序)？
就像 STL 中有 count_if 和 remove_if 算法一样，我想找到类似 execute_if 的东西，它将条件谓词与要执行的函数分开。
例如，我想要 1 行使用 2 个 lambdas 打印所有赔率，如下所示：
auto vec = vector<int>{ 1,2,3,4,5 };
for_each_if(vec.begin(), vec.end(), [](auto val) {return val % 2 != 0; }, [](auto val) { cout << val; });
用算法做到这一点的好方法是什么？