ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನಗಳು ಜಾವಾ



ಜಾವಾ ಸ್ಟ್ರಿಂಗ್

ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಎನ್ನುವುದು ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವಲ್ಲ. ಇದು ಹೆಚ್ಚು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ವಸ್ತುವಾಗಿದೆ. ಜಾವಾ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವು ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ, ಇದನ್ನು ವಿವಿಧ ಕುಶಲತೆಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಬದಲಾಗದ, ಅರ್ಥ, ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

ಪರಿವಿಡಿ

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಲಾಗುತ್ತಿದೆ

ನಾವು 2 ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಬಹುದು:

  • ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ಬಳಸುವುದು
  • ಹೊಸ ಕೀವರ್ಡ್ ಬಳಸುವುದು

ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ಬಳಸಿ ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಿ

ಇದು ರಚಿಸುವ ಅತ್ಯಂತ ನೇರ ಮಾರ್ಗವಾಗಿದೆ ಸ್ಟ್ರಿಂಗ್ ಜಾವಾದಲ್ಲಿ. ಮೌಲ್ಯವನ್ನು ಡಬಲ್-ಕೋಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವ ಮೂಲಕ ನಾವು ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಬಹುದು. ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ “ಮೌಲ್ಯ” “ಜಾವಾ ಭಾಷೆ” ಎಂದು ಹೆಸರಿಸಲಾದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿದೆ

String value = "Java language";

ನಾವು ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ರಚಿಸಿದಾಗ, ಸ್ಟ್ರಿಂಗ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಜೆವಿಎಂ ಮೊದಲು “ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ಪೂಲ್” ನಲ್ಲಿ ಪರಿಶೀಲಿಸುತ್ತದೆ. ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಜೆವಿಎಂ ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ನಿದರ್ಶನವನ್ನು ರಚಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಪೂಲ್ ಮಾಡಿದ ಉದಾಹರಣೆಯ ಉಲ್ಲೇಖವನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡೂ ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ ಕೇವಲ 1 ವಸ್ತುವನ್ನು ರಚಿಸಲಾಗಿದೆ (ಅಂದರೆ s1) ಮತ್ತು s2 ನಲ್ಲಿ s1 ಗೆ ಉಲ್ಲೇಖವಿರುತ್ತದೆ. ಇದರರ್ಥ, ಒಂದೇ ಮೌಲ್ಯದೊಂದಿಗೆ ನಾವು ಎಷ್ಟು ಸ್ಟ್ರಿಂಗ್ ಅಸ್ಥಿರಗಳನ್ನು ರಚಿಸಿದ್ದರೂ, ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ಪೂಲ್‌ನಲ್ಲಿ ಕೇವಲ 1 ನಿದರ್ಶನಗಳನ್ನು ಮಾತ್ರ ರಚಿಸಲಾಗುತ್ತದೆ.

“ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ಪೂಲ್” ಎಂಬುದು ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹಿಡಿದಿಡಲು ವಿಶೇಷ ಮೆಮೊರಿಯನ್ನು ಹೊರತುಪಡಿಸಿ ಏನೂ ಅಲ್ಲ.

String s1 = "Java language"; 
String s2 = "Java language";

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್

ಹೊಸ ಕೀವರ್ಡ್ ಬಳಸಿ ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಲಾಗುತ್ತಿದೆ

ಒಂದೇ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ 2 ವಿಭಿನ್ನ ವಸ್ತುಗಳನ್ನು ಹೊಂದಲು ನಾವು ಬಯಸಿದಾಗ, ನಂತರ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಹೊಸ ಕೀವರ್ಡ್ ಕೆಳಗೆ ವಿವರಿಸಿದಂತೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಜೆವಿಎಂ ರಾಶಿ ಮೆಮೊರಿಯಲ್ಲಿ 2 ವಿಭಿನ್ನ ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುಗಳನ್ನು ರಚಿಸುತ್ತದೆ

String s1 = new String("Java");
String s2 = new String("Java");

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್

ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನಗಳು ಜಾವಾ

Java.lang.String ವರ್ಗವು ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದನ್ನು ಕೆಳಗೆ ವಿವರಿಸಿದಂತೆ ವಿಭಿನ್ನ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ:

ವಿಧಾನವಿವರಣೆನಿಯತಾಂಕಗಳನ್ನು
ಚಾರ್ ಚಾರ್ಅಟ್ (ಇಂಟ್ ಸೂಚ್ಯಂಕ)ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ನ ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಸೂಚ್ಯಂಕ - ಸ್ಟ್ರಿಂಗ್‌ನ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯ
ಇಂಟ್ ಕೋಡ್‌ಪಾಯಿಂಟ್ಅಟ್ (ಇಂಟ್ ಸೂಚ್ಯಂಕ)ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಅಕ್ಷರದ ಯುನಿಕೋಡ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಸೂಚ್ಯಂಕ - ಸ್ಟ್ರಿಂಗ್‌ನ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯ
ಇಂಟ್ ಕೋಡ್ ಪಾಯಿಂಟ್ ಮೊದಲು (ಇಂಟ್ ಸೂಚ್ಯಂಕ)ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೂಚ್ಯಂಕದ ಮೊದಲು ಇರುವ ಅಕ್ಷರಗಳ ಯೂನಿಕೋಡ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಸೂಚ್ಯಂಕ - ಸ್ಟ್ರಿಂಗ್‌ನ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯ
ಇಂಟ್ ಹೋಲಿಕೆ (ಸ್ಟ್ರಿಂಗ್ ಅನರ್‌ಸ್ಟ್ರಿಂಗ್)ಅಕ್ಷರಗಳ ಯುನಿಕೋಡ್ ಮೌಲ್ಯವನ್ನು ಆಧರಿಸಿ 2 ತಂತಿಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಆರ್ಗ್ಯುಮೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮೀರಿದರೆ negative ಣಾತ್ಮಕ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಧನಾತ್ಮಕವಾಗಿರುತ್ತದೆ. ಎರಡೂ ತಂತಿಗಳು ಸಮಾನವಾಗಿದ್ದರೆ ರಿಟರ್ನ್ ಮೌಲ್ಯ 0 ಆಗಿದೆanotherstring - ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ನೊಂದಿಗೆ ಹೋಲಿಸಲು ಸ್ಟ್ರಿಂಗ್
ಇಂಟ್ ಹೋಲಿಕೆ ಟೊಇಗ್ನೋರ್ ಕೇಸ್ (ಸ್ಟ್ರಿಂಗ್ ಅನದರ್ ಸ್ಟ್ರಿಂಗ್)ಹೋಲಿಕೆ ವಿಧಾನಕ್ಕೆ ಹೋಲುತ್ತದೆ ಅದು ಪ್ರಕರಣವನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ.anotherstring - ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ನೊಂದಿಗೆ ಹೋಲಿಸಲು ಸ್ಟ್ರಿಂಗ್
ಸ್ಟ್ರಿಂಗ್ ಕಾನ್ಕಾಟ್ (ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್)ಎರಡು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆstr - ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ ಒಗ್ಗೂಡಿಸುವ ಸ್ಟ್ರಿಂಗ್
ಬೂಲಿಯನ್ ಒಳಗೊಂಡಿದೆ (ಚಾರ್ಸ್‌ಕ್ವೆನ್ಸ್ ಸಿ)ಸ್ಟ್ರಿಂಗ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅಕ್ಷರ ಅನುಕ್ರಮವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುc - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಹುಡುಕಲು ಅಕ್ಷರ ಅನುಕ್ರಮ
ಬೂಲಿಯನ್ ವಿಷಯ ಎಕ್ವಾಲ್ಸ್ (ಚಾರ್ಸ್‌ಕ್ವೆನ್ಸ್ ಸಿ)ಸ್ಟ್ರಿಂಗ್ ನಿಖರವಾದ ಪಾತ್ರವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುc - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಹುಡುಕಲು ಅಕ್ಷರ ಅನುಕ್ರಮ
ಬೂಲಿಯನ್ ವಿಷಯ ಎಕ್ವಾಲ್ಸ್ (ಸ್ಟ್ರಿಂಗ್‌ಬಫರ್ ಎಸ್‌ಬಿ)ಸ್ಟ್ರಿಂಗ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಬಫರ್ ಅನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುsb - ಸ್ಟ್ರಿಂಗ್ ಬಫರ್ ವಿಷಯ
ಬೂಲಿಯನ್ ತುದಿಗಳು (ಸ್ಟ್ರಿಂಗ್ ಪ್ರತ್ಯಯ)ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರತ್ಯಯದೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುಪ್ರತ್ಯಯ - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪರಿಶೀಲಿಸುವ ಪ್ರತ್ಯಯ
ಬೂಲಿಯನ್ ಸಮನಾಗಿರುತ್ತದೆ (ಆಬ್ಜೆಕ್ಟ್ ಆಬ್ಜೆಕ್ಟ್)ರವಾನಿಸಿದ ವಸ್ತುವಿನೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ನ ಹೋಲಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಸಮಾನವಾಗಿದ್ದರೆ ನಿಜವಾಗುತ್ತದೆobj - ಹೋಲಿಸುವ ವಸ್ತು
ಬೂಲಿಯನ್ ಈಕ್ವಲ್ಸ್ ಇಗ್ನೋರ್ ಕೇಸ್ (ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್)ಪ್ರಕರಣವನ್ನು ನಿರ್ಲಕ್ಷಿಸುವ ಮೂಲಕ ಎರಡು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೋಲಿಸುತ್ತದೆ ಮತ್ತು ಎರಡೂ ತಂತಿಗಳು ಸಮಾನವಾಗಿದ್ದರೆ ನಿಜವಾಗುತ್ತದೆstr - ಹೋಲಿಸಲು ಸ್ಟ್ರಿಂಗ್
ಇಂಟ್ ಸೂಚ್ಯಂಕ (ಇಂಟ್ ಚ)ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಯುನಿಕೋಡ್ ಅಕ್ಷರಗಳ ಮೊದಲ ಘಟನೆಯ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆch - ಪಾತ್ರದ ಯುನಿಕೋಡ್ ಮೌಲ್ಯ
ಇಂಟ್ ಇಂಡೆಕ್ಸ್ಆಫ್ (ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್)ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ನ ಮೊದಲ ಘಟನೆಯ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆstr - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯ
ಬೂಲಿಯನ್ isBlank ()ಸ್ಟ್ರಿಂಗ್ ಖಾಲಿಯಾಗಿದೆ ಅಥವಾ ಖಾಲಿ ಸ್ಥಳಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿದೆ ಎಂಬುದು ನಿಜ
ಬೂಲಿಯನ್ isEmpty ()ಸ್ಟ್ರಿಂಗ್ ಖಾಲಿಯಾಗಿದ್ದರೆ ನಿಜ ಅಂದರೆ ಹಿಂತಿರುಗುತ್ತದೆ (ಅಂದರೆ ಉದ್ದ 0)
int lastindexOf (int ch)ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಯುನಿಕೋಡ್ ಅಕ್ಷರಗಳ ಕೊನೆಯ ಘಟನೆಯ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆch - ಪಾತ್ರದ ಯುನಿಕೋಡ್ ಮೌಲ್ಯ
int lastindexOf (ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್)ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ನ ಕೊನೆಯ ಘಟನೆಯ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆstr - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯ
ಇಂಟ್ ಉದ್ದ ()ಸ್ಟ್ರಿಂಗ್ನ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಬೂಲಿಯನ್ ಪಂದ್ಯಗಳು (ಸ್ಟ್ರಿಂಗ್ ರಿಜೆಕ್ಸ್)ನಿಗದಿತ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿಕೆಯಾದರೆ ನಿಜರಿಜೆಕ್ಸ್ - ಪರಿಶೀಲಿಸಬೇಕಾದ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿ
ಸ್ಟ್ರಿಂಗ್ ಪುನರಾವರ್ತನೆ (ಇಂಟ್ ಎಣಿಕೆ)ಎಣಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆಎಣಿಕೆ - ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಜೋಡಿಸಲು ಎಷ್ಟು ಬಾರಿ
ಸ್ಟ್ರಿಂಗ್ ರಿಪ್ಲೇಸ್ (ಚಾರ್ ಓಲ್ಡ್ಚಾರ್, ಚಾರ್ ನ್ಯೂಚಾರ್)ಪಾತ್ರದ ಎಲ್ಲಾ ಘಟನೆಗಳನ್ನು ಹೊಸ ಅಕ್ಷರದೊಂದಿಗೆ ಬದಲಾಯಿಸುವ ಮೂಲಕ ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಓಲ್ಡ್ಚಾರ್ - ಬದಲಿಸುವ ಅಕ್ಷರ
ಹೊಸಚಾರ್ - ಬದಲಾಯಿಸಬೇಕಾದ ಅಕ್ಷರ
ಸ್ಟ್ರಿಂಗ್ [] ವಿಭಜನೆ (ಸ್ಟ್ರಿಂಗ್ ರಿಜೆಕ್ಸ್ಪಿ)ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸುತ್ತದೆ. ಇದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆregexp - ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸಲು ಡಿಲಿಮಿಟರ್
ಸ್ಟ್ರಿಂಗ್ [] ವಿಭಜನೆ (ಸ್ಟ್ರಿಂಗ್ ರಿಜೆಕ್ಸ್, ಇಂಟ್ ಮಿತಿ)ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿ ಮತ್ತು ಅದನ್ನು ಎಷ್ಟು ಬಾರಿ ಅನ್ವಯಿಸಬೇಕೆಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸುತ್ತದೆregexp - ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸಲು ಡಿಲಿಮಿಟರ್
ಮಿತಿ - ಮಾದರಿಯನ್ನು ಎಷ್ಟು ಬಾರಿ ಅನ್ವಯಿಸಬೇಕು
ಬೂಲಿಯನ್ ಪ್ರಾರಂಭಗಳು (ಸ್ಟ್ರಿಂಗ್ ಪೂರ್ವಪ್ರತ್ಯಯ)ನಿರ್ದಿಷ್ಟ ಸ್ಟ್ರಿಂಗ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದ್ದರೆ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಪೂರ್ವಪ್ರತ್ಯಯ - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪರಿಶೀಲಿಸುವ ಪೂರ್ವಪ್ರತ್ಯಯ
ಬೂಲಿಯನ್ ಪ್ರಾರಂಭಗಳು (ಸ್ಟ್ರಿಂಗ್ ಪೂರ್ವಪ್ರತ್ಯಯ, ಇಂಟ್ ಟೂಫ್‌ಸೆಟ್)ಕೊಟ್ಟಿರುವ ಸ್ಟ್ರಿಂಗ್ ಟೂಫ್‌ಸೆಟ್ ನಿಯತಾಂಕದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದ್ದರೆ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಪೂರ್ವಪ್ರತ್ಯಯ - ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪರಿಶೀಲಿಸುವ ಪೂರ್ವಪ್ರತ್ಯಯ
ಟೂಫ್‌ಸೆಟ್ - ಹುಡುಕಾಟವನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾದ ಸೂಚ್ಯಂಕ
ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಪ್ ()ಪ್ರಮುಖ ಮತ್ತು ಹಿಂದುಳಿದಿರುವ ಎಲ್ಲಾ ಜಾಗಗಳನ್ನು ತೆಗೆದುಹಾಕಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಪ್ ಲೇಡಿಂಗ್ ()ಎಲ್ಲಾ ಪ್ರಮುಖ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಹಾಕಿದ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಪ್ ಟ್ರೈಲಿಂಗ್ ()ಎಲ್ಲಾ ಹಿಂದುಳಿದಿರುವ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಹಾಕಿರುವ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಚಾರ್‌ಸ್ಕ್ವೆನ್ಸ್ ಸಬ್‌ಕ್ವೆನ್ಸ್ (ಇಂಟ್ ಸ್ಟಾರ್ಟ್ಇಂಡೆಕ್ಸ್, ಇಂಟ್ ಎಂಡ್ಇಂಡೆಕ್ಸ್)ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯ ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರ ಅನುಕ್ರಮವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆstartIndex - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂಪಡೆಯಬೇಕಾದ ಸೂಚ್ಯಂಕ
endIndex - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂಪಡೆಯಬೇಕಾದ ಸೂಚ್ಯಂಕ
ಸ್ಟ್ರಿಂಗ್ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ (ಇಂಟ್ ಸ್ಟಾರ್ಟ್ಇಂಡೆಕ್ಸ್)ಪ್ರಾರಂಭ ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆstartIndex - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂಪಡೆಯಬೇಕಾದ ಸೂಚ್ಯಂಕ
ಸ್ಟ್ರಿಂಗ್ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ (ಇಂಟ್ ಸ್ಟಾರ್ಟ್ಇಂಡೆಕ್ಸ್, ಇಂಟ್ ಎಂಡ್ಇಂಡೆಕ್ಸ್)ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯ ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆstartIndex - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂಪಡೆಯಬೇಕಾದ ಸೂಚ್ಯಂಕ
endIndex - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂಪಡೆಯಬೇಕಾದ ಸೂಚ್ಯಂಕ
ಚಾರ್ [] ಗೆ ಚಾರ್ಅರ್ರೆ () ಗೆಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಅಕ್ಷರ ಶ್ರೇಣಿಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಲೋವರ್ ಕೇಸ್ ()ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಸಣ್ಣಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಲೋವರ್ ಕೇಸ್ (ಲೊಕೇಲ್ ಲೊಕೇಲ್)ಲೊಕೇಲ್ ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಸಣ್ಣಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆಲೊಕೇಲ್ - ಅನ್ವಯಿಸಬೇಕಾದ ಲೊಕೇಲ್ ನಿಯಮಗಳು
ಸ್ಟ್ರಿಂಗ್ ಟು ಸ್ಟ್ರಿಂಗ್ ()ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಅಪ್ಪರ್‌ಕೇಸ್ ()ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಮೇಲಿನ ಪ್ರಕರಣಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಅಪ್ಪರ್‌ಕೇಸ್ (ಲೊಕೇಲ್ ಲೊಕೇಲ್)ಲೊಕೇಲ್ ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆಲೊಕೇಲ್ - ಅನ್ವಯಿಸಬೇಕಾದ ಲೊಕೇಲ್ ನಿಯಮಗಳು
ಸ್ಟ್ರಿಂಗ್ ಟ್ರಿಮ್ ()ಎಲ್ಲಾ ಪ್ರಮುಖ ಮತ್ತು ಹಿಂದುಳಿದ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಹಾಕಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ (ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್, ಆಬ್ಜೆಕ್ಟ್ ... ಆರ್ಗ್ಸ್)ಸ್ವರೂಪ ಮತ್ತು ವಾದಗಳ ಆಧಾರದ ಮೇಲೆ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಫಾರ್ಮ್ಯಾಟ್ - ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಪೆಸಿಫೈಯರ್
ಆರ್ಗ್ಸ್ - ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಪೆಸಿಫೈಯರ್ನಿಂದ ಉಲ್ಲೇಖಿಸಲಾದ ಆರ್ಗ್ಯುಮೆಂಟ್ಸ್
ಸ್ಟ್ರಿಂಗ್ ಸೇರ್ಪಡೆ (ಚಾರ್‌ಸ್ಕ್ವೆನ್ಸ್ ಡಿಲಿಮಿಟರ್, ಚಾರ್‌ಸ್ಕ್ವೆನ್ಸ್ ... ಅಂಶಗಳು)ಡಿಲಿಮಿಟರ್ ಬಳಸಿ ಅಕ್ಷರ ಅನುಕ್ರಮ ಅಂಶಗಳನ್ನು ಸೇರುತ್ತದೆಡಿಲಿಮಿಟರ್ - ಸೇರಲು ಡಿಲಿಮಿಟರ್
ಅಂಶಗಳು - ಸೇರಲು ಸ್ಟ್ರಿಂಗ್ ಅಂಶಗಳು
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಬೂಲಿಯನ್ ಬಿ)ಬೂಲಿಯನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಿಜವು ಹಾದು ಹೋದರೆ, ನಿಜವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆb - ಬೂಲಿಯನ್ ಮೌಲ್ಯವು ನಿಜ ಅಥವಾ ತಪ್ಪು
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಚಾರ್ ಸಿ)ಅಕ್ಷರ ವಾದದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಸಿ - ಅಕ್ಷರ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಚಾರ್ [] ಡೇಟಾ)ಅಕ್ಷರ ರಚನೆಯ ವಾದದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಡೇಟಾ - ಅಕ್ಷರ ರಚನೆ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಡಬಲ್ ಡಿ)ಡಬಲ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆd - ಡಬಲ್ ಮೌಲ್ಯ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಫ್ಲೋಟ್ ಎಫ್)ಫ್ಲೋಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆf - ಫ್ಲೋಟ್ ಮೌಲ್ಯ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಇಂಟ್ ಐ)ಪೂರ್ಣಾಂಕ ವಾದದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆi - ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯ IOf (ಉದ್ದ l)ದೀರ್ಘ ವಾದದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆl - ದೀರ್ಘ ಮೌಲ್ಯ
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಆಬ್ಜೆಕ್ಟ್ ಆಬ್ಜೆಕ್ಟ್)ಆಬ್ಜೆಕ್ಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆobj - ವಸ್ತು
ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಆಫ್ (ಚಾರ್ [] ಡೇಟಾ, ಇಂಟ್ ಆಫ್‌ಸೆಟ್, ಇಂಟ್ ಎಣಿಕೆ)ಆಫ್‌ಸೆಟ್ ಮತ್ತು ಎಣಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರ ರಚನೆಯ ವಾದದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಡೇಟಾ - ಅಕ್ಷರ ರಚನೆ
ಆಫ್‌ಸೆಟ್ - ಸೂಚ್ಯಂಕವನ್ನು ಪ್ರಾರಂಭಿಸಿ
ಎಣಿಕೆ - ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದ

ಉದಾಹರಣೆ: ಅರೇ ಅಕ್ಷರಗಳಿಂದ ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಒಂದು ಪರಿವರ್ತಿಸುತ್ತೇವೆ ಸರಣಿ ಹೊಸ ಕೀವರ್ಡ್ ಬಳಸಿ ಜಾವಾದಲ್ಲಿನ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಅಕ್ಷರಗಳು.

public class StringDemo1 {

  public static void main(String[] args) {
    char[] c = {'j','a','v','a'};
    String s = new String(c);
    System.out.println(s);
    
  }

}
Output:
java

ಉದಾಹರಣೆ: ಉದ್ದ (), ಚಾರ್ಅಟ್ () ಮತ್ತು ಇಂಡೆಕ್ಸ್ಆಫ್ () ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು

ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಹೇಗೆ ಪಡೆದುಕೊಳ್ಳುವುದು, ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಪಡೆಯುವುದು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಪಾತ್ರದ ಸೂಚಿಯನ್ನು ಹೇಗೆ ಪಡೆಯುವುದು ಎಂಬುದನ್ನು ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ನಿಮಗೆ ತೋರಿಸುತ್ತದೆ.

public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("The character at index 6 is : " + s1.charAt(6));
    System.out.println("The length of the input string is : " + s1.length());
    System.out.println("The index of letter 'v' is : " + s1.indexOf('v'));
  }

}
Output:
The character at index 6 is : u
The length of the input string is : 13
The index of letter 'v' is : 2

ಉದಾಹರಣೆ: ಹೋಲಿಕೆ ಟೊ (), ಕಂಟೆಂಟ್ ಎಕ್ವಾಲ್ಸ್ () ಅನ್ನು ಬಳಸುವುದು ಮತ್ತು ()

ಈ ಉದಾಹರಣೆಯು ಜಾವಾದಲ್ಲಿನ 2 ತಂತಿಗಳ ಹೋಲಿಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ

  1. ಹೋಲಿಕೆ ಟೊ () ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗುವುದರಿಂದ ಇಲ್ಲಿ ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕವನ್ನು ನೀಡುತ್ತದೆ.
  2. ಹೋಲಿಕೆ ಟೊಇಗ್ನೋರ್ ಕೇಸ್ () 0 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಎರಡೂ ತಂತಿಗಳು ಪ್ರಕರಣವನ್ನು ಲೆಕ್ಕಿಸದೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.
  3. ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿರುವುದರಿಂದ () ನಿಜವನ್ನು ನೀಡುತ್ತದೆ
  4. ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ನಿಖರವಾದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿರದ ಕಾರಣ contentEquals () ಸುಳ್ಳನ್ನು ನೀಡುತ್ತದೆ.
public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("Comparison of input string with argument is : " + s1.compareTo("C++"));
    System.out.println("Comparison of input string with argument ignoring case is : " + s1.compareToIgnoreCase("JAVA TUTORIAL"));
    System.out.println("Output of contains method: " + s1.contains("tutorial"));
    System.out.println("Output of contentEquals method: " + s1.contentEquals("Java"));
    }
}
Output:
Comparison of input string with argument is : 7
Comparison of input string with argument ignoring case is : 0
Output of contains method: true
Output of contentEquals method: false

ಉದಾಹರಣೆ: ಸಮನಾಗಿ ಬಳಸುವುದು ()

ವಿಷಯ ಒಂದೇ ಆಗಿದ್ದರೂ ಪ್ರಕರಣವು ಹೊಂದಿಕೆಯಾಗದ ಕಾರಣ 1 ನೇ output ಟ್‌ಪುಟ್ ತಪ್ಪಾಗಿದೆ. ವಿಷಯ ಮತ್ತು ಕೇಸ್ ಹೊಂದಿಕೆಯಾದ ಕಾರಣ 2 ನೇ output ಟ್‌ಪುಟ್ ನಿಜ.

ಎರಡೂ ವಿಷಯಗಳು ವಿಭಿನ್ನವಾಗಿರುವುದರಿಂದ 3 ನೇ output ಟ್‌ಪುಟ್ ಸುಳ್ಳು.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    String s2 = "Java Tutorial";
    String s3 = "java tutorial";
    String s4 = "Tutorial cup";
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    System.out.println(s1.equals(s4));
  }

}
Output:
false
true
false

ಉದಾಹರಣೆ: ತಂತಿಗಳ ಒಗ್ಗೂಡಿಸುವಿಕೆ

ಕಾನ್ಕಾಟ್ () ಬಳಸಿ ನಾವು ಜಾವಾದಲ್ಲಿ 2 ತಂತಿಗಳನ್ನು ಜೋಡಿಸಬಹುದು ಜಾವಾ ವಿಧಾನ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗ. ಮುದ್ರಣ ಹೇಳಿಕೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ 2 ಅಥವಾ ಹೆಚ್ಚಿನ ತಂತಿಗಳನ್ನು ಒಗ್ಗೂಡಿಸಲು “+” ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. 2 ತಂತಿಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುವಾಗ, ತಂತಿಗಳ ನಡುವೆ ಜಾಗವನ್ನು ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಎಸ್ 3 ಎಸ್ 1 ಮತ್ತು ಎಸ್ 2 ನ ಸಂಯೋಜಿತ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ಇದನ್ನು ಮುದ್ರಣ ಹೇಳಿಕೆಯಲ್ಲಿ ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಜೊತೆಗೆ ಬಳಸಲಾಗುತ್ತದೆ.

ಸೇರ್ಪಡೆ () ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಜಾವಾದಲ್ಲಿ 2 ತಂತಿಗಳನ್ನು ಜೋಡಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡಿಲಿಮಿಟರ್ನೊಂದಿಗೆ ವಾದದಲ್ಲಿ ರವಾನಿಸಲಾದ ಪದಗಳಿಗೆ ಇದು ಸೇರಿಕೊಳ್ಳುತ್ತದೆ.

public class StringConcat {

  public static void main(String[] args) {
    String s1 = "Hello,";
    String s2 = "how are you";
    String s3 = s1.concat(s2);
    System.out.println(s3 + " today");
    System.out.println(s1.join(",", "welcome","to","tutorialcup"));
  }

}
Output:
Hello,how are you today
welcome,to,tutorialcup

ಉದಾಹರಣೆ: ದೊಡ್ಡ ಪ್ರಕರಣ ಮತ್ತು ಲೋವರ್ ಕೇಸ್ ನಡುವೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪರಿವರ್ತಿಸಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

public class StringCase {

  public static void main(String[] args) {
    String s1 = "Welcome to tutorialcup";
    System.out.println("Convert to lower case: " + s1.toLowerCase());
    System.out.println("Convert to upper case: " + s1.toUpperCase());

  }

}
Output:
Convert to lower case: welcome to tutorialcup
Convert to upper case: WELCOME TO TUTORIALCUP

ಉದಾಹರಣೆ: ಜಾವಾದಲ್ಲಿ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಬಳಸುವುದು

ನಾವು ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ನ ಭಾಗವನ್ನು ಹಿಂಪಡೆಯಬಹುದು ಸಬ್ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನ. ಸೂಚ್ಯಂಕ ಮೌಲ್ಯವು 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    System.out.println(s1.substring(3));
    System.out.println(s1.substring(1, 10));
  }

}
Output:
a tutorial
ava tutor

ಉದಾಹರಣೆ: ವಿಭಜನೆ ಮತ್ತು ಬದಲಿ ಬಳಸುವುದು

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಸ್ಪ್ಲಿಟ್. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೊದಲು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಡಿಲಿಮಿಟರ್ ”“ ಅನ್ನು ಬಳಸಿ ವಿಭಜಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಇದು ಪ್ರತಿಯೊಂದು ಪದವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಮುದ್ರಿಸುತ್ತದೆ. ಮುಂದೆ, ನಾವು ಡಿಲಿಮಿಟರ್ ಅನ್ನು ಆಧರಿಸಿ ವಿಭಜಿಸುತ್ತೇವೆ ಆದರೆ ಮಿತಿಯನ್ನು 2 ಎಂದು ಸೂಚಿಸುತ್ತೇವೆ ಅಂದರೆ ಅದು ಕೇವಲ ಎರಡು ಸ್ಟ್ರಿಂಗ್ ಅರೇ ಮೌಲ್ಯಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ.

ಬದಲಿಸುವ 1 ನೇ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ವೈಯಕ್ತಿಕ ಅಕ್ಷರವನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ. ಮುಂದಿನದರಲ್ಲಿ, ನಾವು ಅಕ್ಷರ ಅನುಕ್ರಮವನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ.

public class StringDemo4 {

  public static void main(String[] args) {
    String str1 = "Welcome to java programming";
    System.out.println("Split output using delimiter:");
    //Split using only delimiter
    String[] arrval = str1.split(" ");
    for(int i=0;i<arrval.length;i++) {
      System.out.println(arrval[i]);
    }
    System.out.println("\nSplit output using delimiter and limit:");
    //Split using delimiter and limit
    String[] arrval2 = str1.split(" ", 2);
    for(int i=0;i<arrval2.length;i++) {
      System.out.println(arrval2[i]);
    }
    
    System.out.println("\nReplace output with character:");
    //Replace character
    String str2 = str1.replace('j', 'J');
    System.out.println(str2);
    System.out.println("\nReplace output with character sequence:");
    String str3 = str1.replace("java", "javascript");
    System.out.println(str3);
  }

}


Output:
Split output using delimiter:
Welcome
to
java
programming

Split output using delimiter and limit:
Welcome
to java programming

Replace output with character:
Welcome to Java programming

Replace output with character sequence:
Welcome to javascript programming

ಉದಾಹರಣೆ: ಜಾವಾ ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್

ನಾವು ಯಾವುದನ್ನಾದರೂ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬಹುದು ಡೇಟಾದ ಪ್ರಕಾರ ಸ್ವರೂಪ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್‌ಗೆ. ಇಲ್ಲಿ, ನಾವು ಸ್ಟ್ರಿಂಗ್ (“% s”), ಫ್ಲೋಟ್ (% f ”) ಮತ್ತು ಬೂಲಿಯನ್ (“% b ”) ಅನ್ನು ಉದಾಹರಣೆಗಳಾಗಿ ಬಳಸುತ್ತಿದ್ದೇವೆ.

public class StringFormat {

  public static void main(String[] args) {
    String str = "Java";
    String formatstring1 = String.format("Programming language is %s",str);
    String formatstring2 = String.format("Float value is %f", 55.6789);
    String formatstring3 = String.format("Boolean value is %b", true);
    System.out.println(formatstring1);
    System.out.println(formatstring2);
    System.out.println(formatstring3);
  }

}
Output:
Programming language is Java
Float value is 55.678900
Boolean value is true

ತೀರ್ಮಾನ

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನೀವು ಜಾವಾದಲ್ಲಿನ ಸ್ಟ್ರಿಂಗ್, ಅದನ್ನು ರಚಿಸುವ ವಿಭಿನ್ನ ವಿಧಾನಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿಭಿನ್ನ ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ.

ರೆಫರೆನ್ಸ್