<p><strong>堆排序 </strong > 可以就地排序，并且没有最坏的二次行为，但是在大多数情况下平均比快速排序慢。</p> 对其他包隐藏某些方法

如果在 Java 中没有子包的概念，有什么办法可以解决这个问题呢？我有一些只对测试人员和包中的其他成员可用的方法。我应该把所有东西都放在同一个包裹里吗？使用广泛的反射？

游行。

首先是一个定义，因为它非常重要: 稳定型保证不会用相同的键重新排序元素。

建议:

合并排序: 当您需要一个稳定的 O (N log N)排序时，这是您唯一的选择。它唯一的缺点是使用 O (N)辅助空间，并且常数比快速排序稍大。有一些就地合并排序，但 AFAIK 他们都不稳定或比 O (N 日志 N)更差。即使 O (N log N)适当排序的常数也比普通的合并排序的常数大得多，因此它们更多的是理论上的好奇心，而不是有用的算法。

快速排序: 当您不需要稳定的排序时，平均情况下的性能比最差情况下的性能更重要。快速排序的平均值是 O (N logN) ，最坏的情况是 O (N ^ 2)。一个好的实现是使用 O (log N)辅助存储，以堆栈空间的形式进行递归。

合并排序: 当您需要一个稳定的 O (N log N)排序时，这是您唯一的选择。它唯一的缺点是使用 O (N)辅助空间，并且常数比快速排序稍大。有一些就地合并排序，但 AFAIK 他们都不稳定或比 O (N 日志 N)更差。即使 O (N log N)适当排序的常数也比普通的合并排序的常数大得多，因此它们更多的是理论上的好奇心，而不是有用的算法。

堆排序: 当您不需要稳定的排序并且更关心最差情况下的性能而不是平均情况下的性能时。它肯定是 O (N log N) ，并使用 O (1)辅助空间，这意味着在非常大的输入上不会意外地用完堆或堆栈空间。

堆排序: 当您不需要稳定的排序并且更关心最差情况下的性能而不是平均情况下的性能时。它肯定是 O (N log N) ，并使用 O (1)辅助空间，这意味着在非常大的输入上不会意外地用完堆或堆栈空间。

内向排序: 这是一种快速排序，在一定的递归深度之后切换到堆排序，以避免快速排序的 O (N ^ 2)最坏情况。它几乎总是优于普通的老式快速排序，因为您得到了快速排序的平均情况，并保证了 O (N log N)性能。使用堆排序而不使用堆排序的唯一原因可能是在内存严重受限的系统中，其中 O (log N)堆栈空间实际上非常重要。

内向排序: 这是一种快速排序，在一定的递归深度之后切换到堆排序，以避免快速排序的 O (N ^ 2)最坏情况。它几乎总是优于普通的老式快速排序，因为您得到了快速排序的平均情况，并保证了 O (N log N)性能。使用堆排序而不使用堆排序的唯一原因可能是在内存严重受限的系统中，其中 O (log N)堆栈空间实际上非常重要。

插入 sort : 当 N 保证很小时，包括作为快速排序或合并排序的基本情况。当这是 O (N ^ 2)时，它有一个很小的常数，是一个稳定的排序。

插入 sort : 当 N 保证很小时，包括作为快速排序或合并排序的基本情况。当这是 O (N ^ 2)时，它有一个很小的常数，是一个稳定的排序。

气泡排序，选择排序 : 当你正在做一些又快又脏的事情时，由于某些原因，你不能仅仅使用标准库的排序算法。与插入排序相比，它们的唯一优点是实现起来稍微容易一些。

气泡排序，选择排序 : 当你正在做一些又快又脏的事情时，由于某些原因，你不能仅仅使用标准库的排序算法。与插入排序相比，它们的唯一优点是实现起来稍微容易一些。

非比较排序: 在一些相当有限的条件下，可以突破 O (N logN)壁垒，在 O (N)中进行排序。下面是一些值得一试的案例:

非比较排序: 在一些相当有限的条件下，可以突破 O (N logN)壁垒，在 O (N)中进行排序。下面是一些值得一试的案例:

计数排序: 当对范围有限的整数进行排序时。

计数排序: 当对范围有限的整数进行排序时。

基数排序: 当 log (N)显著大于 K 时，其中 K 是基数位数。

基数排序: 当 log (N)显著大于 K 时，其中 K 是基数位数。

Bucket sort: 当您可以保证您的输入是近似均匀分布的时候。

75623 次浏览
小开

@ dsimcha 写道:

