Coffee break #97. Mag-ingat sa Java Opsyonal na pamamaraan. Paano magpapakita at magsama ng mga elemento mula sa isang listahan sa Java

Mag-ingat sa Java Opsyonal na pamamaraan

Pinagmulan: Dev.to Ayon sa Oracle, ang isang Opsyonal na bagay ay "isang lalagyan na bagay na maaaring o hindi naglalaman ng isang hindi null na halaga." Opsyonal unang lumabas sa Java 8 at ginamit ng SpringBoot team sa maraming proyekto. Ang pinakakaraniwang paggamit ng Mga Opsyonal ay sa isang proyekto ng Spring Data. Tingnan natin ang interface ng JpaRepository at isang halimbawang paraan. Halimbawa, mayroon kaming User object na may integer type Id at mayroon kaming JpaRepository para dito.

@Repository
public interface IUserRepo extends JpaRepository<User, Integer>
{
    Optional<User> findByUserName(String userName);
}

Tinukoy namin ang isang paraan na naghahanap ng user sa pamamagitan ng kanilang pangalan at nagbabalik ng Opsyonal para sa User .

Opsyonal na Mga Maginhawang Paraan

Kasama ang opsyonal sa maraming paraan na nagbibigay-daan sa amin na magsulat ng malinis at nababasang code.

• mapa(..).o(...)
• mapa(...).o Iba(...)
• ang isang kumpletong listahan ay matatagpuan sa dokumentasyon ng Oracle .

Gayunpaman, mayroong isang paraan na may mapanganib na hindi inaasahang pag-uugali.

Kilalanin ang orElse na pamamaraan

Ayon sa dokumentasyon ng Oracle:

public T orElse(T other)

Ibalik ang halaga kung mayroon, kung hindi, ibalik ang iba. Ngayon ay maaari na tayong magdagdag ng method call bilang orElse na parameter na tatakbo kung walang laman ang Opsyonal na parameter, di ba? Oo, tama iyon, ngunit paano kung sinabi ko sa iyo na ito ay gagana pa rin, hindi alintana kung mayroong halaga sa Opsyonal o wala. Suriin natin:

@Test
public void orElseTest()
{
    String result = Optional.of("hello").orElse(someMethod());
    assertThat(result).isEqualTo("hello");
}
private String someMethod()
{
    System.out.println("I am running !!");
    return "hola";
}

Ang pagsubok ay matagumpay, ngunit mapapansin mo na ang linyang " Ako ay tumatakbo " ay naka-print sa console.

Bakit ito nangyayari?

Ang Java ay nagpapatakbo ng isang paraan upang ibigay ang halaga na ibabalik sa kaso ng Else .

Kaya mag-ingat ka!

Kailangan mong mag-ingat kung ang isang paraan sa loob ng orElse ay maaaring magkaroon ng side effect dahil ito ay tatakbo pa rin.

Anong gagawin?

Maaari mong gamitin ang OrElseGet na pamamaraan , na nangangailangan ng paraan ng tagapagtustos upang maisakatuparan kung mayroong Opsyonal .

Paano magpapakita at magsama ng mga elemento mula sa isang listahan sa Java

Source: DZone Sa post na ito, matututunan mo kung paano ipakita at ibuod ang bilang ng mga elemento mula sa isang listahan sa Java. Ang pagma-map ng mga item mula sa isang Listahan ay nangangahulugan na ang bawat item sa listahang iyon ay mako-convert sa ibang bagay. Ang pagsasama-sama ng mga elemento mula sa isang listahan ay nangangahulugan na ang lahat ng mga elemento mula sa listahang iyon ay pagsasama-samahin sa isang bagay, na hindi naman kapareho ng uri ng orihinal. Sabihin nating mayroon kaming listahan ng mga order, at ang bawat order ay may listahan ng mga produkto.

record Order(String customer, List<Product> products) {
}

record Product(String brand, String modelName, BigDecimal price) {
}

Ano ang gagawin mo kung gusto mong malaman kung gaano karaming pera ang nanggagaling sa isang listahan ng order? Para sa bawat order, kakailanganin mong kumuha ng listahan ng mga produktong naroroon dito, at para sa bawat produkto sa mga listahang ito, kakailanganin mong makuha ang halaga nito. Pagkatapos nito, kailangan mong buod ang lahat ng mga presyong ito, at ito ay kung paano mo makuha ang resulta. Kapag isinasalin ang nasa itaas sa Map / Reduce kailangan mo:

1. Itugma ang bawat order sa isang listahan ng produkto.
2. Ipakita ang presyo para sa bawat produkto.
3. Isama ang lahat ng mga presyo sa pamamagitan ng pagdaragdag ng mga ito nang sama-sama.

Kaya gawin natin ito sa Java:

public class OrderMapReducer {
    public BigDecimal getTotal(List<Order> orders) {
        return orders.stream() // 1
                     .map(Order::products) // 2
                     .flatMap(List::stream) // 3
                     .map(Product::price) // 4
                     .reduce(BigDecimal::add) // 5
                     .orElse(BigDecimal.ZERO); // 6
    }
}

1. Lumilikha kami ng daloy ng mga order.
2. Tinutugma namin ang bawat order sa listahan ng produkto nito.
3. Tinutugma namin ang bawat listahan ng produkto na may daloy. Tandaan na kailangan naming gumamit ng flatMap dito , kung hindi ay mapupunta kami sa Stream <Stream <Product>> .
4. Para sa bawat produkto ipinapakita namin ang presyo nito.
5. Isama natin ang lahat ng mga presyo.
6. Kung walang laman ang Listahan ng Order , ibalik ang zero.

Iyon lang! Ngayon ay makakagawa na tayo ng pagsubok para matiyak na gumagana ang lahat gaya ng inaasahan.

@Test
void getTotalPrice() {
    List<Order> orders = createOrders();
    OrderMapReducer orderMapReducer = new OrderMapReducer();
    assertEquals(new BigDecimal(17800), orderMapReducer.getTotal(orders));
}

private static List<Order> createOrders() {
    var strato = new Product("Fender", "Stratocaster", new BigDecimal(3500));
    var sg = new Product("Gibson", "SG", new BigDecimal(4800));
    var lesPaul = new Product("Gibson", "Les Paul", new BigDecimal(4500));
    var rr = new Product("Jackson", "RR", new BigDecimal(5000));

    return List.of(
            new Order("David Gilmour", List.of(strato)),
            new Order("Toni Iommi", List.of(sg)),
            new Order("Randy Rhoads", List.of(lesPaul, rr))
    );
}

Gaya ng nakikita mo, nakakatulong ang Map and Reduce sa mga kaso kung saan kailangan mong kumuha ng impormasyon mula sa isang Collection .