{"id":7189,"date":"2025-02-13T09:04:13","date_gmt":"2025-02-13T09:04:13","guid":{"rendered":"https:\/\/algocademy.com\/blog\/string-to-int-in-java-a-comprehensive-guide\/"},"modified":"2025-02-13T09:04:13","modified_gmt":"2025-02-13T09:04:13","slug":"string-to-int-in-java-a-comprehensive-guide","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/string-to-int-in-java-a-comprehensive-guide\/","title":{"rendered":"String to Int in Java: A Comprehensive Guide"},"content":{"rendered":"


\n<\/p>\n

Converting a string to an integer is a common task in Java programming. Whether you’re working with user input, parsing data from files, or manipulating strings in various ways, knowing how to efficiently and safely convert strings to integers is essential. In this comprehensive guide, we’ll explore multiple methods to perform this conversion, discuss their pros and cons, and provide practical examples to help you master this fundamental skill.<\/p>\n

Table of Contents<\/h2>\n
    \n
  1. Introduction<\/a><\/li>\n
  2. Using Integer.parseInt()<\/a><\/li>\n
  3. Using Integer.valueOf()<\/a><\/li>\n
  4. Handling NumberFormatException<\/a><\/li>\n
  5. Implementing Your Own atoi() Method<\/a><\/li>\n
  6. Using Scanner Class<\/a><\/li>\n
  7. Using Character Class Methods<\/a><\/li>\n
  8. Best Practices and Performance Considerations<\/a><\/li>\n
  9. Common Pitfalls and How to Avoid Them<\/a><\/li>\n
  10. Advanced Techniques and Edge Cases<\/a><\/li>\n
  11. Conclusion<\/a><\/li>\n<\/ol>\n

    1. Introduction<\/h2>\n

    Converting strings to integers is a fundamental operation in Java programming. It’s often necessary when dealing with user input, reading data from files, or processing text-based information. Java provides several built-in methods to perform this conversion, each with its own advantages and use cases.<\/p>\n

    In this article, we’ll cover the most common and efficient ways to convert strings to integers in Java, including:<\/p>\n

      \n
    • Using Integer.parseInt()<\/li>\n
    • Using Integer.valueOf()<\/li>\n
    • Handling exceptions<\/li>\n
    • Implementing a custom atoi() method<\/li>\n
    • Using the Scanner class<\/li>\n
    • Leveraging Character class methods<\/li>\n<\/ul>\n

      We’ll also discuss best practices, performance considerations, and how to handle edge cases and potential errors.<\/p>\n

      2. Using Integer.parseInt()<\/h2>\n

      The most straightforward and commonly used method to convert a string to an integer in Java is the Integer.parseInt()<\/code> method. This method takes a string as input and returns the corresponding integer value.<\/p>\n

      Basic Usage<\/h3>\n
      String strNumber = \"123\";\nint number = Integer.parseInt(strNumber);\nSystem.out.println(\"Converted integer: \" + number);\n<\/code><\/pre>\n
      Output:<\/p>\n
      Converted integer: 123<\/code><\/pre>\n
      Handling Different Radixes<\/h3>\n
      The parseInt()<\/code> method also allows you to specify the radix (base) of the number system. This is particularly useful when dealing with numbers in different bases, such as binary, octal, or hexadecimal.<\/p>\n
      String binaryString = \"1010\";\nint binaryToDecimal = Integer.parseInt(binaryString, 2);\nSystem.out.println(\"Binary to Decimal: \" + binaryToDecimal);\n\nString hexString = \"1A\";\nint hexToDecimal = Integer.parseInt(hexString, 16);\nSystem.out.println(\"Hex to Decimal: \" + hexToDecimal);\n<\/code><\/pre>\n
      Output:<\/p>\n
      Binary to Decimal: 10\nHex to Decimal: 26<\/code><\/pre>\n
      Advantages of Integer.parseInt()<\/h3>\n
        \n
      • Simple and straightforward to use<\/li>\n
      • Supports different radixes<\/li>\n
      • Returns a primitive int, which is more memory-efficient for simple use cases<\/li>\n<\/ul>\n
        Disadvantages of Integer.parseInt()<\/h3>\n
          \n
        • Throws NumberFormatException if the input is not a valid integer<\/li>\n
        • Cannot handle null inputs<\/li>\n<\/ul>\n
          3. Using Integer.valueOf()<\/h2>\n
          Another common method for converting strings to integers is Integer.valueOf()<\/code>. This method is similar to parseInt()<\/code>, but it returns an Integer object instead of a primitive int.<\/p>\n
          Basic Usage<\/h3>\n
          String strNumber = \"456\";\nInteger number = Integer.valueOf(strNumber);\nSystem.out.println(\"Converted integer: \" + number);\n<\/code><\/pre>\n
          Output:<\/p>\n
          Converted integer: 456<\/code><\/pre>\n
          Advantages of Integer.valueOf()<\/h3>\n
            \n
          • Returns an Integer object, which can be useful in certain contexts (e.g., when working with collections)<\/li>\n
          • Caches frequently used integer values (-128 to 127) for better performance<\/li>\n
          • Can be used directly in autoboxing contexts<\/li>\n<\/ul>\n
            Disadvantages of Integer.valueOf()<\/h3>\n
              \n
            • Slightly slower than parseInt() for values outside the cached range<\/li>\n
            • Still throws NumberFormatException for invalid inputs<\/li>\n<\/ul>\n
              When to Use valueOf() vs parseInt()<\/h3>\n
              Choose valueOf()<\/code> when:<\/p>\n
                \n
              • You need an Integer object rather than a primitive int<\/li>\n
              • You’re working with values that are likely to be in the cached range (-128 to 127)<\/li>\n
              • You’re using the result in a context that requires autoboxing<\/li>\n<\/ul>\n
                Choose parseInt()<\/code> when:<\/p>\n
                  \n
                • You need a primitive int<\/li>\n
                • You’re working with a large number of conversions and performance is critical<\/li>\n
                • You’re dealing with values outside the cached range<\/li>\n<\/ul>\n
                  4. Handling NumberFormatException<\/h2>\n
                  Both Integer.parseInt()<\/code> and Integer.valueOf()<\/code> can throw a NumberFormatException if the input string is not a valid integer. It’s important to handle this exception to prevent your program from crashing when dealing with potentially invalid input.<\/p>\n
                  Basic Exception Handling<\/h3>\n
                  String input = \"123abc\";\ntry {\n    int number = Integer.parseInt(input);\n    System.out.println(\"Converted number: \" + number);\n} catch (NumberFormatException e) {\n    System.out.println(\"Invalid input: \" + input);\n}\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  Invalid input: 123abc<\/code><\/pre>\n
                  Creating a Safe Conversion Method<\/h3>\n
                  You can create a utility method that safely converts a string to an integer, returning a default value if the conversion fails:<\/p>\n
                  public static int safeParseInt(String str, int defaultValue) {\n    try {\n        return Integer.parseInt(str);\n    } catch (NumberFormatException e) {\n        return defaultValue;\n    }\n}\n\n\/\/ Usage\nString validInput = \"789\";\nString invalidInput = \"456def\";\n\nint result1 = safeParseInt(validInput, 0);\nint result2 = safeParseInt(invalidInput, -1);\n\nSystem.out.println(\"Result 1: \" + result1);\nSystem.out.println(\"Result 2: \" + result2);\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  Result 1: 789\nResult 2: -1<\/code><\/pre>\n
                  5. Implementing Your Own atoi() Method<\/h2>\n
                  While Java provides built-in methods for string to integer conversion, implementing your own atoi()<\/code> (ASCII to Integer) method can be a valuable exercise in understanding the conversion process and handling edge cases.<\/p>\n
                  Basic atoi() Implementation<\/h3>\n
                  public static int atoi(String str) {\n    if (str == null || str.length() == 0) {\n        return 0;\n    }\n\n    int index = 0;\n    int result = 0;\n    int sign = 1;\n\n    \/\/ Handle whitespace\n    while (index < str.length() && Character.isWhitespace(str.charAt(index))) {\n        index++;\n    }\n\n    \/\/ Handle sign\n    if (index < str.length() && (str.charAt(index) == '+' || str.charAt(index) == '-')) {\n        sign = (str.charAt(index) == '+') ? 1 : -1;\n        index++;\n    }\n\n    \/\/ Convert digits\n    while (index < str.length() && Character.isDigit(str.charAt(index))) {\n        int digit = str.charAt(index) - '0';\n        \n        \/\/ Check for overflow\n        if (result > Integer.MAX_VALUE \/ 10 || (result == Integer.MAX_VALUE \/ 10 && digit > Integer.MAX_VALUE % 10)) {\n            return (sign == 1) ? Integer.MAX_VALUE : Integer.MIN_VALUE;\n        }\n        \n        result = result * 10 + digit;\n        index++;\n    }\n\n    return sign * result;\n}\n\n\/\/ Usage\nSystem.out.println(atoi(\"   -42\"));\nSystem.out.println(atoi(\"4193 with words\"));\nSystem.out.println(atoi(\"-91283472332\"));\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  -42\n4193\n-2147483648<\/code><\/pre>\n
                  This implementation handles several edge cases:<\/p>\n
                    \n
                  • Leading whitespace<\/li>\n
                  • Positive and negative signs<\/li>\n
                  • Overflow conditions<\/li>\n
                  • Invalid characters after the number<\/li>\n<\/ul>\n
                    6. Using Scanner Class<\/h2>\n
                    The Scanner class in Java provides a convenient way to parse various types of input, including integers. While it’s more commonly used for reading input from the console or files, it can also be used to parse strings.<\/p>\n
                    Basic Usage of Scanner for String to Int Conversion<\/h3>\n
                    import java.util.Scanner;\n\npublic class ScannerExample {\n    public static void main(String[] args) {\n        String input = \"123 456 789\";\n        Scanner scanner = new Scanner(input);\n\n        while (scanner.hasNextInt()) {\n            int number = scanner.nextInt();\n            System.out.println(\"Scanned integer: \" + number);\n        }\n\n        scanner.close();\n    }\n}\n<\/code><\/pre>\n
                    Output:<\/p>\n
                    Scanned integer: 123\nScanned integer: 456\nScanned integer: 789<\/code><\/pre>\n
                    Advantages of Using Scanner<\/h3>\n
                      \n
                    • Can parse multiple integers from a single string<\/li>\n
                    • Handles whitespace automatically<\/li>\n
                    • Can be used to parse other data types as well (e.g., float, double)<\/li>\n<\/ul>\n
                      Disadvantages of Using Scanner<\/h3>\n
                        \n
                      • More overhead compared to parseInt() or valueOf() for simple conversions<\/li>\n
                      • Requires proper resource management (closing the Scanner)<\/li>\n<\/ul>\n
                        7. Using Character Class Methods<\/h2>\n
                        For more fine-grained control over the conversion process, you can use methods from the Character class to manually convert each digit in the string to its integer value.<\/p>\n
                        Manual Conversion Using Character Methods<\/h3>\n
                        public static int stringToInt(String str) {\n    if (str == null || str.isEmpty()) {\n        throw new IllegalArgumentException(\"Input string is null or empty\");\n    }\n\n    int result = 0;\n    boolean isNegative = false;\n    int i = 0;\n\n    \/\/ Handle sign\n    if (str.charAt(0) == '-') {\n        isNegative = true;\n        i = 1;\n    } else if (str.charAt(0) == '+') {\n        i = 1;\n    }\n\n    \/\/ Convert digits\n    for (; i < str.length(); i++) {\n        char c = str.charAt(i);\n        if (!Character.isDigit(c)) {\n            throw new NumberFormatException(\"Invalid character in input: \" + c);\n        }\n        int digit = Character.getNumericValue(c);\n        result = result * 10 + digit;\n    }\n\n    return isNegative ? -result : result;\n}\n\n\/\/ Usage\nSystem.out.println(stringToInt(\"-12345\"));\nSystem.out.println(stringToInt(\"+9876\"));\nSystem.out.println(stringToInt(\"42\"));\n<\/code><\/pre>\n
                        Output:<\/p>\n
                        -12345\n9876\n42<\/code><\/pre>\n
                        Advantages of Manual Conversion<\/h3>\n
                          \n
                        • Complete control over the conversion process<\/li>\n
                        • Can implement custom error handling and validation<\/li>\n
                        • Useful for educational purposes or when working with non-standard number formats<\/li>\n<\/ul>\n
                          Disadvantages of Manual Conversion<\/h3>\n
                            \n
                          • More complex and error-prone than using built-in methods<\/li>\n
                          • May be less efficient for simple use cases<\/li>\n
                          • Requires careful implementation to handle all edge cases<\/li>\n<\/ul>\n
                            8. Best Practices and Performance Considerations<\/h2>\n
                            When converting strings to integers in Java, it’s important to follow best practices and consider performance implications. Here are some guidelines to keep in mind:<\/p>\n
                            1. Use the Right Method for Your Needs<\/h3>\n
                              \n
                            • Use Integer.parseInt()<\/code> for simple conversions to primitive int<\/li>\n
                            • Use Integer.valueOf()<\/code> when you need an Integer object or are working with values likely to be in the cache range (-128 to 127)<\/li>\n
                            • Use custom implementations only when necessary for specific requirements<\/li>\n<\/ul>\n
                              2. Handle Exceptions Properly<\/h3>\n
                                \n
                              • Always catch and handle NumberFormatException when using parseInt() or valueOf()<\/li>\n
                              • Consider creating utility methods that provide safe conversion with default values<\/li>\n<\/ul>\n
                                3. Validate Input<\/h3>\n
                                  \n
                                • Check for null or empty strings before conversion<\/li>\n
                                • Implement appropriate input validation based on your application’s requirements<\/li>\n<\/ul>\n
                                  4. Consider Performance<\/h3>\n
                                    \n
                                  • For high-performance scenarios, benchmark different methods to find the best fit<\/li>\n
                                  • Be aware of autoboxing overhead when using Integer objects<\/li>\n
                                  • Use primitive ints when possible to avoid unnecessary object creation<\/li>\n<\/ul>\n
                                    5. Use Appropriate Radix<\/h3>\n
                                      \n
                                    • Specify the correct radix when dealing with numbers in different bases<\/li>\n
                                    • Be cautious when parsing user input with different radixes<\/li>\n<\/ul>\n
                                      6. Handle Overflow<\/h3>\n
                                        \n
                                      • Be aware of integer overflow when dealing with large numbers<\/li>\n
                                      • Consider using long or BigInteger for very large numbers<\/li>\n<\/ul>\n
                                        9. Common Pitfalls and How to Avoid Them<\/h2>\n
                                        When converting strings to integers, there are several common pitfalls that developers may encounter. Being aware of these issues and knowing how to avoid them can help you write more robust and error-free code.<\/p>\n
                                        1. Ignoring NumberFormatException<\/h3>\n
                                        Pitfall:<\/strong> Not catching NumberFormatException can lead to unexpected program termination.<\/p>\n
                                        Solution:<\/strong> Always handle NumberFormatException, either by catching it explicitly or by using a safe conversion method.<\/p>\n
                                        public static int safeParseInt(String str) {\n    try {\n        return Integer.parseInt(str);\n    } catch (NumberFormatException e) {\n        System.err.println(\"Invalid number format: \" + str);\n        return 0; \/\/ or any other default value\n    }\n}\n<\/code><\/pre>\n
                                        2. Not Handling Null or Empty Strings<\/h3>\n
                                        Pitfall:<\/strong> Attempting to parse null or empty strings will result in exceptions.<\/p>\n
                                        Solution:<\/strong> Check for null or empty strings before parsing.<\/p>\n
                                        public static int parseIntSafely(String str) {\n    if (str == null || str.isEmpty()) {\n        return 0; \/\/ or throw an exception, or return a special value\n    }\n    return Integer.parseInt(str);\n}\n<\/code><\/pre>\n
                                        3. Ignoring Leading\/Trailing Whitespace<\/h3>\n
                                        Pitfall:<\/strong> Extra whitespace can cause parsing errors.<\/p>\n
                                        Solution:<\/strong> Trim the input string before parsing.<\/p>\n
                                        String input = \"  123  \";\nint number = Integer.parseInt(input.trim());\n<\/code><\/pre>\n
                                        4. Overlooking Locale-Specific Formatting<\/h3>\n
                                        Pitfall:<\/strong> Different locales may use different number formats (e.g., commas as decimal separators).<\/p>\n
                                        Solution:<\/strong> Use NumberFormat for locale-aware parsing.<\/p>\n
                                        import java.text.NumberFormat;\nimport java.text.ParseException;\nimport java.util.Locale;\n\npublic static int parseLocaleInt(String str, Locale locale) throws ParseException {\n    NumberFormat format = NumberFormat.getInstance(locale);\n    return format.parse(str).intValue();\n}\n\n\/\/ Usage\nint number = parseLocaleInt(\"1.234\", Locale.GERMAN); \/\/ Parses as 1234\n<\/code><\/pre>\n
                                        5. Not Considering Integer Overflow<\/h3>\n
                                        Pitfall:<\/strong> Parsing very large numbers can lead to integer overflow.<\/p>\n
                                        Solution:<\/strong> Use long or BigInteger for large numbers, or implement overflow checking.<\/p>\n
                                        public static int parseIntWithOverflowCheck(String str) {\n    long result = Long.parseLong(str);\n    if (result < Integer.MIN_VALUE || result > Integer.MAX_VALUE) {\n        throw new ArithmeticException(\"Integer overflow\");\n    }\n    return (int) result;\n}\n<\/code><\/pre>\n
                                        6. Incorrect Radix Usage<\/h3>\n
                                        Pitfall:<\/strong> Using the wrong radix can lead to incorrect parsing.<\/p>\n
                                        Solution:<\/strong> Always specify the correct radix when parsing non-decimal numbers.<\/p>\n
                                        String binaryString = \"1010\";\nint binaryNumber = Integer.parseInt(binaryString, 2);\n\nString hexString = \"1A\";\nint hexNumber = Integer.parseInt(hexString, 16);\n<\/code><\/pre>\n
                                        10. Advanced Techniques and Edge Cases<\/h2>\n
                                        While the basic methods for converting strings to integers cover most common scenarios, there are some advanced techniques and edge cases that you might encounter in more complex situations. Let’s explore some of these scenarios and how to handle them.<\/p>\n
                                        1. Parsing Numbers with Thousand Separators<\/h3>\n
                                        When dealing with large numbers, you might encounter strings with thousand separators (e.g., “1,000,000”). Here’s how you can handle such cases:<\/p>\n
                                        import java.text.NumberFormat;\nimport java.text.ParseException;\nimport java.util.Locale;\n\npublic static int parseNumberWithSeparators(String str) throws ParseException {\n    NumberFormat format = NumberFormat.getInstance(Locale.US);\n    Number number = format.parse(str);\n    return number.intValue();\n}\n\n\/\/ Usage\nString largeNumber = \"1,234,567\";\nint result = parseNumberWithSeparators(largeNumber);\nSystem.out.println(\"Parsed number: \" + result);\n<\/code><\/pre>\n
                                        2. Handling Scientific Notation<\/h3>\n
                                        Sometimes, numbers might be represented in scientific notation (e.g., “1.23e4”). Here’s how to parse such strings:<\/p>\n
                                        public static int parseScientificNotation(String str) {\n    double doubleValue = Double.parseDouble(str);\n    return (int) doubleValue;\n}\n\n\/\/ Usage\nString scientificNumber = \"1.23e4\";\nint result = parseScientificNotation(scientificNumber);\nSystem.out.println(\"Parsed scientific notation: \" + result);\n<\/code><\/pre>\n
                                        3. Custom Number Formats<\/h3>\n
                                        For more complex number formats, you can use DecimalFormat with a custom pattern:<\/p>\n
                                        import java.text.DecimalFormat;\nimport java.text.ParseException;\n\npublic static int parseCustomFormat(String str, String pattern) throws ParseException {\n    DecimalFormat format = new DecimalFormat(pattern);\n    Number number = format.parse(str);\n    return number.intValue();\n}\n\n\/\/ Usage\nString customNumber = \"(12345)\";\nint result = parseCustomFormat(customNumber, \"(#)\");\nSystem.out.println(\"Parsed custom format: \" + result);\n<\/code><\/pre>\n
                                        4. Handling Very Large Numbers<\/h3>\n
                                        When dealing with numbers that might exceed the range of int, consider using BigInteger:<\/p>\n
                                        import java.math.BigInteger;\n\npublic static BigInteger parseLargeNumber(String str) {\n    return new BigInteger(str);\n}\n\n\/\/ Usage\nString veryLargeNumber = \"12345678901234567890\";\nBigInteger result = parseLargeNumber(veryLargeNumber);\nSystem.out.println(\"Parsed large number: \" + result);\n<\/code><\/pre>\n
                                        5. Parsing Fractional Parts<\/h3>\n
                                        If you need to parse strings that include fractional parts but only want the integer portion:<\/p>\n
                                        public static int parseIntegerPart(String str) {\n    double doubleValue = Double.parseDouble(str);\n    return (int) doubleValue;\n}\n\n\/\/ Usage\nString fractionalNumber = \"123.45\";\nint result = parseIntegerPart(fractionalNumber);\nSystem.out.println(\"Parsed integer part: \" + result);\n<\/code><\/pre>\n
                                        6. Handling Different Bases Dynamically<\/h3>\n
                                        For scenarios where you need to parse numbers in different bases dynamically:<\/p>\n
                                        public static int parseWithDynamicBase(String str) {\n    if (str.startsWith(\"0x\") || str.startsWith(\"0X\")) {\n        return Integer.parseInt(str.substring(2), 16);\n    } else if (str.startsWith(\"0b\") || str.startsWith(\"0B\")) {\n        return Integer.parseInt(str.substring(2), 2);\n    } else if (str.startsWith(\"0\")) {\n        return Integer.parseInt(str, 8);\n    } else {\n        return Integer.parseInt(str);\n    }\n}\n\n\/\/ Usage\nSystem.out.println(parseWithDynamicBase(\"123\"));     \/\/ Decimal\nSystem.out.println(parseWithDynamicBase(\"0x1A\"));    \/\/ Hexadecimal\nSystem.out.println(parseWithDynamicBase(\"0b1010\")); \/\/ Binary\nSystem.out.println(parseWithDynamicBase(\"0123\"));   \/\/ Octal\n<\/code><\/pre>\n
                                        These advanced techniques cover a wide range of scenarios you might encounter when converting strings to integers in Java. By understanding these methods, you’ll be better equipped to handle complex parsing requirements in your applications.<\/p>\n
                                        11. Conclusion<\/h2>\n
                                        Converting strings to integers is a fundamental operation in Java programming, and as we’ve seen, there are multiple ways to accomplish this task. From the simple and widely-used Integer.parseInt()<\/code> method to more advanced techniques for handling complex number formats, each approach has its own strengths and use cases.<\/p>\n
                                        Key takeaways from this guide include:<\/p>\n
                                          \n
                                        • Use Integer.parseInt()<\/code> for simple, efficient conversions to primitive int.<\/li>\n
                                        • Opt for Integer.valueOf()<\/code> when you need an Integer object or are working with small numbers that benefit from caching.<\/li>\n
                                        • Always handle exceptions, particularly NumberFormatException, to prevent unexpected program termination.<\/li>\n
                                        • Be aware of potential pitfalls like null inputs, whitespace, and integer overflow.<\/li>\n
                                        • For more complex scenarios, consider using NumberFormat, DecimalFormat, or custom parsing methods.<\/li>\n
                                        • When dealing with very large numbers or different number bases, use appropriate tools like BigInteger or specify the correct radix.<\/li>\n<\/ul>\n
                                          By mastering these techniques and understanding their implications, you’ll be well-equipped to handle string to integer conversions efficiently and robustly in your Java applications. Remember to always consider the specific requirements of your project, including performance needs, input formats, and potential edge cases, when choosing the most appropriate conversion method.<\/p>\n
                                          As you continue to develop your Java programming skills, keep exploring and practicing these conversion techniques. They are not only essential for basic data processing but also form the foundation for more advanced string and number manipulation tasks you’ll encounter in your programming journey.<\/p>\n
                                          <\/body><\/html><\/p>\n","protected":false},"excerpt":{"rendered":"
                                          Converting a string to an integer is a common task in Java programming. Whether you’re working with user input, parsing…<\/p>\n","protected":false},"author":1,"featured_media":7188,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[],"class_list":["post-7189","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\/7189"}],"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=7189"}],"version-history":[{"count":0,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/7189\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media\/7188"}],"wp:attachment":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media?parent=7189"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/categories?post=7189"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/tags?post=7189"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}