Remove objects from an ArrayList based on a given criteria

You can use Collection::removeIf(Predicate filter) (available from Java8 onwards), here is a simple example:

final Collection<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
list.removeIf(value -> value < 2);
System.out.println(list); // outputs "[2]"

No need to use iterator. With Java 8 (streaming and filtering capability and lambdas) you can accomplish it using one line. For eg. the required code that does the operation you specified will be :

pulseArray = pulseArray.stream().filter(pulse -> pulse != null).collect(Collectors.toList());

When you are removing the element from the same list, the index gets disturbed. Try little differently as below:

  for (int i=0; i < pulseArray.size(); i++) {
     Pulse p = (Pulse)pulseArray.get(i);
     if (p.getCurrent() == null) {
        pulseArray.remove(p);
        i--;//decrease the counter by one
     }
  }

You can implement interface Predicate overriding abstract method boolean test(T);

Use removeIf(Predicate p) method to remove all matching elements from your list.

For example:

List<Book> bookList = new ArrayList<>();
bookList.add(new Book(101, "bookname1"));
bookList.add(new Book(102, "booknamelong2"));
bookList.removeIf(new LongBookNames())

public class LongBookNames implements Predicate<Book> {

  @Override
  public boolean test(Book book) {
    return book.getBookName.length() >10;
  }
}

As an alterative to using an iterator, you can use the Guava collections library. This has the advantage of being more functional (if you are into that sort of thing):

Predicate<Pulse> hasCurrent = new Predicate<Pulse>() {
  @Override public boolean apply(Pulse input) {
    return (input.getCurrent() != null);
  }
};

pulseArray = Lists.newArrayList(Collections2.filter(pulseArray, hasCurrent));

To remove elements from ArrayList based on a condition or predicate or filter, use removeIf() method. You can call removeIf() method on the ArrayList, with the predicate (filter) passed as argument. All the elements that satisfy the filter (predicate) will be removed from the ArrayList.

arraylist.removeIf(element -> (Objects.equals(element.getId(), id)));

You can't alter a collection that you're iterating through using methods on the collection. However, some iterators (including iterators on ArrayLists) support a remove() method that allows you to remove methods in the order that you're iterating.

Iterator<Pulse> iterator = pulseArray.iterator();
while (iterator.hasNext()) {
  Pulse p = iterator.next();
  if (p.getCurrent() == null) {
    iterator.remove();
  }
}

Below one is used when Single ArrayList have multiple types Objects and one object have count == 0 then it removed from pulseArray

Constants.java

public class ViewType {
    public static final int PULSE = 101;
    public static final int HEARTBEAT = 102;
}

BaseModel.java (This is Base Model)

public interface BaseModel {
    int getViewType();
}

PulseModel.java (which implements with BaseModel)

public class PulseModel implements BaseModel {

    @Override
    public int getViewType() {
        return Constants.ViewType.PULSE;
    }

    @SerializedName("PulseId")
    @Expose
    private String pulseId;
    @SerializedName("Count")
    @Expose
    private String count;
}

Remove PulseModel object from pulseArray in which Count = 0

pulseArray.removeIf(
     (BaseModel model) -> {
         boolean remove = false;
         if (model instanceof PulseModel) {
              remove = (((PulseModel) model).getCount() == 0);
              if (remove) {
                 //Success
              }
         }
         return remove;
      });

Using an Iterator would give you the power of modifying the list while iterating through the arraylist