小编ari*_*rin的帖子

我一直在争夺PrintServiceLookup; lookupPrintServices(DocFlavor flavor, AttributeSet attributes)使用初始磨合,在我们的应用程序中检测打印机的方法过于缓慢.拥有100多台网络打印机的客户端报告说,执行此代码的行为在第一次运行时性能很差.

在看到查找结果被缓存后,我最初在一个单独的线程中部署了一个虚拟查找(在启动时执行).但是,对于特定客户端,此解决方案无效.

我目前没有他们的环境,也无法看到导致确切性能问题的原因.

我试图看看是否PrintService支持给定MediaSizeName 而不执行查找DocFlavor和AttributeSet.所以我拉出所有可用的PrintServices和默认值PrintService:

private static final PrintService[] PRINTSERVICES = 
   PrintServiceLookup.lookupPrintServices(null, null);

private static final PrintService DEFAULTSERVICE = 
   PrintServiceLookup.lookupDefaultPrintService();

然后,从客户端请求中获取PrintService和MediaSizeName.最后,我问PrintService是否MediaSizeName支持:

private void checkPrintServiceForMediaSize(PrintService pservice) throws MediaSizeNotSupportedException{
     if(!pservice.isAttributeValueSupported(_mediaSizeName,null,null))
            throw new MediaSizeNotSupportedException("This media size is not supported by the selected printer.");
     }

该API声明时isAttributeValueSupported(Attribute attrval,DocFlavor flavor,AttributeSet attributes)被调用,零DocFlavor和AttributeSet

此方法指示此Print …

我通常在使用带command+的Eclipse时关闭标签w,但有时会错误地点击command+ q.即使我有Eclipse设置在退出时警告我(首选项 - >常规 - >启动和关闭,"关闭最后一个窗口时确认退出"),这个快捷方式似乎绕过警告,这非常烦人.

是否有解决方案与Chrome在点击此快捷方式时显示警告的方式相同？一些plist文件中的hack 可能吗？谷歌搜索没有多大帮助.

在维基百科上提到,此方法在O(n log n)时间内对数组进行排序,但它也是稳定且就地的.这听起来像是一个非常好的排序算法,因为没有其他排序算法一次完成所有这些(Insertion Sort不是O(n log n),Heap Sort不稳定,Quicksort(或Introsort)也不是放置或稳定,Mergesort不在位).但是,在维基百科上只提到了它的名字而没有别的.作为参考,它是Franceschini,Gianni(2007年6月1日)."使用O(n log n)比较和O(n)移动稳定地进行排序".计算系统理论40(4):327-353.然而,这并没有真正解释它是如何实际运作的,它更多地说明了它存在的原因.

我的问题是这个方法是如何工作的(它实际上做了什么步骤),以及为什么有这么少的资源与它有关,考虑到没有其他已知的O(n log n)稳定到位的排序方法.

我有以下结构:

class Bar{
  ....
  protected void restore(){
    ....
  }

  ....
}

该课程扩展Foo如下:

class Foo extends Bar{
    ....

    @Override
    public void restore(){  //valid override
        super.restore();

        ....
    }
}

在我的jUnit测试中,我想测试一下,当foo.restore()调用时,super.restore()随后会调用它.因此,下面是我的jUnit测试方法:

class FooTest{
  @Tested
  Foo _foo;

  @Test
  void testRestore(final Bar bar){

    new Expectations(){{
      bar.restore(); times = 1; // Error! bar.restore() not visible
    }};

    Deencapsulation.invoke(_foo,"restore");
  }
}

不幸的是,我的测试无法编译.原因是1)restore()父母protected和2)FooTest并且Foo在一个单独的项目(因此文件夹)中一起存在Bar.

反正有没有达到预期的测试？我已经检查了jMockit教程(过去几个月多次)并且没有看到类似的测试(在Google上进行搜索也是如此).

更新

在响应的帮助下,我理解强制执行子类调用super并不是最佳实践,但这不是我的实现,我仍然需要测试它.我仍在寻找一种方法来强制执行我的jUnit测试,以检查是否正在调用父项.

Java-8中不允许以下内容:

public interface Operator {
    default String call() throws Exception {
      // do some default things
      return performOperation();
    }

    String performOperation();
}

public abstract class AbstractTestClass {
    public abstract String call() throws Exception;
}

public class TestClass extends AbstractTestClass implements Operator {
    @Override
    public String performOperation() {
      // do some operation
    }
}

上面的错误消息无法编译,说明TestClass需要抽象或覆盖调用方法.

我当时认为默认方法可以提供必要的覆盖.为什么这不起作用？

我不得不做以下事情:

public interface Operator {
    default String doCall() throws Exception {
      // do some default things
      return performOperation();
    }

    String performOperation();
}

public …

在List接口的Collection框架教程中,有一个关于从List实现中删除元素的性能的有趣引用:

对于许多常见的List实现,例如ArrayList,从列表末尾删除元素的性能明显优于从头开始删除元素的性能.

这些教程没有进一步解释这一点,我试图弄清楚为什么会这样.

考虑ArrayList<Integer> list如下:

在第一种情况下,如果我们从结尾删除最后4个元素list,那么这些元素的值将设置为null(或等效).我的理论是,当需要复制操作时,只会null复制不可复制的元素.

在第二种情况下,如果我们删除前4个元素,它们将被反复设置为null仅null复制非元素.

所以从这个角度看,表演看起来差不多了.如果从最后执行操作更快,还有另一个原因吗？

另一方面,因为LinkedList反转似乎是真的; 从开头删除更快,而从末尾删除需要几乎完全遍历,除非tail-pointer 保留.

我有一个Arrays.sort(char[])以下列方式使用的代码:

    void arrayAnalysis(String[] array){
      for(int a=0; a<array.length;a++){
        char[] letters = array[a].toCharArray();
        Arrays.sort(letters);
        ...
        for(int b=a+1; b<array.length;b++){
          char[] letters2 = array[b].toCharArray();
          Arrays.sort(letters2);

          if(Arrays.equals(letters, letters2)
            print("equal");
        }
      }
    }

在这种情况下,n等于数组大小.由于嵌套的for循环,性能自动为O(n ^ 2).但是,我认为Arrays.sort(带有O(nlog(n)))也会影响性能并使其比O(n ^ 2)更差.这个想法是否正确？

最后的表现是O(n*nlog(n)*(n*nlog(n))吗？还是我离开了？

谢谢.

编辑:我应该补充一点,当n与数组大小相关时,Arrays.sort正在处理数组元素中的字母数.如果应该将其添加到性能分析中,这是我困惑的一部分.

编辑2:如果下选民留下评论为什么它被认为是一个糟糕的问题,那将是很酷的.