标签: apache-commons-lang3

根据文档,字符串'123'是数字.

由于我认为这可能是文档中的错误,我运行测试来验证该语句.我发现根据Apache Commons,它是数字的.

为什么这个字符串数字？这些人物代表什么？

我找不到任何解释为什么从Apache Lang3 v3.7弃用StringEscapeUtils的原因.

https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringEscapeUtils.html

我们现在应该使用什么来进行HTML转义/转义

我一直在负责使用更新我们的代码org.apache.commons.lang来org.apache.commons.lang3和我发现,新版本StringEscapeUtils不再有法escapeJavaScript()但我们是在我们整个代码不少地方用这个.

我一直在阅读文档,看起来整个都StringEscapeUtils被重写了lang3(参见发行说明lang 3.3.2),并且他们删除了这些重写,escapeJavaScript()但他们没有说明在任何文档中使用什么作为替代(不是我能看到的).这是什么新文档.

所以我的问题是我不能成为唯一一个注意到这一点并且经历过这个问题的人,那么使用什么替代方案StringEscapeUtils.escapeJavaScript()呢？

我使用org.apache.commons.lang3.BooleanUtils的commons-lang3(3.1版本).当我尝试编译下一行代码时

BooleanUtils.xor(true, true);

使用maven-compiler-plugin(版本3.3),我收到编译失败消息:

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.3:compile (default-compile) on project exchange: Compilation failure
[ERROR] MyClass.java:[33,34] reference to xor is ambiguous, both method xor(boolean...) in org.apache.commons.lang3.BooleanUtils and method xor(java.lang.Boolean...) in org.apache.commons.lang3.BooleanUtils match

我使用Java 1.7.0_55进行编译.

我怎么解决这个问题？

我想知道Apache Commons Lang3(org.apache.commons.lang3)与Apache Commons Text(org.apache.commons.text)之间有什么区别？

我看到他们之间有许多相似之处.
对于intance,他们都有StringEscapeUtils:

• org.apache.commons.lang3.StringEscapeUtils,已弃用.
• org.apache.commons.text.StringEscapeUtils

但我也看到了许多不同之处.
那么我应该使用哪一个,Lang3还是Text？
或者这两者的常见用例是什么？

在Java 8之前,我们实现Comparable.compareTo(...)如下:

public int compare(Person a, Person b) {
    return new CompareToBuilder()
            .append(a.getLastName(), b.getLastName())
            .append(a.getFirstName(), b.getFirstName())
            .toComparison();
}

从Java 8开始,我们可以这样做:

public int compare(Person a, Person b) {
    return Comparator
            .comparing(Person::getLastName)
            .thenComparing(Person::getFirstName)
            .compare(a, b);
}

新的Java 8方式可能允许我们放弃commons-lang3依赖.这种新的Java 8更快吗？有没有办法自动迁移？我没有找到IntelliJ的意图.

请注意,当存在反向订单并且涉及非自然比较时,它会变得有点复杂:

public int compare(SingleBenchmarkResult a, SingleBenchmarkResult b) {
    return new CompareToBuilder()
            .append(b.hasAnyFailure(), a.hasAnyFailure()) // Reverse
            .append(a.getAverageScore(), b.getAverageScore(), resilientScoreComparator)
            .toComparison();
}

变

