స్ట్రీమ్‌లతో పని చేయడం, పార్ట్ 3

1. తనిఖీ చేస్తోంది

డేటా స్ట్రీమ్‌లను కలపడం ఎలాగో నేర్చుకోవడంలో మీరు ఇప్పటికే విసుగు చెందారని నేను భావిస్తున్నాను. మీరు చివరకు డేటాతో ఏదైనా చేయాలనుకుంటున్నారు.

క్లాస్‌లో Streamస్ట్రీమ్‌లను నిర్మించని మూడు ప్రామాణిక పద్ధతులు ఉన్నాయి, బదులుగా వాటిలో ఏ రకమైన డేటా ఉందో తనిఖీ చేయండి. ఈ పద్ధతులు: anyMatch(), allMatch(), మరియు noneMatch().

boolean anyMatch(rule)పద్ధతి

ఈ పద్ధతిలో స్ట్రీమ్‌లో కనీసం ఒక మూలకం ఉందో లేదో తనిఖీ చేస్తుంది. అటువంటి మూలకం ఉంటే, పద్ధతి తిరిగి వస్తుంది true, లేకపోతే false.

ఉదాహరణలు

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).anyMatch(x -> x > 0);

false

చివరి ఉదాహరణలో, మేము మొదట సున్నా కంటే తక్కువ ఉన్న మూలకాలను మాత్రమే ఉంచుతాము, ఆపై ఫిల్టర్ చేయబడిన మూలకాలలో ఏదైనా సున్నా కంటే ఎక్కువగా ఉందో లేదో చూడటానికి మేము ఫలితాన్ని తనిఖీ చేస్తాము. వాస్తవానికి, అటువంటి అంశాలు ఇప్పుడు లేవు.

boolean allMatch(రూల్) పద్ధతి

ఈ పద్ధతి స్ట్రీమ్‌లోని అన్ని ఎలిమెంట్‌లు నియమానికి సరిపోలుతున్నాయో లేదో తనిఖీ చేస్తుంది (దీనిని ప్రిడికేట్ అని కూడా అంటారు). నియమం పద్ధతికి వాదనగా ఆమోదించబడింది:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.allMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.allMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).allMatch(x -> x < 0);

true

చివరి ఉదాహరణలో, మేము మొదట సున్నా కంటే తక్కువ ఉన్న ఎలిమెంట్‌లను మాత్రమే ఫిల్టర్ గుండా అనుమతించాము, ఆపై నిలుపుకున్న అన్ని మూలకాలు సున్నా కంటే తక్కువగా ఉన్నాయో లేదో తనిఖీ చేస్తాము. చెక్ సానుకూల ఫలితాన్ని ఇస్తుంది.

boolean noneMatch(రూల్) పద్ధతి

noneMatch()ఆమోదించిన నియమానికి సరిపోలే మూలకాలు స్ట్రీమ్‌లో లేవని ఈ పద్ధతి తనిఖీ చేస్తుంది. ఇది పద్ధతికి వ్యతిరేకం లాంటిది anyMatch().

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).noneMatch(x -> x > 0);

true

2. యుటిలిటీ తరగతులు: Optionalతరగతి

కొన్నిసార్లు ప్రోగ్రామర్లు సూచనలతో పనిచేయడం చాలా అసౌకర్యంగా ఉంటుంది null. ఉదాహరణకు, మీరు రెండు తీగలను పోల్చి చూస్తున్నారని అనుకుందాం. రెండు వేరియబుల్స్ లేకపోతే null, మీరు కేవలం కాల్ చేయవచ్చు s1.equals(s2)మరియు ప్రతిదీ పని చేస్తుంది. అయితే అలా s1ఉండగలిగితే null, మీరు ఒక దానిని నివారించడానికి ఈ పరిస్థితిని నిర్వహించే కోడ్‌ని వ్రాయవలసి ఉంటుంది NullPointerException.

అందుకే ప్రోగ్రామర్లు Optional<T>యుటిలిటీ క్లాస్‌తో ముందుకు వచ్చారు. దీని కోడ్ సుమారుగా ఇలా కనిపిస్తుంది:

class Optional<Type>
{
   private final Type value;
   private Optional() { this.value = null;}
   private Optional(value) { this.value = value;}
   public static <Type> Optional<Type> of(Type value)
   {
      return new Optional<Type>(value);
   }

   public boolean isPresent()
   {
      return value != null;
   }

   public boolean isEmpty()
   {
      return value == null;
   }

   public Type get()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }

   public Type orElse(Type other)
   {
      return value != null ? value : other;
   }

   public Type orElseThrow()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }
}

ఈ తరగతి యొక్క ఉద్దేశ్యం కేవలం T ఆబ్జెక్ట్‌ను నిల్వ చేయడమే (T రకంగా ఉండే వస్తువుకు సూచన). ఒక వస్తువు లోపల ఆబ్జెక్ట్ రిఫరెన్స్ Optional<T>కావచ్చు null.

ఈ తరగతి ప్రోగ్రామర్‌లు కొంచెం అందమైన కోడ్‌ని వ్రాయడానికి అనుమతిస్తుంది. పోల్చి చూద్దాం:

public void printString(String s)
{
   Optional<String> str = Optional.ofNullable(s);
   System.out.println(str.orElse(""));
}

