{"id":2212,"date":"2024-11-15T08:16:18","date_gmt":"2024-11-15T08:16:18","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=2212"},"modified":"2024-11-15T08:16:21","modified_gmt":"2024-11-15T08:16:21","slug":"how-to-implement-a-basic-search-algorithm-in-java","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/","title":{"rendered":"How to Implement a Basic Search Algorithm in Java"},"content":{"rendered":"\n

Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure or database, and their efficiency directly impacts the performance of applications. In this tutorial, we will take a step-by-step approach to implementing basic search algorithms in Java.<\/p>\n\n\n\n

We will cover the implementation of linear search and binary search. These are foundational algorithms and are perfect for understanding how search works at a basic level. Along the way, I will explain each step thoroughly, and by the end, you will have a clear understanding of these algorithms and how to implement them in Java.<\/p>\n\n\n\n

\n\n\n\n

Prerequisites<\/h3>\n\n\n\n

Before starting, ensure you have the following:<\/p>\n\n\n\n

    \n
  1. Java Development Kit (JDK)<\/strong> installed on your system.<\/li>\n\n\n\n
  2. An Integrated Development Environment (IDE) like IntelliJ IDEA, Eclipse, or Visual Studio Code (or just a simple text editor with a terminal).<\/li>\n\n\n\n
  3. Basic understanding of Java syntax, loops, and arrays.<\/li>\n<\/ol>\n\n\n\n
    \n\n\n\n

    Step 1: Understanding the Search Problem<\/h3>\n\n\n\n

    A search algorithm is designed to find the location of a specific element in a collection. The collection can be an array, list, or any other data structure. To keep things simple, we\u2019ll use arrays.<\/p>\n\n\n\n

    There are two major categories of search algorithms:<\/p>\n\n\n\n

      \n
    1. Linear Search<\/strong>: Checks each element in sequence.<\/li>\n\n\n\n
    2. Binary Search<\/strong>: Works on sorted collections and divides the search space in half with each step.<\/li>\n<\/ol>\n\n\n\n

      Let\u2019s dive into their implementation.<\/p>\n\n\n\n

      \n\n\n\n

      Step 2: Implementing Linear Search in Java<\/h3>\n\n\n\n

      Linear search is the simplest searching algorithm. It checks each element in the array one by one until the desired element is found or the array ends.<\/p>\n\n\n\n

      Algorithm<\/h4>\n\n\n\n
        \n
      1. Start at the first element of the array.<\/li>\n\n\n\n
      2. Compare the target element with the current element.<\/li>\n\n\n\n
      3. If they match, return the index.<\/li>\n\n\n\n
      4. If they don\u2019t match, move to the next element.<\/li>\n\n\n\n
      5. Repeat until the element is found or the array ends.<\/li>\n<\/ol>\n\n\n\n

        Let\u2019s implement linear search in Java.<\/p>\n\n\n

        public<\/span> class<\/span> LinearSearch<\/span> <\/span>{\n\n    \/\/ Linear Search Function<\/span>\n    public<\/span> static<\/span> int<\/span> linearSearch<\/span>(int<\/span>[] array, int<\/span> target)<\/span> <\/span>{\n        for<\/span> (int<\/span> i = 0<\/span>; i < array.length; i++) {\n            if<\/span> (array[i] == target) {\n                return<\/span> i; \/\/ Return the index of the target element<\/span>\n            }\n        }\n        return<\/span> -1<\/span>; \/\/ Element not found<\/span>\n    }\n\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span>[] numbers = {10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>};\n        int<\/span> target = 30<\/span>;\n\n        int<\/span> result = linearSearch(numbers, target);\n\n        if<\/span> (result != -1<\/span>) {\n            System.out.println(\"Element found at index: \"<\/span> + result);\n        } else<\/span> {\n            System.out.println(\"Element not found in the array.\"<\/span>);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
        Explanation<\/h4>\n\n\n\n
          \n
        1. Input Array<\/strong>: {10, 20, 30, 40, 50}<\/code><\/li>\n\n\n\n
        2. Target Element<\/strong>: 30<\/code><\/li>\n\n\n\n
        3. The function linearSearch<\/code> loops through the array.<\/li>\n\n\n\n
        4. It checks each element and compares it with 30<\/code>.<\/li>\n\n\n\n
        5. If found, it returns the index. Otherwise, it returns -1<\/code>.<\/li>\n<\/ol>\n\n\n\n
          Output<\/h4>\n\n\n
          Element found at index: 2<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
          \n\n\n\n
          Step 3: Analyzing Linear Search<\/h3>\n\n\n\n
          Linear search has a straightforward implementation, but its performance is suboptimal for large datasets.<\/p>\n\n\n\n
            \n
          • Best Case<\/strong>: The element is at the first position (O(1)<\/code>).<\/li>\n\n\n\n
          • Worst Case<\/strong>: The element is not in the array, or it is at the last position (O(n)<\/code>).<\/li>\n\n\n\n
          • Average Case<\/strong>: O(n)<\/code> where n<\/code> is the size of the array.<\/li>\n<\/ul>\n\n\n\n
            Linear search is useful for small datasets or unsorted data, but it becomes inefficient as the dataset grows.<\/p>\n\n\n\n
            \n\n\n\n
            Step 4: Understanding Binary Search<\/h3>\n\n\n\n
            Binary search is a much more efficient algorithm but requires the array to be sorted. It works by dividing the search space into two halves, eliminating one half in each step.<\/p>\n\n\n\n
            Algorithm<\/h4>\n\n\n\n
              \n
            1. Find the middle element of the array.<\/li>\n\n\n\n
            2. If the middle element is the target, return its index.<\/li>\n\n\n\n
            3. If the target is smaller than the middle element, search in the left half.<\/li>\n\n\n\n
            4. If the target is larger, search in the right half.<\/li>\n\n\n\n
            5. Repeat until the target is found or the subarray becomes empty.<\/li>\n<\/ol>\n\n\n\n
              \n\n\n\n
              Step 5: Implementing Binary Search in Java<\/h3>\n\n\n
              public<\/span> class<\/span> BinarySearch<\/span> <\/span>{\n\n    \/\/ Binary Search Function<\/span>\n    public<\/span> static<\/span> int<\/span> binarySearch<\/span>(int<\/span>[] array, int<\/span> target)<\/span> <\/span>{\n        int<\/span> left = 0<\/span>;\n        int<\/span> right = array.length - 1<\/span>;\n\n        while<\/span> (left <= right) {\n            int<\/span> mid = left + (right - left) \/ 2<\/span>;\n\n            \/\/ Check if the target is at mid<\/span>\n            if<\/span> (array[mid] == target) {\n                return<\/span> mid;\n            }\n\n            \/\/ If target is smaller, ignore right half<\/span>\n            if<\/span> (target < array[mid]) {\n                right = mid - 1<\/span>;\n            }\n            \/\/ If target is larger, ignore left half<\/span>\n            else<\/span> {\n                left = mid + 1<\/span>;\n            }\n        }\n\n        return<\/span> -1<\/span>; \/\/ Element not found<\/span>\n    }\n\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span>[] numbers = {10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>}; \/\/ Must be sorted<\/span>\n        int<\/span> target = 40<\/span>;\n\n        int<\/span> result = binarySearch(numbers, target);\n\n        if<\/span> (result != -1<\/span>) {\n            System.out.println(\"Element found at index: \"<\/span> + result);\n        } else<\/span> {\n            System.out.println(\"Element not found in the array.\"<\/span>);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
              Explanation<\/h4>\n\n\n\n
                \n
              1. The binarySearch<\/code> function initializes left<\/code> and right<\/code> pointers.<\/li>\n\n\n\n
              2. It calculates the mid<\/code> index and compares the target with array[mid]<\/code>.<\/li>\n\n\n\n
              3. Based on the comparison, it adjusts the search bounds (left<\/code> or right<\/code>).<\/li>\n\n\n\n
              4. If the target is found, it returns the index. Otherwise, it returns -1<\/code>.<\/li>\n<\/ol>\n\n\n\n
                Output<\/h4>\n\n\n
                Element found at index: 3<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
                \n\n\n\n
                Step 6: Binary Search with Recursion<\/h3>\n\n\n\n
                Binary search can also be implemented using recursion. Here\u2019s how:<\/p>\n\n\n
                public<\/span> class<\/span> RecursiveBinarySearch<\/span> <\/span>{\n\n    \/\/ Recursive Binary Search Function<\/span>\n    public<\/span> static<\/span> int<\/span> binarySearchRecursive<\/span>(int<\/span>[] array, int<\/span> target, int<\/span> left, int<\/span> right)<\/span> <\/span>{\n        if<\/span> (left > right) {\n            return<\/span> -1<\/span>; \/\/ Element not found<\/span>\n        }\n\n        int<\/span> mid = left + (right - left) \/ 2<\/span>;\n\n        \/\/ Check if the target is at mid<\/span>\n        if<\/span> (array[mid] == target) {\n            return<\/span> mid;\n        }\n\n        \/\/ If target is smaller, search in the left half<\/span>\n        if<\/span> (target < array[mid]) {\n            return<\/span> binarySearchRecursive(array, target, left, mid - 1<\/span>);\n        }\n\n        \/\/ If target is larger, search in the right half<\/span>\n        return<\/span> binarySearchRecursive(array, target, mid + 1<\/span>, right);\n    }\n\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span>[] numbers = {10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>}; \/\/ Must be sorted<\/span>\n        int<\/span> target = 50<\/span>;\n\n        int<\/span> result = binarySearchRecursive(numbers, target, 0<\/span>, numbers.length - 1<\/span>);\n\n        if<\/span> (result != -1<\/span>) {\n            System.out.println(\"Element found at index: \"<\/span> + result);\n        } else<\/span> {\n            System.out.println(\"Element not found in the array.\"<\/span>);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                \n\n\n\n
                Step 7: Analyzing Binary Search<\/h3>\n\n\n\n
                Binary search significantly reduces the number of comparisons:<\/p>\n\n\n\n
                  \n
                • Best Case<\/strong>: The element is at the middle (O(1)<\/code>).<\/li>\n\n\n\n
                • Worst Case<\/strong>: O(log n)<\/code> where n<\/code> is the size of the array.<\/li>\n\n\n\n
                • Space Complexity<\/strong>: O(1)<\/code> for iterative and O(log n)<\/code> for recursive (due to call stack).<\/li>\n<\/ul>\n\n\n\n
                  Binary search is efficient for large sorted datasets.<\/p>\n\n\n\n
                  \n\n\n\n
                  Step 8: Comparing Linear Search and Binary Search<\/strong><\/h3>\n\n\n\n
                  Feature<\/strong><\/th>Linear Search<\/strong><\/th>Binary Search<\/strong><\/th><\/tr><\/thead>
                  Complexity<\/strong><\/td>O(n)<\/td>O(log n)<\/td><\/tr>
                  Data Requirement<\/strong><\/td>Unsorted or sorted data<\/td>Requires sorted data<\/td><\/tr>
                  Use Case<\/strong><\/td>Small datasets<\/td>Large sorted datasets<\/td><\/tr>
                  Implementation<\/strong><\/td>Simple<\/td>More complex<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                  \n\n\n\n
                  Step 9: Testing the Algorithms<\/strong><\/h3>\n\n\n\n
                  It\u2019s crucial to test both algorithms with different inputs. Below are a few examples:<\/p>\n\n\n\n
                  Test Case 1<\/h4>\n\n\n\n
                  Input Array: {5, 15, 25, 35, 45}<\/code>
                  Target: 25<\/code><\/p>\n\n\n\n
                  Expected Output:<\/p>\n\n\n\n
                    \n
                  • Linear Search: Element found at index: 2<\/code><\/li>\n\n\n\n
                  • Binary Search: Element found at index: 2<\/code><\/li>\n<\/ul>\n\n\n\n
                    Test Case 2<\/h4>\n\n\n\n
                    Input Array: {3, 6, 9, 12, 15}<\/code>
                    Target: 10<\/code><\/p>\n\n\n\n
                    Expected Output:<\/p>\n\n\n\n
                      \n
                    • Linear Search: Element not found in the array.<\/code><\/li>\n\n\n\n
                    • Binary Search: Element not found in the array.<\/code><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
                      Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure or database, and their efficiency directly impacts the performance of applications. In this tutorial, we will take a step-by-step approach to implementing basic search algorithms in Java. We will cover the implementation of […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5,4],"tags":[],"class_list":{"0":"post-2212","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-java","7":"category-programming-languages","8":"entry"},"yoast_head":"\nHow to Implement a Basic Search Algorithm in Java<\/title>\n<meta name=\"description\" content=\"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Implement a Basic Search Algorithm in Java\" \/>\n<meta property=\"og:description\" content=\"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-11-15T08:16:18+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-11-15T08:16:21+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Implement a Basic Search Algorithm in Java\",\"datePublished\":\"2024-11-15T08:16:18+00:00\",\"dateModified\":\"2024-11-15T08:16:21+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/\"},\"wordCount\":695,\"articleSection\":[\"Java\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/\",\"name\":\"How to Implement a Basic Search Algorithm in Java\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-11-15T08:16:18+00:00\",\"dateModified\":\"2024-11-15T08:16:21+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-a-basic-search-algorithm-in-java\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Implement a Basic Search Algorithm in Java\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Implement a Basic Search Algorithm in Java","description":"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/","og_locale":"en_US","og_type":"article","og_title":"How to Implement a Basic Search Algorithm in Java","og_description":"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/","article_published_time":"2024-11-15T08:16:18+00:00","article_modified_time":"2024-11-15T08:16:21+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Implement a Basic Search Algorithm in Java","datePublished":"2024-11-15T08:16:18+00:00","dateModified":"2024-11-15T08:16:21+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/"},"wordCount":695,"articleSection":["Java","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/","name":"How to Implement a Basic Search Algorithm in Java","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-11-15T08:16:18+00:00","dateModified":"2024-11-15T08:16:21+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Search algorithms are an integral part of programming and computer science. They are used to retrieve information stored within a data structure","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-a-basic-search-algorithm-in-java\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Implement a Basic Search Algorithm in Java"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2212","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=2212"}],"version-history":[{"count":1,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2212\/revisions"}],"predecessor-version":[{"id":2213,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2212\/revisions\/2213"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=2212"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=2212"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=2212"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}