在 Java 中没有子包的概念，所以 odp.proj和 odp.proj.test是完全独立的包。

对正整数进行排序(0-Integer.MAX _ VALUE-2，因为存在鸽子洞)。

计数排序: 当对范围

有限的整数进行排序时

我会改成:

您总是可以得到最大值和最小值作为一个效率启发式在线性时间以及。

计数排序: 对正整数进行排序时(0-Integer.MAX _ VALUE-2，因为存在鸽子洞)。

另外，中间数组至少需要 n 个额外的空间，而且它显然是稳定的。

/**
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

您总是可以得到最大值和最小值作为一个效率启发式在线性时间以及。
另外，中间数组至少需要 n 个额外的空间，而且它显然是稳定的。

/**
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

(即使它实际上允许 MAX _ VALUE-2)

(即使它实际上允许 MAX _ VALUE-2) 参见: 参见: Java 数组有最大大小吗？

Java 数组有最大大小吗？

我还要解释的是，对于 n 个字长 w 的整数，基数排序的复杂度是 O (wn)。有时 w 表示为常量，这会使基数排序(对于足够大 n)比最好的基于比较的排序算法更好，后者都执行 O (n log n)比较来对 n 个键进行排序。然而，一般情况下 w 不能被认为是一个常量: 如果所有的 n 个键都是不同的，那么 w 必须至少是 log n，随机存取机器才能将它们存储在内存中，这最多只能给出一个时间复杂度 o (n log n)。(来自维基百科)

我还要解释的是，对于 n 个字长 w 的整数，基数排序的复杂度是 O (wn)。有时 w 表示为常量，这会使基数排序(对于足够大 n)比最好的基于比较的排序算法更好，后者都执行 O (n log n)比较来对 n 个键进行排序。然而，一般情况下 w 不能被认为是一个常量: 如果所有的 n 个键都是不同的，那么 w 必须至少是 log n，随机存取机器才能将它们存储在内存中，这最多只能给出一个时间复杂度 o (n log n)。(来自维基百科)

小开

注意，这些 IDE 将为 odp.proj中的方法生成测试，并为不存在的测试方法创建适当的文件夹。

H

file:/Users/home/java/libs/ejb3-persistence-1.0.2.GA.jar
file:/projects/classes
小开

是的。它适用于除了引导类装入器装入的类之外的所有类。另一种确定的方法是:

Class klass = String.class;
URL location = klass.getResource('/' + klass.getName().replace('.', '/') + ".class");

如 notnoop 所指出的，klass.getResource()方法返回类文件本身的位置。例如:

jar:file:/jdk/jre/lib/rt.jar!/java/lang/String.class
file:/projects/classes/pkg/MyClass$1.class

包的名称暗示这里的应用程序是用于单元测试的。使用的典型模式是将您希望测试的类和单元测试代码放在同一个包中(在您的例子中是 odp.proj) ，但是放在不同的源代码树中。因此，您可以将类放在 src/odp/proj中，将测试代码放在 test/odp/proj中。

getProtectionDomain().getCodeSource().getLocation()方法返回 jar 文件或 CLASSPATH 的位置

file:/Users/home/java/libs/ejb3-persistence-1.0.2.GA.jar
file:/projects/classes

Java 确实有“ package”访问修饰符，当没有指定时，它是默认的访问修饰符(即。不指定 public、 private 或 protected)。使用“ package”访问修饰符，只有 odp.proj中的类可以访问这些方法。但是请记住，在 Java 中，不能依赖访问修饰符来强制执行访问规则，因为通过反射，任何访问都是可能的。访问修饰符仅仅是暗示性的(除非存在限制性的安全管理器)。

小开
{ 抛出新的 InternalError (“默认字符集不存在。您的 VM 出错了。”) ;

使用一个真正的下拉菜单: 一个列表(ul，li)和链接。永远不要误用表单元素作为链接。

} }
小开
我只想让

(我没有足够的名声来评论托斯科的回答。)

测试人员和其他成员 包裹。

我没有阅读屏幕的经验，我相信你的观点是正确的。

然而，就使用键盘操作选择而言，使用键盘选择任何选项都是微不足道的:

这可能有点取决于你不显示它们的动机，但是如果唯一的原因是你不想让那些只用于测试的东西(或者其他内部的东西)污染公共接口，我会把这些方法放在一个单独的公共接口中，让“隐藏”方法的使用者使用那个接口。它不会阻止其他人使用该界面，但我看不出有什么理由你应该这样做。

对于单元测试，如果不需要重写批处理，可以按照建议使用相同的包。

TAB 到控件

N 个较老的实现，通过触发新的页面加载(本质上是一个页面链接)。

打开选择列表的空间

恕我直言，这些都是表单控件的有效用法。

小开

向上或向下箭头滚动到所需的列表项

当我在 IntelliJ 中执行此操作时，我的源代码树如下所示:

src         // source root
- odp
- proj   // .java source here
- test      // test root
- odp
- proj // JUnit or TestNG source here
小开

输入以选择所需的项目

使用 PackageVisibleHelper 类，并在 PackageVisibleHelperFactory 冻结之前将其保持为私有，我们可以在任何地方调用 launchA (通过 PackageVisibleHelper)方法:)

package odp.proj;
public class A
{
void launchA() { }
}


public class PackageVisibleHelper {


private final PackageVisibleHelperFactory factory;


public PackageVisibleHelper(PackageVisibleHelperFactory factory) {
super();
this.factory = factory;
}


public void launchA(A a) {
if (factory == PackageVisibleHelperFactory.INSTNACNE && !factory.isSampleHelper(this)) {
throw new IllegalAccessError("wrong PackageVisibleHelper ");
}
a.launchA();
}
}




public class PackageVisibleHelperFactory {


public static final PackageVisibleHelperFactory INSTNACNE = new PackageVisibleHelperFactory();


private static final PackageVisibleHelper HELPER = new PackageVisibleHelper(INSTNACNE);


private PackageVisibleHelperFactory() {
super();
}


private boolean frozened;


public PackageVisibleHelper getHelperBeforeFrozen() {
if (frozened) {
throw new IllegalAccessError("please invoke before frozen!");
}
return HELPER;
}


public void frozen() {
frozened = true;
}


public boolean isSampleHelper(PackageVisibleHelper helper) {
return HELPER.equals(helper);
}
}
package odp.proj.test;


import odp.proj.A;
import odp.proj.PackageVisibleHelper;
import odp.proj.PackageVisibleHelperFactory;


public class Test {


public static void main(String[] args) {


final PackageVisibleHelper helper = PackageVisibleHelperFactory.INSTNACNE.getHelperBeforeFrozen();
PackageVisibleHelperFactory.INSTNACNE.frozen();




A a = new A();
helper.launchA(a);


// illegal access
new PackageVisibleHelper(PackageVisibleHelperFactory.INSTNACNE).launchA(a);
}
}
小开

注意，这只适用于受保护的成员，它们对扩展类(继承)可见，而不适用于包-私有成员，它们只对同一个包中的子/扩展类可见。希望这能帮到别人！

小开

公认的解决方案看起来不错，但有一种情况它无法处理:

这里的大多数答案都表明在 Java 中没有子包这样的东西，但这并不准确。这个术语是在 Java 语言规范(JLS)中定义的，从规范的初始版本开始就是这样。

当重新选择相同的选项时，不会触发“ onchange”事件。所以，我想出了以下改进方案:

超文本标示语言

<select id="sampleSelect" >
<option value="Home.php">Home</option>
<option value="Contact.php">Contact</option>
<option value="Sitemap.php">Sitemap</option>
</select>

JQuery

$("select").click(function() {
var open = $(this).data("isopen");
if(open) {
window.location.href = $(this).val()
}
//set isopen to opposite so next time when use clicked select box
//it wont trigger this event
$(this).data("isopen", !open);
});

Java 15 JLS :

Esawt、 applet、 io、 lang、 net和 util，但没有编译单元

包的成员是它的子包以及在包的所有编译单元中声明的所有顶级类类型和顶级接口类型。

  • 包 java.awt有一个名为 image的子包，以及许多包含类和接口类型声明的编译单元。

    • 例如，在 JavaSE 平台 API 中:

      子包概念具有实际意义，因为它在包和类/接口之间强制命名约束:

    • 包 java有子包 awt、 applet、 io、 lang、 net和 util，但是没有编译单元。

      • 包可能不包含同名的两个成员，或编译时错误结果。

    • 包 java.awt有一个名为 image的子包，以及许多包含类和接口类型声明的编译单元。

    下面是一些例子:

      子包概念具有实际意义，因为它在包和类/接口之间强制命名约束:

      包可能不包含同名的两个成员，或编译时错误结果。

      下面是一些例子:

      • 因为包 java.awt有一个子包 image，所以它不能(也没有)包含名为 image的类或接口类型的声明。
      • 因为包 java.awt有一个子包 image，所以它不能(也没有)包含名为 image的类或接口类型的声明。
      • 如果在该包中有一个名为 mouse的包和一个成员类型 Button(然后可能被称为 mouse.Button) ，那么不能有任何名为 mouse.Button或 mouse.Button.Click的完全限定的包。
      • 如果在该包中有一个名为 mouse的包和一个成员类型 Button(然后可能被称为 mouse.Button) ，那么不能有任何名为 mouse.Button或 mouse.Button.Click的完全限定的包。
      • 如果 com.nighthacks.java.jag是类型的完全限定名，则不能有任何完全限定名为 com.nighthacks.java.jag或 com.nighthacks.java.jag.scrabble的包。
    • 如果 com.nighthacks.java.jag是类型的完全限定名，则不能有任何完全限定名为 com.nighthacks.java.jag或 com.nighthacks.java.jag.scrabble的包。

    然而，这种命名限制是由语言赋予子包的 只有意义:

    然而，这种命名限制是由语言赋予子包的 只有意义:

    包的分层命名结构旨在便于以常规方式组织相关的包，但其本身并没有任何意义，只是禁止包具有与该包中声明的顶级类型具有相同简单名称的子包。

    包的分层命名结构旨在便于以常规方式组织相关的包，但其本身并没有任何意义，只是禁止包具有与该包中声明的顶级类型具有相同简单名称的子包。

    例如，在名为 oliver的包和另一个名为 oliver.twist的包之间，或者在名为 evelyn.wood和 evelyn.waugh的包之间，没有特殊的访问关系。也就是说，名为 oliver.twist的包中的代码对包 oliver中声明的类型的访问并不比对任何其他包中的代码的访问更好。

    例如，在名为 oliver的包和另一个名为 oliver.twist的包之间，或者在名为 evelyn.wood和 evelyn.waugh的包之间，没有特殊的访问关系。也就是说，名为 oliver.twist的包中的代码对包 oliver中声明的类型的访问并不比对任何其他包中的代码的访问更好。

    有了这个上下文，我们就可以回答这个问题本身。由于一个包和它的子包之间没有特殊的访问关系，或者一个父包的两个不同的子包之间没有特殊的访问关系，因此在语言中没有办法使一个方法以被请求的方式对两个不同的包可见，同时限制它对其他包的访问。这是一个文档化的、有意识的设计决策。

    有了这个上下文，我们就可以回答这个问题本身。由于一个包和它的子包之间没有特殊的访问关系，或者一个父包的两个不同的子包之间没有特殊的访问关系，因此在语言中没有办法使一个方法以被请求的方式对两个不同的包可见，同时限制它对其他包的访问。这是一个文档化的、有意识的设计决策。

    方法可以公开，所有包(包括 odp.proj和 odp.proj.test)都可以访问给定的方法，或者方法可以私有(默认可见性) ，所有需要直接访问它的代码必须放在与方法相同的(子)包中。

    方法可以公开，所有包(包括 odp.proj和 odp.proj.test)都可以访问给定的方法，或者方法可以私有(默认可见性) ，所有需要直接访问它的代码必须放在与方法相同的(子)包中。

    关于测试用例，Java 中的一个标准实践是将类型的测试代码放在与其源代码相同的包中，但是放在文件系统的不同位置。例如，在 玛文和 格拉德尔构建工具中，惯例是将源文件放在 src/main/java/odp/proj中，将测试文件放在

    关于测试用例，Java 中的一个标准实践是将类型的测试代码放在与其源代码相同的包中，但是放在文件系统的不同位置。例如，在 玛文和 格拉德尔构建工具中，惯例是将源文件放在 src/main/java/odp/proj中，将测试文件放在 src/test/java/odp/proj.当由构建工具编译时，两个目录中的项最终都会出现在 odp.proj包中，但是只有 src文件包含在生产构件中; 测试文件仅在构建时用于验证生产文件。通过这种设置，测试代码可以自由地访问它所测试代码的任何包私有或受保护的代码，因为它们将位于同一个包中。

    src/test/java/odp/proj.当由构建工具编译时，两个目录中的项最终都会出现在 odp.proj包中，但是只有 src文件包含在生产构件中; 测试文件仅在构建时用于验证生产文件。通过这种设置，测试代码可以自由地访问它所测试代码的任何包私有或受保护的代码，因为它们将位于同一个包中。

    如果您希望在子包或兄弟包之间共享代码，而不是在测试/生产用例中，我见过一些库使用的一种解决方案是将共享代码作为公共代码，但是将其记录为仅供内部库使用。


    提交答案