ഈ ബ്ലോഗ് പോസ്റ്റിൽ, ഞങ്ങൾ ജാവ 8 സ്ട്രീംസ് സവിശേഷതകൾ ചർച്ചചെയ്യാനും വ്യത്യസ്ത കോഡ് ഉദാഹരണങ്ങൾ നൽകാനും പോകുന്നു.
ജാവ സ്ട്രീമുകൾ ജാവയിലേക്ക് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് കൊണ്ടുവരുന്നു, അവ ജാവ 8 ൽ ആരംഭിക്കുന്നതിനെ പിന്തുണയ്ക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് ജാവയുടെ പഴയ പതിപ്പ് ഉണ്ടെങ്കിൽ, ജാവ സ്ട്രീമുകൾ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ ജാവ 8 ലേക്ക് അപ്ഗ്രേഡ് ചെയ്യണം.
സ്ട്രീമുകളുടെ ചില ഗുണങ്ങൾ:
മിക്ക കേസുകളിലും, ഒരു സ്ട്രീമുകളുടെ പൈപ്പ്ലൈൻ a ഉൾക്കൊള്ളുന്നു
ഉറവിടം ഘടകങ്ങളുടെ ഒരു സ്ട്രീം സ്ട്രീം ചെയ്യാൻ പോകുന്നു.
മൂലകങ്ങളുടെ ആ സ്ട്രീം ഫിൽറ്റർ ചെയ്യാനും തരംതിരിക്കാനും അല്ലെങ്കിൽ മാപ്പുചെയ്യാനോ അല്ലെങ്കിൽ ഓരോ ഘടകത്തിനും ബാധകമായ മറ്റ് പ്രവർത്തന ശ്രേണികൾ നടത്താനോ കഴിയും.
അവസാനം, ഇത് ശേഖരിക്കുകയോ കുറയ്ക്കുകയോ അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ടെർമിനൽ പ്രവർത്തനം നടത്തുകയോ ചെയ്യാം, പക്ഷേ ഒരു ടെർമിനൽ പ്രവർത്തനങ്ങൾ മാത്രമേ നടത്തൂ.
സ്ട്രീം ഉറവിടം ശേഖരങ്ങൾ, ലിസ്റ്റുകൾ, സെറ്റുകൾ, ഇന്റുകളുടെ അറേ, ലോംഗ്സ്, ഇരട്ട, സ്ട്രിംഗുകൾ മുതലായവയിൽ നിന്ന് വരാം.
സ്ട്രീം പ്രവർത്തനങ്ങൾ ഇന്റർമീഡിയറ്റ് അല്ലെങ്കിൽ ടെർമിനൽ:
ചില ഇന്റർമീഡിയറ്റ് പ്രവർത്തനങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:
ഒരു ടെർമിനൽ പ്രവർത്തനം മാത്രമേ അനുവദിക്കൂ.
ഫംഗ്ഷനുകൾ കുറയ്ക്കുന്നതിനുള്ള ചില ഉദാഹരണങ്ങൾ ഇവയാണ്:
ഇപ്പോൾ കോഡ് ഉദാഹരണങ്ങളിൽ മുകളിലുള്ള ആശയങ്ങൾ നോക്കാം.
ആദ്യ ഉദാഹരണം ഒരു പൂർണ്ണ സംഖ്യ മാത്രമാണ്. IntStream
ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു സംഖ്യ സ്ട്രീം സൃഷ്ടിക്കാൻ പോകുന്നു ക്ലാസും അതിന്റെ ശ്രേണി ഫംഗ്ഷനും ഞങ്ങൾക്ക് പൂർണ്ണസംഖ്യകളുടെ ശ്രേണി നൽകുന്നു.
ദി forEach
ഞങ്ങളുടെ ടെർമിനൽ പ്രവർത്തനമാണ്. ഓരോ ഇനത്തിനും, ഞങ്ങൾ അത് പ്രിന്റുചെയ്യാൻ പോകുന്നു.
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream
.range(1, 10)
.forEach(System.out::print);
System.out.println();
} }
Put ട്ട്പുട്ട്:
123456789
രണ്ടാമത്തെ ഉദാഹരണം ഒരു സംഖ്യ സ്ട്രീം ഉപയോഗിക്കുന്നു, പക്ഷേ ഞങ്ങൾ ഒരു skip()
ചേർത്തു ഇവിടെ, അതിനാൽ ഈ സാഹചര്യത്തിൽ, ഞങ്ങളുടെ സ്ട്രീമിലെ ആദ്യ 5 ഘടകങ്ങൾ ഞങ്ങൾ ഒഴിവാക്കാൻ പോകുന്നു.
ഇത് 6 മുതൽ 9 വരെയുള്ള ഘടകങ്ങൾ മാത്രമേ അച്ചടിക്കുകയുള്ളൂ. ഇനം അച്ചടിക്കാൻ ഞങ്ങൾ ഒരു ലളിതമായ ലാംഡ എക്സ്പ്രഷനും ഉപയോഗിക്കുന്നു
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream
.range(1, 10)
.skip(5)
.forEach(x -> System.out.println(x));
System.out.println();
} }
Put ട്ട്പുട്ട്:
6 7 8 9
മൂന്നാമത്തെ ഉദാഹരണം, ഞങ്ങൾ വീണ്ടും IntStream
ഉപയോഗിക്കുന്നു എന്നിരുന്നാലും ഞങ്ങളുടെ ഒബ്ജക്റ്റ് സ്ട്രീം സൃഷ്ടിക്കുന്നതിന്, ഞങ്ങൾ അത് ഒരു println()
സ്റ്റേറ്റ്മെന്റ് പ്രിന്റ് ലൈനിന്റെ പാരാമീറ്ററായി.
ഞങ്ങൾ അച്ചടിക്കാൻ പോകുന്നത് 1 മുതൽ 5 വരെയുള്ള ശ്രേണിയിൽ നിന്ന് മറ്റൊരു തരത്തിൽ പറഞ്ഞാൽ, 1 2 3 & 4 അത് ആ സംഖ്യകളുടെ ആകെത്തുക മാത്രം അച്ചടിക്കാൻ പോകുന്നു:
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
System.out.println(
IntStream
.range(1, 5)
.sum());
System.out.println();
} }
Put ട്ട്പുട്ട്:
10
അടുത്ത ഉദാഹരണം Stream.of
ഉപയോഗിക്കുന്നു ഫംഗ്ഷൻ, ഇത് പൂർണ്ണമാണ്, കാരണം നിങ്ങൾക്ക് പൂർണ്ണസംഖ്യകൾ, ഫ്ലോട്ടിംഗ് പോയിൻറ് മൂല്യങ്ങൾ അല്ലെങ്കിൽ സ്ട്രിംഗുകൾ അല്ലെങ്കിൽ ഒബ്ജക്റ്റുകൾ സ്ട്രീം ചെയ്യാൻ കഴിയും.
ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ നേരായ അക്ഷരമാല ക്രമപ്പെടുത്താൻ പോകുകയാണ്, തുടർന്ന് findFirst()
ഉപയോഗിച്ച് ആദ്യത്തെ ഇനം കണ്ടെത്താൻ പോകുന്നു. പ്രവർത്തനം. തുടർന്ന്, ലിസ്റ്റിലെ ആദ്യ ഇനം ഞങ്ങൾ പ്രിന്റുചെയ്യുന്നു.
import java.io.IOException; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream.of('Ava', 'Aneri', 'Alberto')
.sorted()
.findFirst()
.ifPresent(System.out::println);
} }
Put ട്ട്പുട്ട്
Alberto
ഞങ്ങളുടെ അടുത്ത ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു ശ്രേണിയിൽ നിന്ന് സ്ട്രീം ചെയ്യാൻ പോകുന്നു. തുടർന്ന് ഞങ്ങൾ അടുക്കാനും ഫിൽട്ടർ ചെയ്യാനും അച്ചടിക്കാനും പോകുന്നു.
ഇവിടെ, s
എന്ന് ആരംഭിക്കുന്ന ഇനങ്ങൾ മാത്രം ഞങ്ങൾ ഫിൽട്ടർ ചെയ്യാൻ പോകുന്നു.
X
എടുക്കുന്ന ഒരു ലാംഡ എക്സ്പ്രഷൻ ഞങ്ങൾ ഉപയോഗിക്കുന്നു അത് ഓരോ പേരും എന്നിട്ട് s
എന്ന അക്ഷരത്തിൽ ആരംഭിക്കുന്നവ പരിശോധിക്കുന്നു അത് കടന്നുപോകുന്നവരെ മറികടക്കും.
തുടർന്ന് ഞങ്ങൾ അവയെ അടുക്കാൻ പോകുന്നു, തുടർന്ന് ആ തരം കടന്നുപോകുന്ന ഓരോ ഇനത്തിനും ഞങ്ങൾ അത് പ്രിന്റുചെയ്യാൻ പോകുന്നു.
import java.io.IOException; import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) throws IOException {
String[] names = {'Al', 'Ankit', 'Kushal', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah'};
Arrays.stream(names)
.filter(x -> x.startsWith('S'))
.sorted()
.forEach(System.out::println);
} }
Put ട്ട്പുട്ട്:
Sarah Sarika Shivika
ഒരു ഇന്റർ അറേയുടെ സ്ക്വയറുകളുടെ ശരാശരി എങ്ങനെ എടുക്കാമെന്ന് ഇപ്പോൾ നോക്കാം.
ഇവിടെ, ഞങ്ങൾ Arrays.stream()
ഉപയോഗിക്കുന്നു പൂർണ്ണസംഖ്യകൾ സ്ട്രീം ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം, തുടർന്ന് ഞങ്ങൾ map()
ഉപയോഗിക്കാൻ പോകുന്നു ഓരോ ഇനത്തെയും ഓരോ സംഖ്യയും അതിന്റെ സ്ക്വയറിലേക്ക് മാപ്പ് ചെയ്യുന്നതിന്.
import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) {
Arrays.stream(new int[] {2, 4, 6, 8, 10})
.map(x -> x * x)
.average()
.ifPresent(System.out::println);
} }
Put ട്ട്പുട്ട്:
44.0
ഒരു സംഖ്യയ്ക്ക് പകരം ഇത് ഇരട്ട പ്രിന്റ് ചെയ്യുന്നുവെന്ന് ശ്രദ്ധിക്കുക.
ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു ലിസ്റ്റിൽ നിന്ന് സ്ട്രീം ചെയ്യാനും ആ ഇനങ്ങൾ ഫിൽട്ടർ ചെയ്യാനും അച്ചടിക്കാനും പോകുന്നു.
map()
ഫംഗ്ഷൻ, ഞങ്ങൾ എല്ലാ പേരുകളും ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ പോകുന്നു.
import java.util.Arrays; import java.util.List; public class JavaStreams {
public static void main(String[] args) {
List people = Arrays.asList('Al', 'Ankit', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah');
people
.stream()
.map(String::toLowerCase)
.filter(x -> x.startsWith('a'))
.forEach(System.out::println);
} }
Put ട്ട്പുട്ട്:
al ankit amanda
a
എന്ന് ആരംഭിക്കുന്ന മൂന്ന് പേരുകൾ നമുക്ക് കാണാം അവയെല്ലാം ചെറിയക്ഷരത്തിലാണ്.
ഞങ്ങളുടെ അടുത്ത ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു ടെക്സ്റ്റ് ഫയലിൽ നിന്ന് വരികൾ സ്ട്രീം ചെയ്യാൻ പോകുന്നു. ഞങ്ങൾ അടുക്കാനും ഫിൽട്ടർ ചെയ്യാനും അച്ചടിക്കാനും പോകുന്നു.
ഞങ്ങൾക്ക് bands.txt
എന്ന ഒരു ഫയൽ ഉണ്ടെന്ന് കരുതുക ചുവടെ കാണിച്ചിരിക്കുന്ന ഉള്ളടക്കങ്ങൾക്കൊപ്പം:
Rolling Stones Lady Gaga Jackson Browne Maroon 5 Arijit Singh Elton John John Mayer CCR Eagles Pink Aerosmith Adele Taylor Swift
ഞങ്ങൾ Files.lines()
ഉപയോഗിക്കാൻ പോകുന്നു ഫയലിന്റെ ഓരോ വരിയിലും ഒരു സ്ട്രിംഗിന്റെ ഒരു സ്ട്രീം നൽകാൻ പോകുന്ന ഞങ്ങളുടെ സ്ട്രീം സൃഷ്ടിക്കാൻ.
ഞങ്ങളുടെ സ്ട്രീം ലഭിച്ചുകഴിഞ്ഞാൽ, ഞങ്ങൾ അവ അടുക്കാൻ പോകുന്നു, കൂടാതെ 13 പ്രതീകങ്ങളിൽ കൂടുതലുള്ള ഇനങ്ങൾ ഫിൽട്ടർ ചെയ്യാനും ശേഷിക്കുന്ന ഇനങ്ങൾ പ്രിന്റുചെയ്യാനും പോകുന്നു.
അവസാനമായി, ഞങ്ങൾ ഫയൽ അടയ്ക്കേണ്ടതിനാൽ ഞങ്ങൾ bands.close
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream bands = Files.lines(Paths.get('bands.txt'));
bands
.sorted()
.filter(x -> x.length() > 13)
.forEach(System.out::println);
bands.close();
} }
Put ട്ട്പുട്ട്:
Jackson Browne Rolling Stones
13 പ്രതീകങ്ങളിൽ കൂടുതലുള്ള രണ്ട് ബാൻഡുകൾ ഞങ്ങൾക്ക് ലഭിക്കും.
ഈ ഉദാഹരണത്തിനായി, മുകളിലുള്ള അതേ ടെക്സ്റ്റ് ഫയൽ ഞങ്ങൾ ഉപയോഗിക്കും.
jit
, x.contains()
അക്ഷരങ്ങൾ അടങ്ങിയ ഇനങ്ങൾ ഫിൽട്ടർ ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു ഇത് ഒരു സ്ട്രിംഗ് ഫംഗ്ഷൻ മാത്രമാണ്.
.collect()
ഉപയോഗിക്കുന്നു ഞങ്ങൾ എല്ലാം അക്ഷരങ്ങൾ ചേർത്ത് jit
ഒരു ലിസ്റ്റിലേക്ക്.
ഞങ്ങൾക്ക് list ട്ട് ലിസ്റ്റ് ലഭിച്ചുകഴിഞ്ഞാൽ, നമുക്ക് forEach
ഉപയോഗിക്കാം ഇനങ്ങൾ അച്ചടിക്കാനുള്ള ഓപ്പറേറ്റർ.
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.stream.Collectors; public class JavaStreams {
public static void main(String[] args) throws IOException {
List bands2 = Files.lines(Paths.get('bands.txt'))
.filter(x -> x.contains('jit'))
.collect(Collectors.toList());
bands2.forEach(x -> System.out.println(x));
} }
Put ട്ട്പുട്ട്:
Arijit Singh
ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു CSV ഫയലിൽ നിന്ന് വരികൾ സ്ട്രീം ചെയ്യുന്നു, ഞങ്ങൾ നല്ല വരികൾ എണ്ണാൻ പോകുന്നു.
ഞങ്ങൾക്ക് data.txt
എന്ന ഒരു ഫയൽ ഉണ്ടെന്ന് കരുതുക ഇനിപ്പറയുന്ന ഉള്ളടക്കങ്ങൾക്കൊപ്പം:
A,12,3.7 B,17,2.8 C,14,1.9 D,23,2.7 E F,18,3.4
ഇവിടെ, വരി E- ന് ഡാറ്റയൊന്നുമില്ല, അതിനാൽ അത് ഞങ്ങളുടെ സ്ട്രീമിൽ നിന്ന് ഒഴിവാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
ഇനിപ്പറയുന്ന കോഡിൽ, ഞങ്ങൾ ഓരോ വരിയിലും വായിക്കാൻ പോകുന്നു, തുടർന്ന് കോമയിൽ ഒരു അറേയായി വിഭജിക്കേണ്ടതുണ്ട്, അതിനാൽ ഓരോ വരിയും ഇനങ്ങളുടെ ഒരു നിരയായി മാറും.
മൂന്ന് ഇനങ്ങളില്ലാത്ത വരികൾ ഫിൽട്ടർ ചെയ്യുന്നതിന് ഞങ്ങൾ ഒരു ഫിൽട്ടർ പ്രയോഗിക്കുന്നു.
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream rows1 = Files.lines(Paths.get('data.txt'));
int rowCount = (int)rows1
.map(x -> x.split(','))
.filter(x -> x.length == 3)
.count();
System.out.println(rowCount + ' rows.');
rows1.close();
} }
Put ട്ട്പുട്ട്:
5 rows
റിഡക്ഷൻ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു. ഞങ്ങൾ ഒരു തുകയായി കുറയ്ക്കാൻ പോകുന്നു. ഇവിടെ, Stream.of()
ഉപയോഗിച്ച് ഞങ്ങൾക്ക് ഒരു ഇരട്ട സ്ട്രീം ഉണ്ട് പ്രവർത്തനം. മൂന്ന് വ്യത്യസ്ത ആർഗ്യുമെന്റുകളിൽ ഞങ്ങൾ മൂന്ന് ഡബിൾസ് നിർവ്വചിച്ചു, കൂടാതെ ഞങ്ങൾ കുറയ്ക്കുന്ന പ്രവർത്തനം ഉപയോഗിക്കാൻ പോകുന്നു.
import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) {
double total = Stream.of(7.3, 1.5, 4.8)
.reduce(0.0, (Double a, Double b) -> a + b);
System.out.println('Total = ' + total);
} }
Put ട്ട്പുട്ട്:
13.600000000000001