JavaRush /جاوا بلاگ /Random-SD /اچو ته StringUtils ڪلاس کي ٽوڙيو

سطح

28 February 2021
46 views
0 comments

اچو ته StringUtils ڪلاس کي ٽوڙيو

سڀني کي سلام، منهنجا پيارا پڙهندڙ. مان لکڻ جي ڪوشش ڪريان ٿو ته ڇا واقعي منهنجي دلچسپي آهي ۽ ڇا مون کي هن وقت پريشان آهي. تنهن ڪري، اڄ اتي ڪجهه روشني پڙهڻ وارا هوندا جيڪي مستقبل ۾ هڪ حوالي جي طور تي توهان لاء ڪارائتو هوندا: اچو ته StringUtils بابت ڳالهايون . اچو ته ٽوڙيون StringUtils class - 1

بس ائين ئي ٿيو ته هڪ دفعي مون اپاچي ڪمنس لانگ 3 لائبريريءَ کان پاسو ڪيو . هي هڪ لائبريري آهي جنهن ۾ مختلف شين سان ڪم ڪرڻ لاءِ معاون ڪلاسون آهن. هي اسٽرنگ، گڏ ڪرڻ، وغيره سان ڪم ڪرڻ لاء مفيد طريقن جو هڪ مجموعو آهي. موجوده پروجيڪٽ تي، جتي مون کي 25 سال پراڻي ڪاروباري منطق (COBOL کان جاوا تائين) جي ترجمي ۾ تارن سان وڌيڪ تفصيل سان ڪم ڪرڻو پيو، اهو معلوم ٿيو ته مون کي StringUtils ڪلاس جي تمام گهڻي ڄاڻ نه هئي . تنهن ڪري مون کي هر شيء پاڻ کي ٺاهڻو پوندو. منهنجو مطلب ڇا آهي؟ حقيقت اها آهي ته توهان کي ڪجهه خاص ڪم لکڻ جي ضرورت ناهي جنهن ۾ اسٽرنگ مينيپوليشن شامل آهي، پر هڪ تيار ڪيل حل استعمال ڪريو. پاڻ لکڻ ۾ ڪهڙو حرج آهي؟ گهٽ ۾ گهٽ انهي ۾ اهو وڌيڪ ڪوڊ آهي جيڪو اڳ ۾ ئي گهڻو وقت اڳ لکيو ويو آهي. ڪو به گهٽ دٻاءُ اهو آهي ته ڪوڊ کي جانچڻ جو مسئلو اضافي طور تي لکيو ويو آهي. جڏهن اسان هڪ لائبريري استعمال ڪندا آهيون جيڪو پاڻ کي سٺو ثابت ڪيو آهي، اسان کي اميد آهي ته اهو اڳ ۾ ئي آزمائي چڪو آهي ۽ اسان کي ان کي جانچڻ لاء ٽيسٽ ڪيسن جو هڪ گروپ لکڻ جي ضرورت ناهي. اهو صرف ائين ٿئي ٿو ته جاوا ۾ اسٽرنگ سان ڪم ڪرڻ لاء طريقن جو سيٽ ايترو وڏو ناهي. حقيقت ۾ اهڙا ڪيترائي طريقا نه آهن جيڪي ڪم لاء ڪارائتو هوندا. ھي ڪلاس پڻ ٺاھيو ويو آھي چيڪ مهيا ڪرڻ لاءِ NullPointerException. اسان جي مضمون جو خاڪو هن ريت ٿيندو:

سڀئي ڪيس GitHub تي Javarush ڪميونٽي تنظيم ۾ هڪ الڳ مخزن ۾ شامل ڪيا ويندا . انهن لاءِ الڳ الڳ مثال ۽ ٽيسٽ هوندي.

0. ڪيئن ڳنڍجي

جيڪي مون سان گڏ ھٿ ۾ ھٿ ھلندا آھن سي اڳ ۾ ئي گٽ ۽ ماون ٻنھي کان گھٽ يا گھٽ واقف آھن، تنھنڪري اڳتي ھلي مان ھن علم تي ڀروسو ڪندس ۽ پاڻ کي ورجائي نه سگھندس. انهن لاءِ جن منهنجي پوئين آرٽيڪل کي ياد ڪيو يا صرف پڙهڻ شروع ڪيو، هتي آهن Maven ۽ Git بابت مواد . يقينن، بلڊنگ سسٽم (Maven، Gredl) کان سواء، توهان پڻ هر شي کي دستي طور تي ڳنڍي سگهو ٿا، پر اهو اڄڪلهه چريو آهي ۽ توهان کي يقيني طور تي ائين ڪرڻ جي ضرورت ناهي: اهو بهتر آهي ته فوري طور تي سکڻ لاء سڀ ڪجهه صحيح طريقي سان ڪيئن ڪجي. تنهن ڪري، Maven سان ڪم ڪرڻ لاء، اسان پهريون ڀيرو مناسب انحصار شامل ڪيو:

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-lang3</artifactId>
   <version>${apache.common.version}</version>
</dependency>

جتي ${apache.common.version} هن لائبريري جو نسخو آهي. اڳيون، ڪجھ ڪلاس ۾ درآمد ڪرڻ لاء، درآمد شامل ڪريو:

import org.apache.commons.lang3.StringUtils;

۽ اهو ئي آهي، اهو سڀ ڪجهه بيگ ۾ آهي))

1. حقيقي منصوبي مان مثال

کاٻي پيڊ جو طريقو

پهريون مثال عام طور تي ايترو بيوقوف لڳي ٿو هاڻي اهو تمام سٺو آهي ته منهنجا ساٿي StringUtils.leftPad بابت ڄاڻن ٿا ۽ مون کي ٻڌايو. ڪم ڇا هو: ڪوڊ اهڙي طرح ٺاهيو ويو هو ته اهو ضروري هو ته ڊيٽا کي تبديل ڪرڻ جي صورت ۾ اهو صحيح طور تي نه پهچي. اها توقع ڪئي وئي ته اسٽرنگ فيلڊ صرف انگن تي مشتمل هجڻ گهرجي، يعني. جيڪڏهن ان جي ڊيگهه 3 آهي ۽ ان جي قيمت 1 آهي، پوء داخلا "001" هجڻ گهرجي. اهو آهي، پهرين توهان کي سڀني جڳهن کي هٽائڻ جي ضرورت آهي، ۽ پوء ان کي صفر سان ڍڪيو. ڪم جي جوهر کي واضح ڪرڻ لاء وڌيڪ مثال: "12" -> "012" کان "1" -> "001" وغيره وغيره. مون ڇا ڪيو؟ هن کي LeftPadExample طبقي ۾ بيان ڪيو ويو آهي . مون هڪ طريقو لکيو آهي جيڪو اهو سڀ ڪجهه ڪندو:

public static String ownLeftPad(String value) {
   String trimmedValue = value.trim();

   if(trimmedValue.length() == value.length()) {
       return value;
   }

   StringBuilder newValue = new StringBuilder(trimmedValue);

   IntStream.rangeClosed(1, value.length() - trimmedValue.length())
           .forEach(it -> newValue.insert(0, "0"));
   return newValue.toString();
}

هڪ بنياد جي طور تي، مون اهو خيال ورتو ته اسان صرف اصل ۽ سنواريل قدر جي وچ ۾ فرق حاصل ڪري سگهون ٿا ۽ ان کي سامهون صفر سان ڀريو. ائين ڪرڻ لاءِ مون استعمال ڪيو IntStream ساڳيو آپريشن n ڀيرا ڪرڻ لاءِ. ۽ اهو ضرور جانچڻ جي ضرورت آهي. هتي اهو آهي ته مان ڇا ڪري سگهان ها جيڪڏهن مون کي اڳ ۾ ئي StringUtils.leftPad طريقي جي باري ۾ ڄاڻ هجي ها :

public static String apacheCommonLeftPad(String value) {
   return StringUtils.leftPad(value.trim(), value.length(), "0");
}

جئين توهان ڏسي سگهو ٿا، اتي تمام گهٽ ڪوڊ آهي، ۽ هر ڪنهن جي تصديق ٿيل لائبريري پڻ استعمال ڪئي وئي آهي. ھن مقصد لاءِ، مون LeftPadExampleTest ڪلاس ۾ ٻه ٽيسٽ ٺاھيا (عام طور تي جڏھن اھي ڪلاس کي ٽيسٽ ڪرڻ جو ارادو رکن ٿا، اھي ساڳي نالي سان ڪلاس ٺاھيندا آھن + ساڳي پيڪيج ۾ ٽيسٽ، رڳو src/test/java ۾). اهي تجربا هڪ طريقو چيڪ ڪريو انهي کي يقيني بڻائڻ لاءِ ته اهو صحيح طور تي قدر کي بدلائي ٿو، پوءِ ٻيو. يقينن، تمام گھڻا وڌيڪ ٽيسٽ لکڻ جي ضرورت پوندي، پر جانچ اسان جي ڪيس ۾ بنيادي موضوع نه آھي:

package com.github.javarushcommunity.stringutilsdemo;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@DisplayName("Unit-level testing for LeftPadExample")
class LeftPadExampleTest {

   @DisplayName("Should transform by using ownLeftPad method as expected")
   @Test
   public void shouldTransformOwnLeftPadAsExpected() {
       //given
       String value = "1   ";
       String expectedTransformedValue = "0001";

       //when
       String transformedValue = LeftPadExample.ownLeftPad(value);

       //then
       Assertions.assertEquals(expectedTransformedValue, transformedValue);
   }

   @DisplayName("Should transform by using StringUtils method as expected")
   @Test
   public void shouldTransformStringUtilsLeftPadAsExpected() {
       //given
       String value = "1   ";
       String expectedTransformedValue = "0001";

       //when
       String transformedValue = LeftPadExample.apacheCommonLeftPad(value);

       //then
       Assertions.assertEquals(expectedTransformedValue, transformedValue);
   }

}

مان في الحال ٽيسٽن بابت ڪجھ رايا ڪري سگهان ٿو. اهي JUnit 5 استعمال ڪندي لکيل آهن:

هڪ ٽيسٽ کي ٽيسٽ سمجهيو ويندو جيڪڏهن ان ۾ مناسب تشريح هجي - @Test.
جيڪڏهن نالو ٽيسٽ جي آپريشن کي بيان ڪرڻ ڏکيو آهي يا وضاحت ڊگهو ۽ پڙهڻ ۾ مشڪل آهي، ته توهان @DisplayName تشريح شامل ڪري سگهو ٿا ۽ ان کي عام وضاحت ٺاهيو جيڪو ٽيسٽ هلائڻ دوران ظاهر ٿيندو.
ٽيسٽ لکڻ وقت، مان BDD جو طريقو استعمال ڪريان ٿو، جنهن ۾ مان ٽيسٽن کي منطقي حصن ۾ ورهايان ٿو:
1. // ڏنو - ٽيسٽ کان اڳ ڊيٽا سيٽ اپ بلاڪ؛
2. // جڏهن اهو بلاڪ آهي جتي ڪوڊ جو حصو جيڪو اسان جاچ ڪري رهيا آهيون شروع ڪيو ويو آهي؛
3. // پوء ھڪڙو بلاڪ آھي جنھن ۾ نتيجن جا نتيجا جڏھن بلاڪ چيڪ ڪيا ويا آھن.

جيڪڏهن توهان انهن کي هلائيندا آهيو، اهي تصديق ڪندا ته هر شي ڪم ڪري رهي آهي جيئن توقع ڪئي وئي.

stripStart طريقو

هتي مون کي هڪ مسئلو حل ڪرڻ جي ضرورت آهي هڪ ليڪ سان جنهن جي شروعات ۾ اسپيس ۽ ڪاما هجن. تبديليءَ کان پوءِ انهن کي ڪا نئين معنيٰ نه هئڻ گهرجي ها. مسئلو بيان هميشه کان وڌيڪ واضح آهي. ڪجھ مثال اسان جي سمجھ کي مضبوط ڪندا: “, , books” -> “books” “,,, books” -> “books” b , books” -> “b , books” جيئن ته کاٻي پيڊ جي صورت ۾، مون شامل ڪيو StrimStartExample class ، جنهن ۾ ٻه طريقا آهن. هڪ - ان جي پنهنجي حل سان:

public static String ownStripStart(String value) {
   int index = 0;
   List commaSpace = asList(" ", ",");
   for (int i = 0; i < value.length(); i++) {
       if (commaSpace.contains(String.valueOf(value.charAt(i)))) {
           index++;
       } else {
           break;
       }
   }
   return value.substring(index);
}

هتي خيال اهو هو ته انڊيڪس شروع ٿئي، جنهن ۾ وڌيڪ اسپيس يا ڪاما نه آهن. جيڪڏهن اهي شروعات ۾ نه هئا، پوء انڊيڪس صفر ٿي ويندي. ۽ ٻيو - هڪ حل سان StringUtils ذريعي :

public static String apacheCommonLeftPad(String value) {
   return StringUtils.stripStart(value, StringUtils.SPACE + COMMA);
}

هتي اسان پهرين دليل جي معلومات پاس ڪريون ٿا جنهن بابت اسان ڪهڙي اسٽرنگ سان ڪم ڪري رهيا آهيون، ۽ ٻئي ۾ اسان هڪ اسٽرنگ پاس ڪريون ٿا جنهن ۾ ڪردارن تي مشتمل آهي جنهن کي ڇڏڻو پوندو. اسان ساڳئي طريقي سان StripStartExampleTest ڪلاس ٺاهيون ٿا :

package com.github.javarushcommunity.stringutilsdemo;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Unit-level testing for StripStartExample")
class StripStartExampleTest {

   @DisplayName("Should transform by using stripStart method as expected")
   @Test
   public void shouldTransformOwnStripStartAsExpected() {
       //given
       String value = ", , books";
       String expectedTransformedValue = "books";

       //when
       String transformedValue = StripStartExample.ownStripStart(value);

       //then
       Assertions.assertEquals(expectedTransformedValue, transformedValue);
   }

   @DisplayName("Should transform by using StringUtils method as expected")
   @Test
   public void shouldTransformStringUtilsStripStartAsExpected() {
       //given
       String value = ", , books";
       String expectedTransformedValue = "books";

       //when
       String transformedValue = StripStartExample.apacheCommonLeftPad(value);

       //then
       Assertions.assertEquals(expectedTransformedValue, transformedValue);
   }
}

خالي طريقو آهي

اهو طريقو، يقينا، تمام آسان آهي، پر اهو ان کي گهٽ مفيد نٿو بڻائي. اهو String.isEmpty() طريقي جي صلاحيتن کي وڌائي ٿو ، جيڪو پڻ null لاء چيڪ شامل ڪري ٿو. ڇا جي لاءِ؟ NullPointerException کان بچڻ لاءِ، يعني null variable تي سڏڻ جي طريقن کان بچڻ لاءِ . تنهن ڪري، نه لکڻ لاء:

if(value != null && value.isEmpty()) {
   //doing something
}

توهان صرف اهو ڪري سگهو ٿا:

if(StringUtils.isEmpty(value)) {
   //doing something
}

هن طريقي جو فائدو اهو آهي ته اهو فوري طور تي واضح آهي جتي ڪهڙو طريقو استعمال ڪيو ويندو آهي.

2. StringUtils طبقي جي ٻين طريقن جو تجزيو

هاڻي اچو ته انهن طريقن جي باري ۾ ڳالهايون جيڪي، منهنجي خيال ۾، پڻ ڌيان جي لائق آهن. عام طور تي ڳالهائيندي StringUtils بابت ، اهو چوڻ جي قابل آهي ته اهو null محفوظ طريقا مهيا ڪري ٿو جيڪو String ڪلاس ۾ ملن ٿا (جيئن ته isEmpty طريقي سان آهي ). اچو ته انهن جي ذريعي وڃو:

مقابلي جو طريقو

اهڙو طريقو اسٽرنگ ۾ موجود آهي ۽ هڪ NullPointerException اڇلائي ڇڏيندو جيڪڏهن، جڏهن ٻن تارن جو مقابلو ڪيو وڃي، انهن مان هڪ null آهي. اسان جي ڪوڊ ۾ بدصورت چيڪن کان بچڻ لاءِ، اسان استعمال ڪري سگھون ٿا StringUtils.compare(String str1، String str2) طريقو : اهو موٽائي ٿو هڪ int مقابلي جي نتيجي ۾. انهن قدرن جو ڇا مطلب آهي؟ int = 0 جيڪڏھن اھي ساڳيا آھن (يا ٻئي نال آھن). int <0، جيڪڏھن str1 str2 کان گھٽ آھي. int> 0، جيڪڏهن str1 str2 کان وڏو آهي. انهي سان گڏ، جيڪڏهن توهان انهن جي دستاويزن تي نظر رکون ٿا، هن طريقي جو Javadoc هيٺ ڏنل منظرنامو پيش ڪري ٿو:

StringUtils.compare(null, null)   = 0
StringUtils.compare(null , "a")   < 0
StringUtils.compare("a", null)    > 0
StringUtils.compare("abc", "abc") = 0
StringUtils.compare("a", "b")     < 0
StringUtils.compare("b", "a")     > 0
StringUtils.compare("a", "B")     > 0
StringUtils.compare("ab", "abc")  < 0

تي مشتمل آهي... طريقا

هتي يوٽيلٽي ڊولپرز کي هڪ ڌماڪو هو. جيڪو طريقو توهان چاهيو ٿا اتي موجود آهي. مون ان کي گڏ ڪرڻ جو فيصلو ڪيو:

contains ھڪڙو طريقو آھي جيڪو چيڪ ڪري ٿو ته ڇا متوقع اسٽرنگ ٻئي اسٽرنگ اندر آھي. اهو ڪيئن مفيد آهي؟ توھان ھي طريقو استعمال ڪري سگھو ٿا جيڪڏھن توھان کي پڪ ڪرڻ جي ضرورت آھي ته متن ۾ ڪو خاص لفظ آھي.

مثال:
```
StringUtils.contains(null, *)     = false
StringUtils.contains(*, null)     = false
StringUtils.contains("", "")      = true
StringUtils.contains("abc", "")   = true
StringUtils.contains("abc", "a")  = true
StringUtils.contains("abc", "z")  = false
```
ٻيهر، اين پي اي (نول پوائنٽر استثنا) سيڪيورٽي موجود آهي.

containsAny ھڪڙو طريقو آھي جيڪو چيڪ ڪري ٿو ته ڇا اسٽرنگ ۾ موجود ڪي اکر موجود آھن. پڻ هڪ مفيد شيء: توهان کي اڪثر اهو ڪرڻو پوندو.

دستاويز مان مثال:

StringUtils.containsAny(null, *)                  = false
StringUtils.containsAny("", *)                    = false
StringUtils.containsAny(*, null)                  = false
StringUtils.containsAny(*, [])                    = false
StringUtils.containsAny("zzabyycdxx", ['z', 'a']) = true
StringUtils.containsAny("zzabyycdxx", ['b', 'y']) = true
StringUtils.containsAny("zzabyycdxx", ['z', 'y']) = true
StringUtils.containsAny("aba", ['z'])             = false

containsIgnoreCase هڪ ڪارائتو واڌارو آهي contains method لاءِ . درحقيقت، هن طريقي جي بغير اهڙي صورت ۾ چيڪ ڪرڻ لاء، توهان کي ڪيترن ئي اختيارن ذريعي وڃڻو پوندو. ۽ پوء صرف هڪ طريقو استعمال ڪيو ويندو harmoniously.

دستاويزن مان ڪجھ مثال:

StringUtils.containsIgnoreCase(null, *) = false
StringUtils.containsIgnoreCase(*, null) = false
StringUtils.containsIgnoreCase("", "") = true
StringUtils.containsIgnoreCase("abc", "") = true
StringUtils.containsIgnoreCase("abc", "a") = true
StringUtils.containsIgnoreCase("abc", "z") = false
StringUtils.containsIgnoreCase("abc", "A") = true
StringUtils.containsIgnoreCase("abc", "Z") = false

containsNone - نالي سان فيصلو ڪندي، توهان اڳ ۾ ئي سمجهي سگهو ٿا ته ڇا چيڪ ڪيو پيو وڃي. اندر ڪو به لڪير نه هجڻ گهرجي. هڪ مفيد شيء، يقينا. ڪجهه ناپسنديده ڪردارن لاء جلدي ڳولها؛). اسان جي ٽيليگرام باٽ ۾ اسان فحاشي کي فلٽر ڪنداسين ۽ انهن مزاحيه طريقن کي نظرانداز نه ڪنداسين.

۽ مثال، اسان انهن کان سواء ڪٿي هونداسين:
```
StringUtils.containsNone(null, *)       = true
StringUtils.containsNone(*, null)       = true
StringUtils.containsNone("", *)         = true
StringUtils.containsNone("ab", '')      = true
StringUtils.containsNone("abab", 'xyz') = true
StringUtils.containsNone("ab1", 'xyz')  = true
StringUtils.containsNone("abz", 'xyz')  = false
```

defaultString طريقو

طريقن جو هڪ سلسلو جيڪو اضافي معلومات شامل ڪرڻ کان بچڻ ۾ مدد ڪري ٿو جيڪڏهن اسٽرنگ نيل آهي ۽ توهان کي ڪجهه ڊفالٽ قيمت مقرر ڪرڻ جي ضرورت آهي. هر ذائقي کي پورو ڪرڻ لاء ڪيترائي اختيار آهن. انهن مان مکيه آهي StringUtils.defaultString(final String str، final String defaultStr) - صورت ۾ str null آهي، اسان صرف defaultStr ۾ قدر پاس ڪنداسين . دستاويز مان مثال:

StringUtils.defaultString(null, "NULL")  = "NULL"
StringUtils.defaultString("", "NULL")    = ""
StringUtils.defaultString("bat", "NULL") = "bat"

اهو استعمال ڪرڻ تمام آسان آهي جڏهن توهان ڊيٽا سان POJO ڪلاس ٺاهيندا آهيو.

وائيٽ اسپيس کي حذف ڪرڻ جو طريقو

اهو هڪ دلچسپ طريقو آهي، جيتوڻيڪ اتي ان جي درخواست لاء ڪيترائي اختيار نه آهن. ساڳئي وقت، جيڪڏهن اهڙي صورت پيدا ٿئي ٿي، اهو طريقو ضرور تمام گهڻو مفيد ٿيندو. اهو اسٽرنگ مان سڀني اسپيس کي هٽائي ٿو. جتي به هي خال آهي، اتي ان جو ڪوبه نشان نه هوندو))) دستاويزن جا مثال:

StringUtils.deleteWhitespace(null)         = null
StringUtils.deleteWhitespace("")           = ""
StringUtils.deleteWhitespace("abc")        = "abc"
StringUtils.deleteWhitespace("   ab  c  ") = "abc"

طريقي سان ختم ٿئي ٿو

پاڻ لاءِ ڳالهائي ٿو. هي هڪ تمام مفيد طريقو آهي: اهو چيڪ ڪري ٿو ته ڇا اسٽرنگ تجويز ڪيل اسٽرنگ سان ختم ٿئي ٿي يا نه. اهو اڪثر ضروري آهي. يقينا، توهان پنهنجو پاڻ کي چيڪ ڪري سگهو ٿا، پر هڪ تيار ڪيل طريقو استعمال ڪندي واضح طور تي وڌيڪ آسان ۽ بهتر آهي. مثال:

StringUtils.endsWith(null, null)      = true
StringUtils.endsWith(null, "def")     = false
StringUtils.endsWith("abcdef", null)  = false
StringUtils.endsWith("abcdef", "def") = true
StringUtils.endsWith("ABCDEF", "def") = false
StringUtils.endsWith("ABCDEF", "cde") = false
StringUtils.endsWith("ABCDEF", "")    = true

جيئن توهان ڏسي سگهو ٿا، هر شي هڪ خالي لڪير سان ختم ٿئي ٿي))) مان سمجهان ٿو ته هي مثال (StringUtils.endsWith("ABCDEF"، "") = سچ) صرف هڪ بونس آهي، ڇاڪاڻ ته هي بيوقوف آهي) پڻ هڪ طريقو آهي جيڪو ڪيس کي نظر انداز ڪري ٿو.

برابر طريقو

هڪ null محفوظ طريقي جو هڪ بهترين مثال جيڪو ٻن تارن جو مقابلو ڪري ٿو. جيڪو ڪجھ اسان اتي رکون ٿا، جواب اتي ئي ھوندو، ۽ اھو بغير غلطين جي ھوندو. مثال:

StringUtils.equals(null, null)   = true
StringUtils.equals(null, "abc")  = false
StringUtils.equals("abc", null)  = false
StringUtils.equals("abc", "abc") = true
StringUtils.equals("abc", "ABC") = false

يقينن، اتي پڻ آهي equalsIgnoreCase - هر شي بلڪل ساڳئي طريقي سان ڪئي وئي آهي، صرف اسان ڪيس کي نظر انداز ڪندا آهيون. اچو ته ڏسون؟

StringUtils.equalsIgnoreCase(null, null)   = true
StringUtils.equalsIgnoreCase(null, "abc")  = false
StringUtils.equalsIgnoreCase("abc", null)  = false
StringUtils.equalsIgnoreCase("abc", "abc") = true
StringUtils.equalsIgnoreCase("abc", "ABC") = true

ڪنهن به طريقي جي برابر

