小编shm*_*sel的帖子

我正在尝试编译,我收到此错误:

enigma/Rotor.java:30: incompatible types found : java.lang.String required: int     switch(name){
1 error

为什么我收到此错误？我如何解决它？它在包中,我似乎无法弄明白.这是代码:

String label;

Rotor(){;}

Rotor(String name){
  switch(name){
    case "B":
      conversion_chart = B;
      break;
    case "C":
      conversion_chart = C;
      break;
    case "I":
      conversion_chart=I;
      notch = NOTCH[0];
      break;
    case "II":
      conversion_chart=II;
      notch = NOTCH[1];
      break;
    case "III":
      conversion_chart=III;
      notch = NOTCH[2];
      break;
    case "IV":
      conversion_chart=IV;
      notch = NOTCH[3];
      break;
    case "V":
      conversion_chart=V;
      notch = NOTCH[4];
      break;
    case "VI":
      conversion_chart=VI;
      notch = NOTCH[5];
      break;
    case "VII":
      notch = NOTCH[6];
      conversion_chart=VII;
      break; …

当我运行以下Java代码时:

ClassLoader c = new ClassLoader() {
    @Override
    public Class<?> findClass(String name) {
        return Object.class;
    }
};

Class<?> cc = c.loadClass(Object[][].class.getName());

System.out.println(cc.getName());

我得到java.lang.Object的显示终端,即使我代替Object[][].class.getName()通过[[Ljava.lang.Object在代码中.问题是我期待控制台显示[[Ljava.lang.Object.

实际上,在JVM规范中,我可以阅读以下内容:

数组类由Java虚拟机(第5.3.3节)直接创建,而不是由类加载器创建.但是,D的定义类加载器用于创建数组类C的过程中.

既然Object[][]是一个数组类,我假设findClass不会使用参数调用我[[Ljava.lang.Object的元素类型java.lang.Object.

此外,在"创建数组类"一节中,实际描述了递归算法:

如果组件类型是引用类型,则使用类加载器L递归地应用本节的算法(第5.3节)以便加载并由此创建C的组件类型.

所以我的问题是:

• 为什么我得到这个输出？这是否意味着我必须在我的ClassLoader中手动包含这个递归算法,而不是让JVM为我做这个？如果这意味着什么,最好的方法是什么？
• 我是否误解了第一个引文中的"创建"？它只是意味着我不能创建运行时数组类,但我仍然可以修补它的加载？

我正在实现一个Spliterator通过trySplit()返回明确限制并行化的方法null.实施estimateSize()是否会为此分裂器生成的流提供任何性能改进？或者估计的大小仅对并行化有用？

编辑:澄清一下,我特别询问估计的大小.换句话说,我的分裂者没有这个SIZED特征.

我有这句话来自Goetz的Java Concurrency In Practice:

由于上下文切换导致的线程运行时开销包括保存和恢复执行上下文,丢失局部性以及调度线程而不是运行它们所花费的CPU时间.

什么是"失去地方"？

目前,我正在学习java.time API和我注意到,多数类(例如LocalDate,OffsetDateTime在java.time)实现TemporalAdjuster接口,但ZonedDateTime没有.我只是想知道为什么会这样？为什么要排除ZonedDateTime实现TemporalAdjuster界面？

我正在寻找将我的日食版本（Mars）升级到最新版本（Oxygen）的步骤，因为我使用Masr已有很长时间了，因此它包含所有设置，插件和所有历史记录，因此我希望保留不变并升级到新版本。

这可能吗？

注意：对于任何类型的开发（例如Java，C / C ++，PHP，Javascript和Testers），它都可以是任何类型的蚀

我试图理解在“流文档”中发现的警告。我已经习惯了使用forEach（）作为通用迭代器。这导致我编写这种类型的代码：

public class FooCache {
    private static Map<Integer, Integer> sortOrderCache = new ConcurrentHashMap<>();
    private static Map<Integer, String> codeNameCache = new ConcurrentHashMap<>();

    public static void populateCache() {
        List<Foo> myThings = getThings();

        myThings.forEach(thing -> {
            sortOrderCache.put(thing.getId(), thing.getSortOrder());
            codeNameCache.put(thing.getId(), thing.getCodeName())
        });
    }
}

这是一个简单的例子。我了解该代码违反了Oracle关于有状态lamda和副作用的警告。但是我不明白为什么这个警告存在。

运行此代码时，它似乎表现出预期的效果。那么，我如何打破这一点来说明为什么这是一个坏主意？

在某种程度上，我读到以下内容：

如果并行执行，则ArrayList的非线程安全性将导致错误的结果，而添加所需的同步将导致争用，从而削弱了并行性的优势。

但是，谁能增加清晰度以帮助我理解警告？

有效的Java第3版,第18项:优先于继承的组合描述了使用继承向类添加行为的问题:

子类中脆弱性的一个相关原因是它们的超类可以在后续版本中获取新方法.假设程序依赖于其安全性,因为插入到某个集合中的所有元素都满足某些谓词.这可以通过继承集合并覆盖每个能够添加元素的方法来保证,以确保在添加元素之前满足谓词.这可以正常工作,直到在后续版本中将能够插入元素的新方法添加到超类中.一旦发生这种情况,仅通过调用新方法就可以添加"非法"元素,而新方法不会在子类中重写.

推荐的解决方案:

不要扩展现有类,而是为新类提供一个引用现有类实例的私有字段...新类中的每个实例方法都会在现有类的包含实例上调用相应的方法并返回结果.这称为转发,新类中的方法称为转发方法 ...向现有类添加新方法对新类没有影响...编写转发方法很繁琐,但你必须为每个接口只写一次可重用转发类,并为您提供转发类.例如,Guava为所有集合接口提供转发类.

我的问题是,风险是否仍然存在方法也可以添加到转发类,从而打破子类的不变量？像Guava这样的外部库如何在转发类时采用更新的方法而不会冒客户端的完整性？

为什么Java可以推断多个上限类型的共同祖先,而不是下限类型的共同祖先？

更具体地说,请考虑以下示例:

static class Test {

    static <T> T pick(T one, T two) {
        return two;
    }

    static void testUpperBound() {
        List<? extends Integer> extendsInteger = new ArrayList<>();

        // List<? extends Integer> is treated as a subclass of List<? extends Number>
        List<? extends Number> extendsNumber = extendsInteger;

        // List<? extends Number> is inferred as the common superclass
        extendsNumber = pick(extendsInteger, extendsNumber);
    }

    static void testLowerBound() {
        List<? super Number> superNumber = new ArrayList<>();

        // List<? super Number> is treated as …

我有一个方法,它采用整数列表作为参数.我目前有一个很长的列表,并希望将其转换为整数列表,所以我写道:

  List<Integer> student =
  studentLong.stream()
  .map(Integer::valueOf)
  .collect(Collectors.toList());

但我收到一个错误:

method "valueOf" can not be resolved. 

实际上是否可以将long列表转换为整数列表？