Java的indexOf方法作为手动搜索的捷径

Question

我有以下Java代码，但List.indexOf()似乎做了几乎相同的事情(包括如果未找到则返回-1。有没有什么方法可以传递indexOf()一个对象来表达这样的想法对象不为 0？

/**
 * Find the first non-zero element in a List of Integers
 * @param row List of Integers
 * @return -1 if all zeros in row
 * otherwise position of first non zero element
 */
public static int leading(List<Integer> row) {

 for (int i = 0; i < row.size(); i++) {
   if (row.get(i)!= 0) {
      return i;
   }
 }

 return -1;
}

回复:Thorbjørn Ravn Andersen:如果我将 null 传递到 IndexOf() 中，它将始终返回 -1，因为我的列表始终包含整数。我想做一些类似 row.indexOf(Integer a where !a.equals(0)) 的事情。不确定是否可能

Answer 1

List.indexOf “解决方案”

List.indexOf(Object o) 定义如下:

Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the lowest index i such that

(o==null ? get(i)==null : o.equals(get(i)))

is true, or -1 if there is no such index.

尝试给出一个实际上并不在 List 中的“元”元素对象是很诱人的。 ，甚至可能与 List 的实际元素类型不同。 ，然而是equals基于谓词的某些所需元素。这应该有效，因为 indexOf是根据给定的 Object o 定义的的equals方法针对列表中的元素(而不是相反)，但这是实现您想要的效果的真正“hacky”方式。

这是一个概念证明:

// PROOF OF CONCEPT ONLY! DO NOT IMITATE!
// abusing indexOf(Object) to find index of a negative integer in List

List<Integer> nums = Arrays.asList(3,4,5,-6,7);
Object equalsNegativeInteger = new Object() {
    @Override public boolean equals(Object o) {
        return (o instanceof Integer) && ((Integer) o) < 0;
    }
};
System.out.println(nums.indexOf(equalsNegativeInteger));
// prints 3

“元”元素对象是 equals任何负数Integer ，但没有 Integer可以是equals到它。这种不对称严重违反了 the equals contract ，但它仍然“有效”。

---

Guava 解决方案

传达意图的更好的解决方案是使用 Guava 的高阶函数。这是 com.google.commons.collect.Iterables 中的一个:

<T> int indexOf(Iterable<T> iterable, Predicate<? super T> predicate)

Returns the index in iterable of the first element that satisfies the provided predicate, or -1 if the Iterable has no such elements. More formally, returns the lowest index i such that:

 predicate.apply(Iterables.get(iterable, i))

is true, or -1 if there is no such index.

代码片段

下面的代码片段说明了 Guava 高阶函数的表达能力:

import com.google.common.collect.*;
import com.google.common.base.*;
import java.util.*;

public class IterablesPredicateExample {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1,2,-3,4,-5,6,-7,-8);
        Predicate<Integer> isNegative = new Predicate<Integer>() {
            @Override public boolean apply(Integer n) {
                return n < 0;
            }
        };          
        // Get index of first negative number
        System.out.println(Iterables.indexOf(nums, isNegative));
        // 2

        // Find that number
        System.out.println(Iterables.find(nums, isNegative));
        // -3

        // Find all negative numbers
        System.out.println(Iterables.filter(nums, isNegative));
        // [-3, -5, -7, -8]

        // Are all numbers negative?
        System.out.println(Iterables.all(nums, isNegative));
        // false

        // Find all non-negative numbers
        System.out.println(Iterables.filter(nums, Predicates.not(isNegative)));
        // [1, 2, 4, 6]
    }
}

---

摘要

• List.indexOf(Object)可以被滥用来查找满足给定谓词的元素，但这违反了 equals契约(Contract)
• 使用 Guava 的 Predicate 以及高阶函数，如 indexOf , find , filter , all , any etc 允许您以更强大的表达方式来表达这些操作