小编Oro*_*102的帖子

我有两个表:一个有点,另一个有多边形.

CREATE TABLE `points` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `point` point NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM;

CREATE TABLE `ranges` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `poly` polygon NOT NULL,
  PRIMARY KEY (`id`),
  SPATIAL KEY `poly` (`poly`)
) ENGINE=MyISAM;

我希望将范围加入到多边形内的点上.查询看起来很简单:

SELECT * 
  FROM points 
    LEFT JOIN ranges 
      ON MBRCONTAINS(poly, point) 
  WHERE points.id = 2;

此查询工作正常并使用索引,解释的一部分:

table  | type  | possible_keys | key  | key_len
ranges | range | poly          | poly | 34

但是,当我尝试从表中连接几行时points: …

Java中保存值("o")的最佳方法是什么,如下所示:

                    obj1                 
                     /\
                    /  \
                   /    \
              obj2        obj3
              /\            /\
             /  \          /  \
            /    \        /    \
          obj4  obj5    obj6   obj7
          /\     /\     /\      /\
         /  \   /  \   /  \    /  \
        o8   oN...

它看起来像一棵树,但我不需要任意深度.我更需要强大的数据类型和预定义的好看方法来处理最终结构.

我需要能够通过键获得某种值列表 - 就像我的图片一样.换句话说,结构应该不成为以任何方式平面.

我需要.get(obj3)回来{obj6, obj7}, .get(obj1) - {obj2, obj3}.

现在我使用Map,但是膨胀这样的地图是丑陋的,因为我需要检查结构的每个级别.看起来那样(数据是地图):

if(data.get(somedouble) == null) {
    Map<Integer, Data> inm = new TreeMap<>();
    inm.put(someint, obj);
    Map<Double, Map<Integer, Data>> m = new TreeMap<>();
    m.put(somedouble2, inm);
    data.put(somedouble, m);
} …

我正在研究打印系统,需要在每个打印文档中添加任意文本(如作者,文档哈希,一些sysvars等).我们使用Java Printing Service(javax.print)作为打印客户端和Cups作为服务器.

Cups有一些称为"过滤器"的文档后处理程序.

过滤器 - 是一个由Cups推出的程序.杯子通过过滤一些参数 - 其中的"工作属性".

所以,我决定将自定义属性从java传递到cups并在过滤器中将属性作为文本添加到文档中.一切正常,文档被打印,但我没有在过滤器中获取我的属性.他们甚至没有被传递到Cups(在包嗅探器中看到它).

我已经使用getSupportedAttributeCategories()来查看支持的列表(通过打印机？)属性.也许我应该以某种方式将我添加到该列表中,但我不明白如何.

我不仅限于"属性",我只需要将java中的任意数据传递给Cups过滤器.我该怎么做？

我的java代码如下:

MyAttrSet attrs = new MyAttrSet();
attrs.add(new MyAttr(42));
attrs.add(new Copies(18));  

PrintService service = PrintServiceLookup.lookupDefaultPrintService();
DocFlavor flavor = DocFlavor.INPUT_STREAM.AUTOSENSE;
Doc doc = new SimpleDoc(is, flavor, null);
DocPrintJob job = service.createPrintJob();

job.print(doc, attrs);

Filter是一个简单的bash脚本,它打印传递给它的所有内容:

#!/bin/bash
echo "All args:" > /tmp/f1.log
for var in "$@"
do
        echo "$var, " >> /tmp/f1.log
done

/tmp/f1.log看起来像:

All args:
87, 
oroboros, 
 Java Printing, 
18, <- number of pages is passed! But not MyAttr …

我正在阅读关于在Sedgewick的"算法"中进行排序的章节.在此过程中,我编写了3种基本排序算法:选择,插入和shell排序.该书说,尽管所有三个都具有二次最坏情况复杂性,但shell排序应该比随机数据上的插入排序快得多.在本书中,他们获得了600倍的性能提升.

但是我的笔记本电脑上有以下乘法器(几乎不随数组大小的增加而改变):

