On Fri, 19 Apr 2024 15:49:11 GMT, Evemose <[email protected]> wrote:
>> **Subject**
>> Addition of Predicate-based `indexOf` and `lastIndexOf` methods to
>> `java.util.List`
>>
>> **Motivation**
>> The motivation behind this proposal is to enhance the functionality of the
>> `List` interface by providing a more flexible way to find the index of an
>> element. Currently, the `indexOf` and `lastIndexOf` methods only accept an
>> object as a parameter. This limits the flexibility of these methods as they
>> can only find the index of exact object matches.
>>
>> The proposed methods would accept a `Predicate` as a parameter, allowing
>> users to define a condition that the desired element must meet. This would
>> provide a more flexible and powerful way to find the index of an element in
>> a list.
>>
>> Here is a brief overview of the changes made in this pull request:
>>
>> 1. Added the `indexOf(Predicate<? super E> filter)` method to the `List`
>> interface.
>> 2. Added the `lastIndexOf(Predicate<? super E> filter)` method to the `List`
>> interface.
>> 3. Implemented these methods in all non-abstract classes that implement the
>> `List` interface.
>>
>> The changes have been thoroughly tested to ensure they work as expected and
>> do not introduce any regressions. The test cases cover a variety of
>> scenarios to ensure the robustness of the implementation.
>>
>> For example, consider the following test case:
>>
>> List<String> list = new ArrayList<>();
>> list.add("Object one");
>> list.add("NotObject two");
>> list.add("NotObject three");
>>
>> int index1 = list.indexOf(s -> s.contains("ct t"));
>> System.out.println(index1); // Expected output: 1
>> int index2 = list.lastIndexOf(s -> s.startsWith("NotObject"));
>> System.out.println(index2); // Expected output: 2
>>
>>
>> Currently, to achieve the same result, we would have to use a more verbose
>> approach:
>>
>> int index1 = IntStream.range(0, list.size())
>> .filter(i -> list.get(i).contains("ct t"))
>> .findFirst()
>> .orElse(-1);
>> System.out.println(index1); // Output: 1
>> int index2 = IntStream.range(0, list.size())
>> .filter(i -> list.get(i).startsWith("NotObject"))
>> .reduce((first, second) -> second)
>> .orElse(-1);
>> System.out.println(index2); // Output: 2
>>
>>
>> I believe these additions would greatly enhance the functionality and
>> flexibility of the `List` interface, making it more powerful and
>> user-friendly. I look forward to your feedback and am open to making any
>> necessary changes bas...
>
> Evemose has updated the pull request incrementally with one additional commit
> since the last revision:
>
> reverted code style changes in Vector
> > > I noticed that most (if not all) methods don't ensure non-nullability of
> > > `filter` so NPE would only be thrown if the list is not empty.
> >
> >
> > Yeah, thats true. not sure if it has to throw NPE even if list is emply
>
> Yes, it does. If it shouldn't, then why isn't code in the java.util.List is
> like this:
>
> ```java
> default int findIndex(Predicate<? super T> filter) {
> ListIterator<T> iterator = listIterator();
> if (!iterator.hasNext()) return -1;
> Objects.requireNonNull(filter);
> int index = 0;
> do {
> if (filter.test(iterator.next()))
> return index;
> index++;
> } while (iterator.hasNext());
> return -1;
> }
> ```
>
> Also see methods like `removveIf`. All methods should do checks even if they
> essentially do nothing.
ok, i will fix this in a while
-------------
PR Comment: https://git.openjdk.org/jdk/pull/18639#issuecomment-2067357432
