ஜாவா உதாரணங்களுடன் கணிக்கவும்

பொதுவாக முன்னறிவிப்பு என்பது ஒரு மதிப்பு உண்மையா அல்லது பொய்யா என்பதைத் தீர்மானிக்கும் அறிக்கை. நிரலாக்கத்தில் முன்கணிப்புகள் ஒரு பூலியன் மதிப்பை வழங்கும் ஒரு வாதத்துடன் செயல்பாடுகளைக் குறிக்கின்றன. செயல்பாட்டு இடைமுக முன்கணிப்பு ஜாவா 8 இல் உணரப்பட்டது. "செயல்பாட்டு" என்பது ஒரே ஒரு சுருக்க முறையை மட்டுமே கொண்டுள்ளது. இது ஒரு வாதத்தை ஏற்றுக்கொண்டு ஒரு பூலியனைத் தருகிறது. ஜாவாவில், லாம்ப்டா வெளிப்பாடுகள், கட்டமைப்பாளர்கள் மற்றும் முறை குறிப்புகளைக் கையாளுவதற்கு செயல்பாட்டு இடைமுகங்கள் பயன்படுத்தப்படுகின்றன. வழக்கமாக ஜாவா 8 ப்ரெடிகேட் என்பது பொருள்களின் தொகுப்பிற்கு வடிப்பானைப் பயன்படுத்தப் பயன்படுகிறது. அதன் முக்கிய பயன்பாடுகள் மற்றும் பரவலாகப் பயன்படுத்தப்படும் முறைகளைப் பார்ப்போம், அத்துடன் சில நடைமுறை சிக்கல்களைத் தீர்ப்போம்.

டெவலப்பர்கள் ஏன் முன்னறிவிப்பைப் பயன்படுத்துகிறார்கள்

அடிப்படையில், டெவலப்பர்கள் முன் வரையறுக்கப்பட்ட அளவுகோல்களின் அடிப்படையில் உருப்படிகளை மதிப்பிடுவது மற்றும் பூலியன் மதிப்பை வழங்குவதை உள்ளடக்கிய எந்தவொரு பணிகளுக்கும் முன்னறிவிப்புகளைப் பயன்படுத்தலாம். முன்னறிவிப்புகளைப் பயன்படுத்தி டெவலப்பர்கள் கையாளும் எளிய பணிகளின் எடுத்துக்காட்டுகள் இங்கே:

• முழு எண்களின் தொகுப்பை வடிகட்டுதல்.
• தரவு பல முன் வரையறுக்கப்பட்ட நிபந்தனைகளுடன் இணங்குவதை உறுதி செய்வதன் மூலம் பட்டியல்களை வரிசைப்படுத்துதல் (எ.கா. விலை மற்றும் எடை நிலைகளை அமைப்பதன் மூலம் பொருட்களின் வரம்பை ஒழுங்கமைத்தல்).
• ஒரே நேரத்தில் நிரலாக்கத்தில் பயன்பாட்டு தொகுப்புகளைப் பயன்படுத்துதல்.

மென்பொருள் சோதனையில் கணிப்புகள் ஒரு முக்கிய அம்சமாகும். செயல்பாட்டு இடைமுகமானது, சோதனைக்கான அலகுகளைப் பிரிப்பதை எளிதாக்குகிறது, பயன்பாட்டுக் குறியீட்டின் வாசிப்புத்திறனையும் நிர்வகிக்கும் திறனையும் மேம்படுத்துகிறது.

ஜாவாவில் தொடரியல் கணிக்கவும்

java.util.function.Predicate லாம்ப்டாவில் மதிப்பீட்டு பதிவுகளைக் கையாள ஒரு மாற்று வழியாக ஜாவா 8 இல் அறிமுகப்படுத்தப்பட்டது. இடைமுகத்தின் நிலையான பார்வை Predicate<T> ஆகும் , T என்பது பூலியன் மதிப்பை வழங்கும் ஒற்றை வாதம். ஜாவா முன்னறிவிப்புகளுக்கு ஒரு செயல்பாட்டு (சுருக்க) முறை சோதனை (பொருள்) உள்ளது , இது கொடுக்கப்பட்ட பொருளின் மீது இந்த முன்னறிவிப்பை மதிப்பிடுகிறது.

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}

"அதிகமான", "குறைவான" நிபந்தனைகளின் அடிப்படையில் முழு எண்களை வடிகட்டுவதற்கான எளிய முன்கணிப்பை எழுதுவதற்கான எடுத்துக்காட்டு இங்கே.

// An example of a simple Java predicate
  
