ObjectUtils తరగతికి పరిచయం

పద్ధతులు:

allNotNull(వస్తువు...విలువలు) అన్ని వస్తువులు శూన్యంగా లేవని తనిఖీ చేస్తుంది
allNull(వస్తువు...విలువలు) అన్ని వస్తువులు శూన్యం అని తనిఖీ చేస్తుంది
anyNotNull(వస్తువు...విలువలు) కనీసం ఒక వస్తువు శూన్యం కాదని తనిఖీ చేస్తుంది
anyNull(వస్తువు... విలువలు) కనీసం ఒక వస్తువు శూన్యంగా ఉందో లేదో తనిఖీ చేస్తుంది
క్లోన్ (T obj) ఒక వస్తువును క్లోన్ చేస్తుంది
క్లోన్ఇఫ్పాసిబుల్(T obj) వస్తువును క్లోన్ చేస్తుంది లేదా అసలు దాన్ని తిరిగి ఇస్తుంది
సరిపోల్చండి (T c1, T c2) వస్తువులను పోలుస్తుంది
defaultIfNull(T వస్తువు, T డిఫాల్ట్ విలువ) వస్తువు శూన్యంగా ఉంటే డిఫాల్ట్ ఆబ్జెక్ట్‌ను అందిస్తుంది
సమానం (ఆబ్జెక్ట్ ఆబ్జెక్ట్1, ఆబ్జెక్ట్ ఆబ్జెక్ట్2) రెండు వస్తువులను పోలుస్తుంది
సమానం (ఆబ్జెక్ట్ ఆబ్జెక్ట్1, ఆబ్జెక్ట్ ఆబ్జెక్ట్2) రెండు వస్తువులు సమానంగా లేవని తనిఖీ చేయండి
మొదటి శూన్యత(T...విలువలు) శూన్యం లేని మొదటి వస్తువును అందిస్తుంది
getFirstNonNull(సప్లయర్ ... సరఫరాదారులు) శూన్యం లేని మొదటి వస్తువును అందిస్తుంది
getIfNull(T వస్తువు, సరఫరాదారు డిఫాల్ట్ సరఫరాదారు) ఇచ్చిన ఆబ్జెక్ట్ శూన్యం కాకపోతే దాన్ని అందిస్తుంది, లేకపోతే పాస్ చేసిన సరఫరాదారు యొక్క Supplier.get() విలువను అందిస్తుంది
హ్యాష్ కోడ్(obj) ఆబ్జెక్ట్ కోసం హ్యాష్‌కోడ్‌ను గణిస్తుంది
hashCodeMulti(ఆబ్జెక్ట్... వస్తువులు) వస్తువుల సమూహం కోసం హ్యాష్‌కోడ్‌ను గణిస్తుంది
ఖాళీ (ఆబ్జెక్ట్ ఆబ్జెక్ట్) వస్తువు ఖాళీగా ఉందా లేదా శూన్యంగా ఉందా అని తనిఖీ చేస్తుంది
isNotEmpty(ఆబ్జెక్ట్ ఆబ్జెక్ట్) ఒక వస్తువు ఖాళీగా లేదా శూన్యంగా ఉందా అని తనిఖీ చేస్తుంది
అవసరం లేదు ఖాళీ (T obj) ఒక వస్తువు శూన్యం కాకపోతే తనిఖీ చేస్తుంది, లేకుంటే మినహాయింపును అందిస్తుంది
అవసరంకాని ఖాళీ (T obj, స్ట్రింగ్ సందేశం) ఒక వస్తువు శూన్యం కాకపోతే తనిఖీ చేస్తుంది, లేకుంటే మినహాయింపును అందిస్తుంది
identityToString(వస్తువు వస్తువు) వస్తువు కోసం స్ట్రింగ్‌ను అందిస్తుంది
toString (వస్తువు వస్తువు) వస్తువు కోసం స్ట్రింగ్‌ను అందిస్తుంది
toString(ఆబ్జెక్ట్ obj, స్ట్రింగ్ nullStr) వస్తువు కోసం స్ట్రింగ్‌ను అందిస్తుంది
toString(ఆబ్జెక్ట్ obj, సరఫరాదారు సరఫరాదారు) వస్తువు కోసం స్ట్రింగ్‌ను అందిస్తుంది

ప్రతి సమూహం నుండి ఒక పద్ధతిని చూద్దాం. మీరు వాటిని తరచుగా ఉపయోగిస్తారని నేను ఆశిస్తున్నాను, ఎందుకంటే అవి చాలా సౌకర్యవంతంగా ఉంటాయి మరియు అనవసరమైన కోడ్‌ను నివారించడానికి మిమ్మల్ని అనుమతిస్తాయి.

ObjectUtils.compare()

