String manipulation is a fundamental skill that every programmer must master, especially when preparing for coding interviews at top tech companies. Whether you’re aiming for a position at a FAANG (Facebook, Amazon, Apple, Netflix, Google) company or any other tech giant, proficiency in string operations can make or break your performance during technical assessments. In this comprehensive guide, we’ll explore efficient techniques for string manipulation that will not only help you ace coding questions but also improve your overall programming skills.<\/p>\n
1. Understanding the Basics of Strings<\/h2>\n
Before diving into advanced techniques, it’s crucial to have a solid grasp of what strings are and how they’re represented in various programming languages.<\/p>\n
1.1 What is a String?<\/h3>\n
A string is a sequence of characters, typically used to represent text. In most programming languages, strings are immutable, meaning once created, their contents cannot be changed without creating a new string object.<\/p>\n
1.2 String Representation in Different Languages<\/h3>\n
Different programming languages handle strings in various ways:<\/p>\n
- \n
- Python:<\/strong> Strings are immutable sequences of Unicode characters.<\/li>\n
- Java:<\/strong> Strings are objects of the String class, which are also immutable.<\/li>\n
- C++:<\/strong> Strings can be represented using C-style char arrays or the std::string class.<\/li>\n
- JavaScript:<\/strong> Strings are primitive values and immutable.<\/li>\n<\/ul>\n
2. Essential String Operations<\/h2>\n
Let’s explore some fundamental string operations that form the building blocks of more complex manipulations.<\/p>\n
2.1 Accessing Characters<\/h3>\n
Most languages allow you to access individual characters in a string using index notation:<\/p>\n
\/\/ Python\ns = \"Hello\"\nprint(s[0]) # Output: H\n\n\/\/ Java\nString s = \"Hello\";\nSystem.out.println(s.charAt(0)); \/\/ Output: H\n\n\/\/ C++\nstring s = \"Hello\";\ncout << s[0] << endl; \/\/ Output: H\n\n\/\/ JavaScript\nlet s = \"Hello\";\nconsole.log(s[0]); \/\/ Output: H<\/code><\/pre>\n2.2 String Concatenation<\/h3>\n
Combining strings is a common operation:<\/p>\n
\/\/ Python\ns1 = \"Hello\"\ns2 = \"World\"\nresult = s1 + \" \" + s2 # Result: \"Hello World\"\n\n\/\/ Java\nString s1 = \"Hello\";\nString s2 = \"World\";\nString result = s1 + \" \" + s2; \/\/ Result: \"Hello World\"\n\n\/\/ C++\nstring s1 = \"Hello\";\nstring s2 = \"World\";\nstring result = s1 + \" \" + s2; \/\/ Result: \"Hello World\"\n\n\/\/ JavaScript\nlet s1 = \"Hello\";\nlet s2 = \"World\";\nlet result = s1 + \" \" + s2; \/\/ Result: \"Hello World\"<\/code><\/pre>\n2.3 Substring Extraction<\/h3>\n
Extracting a portion of a string is crucial for many string manipulation tasks:<\/p>\n
\/\/ Python\ns = \"Hello World\"\nsub = s[0:5] # Result: \"Hello\"\n\n\/\/ Java\nString s = \"Hello World\";\nString sub = s.substring(0, 5); \/\/ Result: \"Hello\"\n\n\/\/ C++\nstring s = \"Hello World\";\nstring sub = s.substr(0, 5); \/\/ Result: \"Hello\"\n\n\/\/ JavaScript\nlet s = \"Hello World\";\nlet sub = s.substring(0, 5); \/\/ Result: \"Hello\"<\/code><\/pre>\n3. Advanced String Manipulation Techniques<\/h2>\n
Now that we’ve covered the basics, let’s explore more advanced techniques that are often required in coding interviews.<\/p>\n
3.1 Reversing a String<\/h3>\n
Reversing a string is a common interview question. Here’s how you can do it efficiently:<\/p>\n
\/\/ Python\ndef reverse_string(s):\n return s[::-1]\n\n# Java\npublic String reverseString(String s) {\n return new StringBuilder(s).reverse().toString();\n}\n\n\/\/ C++\nstring reverseString(string s) {\n return string(s.rbegin(), s.rend());\n}\n\n\/\/ JavaScript\nfunction reverseString(s) {\n return s.split('').reverse().join('');\n}<\/code><\/pre>\n3.2 Checking for Palindromes<\/h3>\n
A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward. Here’s an efficient way to check for palindromes:<\/p>\n
\/\/ Python\ndef is_palindrome(s):\n return s == s[::-1]\n\n# Java\npublic boolean isPalindrome(String s) {\n int left = 0, right = s.length() - 1;\n while (left < right) {\n if (s.charAt(left) != s.charAt(right)) return false;\n left++;\n right--;\n }\n return true;\n}\n\n\/\/ C++\nbool isPalindrome(string s) {\n int left = 0, right = s.length() - 1;\n while (left < right) {\n if (s[left] != s[right]) return false;\n left++;\n right--;\n }\n return true;\n}\n\n\/\/ JavaScript\nfunction isPalindrome(s) {\n return s === s.split('').reverse().join('');\n}<\/code><\/pre>\n3.3 String Compression<\/h3>\n
String compression is another common interview question. The goal is to compress repeated characters:<\/p>\n
\/\/ Python\ndef compress_string(s):\n if not s:\n return s\n result = []\n count = 1\n for i in range(1, len(s)):\n if s[i] == s[i-1]:\n count += 1\n else:\n result.append(s[i-1] + str(count))\n count = 1\n result.append(s[-1] + str(count))\n compressed = ''.join(result)\n return compressed if len(compressed) < len(s) else s\n\n# Java\npublic String compressString(String s) {\n if (s == null || s.length() <= 1) return s;\n StringBuilder result = new StringBuilder();\n int count = 1;\n for (int i = 1; i < s.length(); i++) {\n if (s.charAt(i) == s.charAt(i-1)) {\n count++;\n } else {\n result.append(s.charAt(i-1)).append(count);\n count = 1;\n }\n }\n result.append(s.charAt(s.length()-1)).append(count);\n return result.length() < s.length() ? result.toString() : s;\n}\n\n\/\/ C++\nstring compressString(string s) {\n if (s.length() <= 1) return s;\n string result;\n int count = 1;\n for (int i = 1; i < s.length(); i++) {\n if (s[i] == s[i-1]) {\n count++;\n } else {\n result += s[i-1] + to_string(count);\n count = 1;\n }\n }\n result += s.back() + to_string(count);\n return result.length() < s.length() ? result : s;\n}\n\n\/\/ JavaScript\nfunction compressString(s) {\n if (s.length <= 1) return s;\n let result = '';\n let count = 1;\n for (let i = 1; i < s.length; i++) {\n if (s[i] === s[i-1]) {\n count++;\n } else {\n result += s[i-1] + count;\n count = 1;\n }\n }\n result += s[s.length-1] + count;\n return result.length < s.length ? result : s;\n}<\/code><\/pre>\n4. Using Regular Expressions for String Manipulation<\/h2>\n
Regular expressions (regex) are powerful tools for pattern matching and string manipulation. While they can be complex, mastering regex can significantly enhance your string manipulation skills.<\/p>\n
4.1 Basic Regex Operations<\/h3>\n
Here are some common regex operations:<\/p>\n
\/\/ Python\nimport re\n\n# Matching a pattern\npattern = r'\\d+' # Matches one or more digits\ntext = \"I have 123 apples and 456 oranges\"\nmatches = re.findall(pattern, text)\nprint(matches) # Output: ['123', '456']\n\n# Replacing a pattern\nnew_text = re.sub(r'\\d+', 'X', text)\nprint(new_text) # Output: \"I have X apples and X oranges\"\n\n\/\/ Java\nimport java.util.regex.*;\n\n\/\/ Matching a pattern\nPattern pattern = Pattern.compile(\"\\\\d+\");\nMatcher matcher = pattern.matcher(\"I have 123 apples and 456 oranges\");\nwhile (matcher.find()) {\n System.out.println(matcher.group());\n}\n\n\/\/ Replacing a pattern\nString newText = \"I have 123 apples and 456 oranges\".replaceAll(\"\\\\d+\", \"X\");\nSystem.out.println(newText);\n\n\/\/ C++\n#include <regex>\n#include <iostream>\n\n\/\/ Matching a pattern\nstd::string text = \"I have 123 apples and 456 oranges\";\nstd::regex pattern(\"\\\\d+\");\nstd::sregex_iterator iter(text.begin(), text.end(), pattern);\nstd::sregex_iterator end;\nwhile (iter != end) {\n std::cout << iter->str() << std::endl;\n ++iter;\n}\n\n\/\/ Replacing a pattern\nstd::string newText = std::regex_replace(text, pattern, \"X\");\nstd::cout << newText << std::endl;\n\n\/\/ JavaScript\n\/\/ Matching a pattern\nlet text = \"I have 123 apples and 456 oranges\";\nlet matches = text.match(\/\\d+\/g);\nconsole.log(matches); \/\/ Output: ['123', '456']\n\n\/\/ Replacing a pattern\nlet newText = text.replace(\/\\d+\/g, 'X');\nconsole.log(newText); \/\/ Output: \"I have X apples and X oranges\"<\/code><\/pre>\n4.2 Advanced Regex Techniques<\/h3>\n
For more complex string manipulations, you can use advanced regex features like lookaheads, lookbehinds, and capturing groups. Here’s an example of using a positive lookahead to find words followed by specific punctuation:<\/p>\n
\/\/ Python\nimport re\n\ntext = \"Hello, world! How are you? I'm fine.\"\npattern = r'\\b\\w+(?=[,.?!])'\nmatches = re.findall(pattern, text)\nprint(matches) # Output: ['Hello', 'world', 'you', 'fine']\n\n\/\/ Java\nimport java.util.regex.*;\n\nString text = \"Hello, world! How are you? I'm fine.\";\nPattern pattern = Pattern.compile(\"\\\\b\\\\w+(?=[,.?!])\");\nMatcher matcher = pattern.matcher(text);\nwhile (matcher.find()) {\n System.out.println(matcher.group());\n}\n\n\/\/ C++\n#include <regex>\n#include <iostream>\n\nstd::string text = \"Hello, world! How are you? I'm fine.\";\nstd::regex pattern(\"\\\\b\\\\w+(?=[,.?!])\");\nstd::sregex_iterator iter(text.begin(), text.end(), pattern);\nstd::sregex_iterator end;\nwhile (iter != end) {\n std::cout << iter->str() << std::endl;\n ++iter;\n}\n\n\/\/ JavaScript\nlet text = \"Hello, world! How are you? I'm fine.\";\nlet matches = text.match(\/\\b\\w+(?=[,.?!])\/g);\nconsole.log(matches); \/\/ Output: ['Hello', 'world', 'you', 'fine']<\/code><\/pre>\n5. Optimizing String Manipulation for Performance<\/h2>\n
When working with large strings or performing many string operations, performance becomes crucial. Here are some tips to optimize your string manipulation code:<\/p>\n
5.1 Use StringBuilder or StringBuffer in Java<\/h3>\n
For concatenating many strings, use StringBuilder (for single-threaded operations) or StringBuffer (for thread-safe operations) instead of the + operator:<\/p>\n
\/\/ Less efficient\nString result = \"\";\nfor (int i = 0; i < 1000; i++) {\n result += \"a\";\n}\n\n\/\/ More efficient\nStringBuilder sb = new StringBuilder();\nfor (int i = 0; i < 1000; i++) {\n sb.append(\"a\");\n}\nString result = sb.toString();<\/code><\/pre>\n5.2 Use join() Method for Concatenating Multiple Strings<\/h3>\n
When concatenating a list of strings, use the join() method (available in many languages) instead of a loop:<\/p>\n
\/\/ Python\nstrings = [\"Hello\", \"World\", \"!\"]\nresult = \" \".join(strings) # Result: \"Hello World !\"\n\n\/\/ Java\nString[] strings = {\"Hello\", \"World\", \"!\"};\nString result = String.join(\" \", strings); \/\/ Result: \"Hello World !\"\n\n\/\/ C++\nvector<string> strings = {\"Hello\", \"World\", \"!\"};\nstring result = boost::algorithm::join(strings, \" \"); \/\/ Result: \"Hello World !\"\n\n\/\/ JavaScript\nlet strings = [\"Hello\", \"World\", \"!\"];\nlet result = strings.join(\" \"); \/\/ Result: \"Hello World !\"<\/code><\/pre>\n5.3 Use Appropriate Data Structures<\/h3>\n
Sometimes, using a different data structure can lead to more efficient string manipulation. For example, when you need to perform many insertions or deletions in the middle of a string, consider using a list of characters instead of a string:<\/p>\n
\/\/ Python\n# Less efficient for many insertions\ns = \"Hello World\"\ns = s[:5] + \"Beautiful \" + s[5:]\n\n# More efficient\ns_list = list(\"Hello World\")\ns_list[5:5] = list(\"Beautiful \")\nresult = \"\".join(s_list)\n\n\/\/ Java\n\/\/ Less efficient for many insertions\nString s = \"Hello World\";\ns = s.substring(0, 5) + \"Beautiful \" + s.substring(5);\n\n\/\/ More efficient\nList<Character> sList = new ArrayList<>();\nfor (char c : \"Hello World\".toCharArray()) {\n sList.add(c);\n}\nsList.addAll(5, Arrays.asList('B', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l', ' '));\nStringBuilder sb = new StringBuilder();\nfor (Character c : sList) {\n sb.append(c);\n}\nString result = sb.toString();<\/code><\/pre>\n6. Common String Manipulation Interview Questions<\/h2>\n
To help you prepare for coding interviews, here are some common string manipulation questions you might encounter:<\/p>\n
6.1 Longest Palindromic Substring<\/h3>\n
Find the longest palindromic substring in a given string.<\/p>\n
\/\/ Python\ndef longest_palindrome(s):\n if not s:\n return \"\"\n start, max_len = 0, 1\n for i in range(len(s)):\n len1 = expand_around_center(s, i, i)\n len2 = expand_around_center(s, i, i + 1)\n length = max(len1, len2)\n if length > max_len:\n start = i - (length - 1) \/\/ 2\n max_len = length\n return s[start:start+max_len]\n\ndef expand_around_center(s, left, right):\n while left >= 0 and right < len(s) and s[left] == s[right]:\n left -= 1\n right += 1\n return right - left - 1\n\n# Test\nprint(longest_palindrome(\"babad\")) # Output: \"bab\" or \"aba\"\nprint(longest_palindrome(\"cbbd\")) # Output: \"bb\"<\/code><\/pre>\n6.2 Valid Anagram<\/h3>\n
Determine if two strings are anagrams of each other (contain the same characters in a different order).<\/p>\n
\/\/ Java\npublic boolean isAnagram(String s, String t) {\n if (s.length() != t.length()) return false;\n int[] count = new int[26];\n for (int i = 0; i < s.length(); i++) {\n count[s.charAt(i) - 'a']++;\n count[t.charAt(i) - 'a']--;\n }\n for (int i : count) {\n if (i != 0) return false;\n }\n return true;\n}\n\n\/\/ Test\nSystem.out.println(isAnagram(\"anagram\", \"nagaram\")); \/\/ Output: true\nSystem.out.println(isAnagram(\"rat\", \"car\")); \/\/ Output: false<\/code><\/pre>\n6.3 Implement strStr()<\/h3>\n
Implement a function that finds the first occurrence of a substring in a string (similar to the strstr() function in C).<\/p>\n
\/\/ C++\nclass Solution {\npublic:\n int strStr(string haystack, string needle) {\n if (needle.empty()) return 0;\n int m = haystack.length(), n = needle.length();\n for (int i = 0; i <= m - n; i++) {\n int j;\n for (j = 0; j < n; j++) {\n if (haystack[i+j] != needle[j]) break;\n }\n if (j == n) return i;\n }\n return -1;\n }\n};\n\n\/\/ Test\nSolution sol;\ncout << sol.strStr(\"hello\", \"ll\") << endl; \/\/ Output: 2\ncout << sol.strStr(\"aaaaa\", \"bba\") << endl; \/\/ Output: -1<\/code><\/pre>\n7. Advanced String Algorithms<\/h2>\n
For those aiming for top tech companies, it’s beneficial to be familiar with more advanced string algorithms. While these might not come up in every interview, understanding them can give you an edge and help you solve complex string problems more efficiently.<\/p>\n
7.1 KMP Algorithm<\/h3>\n
The Knuth-Morris-Pratt (KMP) algorithm is an efficient string matching algorithm that can find all occurrences of a pattern string within a main text string in linear time complexity.<\/p>\n
\/\/ JavaScript\nfunction KMP(text, pattern) {\n let lps = computeLPS(pattern);\n let i = 0, j = 0;\n let results = [];\n\n while (i < text.length) {\n if (pattern[j] === text[i]) {\n i++;\n j++;\n }\n\n if (j === pattern.length) {\n results.push(i - j);\n j = lps[j - 1];\n } else if (i < text.length && pattern[j] !== text[i]) {\n if (j !== 0) {\n j = lps[j - 1];\n } else {\n i++;\n }\n }\n }\n\n return results;\n}\n\nfunction computeLPS(pattern) {\n let lps = [0];\n let len = 0;\n let i = 1;\n\n while (i < pattern.length) {\n if (pattern[i] === pattern[len]) {\n len++;\n lps[i] = len;\n i++;\n } else {\n if (len !== 0) {\n len = lps[len - 1];\n } else {\n lps[i] = 0;\n i++;\n }\n }\n }\n\n return lps;\n}\n\n\/\/ Test\nconsole.log(KMP(\"ABABDABACDABABCABAB\", \"ABABCABAB\")); \/\/ Output: [10]<\/code><\/pre>\n7.2 Rabin-Karp Algorithm<\/h3>\n
The Rabin-Karp algorithm is another string matching algorithm that uses hashing to find patterns in strings.<\/p>\n
\/\/ Python\ndef rabin_karp(text, pattern):\n n, m = len(text), len(pattern)\n p, t = 0, 0 # hash value for pattern and text\n h = 1\n d = 256 # number of characters in the input alphabet\n q = 101 # a prime number\n\n # The value of h would be \"pow(d, m-1) % q\"\n for i in range(m-1):\n h = (h * d) % q\n\n # Calculate the hash value of pattern and first window of text\n for i in range(m):\n p = (d * p + ord(pattern[i])) % q\n t = (d * t + ord(text[i])) % q\n\n results = []\n # Slide the pattern over text one by one\n for i in range(n - m + 1):\n # Check the hash values of current window of text and pattern\n # If the hash values match then only check for characters one by one\n if p == t:\n # Check for characters one by one\n if text[i:i+m] == pattern:\n results.append(i)\n\n # Calculate hash value for next window of text: Remove leading digit,\n # add trailing digit\n if i < n - m:\n t = (d * (t - ord(text[i]) * h) + ord(text[i + m])) % q\n\n # We might get negative values of t, converting it to positive\n if t < 0:\n t = t + q\n\n return results\n\n# Test\nprint(rabin_karp(\"ABABDABACDABABCABAB\", \"ABABCABAB\")) # Output: [10]<\/code><\/pre>\n7.3 Suffix Array and LCP Array<\/h3>\n
Suffix arrays and Longest Common Prefix (LCP) arrays are powerful data structures for string processing. They can be used to solve various string problems efficiently.<\/p>\n
\/\/ Java\nimport java.util.*;\n\nclass SuffixArray {\n public static int[] buildSuffixArray(String s) {\n int n = s.length();\n Integer[] order = new Integer[n];\n for (int i = 0; i < n; i++) order[i] = i;\n Arrays.sort(order, (a, b) -> s.charAt(a) - s.charAt(b));\n\n int[] clazz = new int[n];\n clazz[order[0]] = 0;\n for (int i = 1; i < n; i++) {\n clazz[order[i]] = clazz[order[i-1]];\n if (s.charAt(order[i]) != s.charAt(order[i-1])) {\n clazz[order[i]]++;\n }\n }\n\n for (int k = 0; (1 << k) < n; k++) {\n int[] c = clazz.clone();\n for (int i = 0; i < n; i++) {\n order[i] = (order[i] - (1 << k) + n) % n;\n }\n countSort(order, c);\n\n clazz[order[0]] = 0;\n for (int i = 1; i < n; i++) {\n int mid1 = (order[i] + (1 << k)) % n;\n int mid2 = (order[i-1] + (1 << k)) % n;\n clazz[order[i]] = clazz[order[i-1]];\n if (c[order[i]] != c[order[i-1]] || c[mid1] != c[mid2]) {\n clazz[order[i]]++;\n }\n }\n }\n\n int[] suffixArray = new int[n];\n for (int i = 0; i < n; i++) suffixArray[i] = order[i];\n return suffixArray;\n }\n\n private static void countSort(Integer[] p, int[] c) {\n int n = p.length;\n int[] cnt = new int[n];\n for (int x : c) cnt[x]++;\n int[] p_new = new int[n];\n int[] pos = new int[n];\n pos[0] = 0;\n for (int i = 1; i < n; i++) pos[i] = pos[i-1] + cnt[i-1];\n for (int x : p) {\n int i = c[x];\n p_new[pos[i]] = x;\n pos[i]++;\n }\n System.arraycopy(p_new, 0, p, 0, n);\n }\n\n public static int[] buildLCP(String s, int[] suffixArray) {\n int n = s.length();\n int[] rank = new int[n];\n for (int i = 0; i < n; i++) rank[suffixArray[i]] = i;\n\n int k = 0;\n int[] lcp = new int[n-1];\n for (int i = 0; i < n; i++) {\n if (rank[i] == n - 1) {\n k = 0;\n continue;\n }\n int j = suffixArray[rank[i] + 1];\n while (i + k < n && j + k < n && s.charAt(i+k) == s.charAt(j+k)) k++;\n lcp[rank[i]] = k;\n if (k > 0) k--;\n }\n return lcp;\n }\n\n public static void main(String[] args) {\n String s = \"banana$\";\n int[] suffixArray = buildSuffixArray(s);\n int[] lcp = buildLCP(s, suffixArray);\n\n System.out.println(\"Suffix Array:\");\n for (int i : suffixArray) System.out.print(i + \" \");\n System.out.println(\"\\nLCP Array:\");\n for (int i : lcp) System.out.print(i + \" \");\n }\n}<\/code><\/pre>\n8. Conclusion<\/h2>\n
Mastering string manipulation techniques is crucial for success in coding interviews, especially when aiming for positions at top tech companies. By understanding the fundamentals, learning advanced algorithms, and practicing with common interview questions, you’ll be well-prepared to tackle any string-related problem that comes your way.<\/p>\n
Remember, the key to excelling in string manipulation (and coding interviews in general) is not just knowing the algorithms, but understanding when and how to apply them efficiently. Always consider the time and space complexity of your solutions, and be prepared to discuss trade-offs between different approaches.<\/p>\n
As you continue your journey in coding education and programming skills development, platforms like AlgoCademy can provide valuable resources and interactive coding tutorials to help you hone your skills. With consistent practice and a solid understanding of these techniques, you’ll be well-equipped to handle string manipulation challenges in your technical interviews and future coding projects.<\/p>\n
Keep coding, keep learning, and best of luck in your programming journey!<\/p>\n<\/article>\n
<\/body><\/html><\/p>\n","protected":false},"excerpt":{"rendered":"
String manipulation is a fundamental skill that every programmer must master, especially when preparing for coding interviews at top tech…<\/p>\n","protected":false},"author":1,"featured_media":5518,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[],"class_list":["post-5519","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-problem-solving"],"_links":{"self":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/5519"}],"collection":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/comments?post=5519"}],"version-history":[{"count":0,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/5519\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media\/5518"}],"wp:attachment":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media?parent=5519"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/categories?post=5519"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/tags?post=5519"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Java:<\/strong> Strings are objects of the String class, which are also immutable.<\/li>\n