import java.util.function.Predicate; 
public class PredicateExample { 
    public static void main(String[] args) 
    { 
        // Creating predicate 
        Predicate<Integer> lesserThan = i -> (i < 18);  
  
        // Calling Predicate method 
        System.out.println(lesserThan.test(10));  
    }
}

வெளியீடு உண்மையாக இருக்கும் ஏனெனில் 10 < 18. வடிப்பானில் () முன்னறிவிப்புடன் மேலும் ஒரு எடுத்துக்காட்டு . அனைத்து பெரியவர்களையும் வயது பட்டியலிலிருந்து வடிகட்ட முன்கணிப்பு உதவுகிறது.

  import java.util.List;
  import java.util.function.Predicate;

  public class PredicateExample {
      public static void main(String[] args) {
          List<Integer> ages = List.of(17, 18, 19, 28, 18, 28, 46, 7, 8, 9, 21, 12);
          NotLessThan18<Integer> isAdult = new NotLessThan18<>();
          ages.stream().filter(isAdult).forEach(System.out::println);
      }
  }



class NotLessThan18<E> implements Predicate<Integer> {

      @Override
      public boolean test(Integer v) {
          Integer ADULT = 18;
          return v >= ADULT;
      }
  }

வெளியீடு:

ஜாவா 8 முன்கணிப்பு முறைகள்

முன்னறிவிப்பு இடைமுகம் ஒரு சில முறைகளைக் கொண்டுள்ளது.

• பூலியன் சோதனை(T t) கொடுக்கப்பட்ட வாதத்தின் முன்கணிப்பை மதிப்பிடுகிறது.
• default Predicate<T> மற்றும்(Predicate<? super T> other) ஆனது இந்த முன்னறிவிப்பு மற்றும் மற்றொன்றின் குறுகிய-சுற்று லாஜிக்கலைக் குறிக்கும் முன்னறிவிப்பை வழங்குகிறது.
• இயல்புநிலை முன்கணிப்பு<T> அல்லது இந்த முன்னறிவிப்பு மற்றும் மற்றொன்றின் குறுகிய-சுற்று தர்க்கத்தை அல்லது மற்றொன்றைக் குறிக்கும் தொகுக்கப்பட்ட முன்னறிவிப்பை வழங்குகிறது.
• default Predicate<T> negate() ஆனது தர்க்கரீதியாக இந்த முன்னறிவிப்புக்கு நேர்மாறான முன்னறிவிப்பை வழங்குகிறது.
• Default Predicate<T> isEqual(Object targetRef) ஆனது Objects.equals(Object, Object) படி இரண்டு வாதங்கள் சமமாக இருந்தால் சோதனையின் முடிவை வழங்குகிறது .

பூலியன் சோதனை (டி டி)

இது ஜாவா முன்னறிவிப்புகளுக்கான செயல்பாட்டு முறையாகும், இது கொடுக்கப்பட்ட வாதம் ஒரு முன்கணிப்பின் நிபந்தனையை திருப்திப்படுத்துகிறதா இல்லையா என்பதை மதிப்பிடுகிறது. எடுத்துக்காட்டு: இங்கு 18 அல்லது அதற்கு மேற்பட்ட வயதுடைய அனைவருக்கும் ஒரு முன்கணிப்பு வயது வந்தவரை உருவாக்குகிறோம். test() முறை ஒரு முழு எண் மதிப்பைப் பெற்று அதைச் சரிபார்க்கிறது.

import java.util.function.Predicate;
public class PredicateTestTest {
   public static void main(String[] args) {
       Predicate<Integer> adult = i -> i >= 18;
       System.out.println(adult.test(12));
       System.out.println(adult.test(19));
       System.out.println(adult.test(21));
   }
}

மேலே உள்ள குறியீட்டின் வெளியீடு என்னவாக இருக்கும்? முதல் வழக்கில், 12 18 ஐ விட குறைவாக இருப்பதால், அது தவறானதாக இருக்கும். இரண்டாவது மற்றும் மூன்றாவது காட்சியைப் பொறுத்தவரை, நிபந்தனைகள் பூர்த்தி செய்யப்படுவதால், திரும்பப் பெறுவது உண்மையாக இருக்கும்.

இயல்புநிலை Predicate.and()

இந்த முறை "மற்றும்" ஆபரேட்டரைக் குறிக்கிறது. அதனால்தான், கொடுக்கப்பட்ட முன்னறிவிப்புகளில் ஒன்று ஒரு குறிப்பிட்ட நிபந்தனைக்கு இணங்கவில்லை என்றால், மற்றொன்று மதிப்பீட்டைப் பெறாது. எடுத்துக்காட்டு: ஜாவாவில் முன்னறிவிப்புகளை உருவாக்குவோம், ஏற்கனவே பெரியவர்கள் ஆனால் 65 வயதுக்கு குறைவானவர்கள் மற்றும்() ஐப் பயன்படுத்தி வடிகட்டலாம் . predicate.add () ஐப் பயன்படுத்தி , இந்த நிபந்தனைகளுக்கு லாம்ப்டாவுடன் ஜாவா முன்னறிவிப்பை எழுதுவோம்: நிபந்தனை உண்மையாக இருந்தால், ஆப்ஸ் பின்வரும் அறிக்கையை வழங்கும்:

import java.util.function.Predicate;

   public class PredicateDemo {
       public static void main(String[] args) {
           Predicate<Integer> adultYet = i -> i >= 18;
           Predicate<Integer> adultStill = i -> i < 65;
           System.out.println(adultYet.and(adultStill).test(5));
           System.out.println(adultYet.and(adultStill).test(38));
           System.out.println(adultYet.and(adultStill).test(90));
       }
   }

வெளியீடு:

இயல்புநிலை Predicate.or()

Predicate.or() முறையானது "OR" ஆபரேட்டரைக் குறிக்கிறது. இரண்டு முன்னறிவிப்புகளில் ஒன்று உண்மையாக இருந்தாலும் மற்றொன்று தவறானதாக இருந்தாலும் நிபந்தனை உண்மையாகவே இருக்கும் என்பதே இதன் பொருள். எடுத்துக்காட்டு: இப்போது எழுத்துச் சரங்களை மதிப்பிடுவோம். "எனது" அல்லது "கிரேயன்" என்ற சப்ஸ்ட்ரிங் கொண்டிருக்கும் அனைத்து சொற்றொடர்களையும் வரிசைப்படுத்த OR முறையைப் பயன்படுத்தவும்.

import java.util.function.Predicate;

  public class PredicateDemo2 {
      public static void main(String[] args) {
          Predicate<String> containsA = t -> t.contains("crayon");
          Predicate<String> containsB = t -> t.contains("my");
          System.out.println(containsA.or(containsB).test("here is my crayon"));
          System.out.println(containsA.or(containsB).test("here is my pencil"));
          System.out.println(containsA.or(containsB).test("here is John's crayon"));
          System.out.println(containsA.or(containsB).test("here is John's pencil"));
      }
  }

வெளியீடு:

இயல்புநிலை முன்கணிப்பு மறுப்பு()

முன் வரையறுக்கப்பட்ட அளவுகோல்களுக்கு இணங்காத அனைத்து மதிப்புகளையும் சேகரிக்க negate() முறை பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டு: நீங்கள் "தக்காளி" வகுப்பை வரிசைப்படுத்தி, "சிவப்பு" இல்லாத அனைத்து உள்ளீடுகளையும் கண்டுபிடிக்க விரும்பினால், நீங்கள் ஒரு முன்னறிவிப்பை எழுதி முழு வரிசையையும் விரைவாக ஸ்கேன் செய்யலாம். இதற்கான குறியீட்டை நீங்களே எழுத முயற்சிக்கவும், நீங்கள் முடித்தவுடன் தீர்வுக்கு எதிராகச் சரிபார்க்கவும்.

import java.util.function.Predicate;

public class PredicateDemo3 {
public static void main(String[] args) {
 Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.negate().test(7));  System.out.println(adult.negate().test(19))
  }
   }

வெளியீடு:

நிலையான முன்கணிப்பு சமம் (பொருள் இலக்கு குறிப்பு)

Objects.equals() இன் அளவுருவாக வரையறுக்கப்பட்ட மதிப்புக்கு இரண்டு பொருள்கள் சமமாக உள்ளதா என்பதை நீங்கள் தீர்மானிக்க விரும்பினால் இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும். இதேபோன்ற சோதனை முடிவுகளை நீங்கள் ஒப்பிட வேண்டும் என்றால் இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும். உதாரணம்: நீங்கள் இரண்டு பேரிக்காய் வண்டிகளை ஒப்பிடுகிறீர்கள் என்று வைத்துக்கொள்வோம், இரண்டிலும் நிலையான எடை மற்றும் நிறத்தில் பழங்கள் உள்ளதா என்பதை உறுதிப்படுத்த விரும்புகிறீர்கள். இந்த வழக்கில், நிலையான முன்கணிப்பு isEqual(Object targetRef) என்பது உங்களுக்குத் தேவையான முறையாகும். இரண்டு சரங்களின் சமத்துவத்தை isEqual எவ்வாறு சரிபார்க்கிறது என்பதைப் பார்ப்போம் :

import java.util.function.Predicate;

