小编Mor*_*Adi的帖子

我无法弄清楚为什么JCF(Java Collection Framework)没有Bag实现(允许重复而不维护顺序).Bag性能比JCF中的当前Collection实现要好得多.

• 我知道如何在java中实现Bag.
• 我知道Apache中有一个Bag集合.
• 我知道我可以使用任何实现作为一个包!但是与Bag相比,在其他实现方面有很多工作要做.

为什么Java Collections框架没有提供这样的直接实现？

我有一个复杂的html表单,使用java脚本动态创建.

我想在java中将键值对的映射作为Map并存储它们.

这是我的控制器来获取提交的数据.

@RequestMapping(value="/create", method=RequestMethod.POST, 
    consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
public String createRole(Hashmap<String, Object) keyVals) {
    ....
}  

但我的地图是空的.

如何在Spring mvc控制器中将表单数据作为名称 - 值对的映射？

我发现了一个非常令人困惑的死锁情况,我需要帮助才能理解.

有两个事务正在进行:
(2)持有查询锁delete from myTable where id = NAME_CONST('p_id',10000).这是PRIMARY KEY的锁定,虽然不是完整的密钥而是范围.看起来这对我来说是一个完整的写锁定lock_mode X locks rec but not gap.
(1)正在等待同样的锁,也用于查询delete from myTable where id = NAME_CONST('p_id',10000).
(2)也试着去获取此锁并且MySQL检测到死锁.

我无法理解的是为什么(2)必须再次获取锁,因为它已经拥有它并且它在所有情况下都是写锁(lock_mode X).

它看起来也像是完全相同的查询.

这是表定义

create myTable (
  id int unsigned not null,
  value1 char(8) not null,
  value2 int unsigned,
  primary key (id, value1)
);

这是来自的信息 SHOW ENGINE INNODB STATUS\G

------------------------
LATEST DETECTED DEADLOCK
------------------------
130313 14:46:28
*** (1) TRANSACTION:
TRANSACTION 75ACB8A3, ACTIVE 0 sec, process no 6110, OS thread id …

我认为java擦除会在编译时擦除泛型类型,但是当我自己测试它时,我意识到在Bytecode中有一些关于泛型类型的信息.

这是我的测试:

我写了2节课:

import java.util.*;
public class Test {
    List integerList;
} 

和

import java.util.*;
public class Test {
    List<Integer> integerList;
} 

我编译了这两个类和泛型类中的某个地方,我看到了这一行

integerList{blah blah}Ljava/util/List;{blah blah}
Signature{blah blah}%Ljava/util/List<Ljava/lang/Integer;>;{blah blah}<init>

在非泛型类中:

integerList{blah blah}Ljava/util/List;{blah blah}<init>

所以显然我在字节码里面有通用信息所以这个擦除的东西是什么？

我们有3层应用程序,每个来自服务层的调用都通过数据层进入业务层和peresist.每层的组件只能调用下面的层;

但是因为我们有数百个实体,而且我们有很多与crud operatins相关的服务,所以我们的团队提出了很多反复无常的事情.

有些人认为,为了维护和易于开发,最好从crud服务调用数据访问,这只是进行crud操作并绕过业务层.

相反,有些人说我们必须为业务层中每个实体的数据访问创建包装器,并从服务中调用这些包装器,永远不允许服务调用数据访问层.

在你的想法中我们应该采取哪种方式？crud服务是否可以调用数据访问并绕过业务层？

有一个内部类SynchronizedCollection - 在java.util.Collections里面有两个构造函数.第一个采用集合,另一个采用集合和互斥.前构造函数检查参数是否为空.但后来不要!这是实施.

 SynchronizedCollection(Collection<E> c) {
        if (c==null)
            throw new NullPointerException();
        this.c = c;
        mutex = this;
  }
 SynchronizedCollection(Collection<E> c, Object mutex) {
        this.c = c;
        this.mutex = mutex;
 }

使用此实现,我可以通过向第二个构造函数发送null来打破类不变量.

我相信它应该是这样的:

 SynchronizedCollection(Collection<E> c) {
        this(c,this)
  }
 SynchronizedCollection(Collection<E> c, Object mutex) {
        if (c==null)
            throw new NullPointerException();
        this.c = c;
        this.mutex = mutex;
 }

但是我无法说服自己Josh Bloch和Neal Gafter看不到这一点.你能真的告诉我我错过了什么吗？

编辑:可能的攻击

    Map<String, String> m = new Map<String, String>(){

        @Override
        public int size() {
            // TODO Auto-generated method stub
            return 0;
        }

                   .
                   . …

拥有这两种方法的IMO是多余的,真的不清楚!我不太明白为什么这两种方法都是在Files API中设计的？

如果文件确实存在,Files.exist(..)返回true,如果不存在或没有权限则返回false.那么为什么在地狱里有一个Files.notExist(..)??

Oracle Docs说!Files.exists(...)不等同于Files.notExists(...)!? 也许有些东西让我无法理解!

当存在exists()方法时,使用notExist()有什么好处？

我无法理解为什么使用Stream api在同一个数组上迭代多次会导致这样的性能!

请参阅下面的代码.

public class WhyIsDifferent {

public static void main(String[] args) {

    int[] values = getArray();
    Iterate(values, 598, 600); // 70 ms
    Iterate(values, 200, 202); // 0 ms
    Iterate(values, 700, 702); // 0 ms
    Iterate(values, 300, 310); // 1 ms
}

public static void Iterate(int[] values, int from, int to) {
    long start = System.currentTimeMillis();
    IntStream.of(values).filter(i -> i < to && i > from)
    .forEach(i -> 
        System.out.println(i) // do a something
    );
    System.out.println("Time:" + (System.currentTimeMillis() - start));
}

public …

我在很多地方甚至在Java核心本身看到,尽管在父类中实现了一个接口,但子类明确地实现了相同的接口.

作为一个例子,这是一个AbstractSet实现Set 的定义

public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> 

和HashSet扩展AbstractSet.

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable

我们为什么要再次明确实施Set？再次LinkedHashSet延伸相同的模式HashSet.

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, java.io.Serializable 

LinkedHashSet延伸Hashset,

HashSet农具Set<E>,Cloneable,java.io.Serializable

LinkedHashSet隐式实现所有接口,其父级扩展.那么为什么呢？我试图搞清楚,但我找不到背后的原因.即使是为了可读性,为什么不明确地实现Collection？

如果删除这个不必要的implements关键字,它的可读性更强 有谁知道这背后的原因？

我在SOF上看到了一些关于这个的问题,但我不相信这是为了更好的可读性,如果这也是为什么不实现Collection接口呢？

我阅读了许多关于不同风格的论坛和帖子,以实现java中的单音模式,似乎"Enum是在java中实现单音模式的最佳方式"!! 我想知道如何使用Java Enum在具有延迟加载功能的java中实现SingleTone模式.因为Enums只是课程.第一次使用类时,它由JVM加载并完成所有静态初始化.枚举成员是静态的,所以它们都将被初始化.

有谁知道如何使用enum与懒惰加载支持？

我们最近决定将我们的解决方案从java 7迁移到8.但是在第一步我们发现java 8中有一些实现更改,比如String.split()方法这可能会导致用Java 7编写的代码出现问题!

我们现在将我们的项目推向Java 7,以便更多地研究这些差异.

你知道Java 8中的任何其他变化都会导致同样的问题吗？

PS:我知道Java 8的新功能通过更改我的意思是那些使用相同API(方法签名)的更改,但不同的实现可能会导致不同的结果!! 喜欢这个方法 - > String.split()

在投票前阅读评论!!