I don't know. I don't think so.But you can, for example:AtomicInteger index = new AtomicInteger(0); String str = "+ 380 43 34 34 343"; str.chars() .mapToObj(i-> (index.getAndIncrement() >= 6 && index.get() < 18) && (i >= 49 && i <= 57) ? '*' : (char)i) .reduce(new StringBuilder(), (a, b) -> a.append(b), (a,b) -> a.append(b)).toString(); But, in my view, the best thing to do without Stream API, for example:String str = "+ 380 43 34 34 343"; str = str.substring(0, 5).concat(" ** ** ** **").concat(str.substring(17,18));

// Есть три списка Collection<Integer> a = new ArrayList<>(); Collection<Integer> b = new ArrayList<>(); Collection<Integer> c = new ArrayList<>(); // Сгруппируем списки по их длине Map<Integer, List<Collection<Integer>>> sizeToLists = Stream.of(a, b, c) .collect(Collectors.groupingBy(Collection::size)); // sizeToLists это мапа, где ключ - размер списка, а значение - списки, чья длина равна ключу. // Если все списки, к примеру, будут длиной в 3 элемента, // то мапа будет содержать единственный ключ - 3 // Если ключ единственный, значит все списки были одинаковой длины final boolean lengthsAreEquals = sizeToLists.size() == 1; if (lengthsAreEquals) { // Теперь превратим три списка в один отсортированный Stream.of(a, b, c) .flatMap(Stream::of) // превратим все списки в один .sorted() // отсортируем .collect(Collectors.toList()); }

I'll give you an example for simplified transformation (Map<Integer, Map<String, Object>> на Map<String, Map<Integer, Object>>):Map<Integer, Map<String, Object>> map2 = map1.entrySet().stream() .flatMap(e1 -> e1.getValue().entrySet() .stream() .map(e2 -> Arrays.asList(e2.getKey(), e1.getKey(), e2.getValue()))) .collect(HashMap::new, (m, l) -> m.put((Integer) l.get(0), Stream.concat(Stream.of(l.subList(1, 3)), m.computeIfAbsent((Integer) l.get(0), HashMap::new) .entrySet() .stream() .map(e -> Arrays.asList(e.getKey(), e.getValue()))) .collect(Collectors.toMap(l1 -> (String) l1.get(0), l1 -> l1 .get(1)))), (m1, m2) -> m2.forEach((k, v) -> m1.put(k, Stream.concat(m1.computeIfAbsent(k, HashMap::new) .entrySet() .stream(), v.entrySet().stream()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))))); It's gonna look like this, not very readable, but on the lambdas and on the same line.But you can use it instead. Arrays.asList Some kind of class, as well as some operations in separate methods and use a reference method, which will increase readability, but also increase the volume of the code. If you need such a solution, it depends on you. In my view, the decision on the cycles is much clearer.

The problem is too small/defis in p -->p.getName().startsWith("Ivan")I'll notice in parentheses that problems are also actual. peopleswith the method random♪

The variable declared in the block exists only within this block. In your case streamPhone ceased to exist after the closure while♪And, as the zRrr has rightly pointed out, you've got a lot of extra stuff. It's easier.Stream<FormForBox> stream = Files.lines(Paths.get("C:\\data\\data.txt")) .map(s -> s.split(" ")) .filter(a -> a.length == 5) .map(a -> new FormForBox(Integer.parseInt(a[0]), a[1], a[2], a[3], Integer.parseInt(a[4]))); Better if you could add it. FormForBox host area designerpublic class FormForBox { ... public FormForBox(String[] fields) throws NumberFormatException { if (fields.length != 5) throw new IllegalArgumentException("Полей должно быть ровно 5!"); this.number = Integer.parseInt(number); this.maker = maker; this.model = model; this.os = os; this.ram = Integer.parseInt(ram); } ... } Then the building of a string would look more compact and more beautiful.Stream<FormForBox> stream = Files.lines(Paths.get("C:\data\data.txt")) .map(s -> s.split(" ")) .filter(a -> a.length == 5) .map(FormForBox::new);

The language is evolving, there is an opportunity to add to the code of procedure, and many programmers need it, because without strings, the code sometimes seems quite cumbersome.

