小编dat*_*ler的帖子

我找到了这段代码

Stream foo() 
{
  ...
  return new MemoryStream(new[] { a, b });
}

并且可以猜测它的作用,但无法找到解释为什么byte[]可以省略类型定义的解释.我看了msdn c#的新解释,但那里太简单了.

有一个仍然支持Java 6的项目.下面的代码位于使用Compiler compliance level 1.6构建的jar文件中

应该从为java 6或更新版本构建的java应用程序中调用该jar文件.它在Java 8中运行良好.

现在使用Java9,我遇到了nio.DirectByteBuffer的问题,我尝试用这种方式解决它,使用反射:

@SuppressWarnings("unchecked")
static void cleanDirectBuffer(sun.nio.ch.DirectBuffer buffer) {
    if (JAVA_VERSION < 1.9) {
        sun.misc.Cleaner cleaner = buffer.cleaner();
        if (cleaner != null) cleaner.clean();
    } else {
        // For java9 do it the reflection way
        @SuppressWarnings("rawtypes")
        Class B = buffer.getClass(); 
        // will be a java.nio.DirectBuffer, which is unknown if compiled in 1.6 compliance mode
        try {
            java.lang.reflect.Method CleanerMethod = B.getMethod("cleaner");
            CleanerMethod.setAccessible(true);  // fails here !
            Object cleaner = CleanerMethod.invoke(buffer);
            if (cleaner == null) return;
            @SuppressWarnings("rawtypes") …

背景

对于嵌入式项目中的 UI，我正在寻找一种很好的通用方式来存储“状态”并通过按下按钮（例如菜单项列表）循环浏览它。

通常，我喜欢为此目的使用枚举，例如：

enum class MenuItem {
    main,
    config,
    foo,
    bar,
};

然后，在我的 UI 代码中，我可以存储一个currentMenuItem状态，如

MenuItem currentMenuItem = MenuItem::MAIN;

并通过与currentMenuItem枚举中声明的任何可能值进行比较来根据当前状态执行操作。

问题

问题是，我现在想进入下一个菜单项。为此，我可以非常轻松地编写一个函数，通过强制转换为 int，递增 1，然后将其转换回枚举来执行此操作。我有多个不同的枚举，所以我什至可以使用这个模板化函数来为任意枚举执行此操作：

template <typename T>
void advanceEnum(T &e) {
    e = static_cast<T>(static_cast<int>(e) + 1);
}

这样做的问题是它不会环绕：它会很高兴地继续增加底层整数，使其超出实际枚举中的元素数量。我可以很容易地解决这个问题（通过对上述函数中的元素数取模），只要有一种干净的方法来获取枚举的元素数。其中，据我所知，真的没有。

自定义枚举？

我正在考虑编写一个实现此行为的自定义“CyclicEnum”类，我随后可以从中派生。这样，我也可以把它写成一个重载的operator++.

但是，我仍然没有设计出如何在不实际使用枚举的情况下获得类似枚举的东西。例如，我得到了这样的东西：

class CyclicEnum {
public:
    uint8_t v;

    CyclicEnum& operator++() {
        v = (v+1) % count;
        return *this;
    }

    CyclicEnum operator++(int) {
        CyclicEnum old = *this;
        operator++();
        return old;
    }
private:
    uint8_t count;

protected: …

package a;
public class A {
  public String toString() {
    // return "I am an a.A"; is too primitive ;) 
    return "I am an " + getClass().getName(); // should give "a.A"
  }
}

-

package a;
public class X extends A {
  public static void main(String[] args) {
    X test = new X();
    System.out.println(test);  // returns "I am an a.X"
  }
}

我也试过this.getClass()和super.getClass().如何获取实际编码toString()和getClass()的类名？(AA)

这只是一个简化的示例,我的观点是如何避免在第一个文件(A.java)中对基类名称进行硬编码

我尝试以下代码：

import java.time.*; 
...
   LocalDateTime now = LocalDateTime.now();
   DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
                                    "dd-MMM-yyyy  HH:mm:ss.n");
   System.out.format("Now = %s %n", now.format(formatter));

为了获得具有亚秒级信息的输出 Now = 12-Apr-2018 14:47:38.039578300

不幸的是，在每秒的前100毫秒中，亚秒信息的前导零被忽略了，并且我得到了非常误导的输出Now = 12-Apr-2018 14:47:38.39578300，很容易将其误解为大约38.4秒，即整秒后的396毫秒，而不是真实的。 38.04秒

我发现的唯一工作方法是ss.nnnnnnnnn正好为9 的格式n，以得到所需的输出。

编辑：

有一个更好的东西，我在发布此问题时错过了。

我对纳秒并不真正感兴趣，但是我真正想要的只是几分之一秒（大约毫秒分辨率）。

然后，这个更合适

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

大写字母S表示亚秒数的位数，当然包括前导零。

我必须将c ++代码与java混合使用。java部分分配一个java.nio.ByteBuffer，而c ++部分通过env-> GetDirectBufferAddress（buffer）获取它的地址为jbyte *并填充数据。

ByteOrder可以。可以通过buffer.get（）.getLong（）等在Java中检索数据。

但是，方法buffer.array（）失败，并且hasArray（）返回false。如果我使用buffer.allocate（size）而不是.allocateDirect（size），则array（）方法效果很好，但是我的C ++代码获取的DirectDirectAddress为NULL并失败。

我的问题是：如何最好地结合两个世界，同时减少数据复制？或者，如何用本机c ++数据最简单地填充java byte []？

简化演示代码以显示我的问题.

class Base {
   public String toString() { return "Base"; }
};
class A extends Base {
   public String toString() { return "A"; }
};

class Test {
  public void test1() {
    A a = new A();
    Base b = (Base)a;    // cast is fine, but b is the same instance as a
    System.out.println(b.toString()); // want "Base", but get "A"
  } 

  private String testB(Base b) {
    return b.toString();   // this should return "Base"
  }   
  public void test2() {
    System.out.println( testB(new …

有没有比肆意抛出异常和捕获堆栈跟踪更好的方法来找出为什么(或至少从哪里)调用我的函数？

我可以记录调用者正在使用的参数,但我无法获得调用者位置本身.它是一些第三方软件,因此查找所有引用并添加日志信息不是一种选择.我也犹豫是否将调试器附加到正在运行的jvm.