מחרוזת היא הכיתה הנפוצה ביותר בתכנות ג'אווה. לכן תכניות מחרוזת משמשות בראיונות עבודה בג'אווה כדי לקבל גישה ליכולות הקידוד.
תכניות מחרוזת בג'אווה
הנה אני מספק כמה תכניות מחרוזת בג'אווה כדי לעזור לך לשדרג את היכולות שלך בקידוד. אנא נסה לפתור את השאלות הללו בעצמך לפני בדיקת התשובות כדי ללמוד בדרך יותר יעילה. אני מנסה להשתמש בכל התכונות האחרונות שהוצגו בג'אווה, כגון Stream, ביטויי למדה, ממשקים פונקציונליים וכו'
איך לקבל תווים בלתי כפולים וספירתם במחרוזת?
package com.journaldev.java.string;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class DistinctCharsCount {
public static void main(String[] args) {
printDistinctCharsWithCount("abc");
printDistinctCharsWithCount("abcab3");
printDistinctCharsWithCount("hi there, i am pankaj");
}
private static void printDistinctCharsWithCount(String input) {
Map charsWithCountMap = new HashMap<>();
// באמצעות שימוש בשיטת המיזוג במפה מג'אווה 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// דרך נוספת באמצעות שיפורים אחרונים של ג'אווה וללא לולאה for, קצת מורכבת אף שם
List list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));
System.out.println(charsWithCountMap);
}
}
כתוב תוכנית Java להפוך מחרוזת?
ישנם דרכים רבות להפוך מחרוזת. כמה מהדרכים הנפוצות הן:
- שימוש בשיטת
reverse()של StringBuilder/StringBuffer - שימוש במערך תווים/בתים ועבור לאחור כדי למלא את מחרוזת התוצאה
אם אתה לא בטוח בתוכן של מחרוזת הקלט, תמיד עדיף להשתמש בשיטת reverse() המובנית של StringBuilder. זה כי שימוש במערך תווים ובתים יכול לגרום לתוצאות שאינן רצויות. ספקתי הסבר מלא על כך ב-הפיכת מחרוזת לאחור ב-Java.
package com.journaldev.java.string;
public class ReverseAString {
public static void main(String[] args) {
reverseInputString("abc");
reverseInputString("ç©∆˙¨˚ø"); //special chars
}
private static void reverseInputString(String input) {
StringBuilder sb = new StringBuilder(input);
String result = sb.reverse().toString();
System.out.println(result);
}
}
איך לבדוק האם מחרוזת היא פלינדרום?
A palindrome string is one whose reverse is also same string. So we can reverse the input string and check if both strings are equal for this. Or we can be smart and use the String charAt(int index) method to check for palindrome string.
package com.journaldev.java.string;
public class PalindromeString {
public static void main(String[] args) {
checkPalindromeString("abc");
checkPalindromeString("abcba");
checkPalindromeString("ç∂©∂ç");
}
private static void checkPalindromeString(String input) {
boolean result = true;
int length = input.length();
for(int i=0; i < length/2; i++) {
if(input.charAt(i) != input.charAt(length-i-1)) {
result = false;
break;
}
}
System.out.println(input + " is palindrome = "+result);
}
}
איך להסיר את כל המופעים של תו נתון ממחרוזת הקלט?
אין פונקציה להסרת ערך במחלקת המחרוזת, אך אנו יכולים להשתמש ב־replaceAll() במקרה זה. הנה תוכנית פשוטה המראה איך לעשות זאת.
package com.journaldev.java.string;
public class RemoveCharFromString {
public static void main(String[] args) {
removeCharFromString("abcbcdjfkd", 'c');
removeCharFromString("Pankaj", 'a');
removeCharFromString("ç∂©∂ç", '©');
}
private static void removeCharFromString(String input, char c) {
String result = input.replaceAll(String.valueOf(c), "");
System.out.println(result);
}
}
איך להוכיח באמצעות קוד שמחרוזת היא לא ניתנת לשינוי?
אנו יודעים ש־מחרוזת היא לא ניתנת לשינוי בְּג'אווה, אך מפתחים חדשים עדיין מתבלבלים בנוגע לכך. בואו נבין את הסיבה לפליאה זו.
String s1 = "Java";
s1 = "Python";
בקטע קוד שלמעלה, נוכל לומר שערך המחרוזת s1 השתנה וזהו אובייקט מחרוזת. אז איך אפשר לטעון שמחרוזת היא לא ניתנת לשינוי? הנקודה החשובה ביותר להבין היא איך מחרוזות נוצרות בג'אווה. כאשר אנו יוצרים מחרוזת באמצעות ליטרל מחרוזת, זה לא משנה את ערך המחרוזת המקורית. זה יוצר מחרוזת חדשה בבריכת המחרוזות ומשנה את ההפניה של המשתנה. לכן ערך המחרוזת המקורית לא משתנה ולכן מחרוזות הן לא ניתנות לשינוי. התוכנית למטה מוכיחה את דברינו, אנא קרא את ההערות להבנת המושג.
package com.journaldev.java.string;
public class StringImmutabilityTest {
public static void main(String[] args) {
String s1 = "Java"; // "Java" String created in pool and reference assigned to s1
String s2 = s1; //s2 is also having the same reference to "Java" in the pool
System.out.println(s1 == s2); // proof that s1 and s2 have same reference
s1 = "Python";
//s1 הערך של הערך שונה למעלה, לכן איך ניתן להסביר את כך שמחרוזת היא לא נעימה?
//במקרה שלמעלה נוצרה מחרוזת חדשה "Python" בבריכה
//s1 מצביע כעת על המחרוזת החדשה בבריכה
//אך, המחרוזת המקורית "Java" עדיין לא שונתה ונשארת בבריכה
//s2 עדיין מצביע על המחרוזת המקורית "Java" בבריכה
// הוכחה ש-s1 ו-s2 יש להם הפניה שונה
System.out.println(s1 == s2);
System.out.println(s2);
// מדפיס "Java" תומך בעובדה שערך המחרוזת המקורי לא שונה, לכן מחרוזת היא לא נעימה
}
}
כתוב תוכנית כדי לספור את מספר המילים במחרוזת?
הפתרון הפשוט לתוכנית זו נראה להיות input.split(" ").length אך זה לא יעבוד אם המחרוזת שלך אינה מעוצבת כראוי והיא מכילה רווחים מובילים ונותנים, רווחים כפולים וטאבים. למרבה המזל String split() פונקציה לוקחת ביטוי רגולרי כארגומנט ואנו יכולים להשתמש בו כדי לספור את מספר המילים במחרוזת.
package com.journaldev.java.string;
public class CountNumberOfWordsInString {
public static void main(String[] args) {
countNumberOfWords("My name is Pankaj");
countNumberOfWords("I Love Java Programming");
countNumberOfWords(" This is not properly formatted line ");
}
private static void countNumberOfWords(String line) {
//System.out.println(line.split(" ").length); //לא יעבוד עם טאבים ורווחים מרובים
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
כתוב תוכנית לבדיקה האם שני מחרוזות נוצרו עם אותם תווים?
לפני הכל, עלינו ליצור סט של תווים מהמחרוזות הקלט. לאחר מכן נשתמש בשיטת equals() של סט כדי לבדוק האם הן מכילות את אותם תווים או לא. הנה תוכנית פשוטה לבדיקה האם שתי מחרוזות נוצרו עם אותם תווים.
package com.journaldev.java.string;
import java.util.Set;
import java.util.stream.Collectors;
public class CheckSameCharsInString {
public static void main(String[] args) {
sameCharsStrings("abc", "cba");
sameCharsStrings("aabbcc", "abc");
sameCharsStrings("abcd", "abc");
sameCharsStrings("11", "1122");
sameCharsStrings("1122", "11");
}
private static void sameCharsStrings(String s1, String s2) {
Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
System.out.println(set1.equals(set2));
}
}
קראו קלט מהמשתמש עבור שתי מחרוזות ובדקו האם המחרוזת הראשונה מכילה את השנייה?
זוהי תוכנית פשוטה ונוכל להשתמש בשיטת contains() של מחרוזת כדי לבדוק האם המחרוזת המצויינת היא חלק מהמחרוזת הנוכחית. עם זאת, עלינו להשתמש במחלקת Scanner כדי לקרוא קלט מהמשתמש.
package com.journaldev.java.string;
import java.util.Scanner;
public class StringContainsSubstring {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
String s1 = scanner.nextLine();
System.out.println("Enter Second String:");
String s2 = scanner.nextLine();
scanner.close();
boolean result = stringContainsSubstring(s1, s2);
System.out.println(s1+" contains "+s2+" = "+result);
}
private static boolean stringContainsSubstring(String string, String substring) {
boolean result = false;
result = string.contains(substring);
return result;
}
}
הנה פלט דוגמה של התוכנית לעיל:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
כיצד להחליף שתי מחרוזות בלי להשתמש במשתנה שלישי?
אנחנו יכולים לעשות זאת באמצעות שימוש בפונקציית substring() של מחרוזת. הנה קטע קוד פשוט שמדגים זאת:
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
מה אם נרצה לכתוב פונקציה שתעשה זאת? מאחר ומחרוזת היא לא שינוית, השינוי בערכים של המצבי מחרוזות בתוך הפונקציה ייעלם מהר מאוד לאחר שהפונקציה מסתיימת. כמו כן, אין לנו אפשרות להחזיר ערכים מרובים מתוך פונקציה ב-Java. לכן עלינו ליצור תופסת כדי להחזיק את מחרוזות הקלט ולאחר מכן לבצע את הלוגיקה הנ"ל בתוך הפונקציה. בקטע הקוד למעלה מודגש כיצד ניתן לעשות זאת, אם כי זה עשוי להיראות מורכב, הלוגיקה זהה לזו שלמעלה.
package com.journaldev.java.string;
import java.util.Scanner;
public class SwapTwoStrings {
public static void main(String[] args) {
Container container = new Container();
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
container.setFirstString(scanner.nextLine());
System.out.println("Enter Second String:");
container.setSecondString(scanner.nextLine());
scanner.close();
System.out.println(container);
container = swapStrings(container);
System.out.println(container);
}
private static Container swapStrings(Container container) {
container.setFirstString(container.getFirstString().concat(container.getSecondString())); //s1 = s1+s2
container.setSecondString(container.getFirstString().substring(0, container.getFirstString().length()-container.getSecondString().length())); // s2=s1
container.setFirstString(container.getFirstString().substring(container.getSecondString().length()));
return container;
}
}
class Container{
private String firstString;
private String secondString;
public String getFirstString() {
return firstString;
}
public void setFirstString(String firstString) {
this.firstString = firstString;
}
public String getSecondString() {
return secondString;
}
public void setSecondString(String secondString) {
this.secondString = secondString;
}
@Override
public String toString() {
return "First String = "+firstString+", Second String = "+secondString;
}
}
פלט דוגמה:
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
כתוב תוכנית למציאת התו שאינו חוזר ראשון מתוך מחרוזת הקלט?
package com.journaldev.java.string;
import java.util.ArrayList;
import java.util.List;
public class FindNonRepeatingChar {
public static void main(String[] args) {
System.out.println(printFirstNonRepeatingChar("abcaabcdedxy"));
System.out.println(printFirstNonRepeatingChar("abca"));
System.out.println(printFirstNonRepeatingChar("aaa"));
}
private static Character printFirstNonRepeatingChar(String string) {
char[] chars = string.toCharArray();
List<Character> discardedChars = new ArrayList<>();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (discardedChars.contains(c))
continue;
for (int j = i + 1; j < chars.length; j++) {
if (c == chars[j]) { // match found
discardedChars.add(c);
break;
} else if (j == chars.length - 1) { // no match found till end
return c;
}
}
}
return null;
}
}
ספק שני דרכים לבדיקה אם מחרוזת מכילה רק ספרות?
ניתן להשתמש בביטוי רגולרי כדי לבדוק אם מחרוזת היא מספרית או לא. דרך נוספת היא לנתח את המחרוזת ל-Long ואם זהו מחרוזת לא מספרית אז זה יזרוק NumberFormatException.
package com.journaldev.java.string;
public class CheckIfStringContainsDigitsOnly {
public static void main(String[] args) {
digitsOnlyString("111");
digitsOnlyString("111a 1");
digitsOnlyString("111 222");
digitsOnlyString("111L");
}
private static void digitsOnlyString(String string) {
if(string.matches("\\d+")) System.out.println("Digit Only String ::"+string);
try {
long l = Long.parseLong(string);
System.out.println("Digit Only String ::"+string);
}catch(Exception e){
System.out.println("Non Digit Only String ::"+string);
}
}
}
איך לבצע העתק עמוק עבור מחרוזת?
מחרוזת היא לא ניתנת לשינוי, כך שאין צורך לדאוג להעתק עמוק או העתק שטחי. ניתן פשוט להשתמש באופרטור ההשמה (=) כדי להעתיק מחרוזת אחת לאחרת. לקריאת מידע נוסף ראה העתק של מחרוזת ב-Java.
ניתן להוריד את הדוגמאות מתיקיית ה-GitHub שלי GitHub Repository.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java