Java Academy · Oppitunti

Primitiivivirtojen luonti

iterate ja generate.

Oppitunti 4/413 vaihetta

Primitiivivirtojen luonti on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Java Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Java Academy-kurssilla on yhteensä 4 oppituntia.

Äärettömät virrat tarvitsevat rajoituksen

iterate ja generate luovat mahdollisesti äärettömiä virtoja. Niihin on lisättävä limit (tai predikaatti), jotta virroista tulee äärellisiä.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterointi seed-arvolla

iterate(seed, next) aloittaa seed-arvosta ja soveltaa funktiota toistuvasti edelliseen arvoon.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(2, n -> n * 2)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterointi predikaatilla

Kolmiargumenttinen iterate(seed, hasNext, next) lopettaa automaattisesti, kun predikaatti on epätosi, funktionaalisen for-silmukan tavoin.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n <= 100, n -> n * 3)
            .forEach(System.out::println);
    }
}

Generointi Supplierilla

generate ottaa vastaan IntSupplier-olion, joka tuottaa jokaisen alkion itsenäisesti ilman riippuvuutta edellisestä arvosta.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.generate(() -> 7)
            .limit(3)
            .forEach(System.out::println);
    }
}

Satunnaislukujen generointi

generate-metodin Supplier voi kutsua satunnaislukulähdettä. Tässä jokainen alkio on itsenäinen nopanheitto.

import java.util.Random;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Random rnd = new Random(42);
        IntStream.generate(() -> rnd.nextInt(6) + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

iterate ja generate

Keskeinen ero:

iterate: jokainen arvo johdetaan edellisestä arvosta (sarjat).
generate: jokainen arvo tuotetaan itsenäisesti (vakiot, satunnaisarvot).

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.iterate(1, n -> n + 1).limit(10).sum();
        System.out.println(sum);
    }
}

Generoituja virtoja yhdistävät operaatiot

Kun generoidulle virralle on asetettu raja, se tukee kaikkia tavallisia koostavia operaatioita.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.iterate(0, n -> n + 2)
            .limit(50)
            .filter(n -> n % 3 == 0)
            .count();
        System.out.println(count);
    }
}

Fibonaccin luvut iterate-operaatiolla oliovirralta

Fibonaccin lukujen kaltaisissa tilallisissa sarjoissa käyttäkää Stream.iterate-operaatiota taulukon muodostamaan pariin ja muuntakaa tulos sitten takaisin int-tyyppiin.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, p -> new int[]{p[1], p[0] + p[1]})
            .limit(8)
            .mapToInt(p -> p[0])
            .forEach(System.out::println);
    }
}

Taulukon muodostaminen generaattorista

Yhdistämällä generaattorin ja toArray-operaation voitte muodostaa primitiivitaulukon ohjelmallisesti.

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] squares = IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .map(n -> n * n)
            .toArray();
        System.out.println(Arrays.toString(squares));
    }
}

Laiskuus säästää työtä

Virrat ovat laiskoja: kun käytössä on limit, äärettömästä lähteestäkin generoidaan vain tarvittavat alkiot.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int first = IntStream.iterate(10, n -> n + 10)
            .filter(n -> n > 25)
            .findFirst()
            .getAsInt();
        System.out.println(first);
    }
}

Suosikaa predikaattimuotoa

Predikaattiin perustuva iterate on usein selkeämpi kuin iterate(...).limit(...), koska lopetusehto on samassa paikassa generointilogiikan kanssa.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long product = LongStream.iterate(1, n -> n <= 5, n -> n + 1)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Pikatarkistus

Mitä tapahtuu, jos kutsutte generate-metodia ilman limit-operaatiota ja sen jälkeen päätösoperaatiota, kuten forEach?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Generoitte primitiivivirtoja:

iterate johtaa jokaisen arvon edellisestä arvosta.
generate tuottaa arvot itsenäisesti Supplier-oliolta.
Molemmat ovat äärettömiä; rajatkaa niitä limit-operaatiolla tai iterate-operaation predikaattimuodolla.
Laiskuus tarkoittaa, että vain tarvittavat alkiot lasketaan.

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 104
Oppitunnit: 374

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Primitiivivirtojen luonti” ilmainen?

Kyllä – oppitunnin ”Primitiivivirtojen luonti” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Java Academy-kurssin, päivitä CoddyKit PROhon. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Primitiivivirtojen luonti”?

iterate ja generate. Harjoittelet Java Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Java Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Java Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Primitiivivirtojen luonti”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Java Academy-oppitunnilla?

Kyllä. Jokainen Java Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

IntStream ja LongStream
Väli- ja koontioperaatiot
Kuvaus olio- ja primitiivivirtojen välillä
Primitiivivirtojen luonti

← Takaisin: Java Academy