We can use the operation. flatMap (instead Pair ♪ AbstractMap.SimpleEntryit accepts the function of returning Stream and builds the elements of the returned flow into the main: Map<String, List<String>> map = new HashMap<>(); map.put( "a", Arrays.asList( "obj1", "obj2", "obj3" ) ); map.put( "b", Arrays.asList( "obj4", "obj5" ) ); map.put( "c", Arrays.asList( "obj6", "obj7" ) ); System.out.println( map ); List&lt;Map.Entry&lt;String, String&gt;&gt; list = map.entrySet().stream().flatMap( entry -&gt; entry.getValue().stream() .map( listElement -&gt; new AbstractMap.SimpleEntry&lt;&gt;( entry.getKey(), listElement ) ) ).collect( Collectors.toList() ); System.out.println( list );

(1) From the line, the body of symbols is better equipped with:String text = ("Some example").toLowerCase().replaceAll("\\s", ""); List<Character> textInChar = Chars.asList(text.toCharArray()); or:textInChar = text.chars().mapToObj(e->(char)e).collect(Collectors.toList()); (2) The Xash Mapu of non-recurring symbols is better then:Map<Character, Integer> countChar = textInChar.stream().collect(HashMap::new, (m, c) -> { m.put(c, 1); m.put(c, 1); }, HashMap::putAll); And the whole job I'd be doing is:textInChar = text.chars().mapToObj(e->(char)e).collect(Collectors.toList()); Map<Character, Integer> countChar = textInChar.stream().collect(HashMap::new, (m, c) -> { if(m.containsKey(c)) m.put(c, m.get(c) + 1); else m.put(c, 1); }, HashMap::putAll); Let's check:countChar.forEach( (k, v) -> LOG.debug(k + " -> " + v)); He'll find out:p -> 1 a -> 1 s -> 1 e -> 3 x -> 1 l -> 1 m -> 2 o -> 1 UPD:if(m.containsKey(c)) m.put(c, m.get(c) + 1); else m.put(c, 1); Can be reduced to:m.put(c, m.containsKey(c) ? (m.get(c) + 1) : 1);

public static <T> Pair<T, T> findMinMax( Stream<? extends T> stream, Comparator<? super T> order, Pair<T, T> identity) { return stream.reduce( identity, (pair, t) -> { T min = order.compare(pair.getKey(), t) < 0 ? pair.getKey() : t; T max = order.compare(pair.getValue(), t) > 0 ? pair.getValue() : t; return new Pair<>(min, max); }, (p1, p2) -> { T min = order.compare(p1.getKey(), p2.getKey()) < 0 ? p2.getKey() : p1.getKey(); T max = order.compare(p1.getValue(), p2.getValue()) > 0 ? p1.getValue() : p1.getValue(); return new Pair<>(min, max); } ); } Some kind of nightmare. ♪public static void main(String[] args) { Pair&lt;Integer, Integer&gt; identity = new Pair&lt;&gt;(Integer.MAX_VALUE, Integer.MIN_VALUE); Stream&lt;Integer&gt; s = Stream.of(1,2,3,4,5,6,7,8,9,10); Comparator&lt;Integer&gt; comp = (Integer o1, Integer o2) -&gt; o1.compare(o1, o2); Pair&lt;Integer, Integer&gt; p = Example.findMinMax(s, comp, identity); System.out.println(p); // 1..10 } PS: Alternative implementation without identity on @TagirValeev :public static <T> Pair<T, T> findMinMax( Stream<? extends T> stream, Comparator<? super T> order) { return stream.reduce( null, (pair, t) -> { if (pair == null) return new Pair<>(t,t); T min = order.compare(pair.getKey(), t) < 0 ? pair.getKey() : t; T max = order.compare(pair.getValue(), t) > 0 ? pair.getValue() : t; return new Pair<>(min, max); }, (p1, p2) -> { if (p1 == null) return p2; if (p2 == null) return p1; T min = order.compare(p1.getKey(), p2.getKey()) < 0 ? p2.getKey() : p1.getKey(); T max = order.compare(p1.getValue(), p2.getValue()) > 0 ? p1.getValue() : p1.getValue(); return new Pair<>(min, max);} ); }

You haven't changed. IntStream Total Stream<Integer>♪ By fact map(id -> Integer.valueOf(id)) Doesn't do anything because map returning the same. IntStream♪ To convert to an objective flow, in general, mapToObjAnd in your particular case, it's easier to write. boxed():ArrayList<Integer> visitorsIdexes = Arrays.stream(targetVisitors) .filter(id -> checkVisitor(id, target.getTargetSegmentCube())) .boxed() .collect(Collectors.toList());

As noted correctly by @kofemann, Stream - a one-time thing. That's what he looks like. Iterator♪ To use it several times, you need to create a new one. Stream♪ If you some reason want to create Stream Exit outwards (e.g. for you) Stream They've given the parameter, but you need it a few times, and it's recommended use. Supplier<Stream>:private boolean test(String line) { String[] words = line.split(" "); Supplier<Stream<String>> wordsStream = () -> Arrays.asList(words).stream(); for (int i = 0; i < controlWords.length; i++) { if (!wordsStream.get().anyMatch(Predicate.isEqual(controlWords[i]))) { return false; } } return true; } Still notice there's a method. Arrays.stream()So you don't have to turn your words on the list first:Supplier<Stream<String>> wordsStream = () -> Arrays.stream(words); Finally, notice that your task is much easier to do without Stream API:private boolean test(String line) { List<String> words = Arrays.asList(line.split(" ")); for (int i = 0; i < controlWords.length; i++) { if (!words.contains(controlWords[i])) { return false; } } return true; } However, the cycle itself could be reversed. for Turn. Stream of controlWords:private boolean test(String line) { List<String> words = Arrays.asList(line.split(" ")); return Arrays.stream(controlWords).allMatch(controlWord -> words.contains(controlWord)); } You can replace the lambdu with the reference:private boolean test(String line) { List<String> words = Arrays.asList(line.split(" ")); return Arrays.stream(controlWords).allMatch(words::contains); } And even inclined. words (after the inlining, he's still counting once!)private boolean test(String line) { return Arrays.stream(controlWords).allMatch(Arrays.asList(line.split(" "))::contains); }

If I've understood your problem correctly, we've got to do something like this:long total = IntStream.range( 0, vector.size() ).parallel().filter( index -> vector.get( index ) ) .mapToLong( index -> trafficDataList.stream().parallel().map( trafficData -> { int visitorTrafficDataIndex = getVisitorTrafficDataIndex( index, trafficData ); if (visitorTrafficDataIndex >= 0) { return trafficData.getVolume()[visitorTrafficDataIndex]; } return 0; } ).sum() ).sum(); You can't do what you want. map(trafficData -> getVisitorTrafficDataIndex(index, trafficData)) There's no object in your design anymore. trafficDataHe's just a collection of int.

And what are your numbers? I have: 40411064So the parallel grading was four times faster.In fact, your results will depend on many factors:Number of processors and processor nucleus on your systemprocessor loads at the time of programme launchNumber of elements in your linecost of operation on the individual string element (and some operations are not fully melted)The fact is that the parallel grading will only increase if the overhead costs of creating flows are less than the gains of separation. If your system is loaded with another job, a few streams can slow the test instead of accelerating it. The same applies to small streams: for them, the cost of creating additional flows may be higher than the gains of separation.Well, there baccalaureate itself has observations:Measuring productivity in this way is wrong. There are special tools for this, such as the Java-Benchmarking official tunnel. http://openjdk.java.net/projects/code-tools/jmh/ ♪

When the netter comes into it, the empty list that created JAXB. And you see that. after: [ ]♪ But then JAXB starts filling this list with elements. But since in the first case you're setting up a new list filled with a list just disappears somewhere in JAXB's suburbs, in the second case, you're retaining exactly the reference to the list that will then be filled and as a result you see. Class1{i1=[1, 2, 3]}

The second option should be quicker in theory, with a smaller set of methods, but not exactly 1.5-2 times. How did productivity compare? 99.99999 per cent of cases are incorrect in comparison.

If necessary, implement the designer(s) PaymentEntity for initialization of zeros:class PaymentEntity { // ... public PaymentEntity() { this(BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO); } public PaymentEntity(BigDecimal n, BigDecimal f, BigDecimal p) { number = n; fullDebtRemnant = f; percentAmount = p; } } Determine a method for summarizing all fields PaymentEntity:as static:public class Accumulator { public static PaymentEntity add(PaymentEntity acc, PaymentEntity add) { acc.setNumber(acc.getNumber().add(add.getNumber())); acc.setFullDebtRemnant(acc.getFullDebtRemnant().add(add.getFullDebtRemnant())); acc.setPercentAmount(acc.getPercentAmount().add(add.getPercentAmount())); return acc; } } Then the list can be construed as follows:PaymentEntity total = list.stream() .reduce(new PaymentEntity(), Accumulator::add); Class method PaymentEntity similarly:// class PaymentEntity PaymentEntity accumulate(PaymentEntity that) { this.setNumber(this.getNumber().add(that.getNumber())); this.setFullDebtRemnant(this.getFullDebtRemnant().add(that.getFullDebtRemnant())); this.setPercentAmount(this.getPercentAmount().add(that.getPercentAmount())); return this; } The amount is calculated as follows:PaymentEntity total = list.stream() .reduce(new PaymentEntity(), PaymentEntity::accumulate); Test:List<PaymentEntity> list = Arrays.asList( new PaymentEntity(new BigDecimal("120"), new BigDecimal("1250"), new BigDecimal("10.5")), new PaymentEntity(new BigDecimal("150"), new BigDecimal("1000"), new BigDecimal("8.5")), new PaymentEntity(new BigDecimal("100"), new BigDecimal("750"), new BigDecimal("6.0")) ); PaymentEntity total = list.stream() .reduce(new PaymentEntity(), PaymentEntity::accumulate); System.out.println(total); Conclusion:number: 370; debtRemnant: 3000; percentAmount: 25.0

It's not understandable which of the object's fields. ReformJson refers to votes, so in the following example, List<ReformJson> We'll take the field. body - so they're not null and empty:List<ReformJson> reformJsons = mapper.readValue( response.getEntity().getContent(), new TypeReference<>() {} ) .stream() .filter(rj -> Objects.nonNull(rj.getBody()) && !rj.getBody().isEmpty()) .collect(Collectors.toList());

Collect Collectors.toList() No change in existing list doublesListand returns a new one that needs to be returned as a model attribute.It is possible to filter and distort this list immediately after it has been received from the mapper:public String getStartPage(Model model) { List<ItemDto> doublesList = itemMapper.listToDto(itemService.findByRating(4.0)) .stream() .filter(i -> i.getRating() != null) .sorted(Comparator.comparing(ItemDto::getRating).reversed()) .limit(4) .collect(Collectors.toList()); // отфильтрованный и сортированный список model.addAttribute("items", doublesList); return "index"; }

Lines broken by String::split, but in this case the symbol should be racked |as it is used in regular expressions as OR operator: line -> line.split("\\|")Numbers of all cars with black or zero passes. / filter + mapreader.lines() // Stream<String> .map(line -> line.split("\\|")) // Stream<String[]> .filter(arr -> "Black".equalsIgnoreCase(arr[2]) // цвет чёрный || 0 == Integer.parseInt(arr[3]) // или пробег нулевой ) .forEach(arr -> System.out.println(arr[0])); // номер Conclusion:н455сх178 а787ук197 р435ав777 Number of unique models in price range from 700 to 800,000 // distinct + filterThis is where they come out. unique modelslong countFrom700to800 = reader.lines() // Stream<String> .map(line -> line.split("\\|")) // Stream<String[]> .filter(arr -> 700_000 <= Integer.parseInt(arr[4]) // от 700 тыс. && Integer.parseInt(arr[4]) < 800_000 // до 800 тыс. ) .map(arr -> arr[1]) // модель .distinct() .count(); // количество моделей System.out.println(countFrom700to800); Conclusion:2 distinct In this case, each line contains a unique number and a different price, which is the number of unique lines. Model Model Model Model Model Model Model Model♪

You've got to work right.public class Main { public static void main(String[] args) { List&lt;Product&gt; products = new ArrayList&lt;&gt;(); products.add(new Product(1,"A")); products.add(new Product(1,"B")); products.add(new Product(1,"A")); products.add(new Product(2,"A")); System.out.println(distinct(products)); } public static List&lt;Product&gt; distinct(List&lt;Product&gt; products) { return products.stream().distinct().collect(Collectors.toList()); } } Conclusion[Product{code=1, title='A'}, Product{code=1, title='B'}, Product{code=2, title='A'}] Comparison follows the Equals method, if you need to compare it only by code, change it@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Product product = (Product) o; return code == product.code; } @Override public int hashCode() { return Objects.hash(code); } after[Product{code=1, title='A'}, Product{code=2, title='A'}]