小编pet*_*ter的帖子

我想知道使用空块的目的是什么.例如,

    static{
        int x = 5;
    }

    public static void main (String [] args){

          int i = 10;

          {
               int j = 0 ;
               System.out.println(x);  // compiler error : can't find x ?? why ??
               System.out.println(i);  // this is fine
          }
          System.out.println(j); //compiler error :  can't find j

    }

有人可以解释

1. 在什么情况下我们想要使用空块.
2. 该空块内的所有变量是否仍然存在stack？
3. 为什么不能访问static variable x？

我试图通过使用PURE Javascript(没有其他框架)来实现线扫描算法,它基本上从左到右扫描屏幕并查看共享相同x坐标的所有元素(包括重叠元素).

例如

我有6个div带黑色边框的元素,它们都在屏幕上随机排列.为了便于说明,我使用垂直虚线蓝线从左到右扫过飞机.目标是报告该行传递的所有元素.对于上面的例子,我们如何报告Div A,Div E,Div D,也是hyperlink D内Div D通过使用JavaScript？

我正在尝试实现一个读/写缓冲区类,它可以支持多个写入器和读取器,并且读取器可以在写入缓冲区时同时读取缓冲区.这是我的代码,到目前为止我还没有看到任何问题,但我不能100%确定这是否是线程安全的,或者是否有更好的方法.

public class Buffer{
       private StringBuilder sb = new StringBuilder();
       private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
       private Random random = new Random();

       public void read(){
            try{
                lock.readLock().lock();
                System.out.println(sb.toString());
            } finally{
                lock.readLock().unlock();
            }
       }
       public void write(){
            try{
                lock.writeLock().lock();
                sb.append((char)(random.nextInt(26)+'a'));
            } finally{
                lock.writeLock().unlock();
            }
       }
} 

有人可以解释一下以下代码的范围绑定吗

window.name = "window";

object = {
       name: "object",
       method: function() {
             nestedMethod: function() {
                   console.log(this.name);
             }
             nestedMethod();
       }
}

object.method();  // print 'window'

我认为我的问题更多是关于this......为什么this会失去范围并默认为全局范围？我们创建的所有匿名函数都会在全局范围内吗？

我想知道有没有办法简化以下代码？我试图通过使用EBean从数据库中获取一些东西.如果有什么东西然后将其映射到对象或以其他方式返回默认实现实例.

public static ObjectA test1() {

    Function<Optional<SqlRow>, ObjectA> sqlRowToObjectA= new Function<Optional<SqlRow>, ObjectA>() {
        @Override
        public AccountSummary apply(Optional<SqlRow> entry) {
            return entry.isPresent() ? new ObjectA(entry.get().getInt("id"), entry.get().getString("name"))
                 : ObjectA.EMPTY;
        }
    };

    return sqlRowToObjectA.apply(Optional.of(Ebean.createSqlQuery("select * from table1").findUnique()));
}

以下是典型的读写器模式(大量读取和少量写入)

  private ReadWriteLock lock = new ReentrantReadWriteLock();
  private int value;

  public void writeValue(int newValue){
       lock.writeLock().lock();
       try{
           this.value = newValue;
       }
       finally{
           lock.writeLock().unlock();
       }
  }

  public int readValue(){
       lock.readLock().lock();
       try{
           return value;
       }
       finally{
           lock.writeLock().unlock();
       }
  }

我想知道是否有可能优先考虑作家和读者？例如,通常编写者可能会等待很长时间(可能永远),如果其他线程持有读取锁定,那么是否可以让编写器具有更高的优先级,因此每当编写器出现时,它都可以被认为是正如高优先级(跳过线)类似的东西.

我对如何使用LinkedHashMap构建LRU缓存感到有点困惑(如何在Java 6中实现LRU缓存？),我想确保我理解它在幕后的内部工作原理.

假设我定义了一个类LRUMap,它扩展了LinkedHashMap并覆盖了removeEldestEntry(final Map.Entry<A, B> eldest)它的方式.

然后我构建数据结构并在地图中插入4个项目

    LRUMap<String,String> map = new LRUMap<String,String>(3); //capacity 3
    map.put("a", "a");
    map.put("b", "b");
    map.put("c", "c");
    map.put("d", "d");

并且通常LinkedHashMap使用被Entry object调用header的起始节点来链接您添加到地图中的所有项目.所以在这种情况下它会

   [header] ->  ["a"] -> ["b"] -> ["c"] -> ["d"] -> [header]

头文件Entry对象既是header.before = header.after = header,也是最初构造时双向链表的开头和结尾.

并且假设地图达到了我想要的最大条目(3项),并且来自

    Entry<K,V> eldest = header.after;
    if (removeEldestEntry(eldest)) {
         removeEntryForKey(eldest.key);
    }
    .....

那么这是否意味着它首先会删除["a"]？
当我们调用get(Object key)它时,重新排列列表顺序,它将该键放在标题节点之前(比如说"b"),所以它变成了

     [header] ->  ["c"] -> ["d"] -> ["b"] -> [header]

只是想澄清一下.

我想知道为什么HashSet在场景后面内部使用HashMap,TreeSet使用TreeMap和LinkedHashSet使用LinkedHashMap？因为Set只携带和存储密钥但值,所以不使用额外的内存空间,如不经济？

在Entry该内部类HashMap具有是以下

class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;
    ...
    ....
}

对于Set我们真的不需要那个V value变量,对吗？那么内部使用地图对象的好处和主要原因是什么？

我听到我的同事说，在缓存不可变的对象（最终的一致性）时，进程内缓存将是更好的选择。外部分布式缓存更适合于可变对象，而您始终希望读取保持一致（强）。

这始终是事实吗？我真的看不到可变性与一致性之间的关系。有人可以帮我理解吗？

我想知道如何强制立即评估Java8中的每个map函数？我现在的情况是我需要进行多个级别的转换(来自ObjectA - > ObjectB - > ObjectC - > ObjectD),并且在某个对象的转换的每个级别上都可能存在失败(抛出异常).例如

 // stream -> map -> collect sequence
 lists.stream()
      .map(aToB)
      .collect(Collectors.toList())
      .stream()
      .map(bToC)
      .collect(Collectors.toList())
      .stream()
      .map(cToD)
      .collect(Collectors.toList())

 // Try api is from javaslangs
 Function<ObjectA, ObjectB> aToB = a -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

 Function<ObjectB, ObjectC> bToC = b -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

 Function<ObjectC, ObjectD> cToD = c -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

我想测试我的单元测试中的每个转换,例如测试是否测试抛出异常,以及如果A在将A转换为B之类的异常时未成功转换为C,但是使用惰性求值,则无法测试,我能想到的唯一方法是做这一系列的steam() -> map(...) -> collect(...)调用,迫使立即进行评估.我想知道是否有更好的方式来写这个.