public void printString(String s)
{
   String str = s != null ? s : "";
   System.out.println(str)
}

వారు సూచనలను నిల్వ చేసినప్పటికీ, పద్ధతిని ఉపయోగించి ఒక Optionalవస్తువును మరొక వస్తువుతో ఎల్లప్పుడూ పోల్చవచ్చు .Optionalequalsnull

సరళంగా చెప్పాలంటే, ఒక వస్తువు విలువను నిల్వ చేసిన సందర్భంలో Optional"అందమైన" తనిఖీలను మరియు "అందమైన" చర్యలను వ్రాయడానికి తరగతి మిమ్మల్ని అనుమతిస్తుంది .nullOptionalnull

3. అంశాలను కనుగొనడం

తిరిగి తరగతికి వద్దాం Stream. క్లాస్‌లో Streamస్ట్రీమ్‌లోని ఎలిమెంట్‌ల కోసం వెతకడానికి మిమ్మల్ని అనుమతించే మరో 4 పద్ధతులు ఉన్నాయి. ఈ పద్ధతులు findFirst(), findAny(), min()మరియు max().

Optional<T> findFirst()పద్ధతి

పద్ధతి findFirst()కేవలం స్ట్రీమ్‌లోని మొదటి మూలకాన్ని తిరిగి అందిస్తుంది. అది చేసేది అంతే.

ఇక్కడ గమనించదగ్గ మరింత ఆసక్తికరమైన విషయం ఏమిటంటే, పద్ధతి ఒక Tవస్తువును తిరిగి ఇవ్వదు, కానీ ఒక Optional<T>రేపర్ వస్తువును తిరిగి ఇవ్వదు. nullఒక వస్తువును కనుగొనడంలో విఫలమైన తర్వాత పద్ధతి ఎప్పటికీ తిరిగి రాదని ఇది నిర్ధారిస్తుంది .

ఉదాహరణ:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello

మరింత స్పష్టత కోసం, చివరి పంక్తిని అనేక పంక్తులుగా విడదీద్దాం:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

Stream<String> stream = list.stream();
Optional<String> result = stream.findFirst();
String str = result.get(); // Hello

చివరి get()పద్ధతి కేవలం వస్తువు లోపల నిల్వ చేయబడిన విలువను తిరిగి పొందడం Optional.

Optional<T> findAny()పద్ధతి

పద్ధతి findAny()స్ట్రీమ్ నుండి ఏదైనా మూలకాన్ని తిరిగి ఇస్తుంది మరియు అక్కడ ముగుస్తుంది. ఈ పద్ధతిని పోలి ఉంటుంది findFirst(), కానీ సమాంతర కార్యకలాపాలలో ఉపయోగించే స్ట్రీమ్‌లకు ఇది చాలా బాగుంది.

స్ట్రీమ్‌లను సమాంతరంగా ప్రాసెస్ చేస్తున్నప్పుడు, ఇది స్ట్రీమ్‌లోని కొంత భాగంలో ఒక మూలకం ఇప్పటికే కనుగొనబడి ఉండవచ్చు, కానీ ఇది మొదటిదా కాదా అనేది ఇంకా స్పష్టంగా తెలియలేదు.

అనేక అంశాలు అన్ని ఫిల్టర్‌లతో సరిపోలినట్లయితే మరియు ప్రోగ్రామర్ వాటిలో మొదటిదాన్ని సరిగ్గా పొందడం చాలా ముఖ్యం, అప్పుడు పద్ధతిని findFirst()పిలవాలి. వాస్తవానికి 0 లేదా 1 మూలకం అన్ని ఫిల్టర్‌లతో సరిపోలుతుందని ప్రోగ్రామర్‌కు తెలిస్తే, కేవలం కాల్ చేస్తే సరిపోతుంది findAny()- మరియు ఇది వేగంగా ఉంటుంది.

Optional<T> min(Comparator<T>)పద్ధతి

స్ట్రీమ్‌లోని అన్ని మూలకాలను పోల్చడానికి పద్ధతి ఒక వస్తువును ఉపయోగిస్తుంది మరియు కనిష్ట మూలకాన్ని అందిస్తుంది min(). comparatorలాంబ్డా ఫంక్షన్‌తో కంపారిటర్ ఆబ్జెక్ట్‌ను నిర్వచించడానికి అత్యంత అనుకూలమైన మార్గం.

చిన్న స్ట్రింగ్ కోసం శోధించడానికి ఉదాహరణ:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String min = list.stream().min( (s1, s2)-> s1.length()-s2.length() ).get();

Optional<T> max(Comparator<T>)పద్ధతి

స్ట్రీమ్‌లోని అన్ని మూలకాలను పోల్చడానికి పద్ధతి ఒక వస్తువును ఉపయోగిస్తుంది మరియు గరిష్ట మూలకాన్ని అందిస్తుంది max(). comparatorలాంబ్డా ఫంక్షన్‌తో కంపారిటర్ ఆబ్జెక్ట్‌ను నిర్వచించడానికి అత్యంత అనుకూలమైన మార్గం.

పొడవైన స్ట్రింగ్ కోసం శోధించడానికి ఉదాహరణ:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max( (s1, s2)-> s1.length()-s2.length() ).get();