• 选择:5.5x
• 插入:1x
• 外壳:1.8倍!

困扰我的问题是 - 为什么shell排序几乎比插入排序慢两倍？!

我想,我的shellort实现有问题.但我几乎从书中复制了它:

class ShellSort extends Sort {
    //precalculate sequence: 1, 4, 13, 40, 121, 364, 1093, ...
    //(3^20 - 1)/2 is enough for any array I sort
    private static final int[] SEQUENCE = new int[20];
    static {
        for(int i = 1; i <= SEQUENCE.length; i++)
            SEQUENCE[i - 1] = (int)(Math.pow(3, i) - 1) / 2;
    }

    public void sort(int[] a) {
        int length = a.length;

        int seqLen = SEQUENCE.length;
        int nth;
        int j; …

今天我在openjdk 7上使用javaagent和instrumentation来探索大型应用程序(如jboss服务器和应用程序)的类.我每隔10秒就调用所有类的重新转换,因此它们的字节码在我的ClassFileTransformer实现中得到.

我的实现只是跟踪类的字节码如何随时间变化.首先,我很惊讶,字段和方法的顺序,方法访问修饰符,常量池的内容和其他类似的东西因检查而异.但是,它仍然记录在案.

没有记录的内容 - 某些项目可以在类中创建常量池并注入方法中.现在我注意到数字值(Longs,Doubles,Floats等)会发生.

这是它在javap中的样子; 之前:

pool:
...
#17 Float NaNf
method:
#1 fload #17 //NaNf
...

在运行时更改类之后:

pool:
...
#17 Float NaNf
#18 Float NaNf
method:
#1 fload #18 //NaNf <- look, it loads #18 now

我仔细检查过,没有附加任何其他变压器或代理商.

为什么JVM不能让我的字节码保持不变？我在哪里可以阅读有关此类优化/转换(或其他什么)？我读过JVM源代码,但这些只会让我更加困惑.

我只是想创建一种实时字节码验证器 - 一种安全工具.

我知道,我们使用这个习惯来等待处理虚假唤醒的通知:

synchronized (obj) {
    while(somecond)
        obj.wait();
}

如果出现虚假的唤醒,我们只需检查状态并返回等待状态.

但是,考虑一下情况:

1. 我们开始等待,obj.wait()释放对obj的锁定.
2. 操作系统虚假通知等待线程
3. 我们返回检查条件(由于等待而释放obj锁)
4. obj.notify()在那一刻被称为正确.

是的,条件检查非常快,并且我们可以进行状态检查而不是进入的可能性obj.wait()小到可以忽略不计.在那种情况下,我们可以obj.notify()通话.

我是否误解了某些内容,或者我们真的可以使用此模式忽略通知？

试图理解Java中的upcasting.最近发现奇怪的行为.

例:

public class A extends B {

    public int i = 2;

    public void printI() {
        System.out.println("print i = " + this.i);
    }

    public static void main(String[] args) {

        B a = new A(); // <- upcasting here

        System.out.println("i = " + a.i);
        a.printI();
    }
}

class B {
     public int i = 1;
     public void printI() {}
}

//Output:
//i = 1
//print i = 2

似乎,upcasted对象有两个独立的"i"属性.一个"i"可以直接访问(ai),另一个通过子类(a.printI())的方法访问.

看起来像upcasted对象从超类和子类的方法获取属性.

对象如何拥有两个独立的"我"？!

我正在尝试实现基于java.nio Selector的http服务器(为了好玩).在key.isReadable()我读这样的数据:

ByteBuffer buf = ByteBuffer.allocate(4096);
SocketChannel client = (SocketChannel) key.channel();
//Gathering whole client request
((ByteBufferQueue) key.attachment()).enqueue(buf);
key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);

请看收集客户的请求.在OP_READ操作期间,在某种队列中收集ByteBuffers是一种常见做法吗？OP_READ和OP_WRITE操作之间是否还有其他(更优化)的通信方式？