public class PredicateDemo2 {
   public static void main(String[] args) {
       Predicate<String> i = Predicate.isEqual("here is my crayon");
       System.out.println(i.test("here is my pencil"));
       System.out.println(i.test("here is my crayon"));
   }
}

நீங்கள் பகுப்பாய்வு செய்யும் பொருள் நிலையான நிபந்தனைகளுக்கு இணங்கினால், செயல்பாடு உண்மையாக இருக்கும். வெளியீடு:

Java IntPredicate

Java IntPredicate ஒரு செயல்பாட்டு இடைமுகம், எனவே நீங்கள் அதை ஒரு லாம்ப்டா வெளிப்பாடு அல்லது முறை குறிப்புக்கான ஒதுக்கீட்டு இலக்காகப் பயன்படுத்தலாம். IntPredicate ஒரு முழு எண்ணில் இயங்குகிறது மற்றும் நிபந்தனையின் அடிப்படையில் ஒரு கணிப்பு மதிப்பை வழங்குகிறது. Predicate Interface போன்ற, IntPredicate ஆனது test() , and() , negate() , or() முறைகளையும் கொண்டுள்ளது. IntPredicate இன் உதாரணம் இங்கே. இது அனைத்து பெரியவர்களையும் (18 அல்லது அதற்கு மேற்பட்டவர்கள்) வரிசையில் இருந்து வடிகட்டுகிறது.

import java.util.Arrays;
import java.util.function.IntPredicate;

public class IntPredicateExample {

   public static void main(String[] args) {

       int[] ages = { 18, 28, 18, 46, 90, 45, 2, 3, 1, 5, 7, 21, 12 };

       IntPredicate p = n -> n >= 18;

       Arrays.stream(ages).filter(p).forEach(System.out::println);
   }
}

வெளியீடு:

ஜாவாவில் சுத்தமான கணிப்புகளை எழுதுதல்

ஜாவா முன்னறிவிப்புகள் மிகவும் செயல்பாட்டுடன் செயல்படுகின்றன. இருப்பினும், நீங்கள் எழுதும் லாம்ப்டா வெளிப்பாடுகள் குறியீட்டை எவ்வாறு பாதிக்கிறது என்பதை நீங்கள் கவனத்தில் கொள்ளாவிட்டால், குழப்பமான முன்னறிவிப்புகளுடன் குறியீட்டைப் பராமரிக்கும் தன்மையைக் குறைக்கும் அபாயம் உள்ளது. உங்கள் செயல்பாட்டு இடைமுகங்களை நிர்வகிக்கவும் படிக்கவும் எளிதாக இருப்பதை உறுதிசெய்ய உதவும் சில எளிய நடைமுறைகள் இங்கே உள்ளன.

• உங்களை மீண்டும் மீண்டும் செய்யாதீர்கள் — மீண்டும் மீண்டும் மதிப்புகள், முறைகள் மற்றும் நிபந்தனைகளுடன் ஜாவாவுடன் முன்னறிவிப்புகளை ஒன்றுக்கு மேற்பட்ட முறை உருவாக்க வேண்டாம். இந்த வழியில், நீங்கள் உங்கள் உற்பத்தி நேரத்தை வீணடித்து, குறியீட்டை குழப்பமடையச் செய்கிறீர்கள்.
• சோதனைத்திறனை உறுதிப்படுத்த, பயன்பாட்டுக் குறியீட்டிலிருந்து கணிப்புகளைப் பிரிக்கவும். அது தவிர, ஒரு முன்னறிவிப்பு அலகு சோதனை அட்டவணையை உருவாக்கி அதை ஒட்டிக்கொள்ளவும்.
• உங்கள் வகுப்புகள் வீங்காமல் இருப்பதையும், நிர்வகிக்க எளிதாக இருப்பதையும் உறுதிப்படுத்த இறக்குமதிகள் மற்றும் கலவை வடிவங்களைப் பயன்படுத்தவும்.
• ஜாவா முன்னறிவிப்புகளை ஹெல்பர் வகுப்புகளுக்கு நகர்த்துவதைக் கவனியுங்கள் - இந்த வழியில், உங்கள் குறியீட்டின் மறுபயன்பாட்டை மேம்படுத்தி பராமரிப்பை எளிதாக்குகிறீர்கள்.
• வாசிப்புத்திறன் - சாத்தியமான போதெல்லாம், சிக்கலான முன்னறிவிப்புகளை விட ஒரு வரி அறிக்கைகளை விரும்புங்கள். சிக்கலான செயல்பாட்டு இடைமுகங்களைப் பற்றிய உங்கள் புரிதலைக் காட்ட இது தூண்டுதலாக இருக்கலாம். இருப்பினும், பராமரிப்புக்கு வரும்போது, ​​​​குறைவானது அதிகம்.