public int compare(SingleBenchmarkResult a, SingleBenchmarkResult b) {
    return Comparator
            .comparing(SingleBenchmarkResult::hasAnyFailure, Comparator.reverseOrder()) // Reverse
            .thenComparing(SingleBenchmarkResult::getAverageScore, resilientScoreComparator)
            .compare(a, …

Apache commons-lang有两个重载BooleanUtils.and方法.

public static boolean and(final boolean... array) {

public static Boolean and(final Boolean... array) {

调用BooleanUtils.and方法时,抛出模糊方法调用错误.

java: reference to and is ambiguous
  both method and(boolean...) in org.apache.commons.lang3.BooleanUtils and method and(java.lang.Boolean...) in org.apache.commons.lang3.BooleanUtils match

可以使用以下语法调用它.

BooleanUtils.and(new Boolean[]{Boolean.TRUE, Boolean.TRUE});

但是,根据方法的javadoc,使用细节是不同的.

我目前正在评估 Apache StopWatch 和 Guava 的 Stopwatch 之间的实现，前者的拆分功能引起了我的兴趣，但我很难理解它究竟做了什么，以及它有什么价值。

根据秒表的文档：https : //commons.apache.org/proper/commons-lang/javadocs/api-3.9/org/apache/commons/lang3/time/StopWatch.html

split() 手表以获取时间，同时手表在后台继续运行。unsplit() 将消除拆分的影响。此时，这三个选项又可用了。

我发现了一些例子，比如this，它们提供的很少，因为看起来 split 只是累积的。该页面说该方法用于“分割时间”，我根据该方法计算了该方法，但该页面并未提及其实际含义。它甚至会出现，这个例子是完全错误的，因为文档建议，你应该unsplit在你面前split一次。

我最初认为它用于以下用例：

StopWatch stopwatch = StopWatch.createStarted();
do something for 5 seconds
stopwatch.split();
do something for 10 seconds
stopwatch.stop();
System.out.println(stopwatch.getTime());
System.out.println(stopwatch.getSplitTime());

我认为秒表总时间将读取为 15 秒，秒表分段时间将读取为 10 或 5 秒，但似乎两种方法都输出 15 秒。

接下来，我想也许拆分值是您可以采用的增量，然后从总计时器中删除，例如：

StopWatch stopwatch = StopWatch.createStarted();
do something for 5 seconds
stopwatch.split();
do something for 10 seconds
stopwatch.unsplit();
stopwatch.stop();
System.out.println(stopwatch.getTime());
// System.out.println(stopwatch.getSplitTime()); errors because of unsplit

我的想法是分割时间为 10 秒，当与主计时器分离时，主计时器将读取为 …

我们为服务响应和模型中的请求对象定义了很少的数据类型.最近我们发现需要在所有这些类型上实现ToString,HashCode和Equals,以便在比较和断言上使用它们.从少数几个来源确认在Java中覆盖equals和hashCode时应该考虑哪些问题？,实行正确的做法等于合同 等我们跟着执行的toString,equals和hashCode使用org.apache.commons.lang3.builder.EqualsBuilder,HashCodeBuilder并ToStringBuilder如下-

Response.java

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;

public class Response {

    private Integer value;
    private Currency currency;
    private Object edited;

    public Response() {
    }

    public Response(Integer value, Currency currency, Object edited) {
        this.value = value;
        this.currency = currency;
        this.edited = edited;
    }

    public Currency getCurrency() {
        return currency;
    }

    public void setCurrency(Currency currency) {
        this.currency = currency;
    }

    public Integer getValue() {
        return value;
    }

    public void …

如何为非法反射访问警告抛出异常？例如，考虑以下代码：

import org.apache.commons.lang3.builder.*;

class Test {
    public static void main(String[] args) {
        System.out.println(ReflectionToStringBuilder.toString(Boolean.TRUE));
    }
}

此代码向 System.err 打印以下警告：

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by org.apache.commons.lang3.builder.ReflectionToStringBuilder (file:/Users/brianschack/eclipse-workspace/User%20Libraries/com
mons-lang3-3.7/commons-lang3-3.7.jar) to field java.lang.Boolean.value
WARNING: Please consider reporting this to the maintainers of org.apache.commons.lang3.builder.ReflectionToStringBuilder
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

Boolean.TRUE 是一个如此简单的值，我真的不需要 ReflectionToStringBuilder。但是更复杂的类型（例如 HashMap）会打印相同的警告。我选择 Boolean.TRUE 是为了简化这个例子。

当我搜索此警告消息时，我发现建议将其报告给包维护者、避免警告或完全禁用它（JDK9：发生非法反射访问操作。org.python.core.PySystemState）。 …

我的代码使用Apache Commons Lang v.2（commons-lang）。如果我将代码更新为使用v.3（commons-lang3），我应该担心我的代码可能会开始表现出不同的行为（当然，由于固定的错误和可能的新错误而造成的差异，这是正常现象，因此不计在内） ？

换句话说，是否可以使用lang3在方法中lang（具有完全相同的签名）但在两个版本中可能返回不同结果的方法？

Apache确实并且非常清楚地提到了向后不兼容，但是我始终理解这些不兼容是因为它们破坏了编译，而不是完全相同的方法可以返回不同的结果。

我之所以这样问是因为，据我所知，某些向后不兼容的特性促使Apache将包从重命名为lang，lang3这些方法可能返回不同的结果。我认为这是一个错误的主张，对我而言，这很重要，因为我总是很高兴地用我偶然发现的所有s 替换lang，并且我只检查它仍然可以编译，而且我真的认为我是对的，但是现在，由于我被告知停止这些索赔，这是我认为是错误的，但是我没有任何信息可以用来反驳这些索赔并可以继续进行。lang3import

在编写测试时，我遇到了克隆对象的需求。通过 apache-commons 找到了 2 个 Utill 类，然后我试图找到我应该使用哪一个，我试图通过读出两个 API 文档来找到差异，但没有找到我应该使用哪一个

BeanUtils cloneBean() API 文档

根据文档： 根据可用的属性 getter 和 setter 克隆 bean，即使 bean 类本身没有实现 Cloneable。

疑问：我应该在 DTO 克隆上使用它吗？

SerializationUtils clone() API 文档

根据文档：

使用序列化深度克隆对象。

这比在对象图中的所有对象上手动编写克隆方法要慢很多倍。然而，对于复杂的对象图，或者对于那些不支持深度克隆的对象图，这可能是一个简单的替代实现。当然，所有对象都必须是可序列化的。

疑问：我应该将它用于 DTO 和实体对象吗？或仅适用于实体

在下面的代码中，为什么包含的两行会System.out.println(person); 产生不同的输出？第二行间接调用了Job.toString产生字符串的方法"Manager"，但第一行神秘地没有产生Job@28f67ac7。在person.put("a", "b");我看来，这两者之间的界限应该没有任何区别。

代码：

import java.util.*;
import org.apache.commons.lang3.builder.*;

class Job extends HashMap<String, String> {
    @Override public String toString() {
        return "Manager";
    }
}

class Person extends HashMap<String, String> {
    Job job;

    Person() {
        this.job = new Job();
    }

    @Override public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }
}

class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
        person.put("a", "b");
        System.out.println(person);
    }
}

安慰：

Person@2b80d80f[job=Job@28f67ac7,threshold=0,loadFactor=0.75]
Person@2b80d80f[job=Manager,threshold=12,loadFactor=0.75]