小编Gen*_*zer的帖子

我有一个接口,其声明如下:

/**
* @param T - the type of entity.
* @param C - the type of entity container will be returned.
*/
public interface FindByNamedQuery<T extends Serializable, C extends Collection<T>> extends Command {
    C executeNamedQuery(String namedQuery);
}

我想知道我是否可以(应该)打破Java命名约定来执行此操作:

public interface FindByNamedQuery<ENTITY_TYPE extends Serializable, RETURNED_CONTAINER extends Collection<ENTITY_TYPE>> extends Command {
    RETURNED_CONTAINER executeNamedQuery(String namedQuery);
}

我正在写一本字典,大量使用String作为键Map<String, Index>.我关心的是哪一个HashMap,并TreeMap会产生更好的(更快)的性能在搜索在地图上的关键？

我正在为android制作一个字典应用程序.这个应用程序使用stardict和DICT文件,这些文件通常很大(10MB或更多)并且只包含纯文本.

当用户查找单词时,我的应用程序将随机读取该文件并返回结果.我读过一些文章,认为阅读文件既昂贵又缓慢.所以我想知道将所有数据带入数据库是否是更好的解决方案？

我有用于处理原始数组输入的类:char []的CharArrayExtractor,byte []的ByteArrayExtractor,int []的IntegerArrayExtractor,...

public void CharArrayExtractor {

    public List<Record> extract(char[] source) {
        List<Record> records = new ArrayList<Record>();
        int recordStartFlagPos = -1;
        int recordEndFlagPos = -1;
        for (int i = 0; i < source.length; i++) {
            if (source[i] == RECORD_START_FLAG) {
                recordStartFlagPos = i;
            } else if (source[i] == RECORD_END_FLAG) {
                recordEndFlagPos = i;
            }
            if (recordStartFlagPos != -1 && recordEndFlagPos != -1) {
                Record newRecord = makeRecord(source, recordStartFlagPos,
                        recordEndFlagPos);
                records.add(newRecord);
                recordStartFlagPos = -1;
                recordEngFlagPos = -1;
            }
        }
    } …

假设我有一个类层次结构如下:

class Vehicle;
class Car extends Vehicle;
class Plane extends Vehicle;

我有一个比较两个对象的函数

public <T extends Vehicle> generateDiff(T original, T copy)

在编译时,上面的方法保证了两个对象Vehicle,但是它不能确保两个对象的类型是相同的.

generateDiff(new Car(), new Car()); //OK
generateDiff(new Plane(), new Plane()); //OK
generateDiff(new Car(), new Plane()); //WRONG

我可以在编译时使用泛型来实现这个目的吗？

Ps:目前,我已实现它将抛出异常,如果Class两个对象不相同.但我对此并不满意.

提前致谢.

可能重复:
未定义的行为和序列点

x这段代码后的价值是多少？

int x = 5;
x = ++x + x++;

在Java中,结果是12,但在C++中,结果是13.

我搜索了Java和C++的运算符优先级,它们看起来一样.那么为什么结果不同呢？是因为编译器吗？

我有一个包含缓存(Set)的类,缓存是在实例化的基础上构建的.我很困惑,如果构建缓存失败(无法连接到数据库或某些),我应该抛出哪个异常/错误.

class Provider {

   public Provider() {
       buildCache();
   }

   private void buildCache() {
       try {
           this.cache = getDataFromDb();
       } catch (Exception ex) {
           throw new ???
       }          
   }
}

我脑子里有一个例外ExceptionInInitializerError,但是javadoc说它是在初始化静态成员时抛出的.

我应该抛出一个IllegalStateException原因,没有构建缓存,所以这个类是没用的？

很明显,我可以创建自己的ErrorOnBuildingCache并抛出它,但我想知道Java库中的任何异常是否适合这种情况.

我有一段代码创建一个新String的如下:

private final static Charset UNICODE_CHARSET = Charset.forName("UTF-8");

public String makeNewUnicodeString(byte[] octects) {
    return new String(octects, UNICODE_CHARSET);
}

在我的计算机上测试时它工作正常.但是当我在Android模拟器上运行时,它会抛出:

java.lang.NoSuchMethodError: java.lang.String.<init>

但这有效:

public String makeUnicodeString(byte[] octets) {
    try {
        return new String(octets, "UTF-8")
    } catch (UnsupportedEncodingException uee) {
       // never throw.
    }
}

我正在使用Android 2.2 API 8,rev 2.

我正在编写一个读取文件的程序(使用自定义缓冲区,8KB),然后在该缓冲区中找到一个关键字.由于Java提供了两种类型的流:字符和字节,我使用它们byte[]和char[]缓冲来实现它.

我只是想知道,这将是对性能更快,更好,因为char是2 byte和使用时Reader阅读起来char[]时,Reader将执行转换从后byte到char,我认为可以把它比仅使用较慢byte[].

我一直在尝试重现(并解决)ConcurrentModificationException当一个实例HashMap被多个Threads 读取和写入时.

免责声明:我知道这HashMap不是线程安全的.

在以下代码中:

import java.util.*;

public class MyClass {

    public static void main(String args[]) throws Exception {
        java.util.Map<String, Integer> oops = new java.util.HashMap<>();
        oops.put("1", 1);
        oops.put("2", 2);
        oops.put("3", 3);

        Runnable read = () -> {
            System.out.println("Entered read thread");

            /*
             * ConcurrentModificationException possibly occurs
             *
            for (int i = 0; i < 100; i++) {
                List<Integer> numbers = new ArrayList<>();
                numbers.addAll(oops.values());
                System.out.println("Size " + numbers.size());
            }
            */

            for (int i = 0; …