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 నుండి ఎంపికలను ఎక్కువగా చూడవచ్చు , ఇది తరచుగా ఓపెన్ సోర్స్లో జరుగుతుందని గమనించడం ముఖ్యం. అవి ఎలా విభిన్నంగా ఉన్నాయో ఇక్కడ మీరు చూడవచ్చు .
GO TO FULL VERSION