The only way I see is putting the condition in the map call. If you use filter you lose the "else" part.

List<String> myList = source.stream()
            .map(item -> {
                  if (!(item.get(bar) instanceof JSONObject)) {
                      return item.get(bar).toString();
                  } else {
                      return item.getJSONObject(attribute).get("key").toString();
                  }
            })
            .collect(Collectors.toList());

or, as Holger suggested in a comment, use the ternary conditional operator:

List<String> myList = source.stream()
            .map(i -> (i.get(bar) instanceof JSONObject ? i.getJSONObject(attribute).get("key") : i.get(bar)).toString())
            .collect(Collectors.toList());

I'd say, this is the canonical approach. No separate needs to be created, further operations like filter can be added. Still that's a matter of taste, I guess.

List<PhoneType> phoneTypes = phones.stream()
  .map(p -> new PhoneType(p.getId(), p.getType())))
  .collect(Collectors.toList());

There's a number of possibilities listed below with empirical test results gathered on an 8 core/8Gb machine, 4Gb JVM heap size. If there's a certain takeaway from that, it's, that differences don't range in orders of magnitude, with collection.foreach perhaps coming out somehow ahead of everything else. Find another similar discussion here, measuring further variations including iterators and arriving at similar conclusions.

As for the different approaches: stream.forEach() doesn't preserve the order of the input, everything else does, here's a detailed discussion of stream vs collections.

The first way mentioned above disqualifies because of parallelStream, it proves to be consistently slower in the case of a simple map operation.

The second, because collection.forEach does the same job, preserves the order and is faster too. At this occasion, without tapping into heavily mined ideological terrain, I'd like to hint at a discussion whether premature optimization is the root of all evil or not.

An intermediate version would be collection.forEach instead of stream().forEach, still I find it less appealing to look at than stream().map, some performance gain seems to be there, is not huge though, which has to we weighed against aesthetical drawbacks. A matter of taste perhaps.

One could choose to operate with for-loops and arrays only, circumventing collections and streams altogether. Drawback is, they come in fixed length only and look messy compared to the slick functional versions.

I made a series of test runs, find the results below, where surprisingly collection.foreach came out ahead, followed by the loop versions and the stream versions last, with parallelStream running slowest. The test results are blurred by factors I can't precisely pin down, garbage collection being the main suspect.

You can find code and data producing these results in a gist.

I did 10 runs, in each one running mappings for list/array sizes of 100000,1000000,10000000,20000000 and 30000000.

Before each run a warmup run with 30000000 which was not measured. Still there were random outliers scattered all over the place (kind of 17 seconds at an average of 1.5), I'd blame it on the garbage collector. For the final calculation of the averges I replaced the outliers with the average of the column (including the outlier)

loop:array→array    1.8
loop:array→list     0.983
collection.foreach  0.8
stream.foreach      1.3
mapSeq              1.8
mapParallel         2.1

I believe you're trying to simply sum the values grouping by date. So assuming you have parsed data as a List

List<Data> list = getDataAsList();
List<DataHistory> historyList = list.stream()
            .collect(Collectors.groupingBy(data -> data.date)).entrySet().stream()
            .map((entry) -> {
                DataHistory history = new DataHistory();
                history.date = entry.getKey();
                List<Data> dataList = entry.getValue();
                history.sum_Int1_beforeOrEqualDate = dataList.stream().mapToInt(data -> data.int1).sum();
                history.sum_Int2_beforeOrEqualDate = dataList.stream().mapToInt(data -> data.int2).sum();
                return history;
            })
            .collect(Collectors.toList());

Tell me if I got the logic correct.

Simple use map() method in stream api and collect results:

  List<Emp> employe = Arrays.asList(new Emp(1, 100), new Emp(2, 200), new Emp(3, 300));
  List<Emp> employeRise = employe.stream()
                                 .map(emp -> new Emp(emp.getId(), emp.getSalary * 100))
                                 .collect(Collectors.toList());
  employeRise.stream()
            .forEach(s -> System.out.println("Id :" + s.getId() + " Salary :" + s.getSalary()));

You can use Map:

Map<String, Integer> otherMap = new HashMap<>(other.size());
int index = 0;
for(String otherElem : other) {
    otherMap.put(otherElem, index++);
}

And then:

for(String oneElem : one) {
    Integer index = otherMap.get(oneElem);
    indices.add(index == null ? -1 : index);
}

Doing so, you get the index directly instead of iterating on a potentially very big list each time you look for and index.

Don't worry about any performance differences, they're going to be minimal in this case normally.

Method 2 is preferable because

1. it doesn't require mutating a collection that exists outside the lambda expression.

2. it's more readable because the different steps that are performed in the collection pipeline are written sequentially: first a filter operation, then a map operation, then collecting the result (for more info on the benefits of collection pipelines, see Martin Fowler's excellent article.)

3. you can easily change the way values are collected by replacing the Collector that is used. In some cases you may need to write your own Collector, but then the benefit is that you can easily reuse that.

List<Value> list = new ArrayList<Value>(map.values());

assuming:

Map<Key,Value> map;

There is no built-in way of doing this in Java - you have to write or use a helper class. Google Collections includes

public static <F,T> List<T> transform(List<F> fromList,
                                  Function<? super F,? extends T> function)

This works well, but it's a bit clumsy to use, as you have to use a one-method anonymous class and a static method. This is no fault of Google Collections, it is just the nature of doing this type of task in Java.

Note that this lazily transforms items in the source list as needed.