Difference Between findElement() and findElements() in Java

When it comes to web automation testing with Java and Selenium, there are essential tools and functions that every automation engineer must understand. Among these are findElement() and findElements(). These methods are crucial for locating web elements on a page, but they serve different purposes and have distinct use cases.

In this section, we will delve into the differences between findElement() and findElements() in Java Selenium. We will also provide full Java programs with sample output to illustrate their usage in practical scenarios.

Understanding the Basics

Before we dive into the differences, let's establish a fundamental understanding of these two methods:

findElement()

findElement() is a method provided by the WebDriver interface in Selenium.
It is used to locate the first element that matches a specified set of criteria.
If no matching element is found, it throws a NoSuchElementException.
findElement() returns a single WebElement object.

findElements()

findElements() is another method provided by the WebDriver interface in Selenium.
It is used to locate all elements that match a specified set of criteria.
If no matching elements are found, it returns an empty list (not null).
findElements() returns a list of WebElement objects.

Difference 1: Singular vs. Plural

The most apparent difference between findElement() and findElements() is in their names, which suggest their return types. findElement() returns a single WebElement, whereas findElements() returns a list of WebElements.

Here's a simple program to demonstrate this difference:

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
public class FindElementVsFindElements {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver.exe");
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");
        // Using findElement() to locate a single element
        WebElement singleElement = driver.findElement(By.tagName("h1"));
        // Using findElements() to locate multiple elements
        List<WebElement> multipleElements = driver.findElements(By.tagName("p"));
        System.out.println("Single Element Text: " + singleElement.getText());
        System.out.println("Number of Multiple Elements: " + multipleElements.size());
        driver.quit();
    }
}

Output:

Single Element Text: Example Domain
Number of Multiple Elements: 4

As we can see, findElement() returns a single WebElement, while findElements() returns a list of WebElements.

Difference 2: Exception Handling

Another significant difference between these methods is how they handle exceptions when no matching elements are found on the page.

findElement()

When findElement() doesn't find a matching element, it throws a NoSuchElementException.

findElements()

When findElements() doesn't find any matching elements, it returns an empty list (not null).

Here's a program illustrating the exception handling difference:

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.List;
public class ExceptionHandlingExample {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver.exe");
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");
        // Using findElement() when no matching element is present
        try {
            WebElement element = driver.findElement(By.id("nonExistentElement"));
            System.out.println("Found Element: " + element.getText());
        } catch (org.openqa.selenium.NoSuchElementException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
        // Using findElements() when no matching elements are present
        List<WebElement> elements = driver.findElements(By.className("nonExistentClass"));
        System.out.println("Number of Elements Found: " + elements.size());
        driver.quit();
    }
}

Output:

Exception caught: no such element: Unable to locate element: {"method":"id","selector":"nonExistentElement"}
Number of Elements Found: 0

In this program, we attempt to find an element with an ID that doesn't exist and elements with a class that doesn't exist on the page.

As we can see, findElement() throws an exception when it doesn't find a matching element, while findElements() simply returns an empty list without throwing an exception.

Difference 3: Use Cases

The choice between findElement() and findElements() largely depends on the specific testing scenario and what we intend to do with the located elements.

findElement()

Use findElement() when you expect only one element to match your criteria, and you want to interact with or assert something on that element.
It's ideal for scenarios where you need to locate the first occurrence of an element, such as clicking on a button or extracting text from a header.

findElements()

Use findElements() when you expect multiple elements to match your criteria, and we want to interact with or assert something on each of these elements.
It's useful for scenarios where you need to validate the presence of multiple elements, such as checking the count of search results or extracting data from a table with multiple rows.

UseCasesExample.java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.List;
public class UseCasesExample {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver.exe");
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");
        // Use findElement() to click on the first 'Learn More' link
        WebElement learnMoreButton = driver.findElement(By.linkText("Learn More"));
        learnMoreButton.click();
        // Use findElements() to count and print all links on the page
        List<WebElement> allLinks = driver.findElements(By.tagName("a"));
        System.out.println("Total Links on the Page: " + allLinks.size());
        driver.quit();
    }
}

Output:

Total Links on the Page: 10

Key Differences Between findElement() and findElements()

Aspect	findElement()	findElements()
Purpose	Locates the first matching element.	Locates all matching elements.
Return Type	Returns a single WebElement object.	Returns a list of WebElement objects.
Exception Handling	Throws a NoSuchElementException when no matching element is found.	Returns an empty list (not null) when no matching elements are found.
Use Cases	Suitable when we expect only one element to match criteria, and we want to interact with or assert something on that element. Ideal for scenarios where we need to locate the first occurrence of an element, such as clicking on a button or extracting text from a header.	Suitable when we expect multiple elements to match criteria, and we want to interact with or assert something on each of these elements. Useful for scenarios where we need to validate the presence of multiple elements, such as checking the count of search results or extracting data from a table with multiple rows.

Wrapping It Up

In the world of Java Selenium automation testing, understanding the differences between findElement() and findElements() is crucial. These methods serve different purposes and have distinct use cases, as we have explored in this section.

In summary, findElement() is used to locate and interact with a single element, throwing an exception if none is found. findElements() is used to locate multiple elements, returning an empty list if none are found. By choosing the appropriate method based on your testing needs, we can write efficient and effective automation scripts that navigate and validate web pages with ease. Remember that these methods are just one piece of the Selenium puzzle, and mastering them is essential for building robust automation solutions.

Next TopicDifference Between Inheritance and Interfaces in Java

← prev next →