Question

我刚接触java编程。下面的源代码可以在一本书中找到，当我尝试执行程序时，它会显示一些不正确的数据。

public class Pair<T> {

    private T first;
    private T second;

    public Pair() {
        first = null;
        second = null;
    }

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void setFirst(T newValue) {
        first = newValue;
    }

    public void setSecond(T newValue) {
        second = newValue;
    }  
}

查找字符串数组的最小值和最大值的逻辑

public class ArrayAlg {

    public static Pair<String> minmax(String[] arr) {
        if (arr == null || arr.length == 0)
            return null;

        String min = arr[0];
        String max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (min.compareTo(arr[i]) > 0)
                min = arr[i];
            if (max.compareTo(arr[i]) < 0)
                max = arr[i];
        }
        return new Pair<String>(min, max);

    }
}

public static void main(String[] args) {

        String[] words = { "Mary", "had", "a", "little", "lamb" };
        Pair<String> obj = ArrayAlg.minmax(words);
        System.out.println("Minvalue " + obj.getFirst());
        System.out.println("Maxvalue " + obj.getSecond());

    }

如果您执行上述程序，则会显示Minvalue = Mary and MaxValue = little。 String数组中的值a是最小值，但在这种情况下，它显示Mary作为最小值。
有人能告诉我在String数组中找到最小值和最大值的更好方法吗？

Answer 1

你得到的输出是正确的输出，因为字符串的自然顺序是字典顺序，其中大写字母在小写字母之前。因此Mary是最小的＆＃34;字符串。

为了不使用自然排序，请勿使用String的{{1}}方法。相反，您可以实现您认为合适的任何逻辑来确定哪个String更小。引入替代排序的一种方法是将compareTo实例传递给您的Comparator<String>方法，并使用其minmax方法来比较compare s。

Answer 2

我认为，为了您的目的，最好使用String方法compareToIgnoreCase()。

但这取决于您了解Minimum string和Maximum string是什么。

此外，还有一种比较任何对象的优先方式 - 通过Comparator。

public static Pair<String> minmax(String[] arr) {
    if (arr == null || arr.length == 0)
        return null;

    Arrays.sort(arr, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareToIgnoreCase(o2); // to compare by lexicographical order
            //return o1.length() - o2.lenth(); // to compare by length
        }
    });

    return new Pair<String>(arr[0], arr[arr.length - 1]);
}

以下是一些链接：

Answer 3

您需要使用test('test', function(assert) { let partner = this.subject(); let store = this.store(); // set a relationship run(() => { let invoice = store.createRecord('invoice', { }); partner.get('invoices').pushObject(invoice); console.log(partner.get('resolvedInvoices')); }); assert.ok(true); });。您可以使用Comparator String.CASE_INSENSITIVE_ORDER按字母顺序对单词进行排序，忽略大小写。

在Java 8中，这可以使用Lambdas轻松实现：

Comparator

测试：

public final Pair<String> miniMax(final String[] words) {
    final String min = Arrays.stream(words).min(String.CASE_INSENSITIVE_ORDER).orElse(null);
    final String max = Arrays.stream(words).max(String.CASE_INSENSITIVE_ORDER).orElse(null);
    return new Pair<>(min, max);
}

输出：

String[] words = { "Mary", "had", "a", "little", "lamb" };
System.out.println(miniMax(words));

Answer 4

compareTo()按字典顺序比较字符串，这意味着大写字母位于小写字母之前，因为这是Unicode中的顺序。相反，请执行以下操作之一：

使用compareToIgnoreCase()
使用不区分大小写的Comparator，可从String.CASE_INSENSITIVE_ORDER
使用完整的语言专用Comparator，可以订购特殊字符和国际字母，就像您在书籍索引中看到的那样，可从Collator.getInstance()

或者，对于良好的Java 8实现，请参阅answer by arizzle。

所以，你的循环可能是：

for (int i = 1; i < arr.length; i++) {
    if (min.compareToIgnoreCase(arr[i]) > 0)
        min = arr[i];
    if (max.compareToIgnoreCase(arr[i]) < 0)
        max = arr[i];
}

或者：

Comparator<String> comp = Collator.getInstance();
for (int i = 1; i < arr.length; i++) {
    if (comp.compare(min, arr[i]) > 0)
        min = arr[i];
    if (comp.compare(max, arr[i]) < 0)
        max = arr[i];
}

Java - 查找字符串数组的最小值和最大值

4 个答案: