Java හි contains() ක්‍රමය පරිපූර්ණ කිරීම: කාර්යක්ෂම උපස්තර සෙවීම් ක්‍රම

1. ආරම්භකය: Java හි String Search ඇයි වැදගත්ද

Java හි ප්‍රොග්‍රෑම් කිරීමේදී String manipulation එක වඩාත් සාමාන්‍යයෙන් භාවිතා වන මෙහෙයුම්වලින් එකකි.
පරිශීලක ආදාන පරීක්ෂා කිරීම, ෆයිල් අන්තර්ගත පාර්ස් කිරීම, හෝ විශේෂ මූලපද සෙවීම වැනි දේවල් සඳහා, ඔබට බොහෝ විට නිශ්චිත වචනයක් දක්වා දක්වා ඇති string එකක් තුළ ඇතිද යන්න තීරණය කිරීමට අවශ්‍ය වේ.

මෙම අවශ්‍යතා සපුරාලීම සඳහා, Java contains() නම් පහසු මෙහෙයුමක් සපයයි.
මෙම මෙහෙයුම භාවිතයෙන්, ඔබට එක් string එකක් අනිත් එක අර්ධීයව අඩංගු කර ඇතිද යන්න ලේසියෙන් තීරණය කළ හැකිය.
උදාහරණයක් ලෙස, දෝෂ පණිවිඩයක් විශේෂ මූලපදයක් අඩංගු කර ඇත්ද යන්න පරීක්ෂා කිරීමට අවශ්‍ය නම්, contains() එක පේළියක කේතයකින් එය කිරීමට ඉඩ සලසයි.

විශේෂයෙන්ම වෙබ් යෙදුම්, API සැකසුම්, හෝ log විශ්ලේෂණය වැනි විශාල පරිමාණ text ප්‍රමාණ සම්බන්ධ සිදුවීම්වලදී—contains() මෙහෙයුම කේතයේ පාඨකත්වය සහ නඩත්තු කිරීමේ හැකියාව ඉතා වැඩි දියුණු කරයි.
කෙසේ වෙතත්, case sensitivity සහ null හැකියාව වැනි වැදගත් සලකා බැලීම් ද තිබේ.

මෙම ලිපිය Java හි contains() මෙහෙයුම විස්තරාත්මකව පැහැදිලි කරයි—මූලික භාවිතය සහ සාමාන්‍ය දෝෂ සිට අනෙ මෙහෙයුම්වල වෙනස්කම් සහ ප්‍රායෝගික යෙදුම් දක්වා.
අපගේ ඉලක්කය ආරම්භකයින්ට පමණක් නොව, යථාර්ථ ව්‍යාපෘතිවල Java භාවිතා කරන සංවර්ධකයින්ටද උපකාරී තොරතුරු සැපයීමයි.

2. contains() මෙහෙයුමේ මූලික ව්‍යාකරණය සහ ලක්ෂණ

Java හි contains() මෙහෙයුම string එකක් අර්ධීයව අඩංගු කර ඇතිද යන්න තීරණය කරයි.
එහි ව්‍යාකරණය ඉතා සරලයි, නමුත් එය ඉතා ප්‍රායෝගික වන අතර දෛනික ප්‍රොග්‍රෑම් කිරීමේ කාර්යයන්හි බහුලව භාවිතා වේ.

මූලික ව්‍යාකරණය

boolean result = targetString.contains(searchString);

මෙහෙයුම String පන්තියට අයත් වන අතර CharSequence (සාමාන්‍යයෙන් String එකක්) එක තර්කයක් ලෙස භාවිතා කරයි.
එහි ප්‍රතිඵලය boolean වේ: ඉලක්ක string එක දක්වා substring එක අඩංගු නම් true, නැතිනම් false.

නියමු කේතය

String message = "Java programming is fun!";
boolean hasKeyword = message.contains("programming");

System.out.println(hasKeyword); // Output: true

ඉහත උදාහරණයේ, "programming" substring එක ඉලක්ක string එක තුළ ඇති නිසා, contains() true ප්‍රතිඵලය ලබා දෙයි.

මෙහෙයුමේ ලක්ෂණ

• අර්ධීය ගැලපීම පමණක් පරීක්ෂා කරයි: නිවැරදි ගැලපීමක් අවශ්‍ය නම්, equals() භාවිතා කරන්න.
• Case-sensitive: උදාහරණයක් ලෙස, "Java" සහ "java" වෙනස් ලෙස සැලකේ (විස්තර පසුව පැහැදිලි කරනු ලැබේ).
• Regular expressions සඳහා සහාය නොදක්වයි: එය string එකක පැවිදි බව පමණක් පරීක්ෂා කරන නිසා, pattern matching සඳහා matches() හෝ Pattern පන්තිය අවශ්‍ය වේ.

null ලබා දීමේදී හැසිරීම

contains() වෙත null ලබා දීම NullPointerException එකක් ඇති කරයි.
උදාහරණයක් ලෙස, පහත කේතය යම් ව්‍යතිරේකයක් ඇති කරයි:

String text = null;
System.out.println(text.contains("test")); // Exception occurs

එසේම, ඉලක්ක string එකම null නම්, එම ව්‍යතිරේකයම ඇති වේ.
එබැවින්, contains() කැඳවීමට පෙර null පරීක්ෂාවන් කිරීම ඉතා උපදෙස් කෙරේ.

3. ප්‍රායෝගික භාවිත උදාහරණ සහ වැදගත් සලකා බැලීම්

Java හි contains() මෙහෙයුම ඉතා සරල සහ පහසුයි, නමුත් වැරදි භාවිතය අනපේක්ෂිත bugs හෝ අකාර්යක්ෂම කේතයකට තුඩු දිය හැකිය.
මෙම කොටස contains() හි මූලික භාවිතය සමඟ ඔබ ගැන වැදගත් දැනුම ලබා ගත යුතු ප්‍රධාන කරුණු පැහැදිලි කරයි.

3-1. මූලික භාවිත උදාහරණය

පහත කේතය ඉලක්ක string එක විශේෂ මූලපදයක් අඩංගු ද යන්න පරීක්ෂා කිරීමේ සරල උදාහරණයක් දක්වයි:

String sentence = "今日はJavaの勉強をしています。";

if (sentence.contains("Java")) {
    System.out.println("Javaが含まれています。");
} else {
    System.out.println("Javaは含まれていません。");
}

පෙන්වා ඇති පරිදි, contains() බොහෝ විට if ප්‍රකාශන සමඟ ඒකාබද්ධ කර තත්ත්ව සහභාගිත්වයන් සඳහා භාවිතා වේ.

3-2. Case Sensitivity

contains() මෙහෙයුම case-sensitive ය.
උදාහරණයක් ලෙස, පහත කේතය false ප්‍රතිඵලය ලබා දෙයි:

String text = "Welcome to Java";
System.out.println(text.contains("java")); // false

.

In such cases, it is common to convert the strings to lowercase (or uppercase) before comparison:

String text = "Welcome to Java";
System.out.println(text.toLowerCase().contains("java")); // true

This approach helps eliminate differences in input case (e.g., user input).

3-3. null සහ හිස් පදයන්හි සැකසීම

contains() භාවිතා කරන විට සැලකිල්ලට ගත යුතු වැදගත් කරුණක් null සැකසීමයි.
ඉලක්ක පදය හෝ පරාමිතිය null නම්, NullPointerException එකක් සිදුවේ.

String text = null;
System.out.println(text.contains("test")); // Runtime error

මෙම ගැටලුව වැළැක්වීමට, සෑම විටම null පරීක්ෂාවක් එක් කරන්න:

if (text != null && text.contains("test")) {
    // Safe to process
}

තවත් සලකන්න:
හිස් පදයක් ("") ලබා දීම සෑම විටම true ලබා දේ.

String sample = "test";
System.out.println(sample.contains("")); // true

කෙසේ වෙතත්, මෙම හැසිරීම ප්‍රායෝගිකව අඩු ප්‍රයෝජනවත් වන අතර, හිස් පදයන් අනිසි ලෙස ලබා දුන් විට දෝෂ ඇති වීමට ඉඩ ඇත.

3-4. බහු යතුරුපද සෙවීම් සඳහා සහය නොදේ

contains() එකවර එක් යතුරුපදයක් පමණක් පරීක්ෂා කළ හැක.
බහු යතුරුපද පරීක්ෂා කිරීමට, contains() බහු වරක් කැඳවන්න හෝ Stream API භාවිතා කරන්න.

String target = "エラーコード123：アクセス拒否";
if (target.contains("エラー") || target.contains("拒否")) {
    System.out.println("問題のあるメッセージです。");
}

හෝ, ගතික යතුරුපද කට්ටල සඳහා:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(target::contains);

4. contains() සමඟ නිතර සසඳන ක්‍රම

Java පදයන් සසඳීමට හෝ නියමිත උපපදයක් පදයක් තුළ පවතිනදැයි පරීක්ෂා කිරීමට විවිධ ක්‍රම ලබා දේ. ඒ අතර, contains() “අර්ධ-ගැලපීම” සඳහා භාවිතා වේ, නමුත් අනෙකුත් ක්‍රමද සමාන අරමුණු සඳහා භාවිතා වේ. මෙම කොටස එම ක්‍රමවල ලක්ෂණ සහ වෙනස්කම් පැහැදිලි කර ඔබට ඒවා නිසි ලෙස භාවිතා කිරීමට උපකාරී වේ.

4-1. equals() සමඟ වෙනස: සම්පූර්ණ ගැලපීම vs. අර්ධ-ගැලපීම

equals() පද දෙකක් සම්පූර්ණයෙන් එකසේද යන්න තීරණය කරයි. එයට විරුද්ධව, contains() අර්ධ-ගැලපීම් පරීක්ෂා කරයි.

String a = "Java";
String b = "Java";

System.out.println(a.equals(b));      // true: Exact match
System.out.println(a.contains("av")); // true: Partial match

ප්‍රධාන වෙනස්කම්:

භාවිතා කිරීමේ මාර්ගෝපදේශය:
අගයන් සම්පූර්ණයෙන් ගැලපිය යුතු විට (උදා: හැඳුනුම්පත් පරීක්ෂාව) equals() භාවිතා කරන්න.
අර්ධ-ගැලපීම් පිළිගත හැකි විට (උදා: යතුරුපද සෙවීම) contains() භාවිතා කරන්න.

4-2. indexOf() සමඟ වෙනස: ඔබට ස්ථානය අවශ්‍යද

indexOf() ක්‍රමයද උපපදයක් පදයක් තුළ පවතිනදැයි පරීක්ෂා කිරීමට භාවිතා කළ හැක. වෙනස වන්නේ, උපපදය සොයාගත් විට indexOf() ආරම්භක ඉන්ඩෙක්ස් එක ලබා දේ. සොයාගත නොහැකි නම්, එය -1 ලබා දේ.

String text = "Hello, Java World!";
System.out.println(text.indexOf("Java"));    // 7
System.out.println(text.indexOf("Python"));  // -1

contains() ක්‍රියාවලිය අනුකරණය කිරීමට indexOf() භාවිතා කළ හැක:

if (text.indexOf("Java") >= 0) {
    System.out.println("It is contained.");
}

භාවිතා කිරීමේ මාර්ගෝපදේශය:
ඔබට ඉන්ඩෙක්ස් අවශ්‍ය නොවේ නම්, contains() වඩා කියවීමට පහසු සහ ප්‍රියතම වේ.

4-3. matches() සමඟ වෙනස: නියමිත ප්‍රකාශන (regex) සඳහා සහය

matches() ක්‍රමය පදයක් දෙන ලද නියමිත ප්‍රකාශනයකට සම්පූර්ණයෙන් ගැලපේද යන්න පරීක්ෂා කරයි. එයට විරුද්ධව, contains() පදයක් පදනම් කරගත් උපපද ගැලපීම් පමණක් පරීක්ෂා කර regex සඳහා සහය නොදේ.

String text = "abc123";
System.out.println(text.matches(".*123")); // true
System.out.println(text.contains(".*123")); // false (not regex)

regex-අධාරිත අර්ධ-ගැලපීම අවශ්‍ය නම්, Pattern පන්තිය භාවිතා කරන්න:

4-4. විශේෂාංග සංසන්දන සාරාංශය

5. සාමාන්‍ය භාවිතා අවස්ථා සහ නියැදි කේත

Java හි contains() ක්‍රමය සරල වුවද, සැබෑ සංවර්ධන අවස්ථා වල පුළුල් ලෙස භාවිතා වේ.
සාමාන්‍ය භාවිතා අවස්ථා අතර පරිශීලක ඇතුළත් කිරීමේ වලංගුකරණය, ලොග් විශ්ලේෂණය, සහ පෙරහන් කිරීමේ ක්‍රියාමාර්ග ඇතුළත් වේ.
මෙම කොටස ප්‍රායෝගික උදාහරණ සමඟ සම්බන්ධිත කේත උදාහරණ ආවරණය කරයි.

5-1. පරිශීලක ඇතුළත් කිරීමේ වලංගුකරණය (තහනම් වචන හඳුනා ගැනීම)

පෝරම හෝ සංවාද යෙදුම් වල, ඔබට නියමිත තහනම් වචන ඇතුළත් වී ඇතිදැයි හඳුනා ගැනීමට අවශ්‍ය විය හැකිය.

String input = "このアプリは最悪だ";
String banned = "最悪";

if (input.contains(banned)) {
    System.out.println("不適切な言葉が含まれています。");
}

බහු NG වචන හසුරවීම:

List<String> bannedWords = Arrays.asList("最悪", "バカ", "死ね");
for (String word : bannedWords) {
    if (input.contains(word)) {
        System.out.println("不適切な言葉が含まれています: " + word);
        break;
    }
}

5-2. ලොග් ගොනු විශ්ලේෂණය (විශේෂිත පණිවුඩ හඳුනා ගැනීම)

පද්ධතිය හෝ යෙදුම් ලොග් විශ්ලේෂණය කරන විට, ඔබට ERROR හෝ WARN වැනි විශේෂිත යතුරුපද අඩංගු පේළි පමණක් ලබා ගැනීමට අවශ්‍ය විය හැකිය.

List<String> logs = Arrays.asList(
    "[INFO] サーバーが起動しました",
    "[ERROR] データベース接続失敗",
    "[WARN] メモリ使用率が高い"
);

for (String log : logs) {
    if (log.contains("ERROR")) {
        System.out.println("エラー発生ログ: " + log);
    }
}

5-3. ලැයිස්තුවක 문자열 පෙරහන් කිරීම (Stream API භාවිතා කිරීම)

විශාල දත්ත කට්ටල හසුරවන විට, Stream API භාවිතා කර විශේෂිත උපස්තරයක් අඩංගු අංග පමණක් ලබා ගන්න:

List<String> users = Arrays.asList("tanaka@example.com", "sato@gmail.com", "yamada@yahoo.co.jp");

List<String> gmailUsers = users.stream()
    .filter(email -> email.contains("@gmail.com"))
    .collect(Collectors.toList());

System.out.println(gmailUsers); // [sato@gmail.com]

5-4. HTTP ඉල්ලීම් ශීර්ෂක හෝ URL විග්‍රහ කිරීම

වෙබ් සංවර්ධනයේ, රවුටින් හෝ උපාංග-විශේෂිත හසුරවීම සඳහා User-Agent හෝ URL හි උපස්තර පරීක්ෂා කිරීම අවශ්‍ය විය හැකිය.

String userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)";
if (userAgent.contains("iPhone")) {
    System.out.println("スマートフォンからのアクセスです。");
}

5-5. ගොනු මාර්ග හෝ දිගු නාමය පරීක්ෂා කිරීම

ගොනුවේ මාර්ගය භාවිතා කර එහි වර්ගය තීරණය කිරීම:

String filePath = "/usr/local/data/sample.csv";
if (filePath.contains(".csv")) {
    System.out.println("CSVファイルです。");
}

සටහන:
ගොනු දිගු නාම පරීක්ෂා කිරීම සඳහා, endsWith(".csv") යනු සාමාන්‍යයෙන් වඩාත් නිරවද්‍ය වේ.

ප්‍රායෝගික සැලකිලිමත්කම්

• නිශ්චිතතාව අවශ්‍ය වන විට නරමීකරණය (උදා: toLowerCase(), trim()) යොදා ගන්න.
• විශාල-පරිමාණ දත්ත සඳහා Stream API හෝ regex භාවිතා කිරීම සලකා බලන්න.
• contains() යනු අංශික ගැලපීමක් වන බැවින්, ආරක්ෂිත තර්කයක් සඳහා අනෙකුත් කොන්දේසි සමඟ එකතු කරන්න.

6. කාර්ය සාධන සැලකිලිමත්කම්

contains() ක්‍රමය උසස් කියවීමේ හැකියාව සහ සරලත්වය ලබා දුන් නමුත්, විශාල දත්ත කට්ටල හසුරවීමේදී හෝ නැවත නැවත ක්‍රියාත්මක කිරීමේදී එහි කාර්ය සාධන බලපෑම සැලකිල්ලට ගත යුතුය.
මෙම කොටස contains() හි සැකසුම් පිරිවැය සහ වැඩි කාර්යක්ෂමතාව සඳහා විකල්ප ක්‍රම පිළිබඳ විස්තර කරයි.

6-1. contains() හි අභ්‍යන්තර හැසිරීම සහ කාල සංකීර්ණතාවය

contains() ක්‍රමය ඉලක්ක 문자열ය ආරම්භයෙන් පටන් අනුක්‍රමිකව උපස්තරය සොයයි.
අභ්‍යන්තරයෙන්, එය indexOf() ක්‍රමය මත පදනම් වෙයි, සහ එහි අධිකතම කාල සංකීර්ණතාවය වන්නේ:

O(n * m)
– n = ඉලක්ක 문자열යේ දිග
– m = සෙවීමේ 문자열යේ දිග

බර පිරිවැය උදාහරණයක්:

for (String line : hugeTextList) {
    if (line.contains("error")) {
        // processing
    }
}

මෙය විශාල ලූප තුළ නැවත නැවත භාවිතා කරන විට කාර්ය සාධනයට වැදගත් ලෙස බලපායි.

6-2. නිතර සෙවීම් සඳහා කාර්ය සාධනය වැඩිදියුණු කිරීමේ තාක්ෂණයන්

විශාල දත්ත කට්ටල තුළ contains() නැවත නැවත භාවිතා කරන විට, පහත තාක්ෂණයන් මඟින් සැකසුම් වේගය වැඩි කළ හැකිය:

• සියලු 문자열ය පෙරමුණේම කුඩා අකුරට (lowercase) පරිවර්තනය කිරීම

සෑම සැසියකම toLowerCase() කැඳවීම වෙනුවට, 문자열 පෙරමුණේම නරමීකරණය කරගන්න:

List<String> normalizedList = originalList.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

• parallel() සමඟ සමාන්තර සැකසීම සඳහා Stream API භාවිතා කරන්න

CPU මූලිකයන් භාවිතා කර සෙවීම් වේගවත් කරන්න:

List<String> result = hugeTextList.parallelStream()
    .filter(line -> line.contains("keyword"))
    .collect(Collectors.toList());

• සංකීර්ණ සෙවීම් රටා සඳහා නියමිත ප්‍රකාශන (regular expressions) භාවිතා කරන්න

කොන්දේසි සංකීර්ණ වන අතර එක් regex එකක් තුළ ප්‍රකාශ කළ හැකි නම්, Pattern වැඩි දියුණු ලෙස ක්‍රියා කරනු ඇත:

Pattern pattern = Pattern.compile("error|fail|fatal");
for (String log : logs) {
    if (pattern.matcher(log).find()) {
        // matched
    }
}

6-3. මතක කාර්යක්ෂමතාව සහ නැවත භාවිතා කිරීමේ සැලකිලිමත්කම්

ස්ට්‍රින්ග් පරිවර්තනය කරන මෙහෙයුම්—උදාහරණ olarak toLowerCase() හෝ substring()—බොහෝ අවශ්‍ය නොවන ස්ට්‍රින්ග් වස්තු නිර්මාණය කරනු ඇත, එය මතක භාවිතයට බලපායි.
මෙය විශේෂයෙන් දිගුකාලීන යෙදුම් හෝ සේවාදායක-පාර්ශ්ව සැකසීමේදී වැදගත් වේ.

ප්‍රධාන කරුණු:

• අවශ්‍ය නොවන ස්ට්‍රින්ග් උදාහරණ නිර්මාණය කිරීමෙන් වැළකී සිටින්න.
• විශාල දත්ත කට්ටල සඳහා, බෆරින් හෝ කොටස් සැකසීම ගැන සිතන්න.
• නැවත නැවත contains() ප්‍රතිඵල සුරකින්න (caching) කිරීම, සමහර අවස්ථාවල කාර්යක්ෂමතාව වැඩි කරයි.

7. වෙනත් වැඩසටහන් භාෂා සමඟ සංසන්දනය

Java හි contains() ක්‍රමය සරල, විශ්වාසදායක උපස්ට්‍රින් ගැලපීම ලබා දේ, නමුත් අනෙකුත් භාෂාද තමන්ගේම ලක්ෂණ සමඟ සමාන විශේෂාංග ලබා දෙයි.
මෙම කොටස Python, JavaScript, C# භාෂා තුළ උපස්ට්‍රින් පරීක්ෂාව සසඳා වෙනස්කම් සහ සමානතා ප්‍රදර්ශනය කරයි.

7-1. Python: in මෙහෙයුම්කරු සමඟ සරල අංශික ගැලපීම

Python හි, in මෙහෙයුම්කරු භාවිතා කර උපස්ට්‍රින් ඇතුළත් වීම පරීක්ෂා කළ හැක:

text = "Hello, Python!"
if "Python" in text:
    print("含まれています")

මෙම සින්ටැක්ස් ඉතා කියවීමට පහසුය—ආසන්නව ස්වභාවික භාෂාවක් වැනි—එබැවින් ඉගෙන ගැනීම අවම වේ.

වෙනස්කම් සහ සටහන්:

• in යනු භාෂා මෙහෙයුම්කරු වන අතර, ක්‍රමයක් නොවේ.
• Python හි ස්ට්‍රින්ග් සසඳීම කේස්-සංවේදීය.
• None භාවිතා කිරීමෙන් εξαίρεση (exception) සිදුවේ; null පරීක්ෂා කිරීම අවශ්‍ය වේ.

7-2. JavaScript: includes() සමඟ අංශික ගැලපීම

JavaScript (ES6+) හි, includes() ක්‍රමය භාවිතා කළ හැක:

const text = "JavaScript is fun";
console.log(text.includes("fun")); // true

මෙම ක්‍රමය Java හි contains() සමඟ ඉතා සමාන වන අතර, මනසින් මාරු කිරීම පහසුය.

වෙනස්කම් සහ සටහන්:

• undefined ලබා දීමෙන් εξαίρεση (exception) නොසිදුවේ; එය සරලව false 반환 කරයි.
• includes() අරේ (arrays) මතද ක්‍රියා කරයි, එමඟින් එහි බහුකාර්යභාරය වැඩි වේ.

7-3. C#: Contains() Java සමඟ සමාන

C# ද Java වැනි Contains() ක්‍රමයක් ලබා දේ:

string text = "Welcome to C#";
bool result = text.Contains("C#");

වෙනස්කම් සහ සටහන්:

• C# හි Contains() පෙරනිමි ලෙස කේස්-සංවේදීය, නමුත් StringComparison.OrdinalIgnoreCase භාවිතා කර කේස් නොසංවේදී ලෙස පරිවර්තනය කළ හැක.
• null ලබා දීමෙන් ArgumentNullException εξαίρεση (exception) සිදුවේ.

7-4. භාෂා අතර සංසන්දන වගුව

සාරාංශය: ඔබේ භාවිතය සඳහා නිවැරදි සින්ටැක්ස් තෝරන්න

උපස්ට්‍රින් පරීක්ෂාව බොහෝ භාෂා තුළ පොදු අවශ්‍යතාවයක් වන නමුත්, එක් එක් භාෂාව තමන්ගේම ක්‍රමය හෝ සින්ටැක්ස් ලබා දෙයි.
Java හි contains() ස්ථාවරත්වය සහ පැහැදිලිත්වය ලබා දේ, එය ව්‍යාපාරික පද්ධති සහ නඩත්තු කළ හැකි යෙදුම් සඳහා සුදුසුය.
Python සහ JavaScript වැනි භාෂා සරල හා කෙටි සින්ටැක්ස් ලබා දේ, එය සුළු ස්ක්‍රිප්ට් හෝ වේගවත් ප්‍රොටොටයිප් කිරීම සඳහා ඉතා හොඳය.

මෙම පොදු සංකල්ප සහ එක් එක් භාෂාවේ විශේෂාංග අවබෝධ කරගැනීමෙන්, ඔබට විවිධ භාෂා අතර ආරක්ෂිත හා කාර්යක්ෂම කේතය ලිවිය හැක.

8. නිතර අසන ප්‍රශ්න (FAQ)

Java හි contains() ක්‍රමය සම්බන්ධයෙන් සාමාන්‍යයෙන් අසන ප්‍රශ්න පහත දැක්වේ—ඔබට ගැටළු තේරුම් ගැනීමට සහ පොදු වැරදි වලින් වැළකීමට උපකාරී වේ.

Q1. contains() අකුරු-කේස් සංවේදීද?

ඔව්, එය අකුරු-කේස් සංවේදීය.
උදාහරණ olarak, "Java".contains("java") false 반환 කරයි.

විසඳුම:

String input = "Welcome to Java";
boolean result = input.toLowerCase().contains("java");

Q2. නියමිත ප්‍රකාශන (regular expressions) භාවිතා කර අංශික ගැලපීම් කෙසේ පරීක්ෂා කළ හැකිද?

contains() සාමාන්‍ය ප්‍රකාශන (regular expressions) සඳහා සහය නොදේ.
matches() හෝ Pattern පන්තිය භාවිතා කරන්න.

උදාහරණය (සංඛ්‍යාත්මක රටාව පරීක්ෂා කිරීම):

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "注文番号: A123456";
Pattern pattern = Pattern.compile("A\\d+");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
    System.out.println("パターンに一致しました。");
}

Q3. contains() ක්‍රමය null මත කැඳවන්නේ නම් කුමක් වේද?

NullPointerException එකක් නක්ෂේපණය වේ.

String target = null;
System.out.println(target.contains("test")); // Error

විසඳුම:

if (target != null && target.contains("test")) {
    System.out.println("含まれています。");
}

Q4. contains() වෙත හිස් 문자열 ("")ක් ලබා දුන්නේ නම් කුමක් වේද?

එය සෑම විටම true (සත්‍ය) ලබා දෙයි.

String text = "Java";
System.out.println(text.contains("")); // true

නිල විධි නියමයේ කොටසක් වුවද, මෙම හැසිරීම අඩු වශයෙන් ප්‍රයෝජනවත් වන අතර, හිස් 문자열 ඉලක්ක නොකළහොත් අනපේක්ෂිත දෝෂ ඇති විය හැක.

Q5. contains() එකවර බහු කීවර්ඩ් සෙවිය හැදුවේද?

නැත. එක් එක් කැඳවීමක් එක කීවර්ඩ් පමණක් පරීක්ෂා කරයි.

String text = "本日はシステムエラーが発生しました";
if (text.contains("エラー") || text.contains("障害") || text.contains("失敗")) {
    System.out.println("問題が検出されました。");
}

ගතික (Dynamic) ප්‍රවේශය:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(text::contains);

Q6. contains() සහ indexOf() අතර කවදා භාවිතා කළ යුතුද?

contains() බූලියන් (boolean) අගයක් ලබා දෙයි, indexOf() සංඛ්‍යාත්මක දර්ශකයක් (numeric index) ලබා දෙයි.

• උප-ස්ට්‍රින් (substring) පවතිනවාදැයි ඔබට පමණක් දැන ගැනීමට අවශ්‍ය නම් contains() භාවිතා කරන්න.
• ඔබට තත්ත්වය (position)ද අවශ්‍ය නම් indexOf() භාවිතා කරන්න.

  String text = "Error: Disk full";
  if (text.contains("Error")) {
      int pos = text.indexOf("Error");
      System.out.println("Position: " + pos);
  }
  

9. නිගමනය

Java හි contains() ක්‍රමය විශේෂිත උප-ස්ට්‍රින් එක ස්ට්‍රින් එකක් තුළ අඩංගුද යන්න තීරණය කිරීම සඳහා බලවත් සහ පහසු මෙවලමකි.
එය පරිශීලක ආදාන වලංගු කිරීම, ලොග් විශ්ලේෂණය, දත්ත පෙරහන් කිරීම වැනි විවිධ අවස්ථා වල පුළුල් ලෙස භාවිතා වේ.

මෙම ලිපියේ, අපි ආවරණය කළේ:

• මූලික වාක්‍ය රචනය සහ ආපසු ලබා දෙන අගයන්
• අකුරු ප්‍රමාණ සංවේදනය සහ එය කළමනාකරණය කිරීම
• null සහ හිස් ස්ට්‍රින් ගැලවීම
• වෙනත් ස්ට්‍රින් සැසඳීමේ ක්‍රමවලින් වෙනස්කම්
• ප්‍රායෝගික භාවිතා: වලංගු කිරීම, ලොග් සෙවීම, Stream සැකසීම
• කාර්ය සාධන සැලකිලි සහ උපරිම කිරීමේ තාක්ෂණ
• Python, JavaScript, සහ C# සමඟ සැසඳීම
• නිතර අසන ප්‍රශ්න සහ ගැටළු විසඳුම් උපදෙස්

contains() සරල සහ බහුදෘශ්‍යය වුවද, එය විශාල දත්ත කට්ටල, නිතර කැඳවීම්, හෝ සංකීර්ණ සෙවීමේ කොන්දේසි ඇතුළත් අවස්ථා වලදී සැලකිලිමත් ලෙස ඇගයිය යුතුය.
සාමාන්‍යීකරණය, සමකාලීන සැකසීම, regex, සහ කෑෂ් කිරීමේ උපාය මාර්ග එකතු කිරීමෙන්, ඔබට කාර්ය සාධනය සහ කියවීමට පහසුකම දෙකම රැකගත හැක.

contains() ස්ට්‍රින් සමඟ වැඩ කිරීමේ මූලික අංගයක් වන බැවින්, මෙම ලිපිය ඔබට එය ඔබේ සංවර්ධන ව්‍යාපෘති වලදී ආරක්ෂිතව සහ ප්‍රභාවී ලෙස භාවිතා කිරීමට උපකාරී වේ යැයි අපි බලාපොරොත්තු වෙමු.