Java Stream API: Change values by criteria

There is Java class:

public class Item {
  private String dateModified;
  private Integer color;
}

where dateModified in format "hh:mm:ss",

and ArrayList<Item> list which contains 10 elements.

So i want check my list and:

if now() - dateModified > 1 min , then change color to 1
if now() - dateModified > 5 min , then change color to 2
if now() - dateModified > 10 min, then change color to 3

How to implements it with Java Stream API?

UPDATE:
I implemented my task in such code below. It works as expected, but it seems huge and non-elegance.
I forget to say that list should be mutable.

 list.stream()
 .map(c -> {
  if (compareTime(c.getDateModified(), 600)) {
     c.setColor(3);                       
  } else if (compareTime(c.getDateModified(), 300)) {
     c.setColor(2);
  } else if (compareTime(c.getDateModified(), 60)) {
     c.setColor(1);
  }
     return c;
  }).collect(Collectors.toList());


private boolean compareTime(String dateModified, Integer delta) {
        boolean result = false;
        LocalDateTime now = LocalDateTime.now();
        int hour = now.getHour();
        int minute = now.getMinute();
        int second = now.getSecond();
        Integer secondsDateModified = Integer.parseInt(dateModified.substring(0, 2)) * 3600 +
        Integer.parseInt(dateModified.substring(3, 5)) * 60 +
        Integer.parseInt(dateModified.substring(6, 8)) ;
        Integer secondsNow = hour * 3600 + minute * 60 + second ;
        Integer delta1 = secondsNow - secondsDateModified;
        if ((delta1) > delta) {
            result = true;
        }
        return result;
    }

Any suggestions to improve the code are appreciated.

Instead of storing a String as the time, store a LocalTime object. Also, instead of mutating the original item, return the item or a new item with the new color.

  public static class Item {

        private final LocalTime dateModified;

        private final Integer color;

        public Item(LocalTime dateModified, Integer color) {
            this.dateModified = dateModified;
            this.color = color;
        }

        public Item withColor(int color) {
            return new Item(dateModified, color);
        }

        public LocalTime getDateModified() {
            return dateModified;
        }

        public Integer getColor() {
            return color;
        }
    }

Example

    public static void main(String[] args) {
        List<Item> items = new ArrayList<>(Arrays.asList(
                new Item(LocalTime.parse("10:30:00"), 0),
                new Item(LocalTime.parse("10:30:01"), 255)));

        LocalTime now = LocalTime.now();

        List<Item> modified = items.stream().map(item -> {
            long minutes = Duration.between(item.dateModified, LocalTime.now())
                    .toMinutes();

            return minutes >= 1 ? 
                    item.withColor(minutes >= 10 ? 3 : minutes >= 5 ? 2 : 1) : item;
        }).collect(Collectors.toList());
    }

What about to use separate streams for update each required range of items:

public static void updateColor(List<Item> items) {
    final LocalTime now = LocalTime.now();
    final Function<Item, Long> getDurationInMinutes = item -> Duration.between(LocalTime.parse(item.dateModified), now).toMinutes()

    final Predicate<Item> betweenOneAndFive = item -> {
        long duration = getDurationInMinutes.apply(item);
        return duration > ONE && duration <= FIVE;
    };

    final Predicate<Item> betweenFiveAndTen = item -> {
        long duration = getDurationInMinutes.apply(item);
        return duration > FIVE && duration <= TEN;
    };

    final Predicate<Item> greaterThanTen = item -> getDurationInMinutes.apply(item) > TEN;


    items.stream().filter(betweenOneAndFive).forEach(item -> item.color = 1);
    items.stream().filter(betweenFiveAndTen).forEach(item -> item.color = 2);
    items.stream().filter(greaterThanTen).forEach(item -> item.color = 3);
}

It is a matter of proper mapping function from difference of minutes to numbers.

items.forEach(item -> item.setColor(((int) Math.floor(differenceInMinutes(item.getDateModified(), now) + 5)) / 5));

Note, that the differenceInMinutes method would return the difference in floating point arithmetic.

The steps taken are:

1. Find the difference in minutes from the date of the items with now.
2. Cast the result to an int which will work like Math.floor.
3. Add 5 to the result.
4. Divide by 5.

So, for example 1.3 minutes would result in (1+5)/5 which is 1.

9.8 minutes would result in (9+5)/5 which is 2.

And so on.

First, as Jason, said do not mutate yours items inside streams, make copies. (https://stackoverflow.com/questions/47041144/what-is-the-danger-of-side-effects-in-java-8-streams).

You will need intermediates operations :

long getElapseTimeSinceModification(Item item) {
	return ChronoUnit.MINUTES.between(LocalTime.parse(item.dateModified), LocalDate.now());
}

Optional<Integer> getNewColor(long elapseTimeSinceModification) {
	if (elapseTimeSinceModification > 10) {
		return Optional.of(3);
	} else if (elapseTimeSinceModification > 5) {
		return Optional.of(2);
	} else if (elapseTimeSinceModification > 1) {
		return Optional.of(1);
	}

	return Optional.empty();
}

Item withNewColor(int newColor, Item item) {
	Item newTtem = new Item();
	newTtem.color = newColor;
	newTtem.dateModified = item.dateModified;
	return newTtem;
}

and then you can apply them to your stream :

List<Item> itemsWithNewColor = items.stream()
		.map(item -> getNewColor(getElapseTimeSinceModification(item))
				.map(newColor -> withNewColor(newColor , item))
				.orElse(i))
		.collect(Collectors.toList());