ఈ పద్ధతి వస్తువులను పోలిక చేసే విధంగానే పోలుస్తుంది: దానికంటే ఎక్కువ, తక్కువ లేదా సమానం. ఇది వస్తువులను క్రమబద్ధీకరించడానికి ఉపయోగించవచ్చు.

పద్ధతి సంతకం ఇలా కనిపిస్తుంది:

public static <T extends Comparable<? super T>> int compare(final T c1, final T c2);
public static <T extends Comparable<? super T>> int compare(final T c1, final T c2, final boolean nullGreater);

మూడవ పరామితి ( nullGreater ) నిజమైతే , శూన్యత ఎల్లప్పుడూ శూన్యత కంటే ఎక్కువగా పరిగణించబడుతుంది . పద్ధతి c1> c2 అయితే ధనాత్మకం, c1<c2 అయితే ప్రతికూలం మరియు c1 == c2 అయితే 0.

ఉదాహరణ:

String firstValue = "codeGym";
String secondValue = "codeGym";
System.out.print(ObjectUtils.compare(firstValue, secondValue));
System.out.println();

firstValue = "codeGym";
secondValue = null;
System.out.print(ObjectUtils.compare(firstValue, secondValue));
System.out.println();

firstValue = "";
secondValue = "codeGym";
System.out.print(ObjectUtils.compare(firstValue, secondValue));
System.out.println();

ప్రోగ్రామ్ ఫలితాన్ని ప్రదర్శిస్తుంది:

0
1
-8

ObjectUtils.isNotEmpty()

isNotEmpty() పద్ధతి దానికి పంపబడిన వస్తువు ఖాళీగా లేదా శూన్యంగా లేదని తనిఖీ చేస్తుంది .

పద్ధతి సంతకం:

public static boolean isNotEmpty(final Object object)

ఉదాహరణ:

List<String> values = new ArrayList<>();
System.out.println(ObjectUtils.isNotEmpty(values));

values.add("codeGym");
System.out.println(ObjectUtils.isNotEmpty(values));

values = null;
System.out.println(ObjectUtils.isNotEmpty(values));

ఫలితం తెరపై ప్రదర్శించబడుతుంది:

false
true
false

java.util.Objects

జావా డెవలపర్లు ObjectUtils ఆలోచనను నిజంగా ఇష్టపడ్డారు , కాబట్టి JDK 7లో వారు తమ స్వంత వాటిని జోడించారు:

శూన్యం(ఆబ్జెక్టోబ్జ్) వస్తువు శూన్యంగా ఉందో లేదో తనిఖీ చేస్తుంది
నాన్ శూన్య (ఆబ్జెక్ట్ ఆబ్జెక్ట్) వస్తువు శూన్యం కాకపోతే తనిఖీ చేస్తుంది
టు స్ట్రింగ్(ఆబ్జెక్టో) ఒక వస్తువును స్ట్రింగ్‌గా మారుస్తుంది
toString(ఆబ్జెక్టో, స్ట్రింగ్ nullDefault) ఒక వస్తువును స్ట్రింగ్‌గా మారుస్తుంది
బూలియన్ సమానం (ఆబ్జెక్ట్ ఎ, ఆబ్జెక్ట్ బి) వస్తువులను పోలుస్తుంది
బూలియన్ డీప్ ఈక్వల్స్ (ఆబ్జెక్ట్ ఎ, ఆబ్జెక్ట్ బి) వస్తువులను పోలుస్తుంది
T అవసరంNonNull(T obj) పాస్ చేసిన పరామితి శూన్యం కాకపోతే తనిఖీ చేస్తుంది
T అవసరంNonNull(T obj, స్ట్రింగ్ సందేశం) పాస్ చేసిన పరామితి శూన్యం కాకపోతే తనిఖీ చేస్తుంది
పూర్ణ హాష్ కోడ్ (ఆబ్జెక్ట్ o) ఆబ్జెక్ట్ కోసం హ్యాష్‌కోడ్‌ను గణిస్తుంది
పూర్ణ హాష్ (వస్తువు...విలువలు) వస్తువుల సమూహం కోసం హ్యాష్‌కోడ్‌ను గణిస్తుంది
int compare(T a,T b,comparator c) వస్తువులను పోలుస్తుంది

java.util.Objects తరగతి JDKలో భాగం కాబట్టి , మీరు దీన్ని మీ కోడ్‌లో ఉపయోగించాల్సిందిగా సిఫార్సు చేయబడింది.

మీరు వేరొకరి కోడ్‌ను చదివినప్పుడు, మీరు ObjectUtils నుండి ఎంపికలను ఎక్కువగా చూడవచ్చు , ఇది తరచుగా ఓపెన్ సోర్స్‌లో జరుగుతుందని గమనించడం ముఖ్యం. అవి ఎలా విభిన్నంగా ఉన్నాయో ఇక్కడ మీరు చూడవచ్చు .