اچو ته اڳتي وڌون ۽ برابري واري طريقي کي وڌايو . اچو ته چون ٿا ته ڪيترن ئي برابري جي چڪاس جي بدران، اسان هڪ انجام ڏيڻ چاهيون ٿا. ان لاءِ، اسان هڪ تار پاس ڪري سگهون ٿا جنهن سان تارن جي هڪ سيٽ جو مقابلو ڪيو ويندو؛ جيڪڏهن انهن مان ڪو به تجويز ڪيل هڪ جي برابر آهي، اهو صحيح ٿيندو. اسان هڪ اسٽرنگ ۽ تارن جو مجموعو پاس ڪريون ٿا انهن کي هڪ ٻئي سان موازنہ ڪرڻ لاءِ (پهريون اسٽرنگ جنهن ۾ گڏ ڪيل تارن سان). مشڪل؟ هتي دستاويزن مان مثال آهن توهان کي سمجهڻ ۾ مدد ڏيڻ لاءِ ته ڇا مطلب آهي:

StringUtils.equalsAny(null, (CharSequence[]) null) = false
StringUtils.equalsAny(null, null, null)    = true
StringUtils.equalsAny(null, "abc", "def")  = false
StringUtils.equalsAny("abc", null, "def")  = false
StringUtils.equalsAny("abc", "abc", "def") = true
StringUtils.equalsAny("abc", "ABC", "DEF") = false

هتي پڻ برابر آهيAnyIgnoreCase . ۽ ان لاء مثال:

StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null) = false
StringUtils.equalsAnyIgnoreCase(null, null, null)    = true
StringUtils.equalsAnyIgnoreCase(null, "abc", "def")  = false
StringUtils.equalsAnyIgnoreCase("abc", null, "def")  = false
StringUtils.equalsAnyIgnoreCase("abc", "abc", "def") = true
StringUtils.equalsAnyIgnoreCase("abc", "ABC", "DEF") = true

هيٺين لائن

نتيجي طور، اسين ڄاڻون ٿا ته StringUtils ڇا آھي ۽ ان ۾ ڪھڙا ڪارآمد طريقا آھن. خير، اهو سمجهڻ سان ته اهڙيون ڪارائتيون شيون موجود آهن ۽ هر دفعي انهن هنڌن تي ڪچري سان باهه لڳائڻ جي ضرورت ناهي، جتي اهو ممڪن آهي ته مسئلي کي تيار ڪيل حل جي مدد سان بند ڪيو وڃي. عام طور تي، اسان طريقن جو صرف حصو تجزيو ڪيو آهي. جيڪڏھن توھان چاھيو، مان جاري رکي سگھون ٿا: انھن مان گھڻا آھن، ۽ اھي حقيقت ۾ ڌيان جا مستحق آھن. جيڪڏهن توهان وٽ ڪي خيال آهن ته اهو ڪيئن پيش ڪري سگهجي ٿو، مهرباني ڪري لکندا - مان هميشه نئين خيالن لاء کليل آهيان. طريقن لاء دستاويز تمام سٺو لکيو ويو آهي، نتيجن سان گڏ امتحان جا مثال شامل ڪيا ويا آهن، جيڪي طريقن جي آپريشن کي بهتر سمجهڻ ۾ مدد ڪن ٿيون. تنهن ڪري، اسان دستاويز پڙهڻ کان پري نه ٿا وڃون: اهو توهان جي شڪ کي ختم ڪري ڇڏيندو افاديت جي ڪارڪردگي بابت. نئون ڪوڊنگ تجربو حاصل ڪرڻ لاءِ، مان توهان کي صلاح ڏيان ٿو ته ڏسو ته ڪيئن يوٽيلٽي ڪلاسز ٺاهيا ۽ لکيا ويندا آهن. اهو مستقبل ۾ ڪارائتو ٿيندو، ڇاڪاڻ ته عام طور تي هر پروجيڪٽ جا پنهنجا اسڪراپ ڪلاس هوندا آهن، ۽ انهن کي لکڻ جو تجربو به ڪم ايندو. روايتي طور تي، مان مشورو ڏيان ٿو ته توهان سبسڪرائب ڪريو منهنجي اڪائونٽ تي Github ) انهن لاءِ جيڪي منهنجي پروجيڪٽ بابت ٽيليگرام بوٽ سان نٿا ڄاڻن، هتي پهرين مضمون جي لنڪ آهي . پڙهڻ لاءِ سڀني جي مهرباني. مون ھيٺ ڏنل ڪجھ مفيد لنڪ شامل ڪيا آھن.

مفيد لنڪس

تبصرا

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION