Java Vector Contains
📅 2026-06-22 | 📂 Java
Java Vector contains() Method | Novice Tutorial
[ Java Vector](#)
* * *
The `contains` method is a very useful method provided by the `Vector` class, used to check whether the collection contains the specified element.
### Syntax Format
public boolean contains(Object o)
### Parameter Description
* `o`: The element to check for existence in the collection
### Return Value
* `true`: If the collection contains the specified element
* `false`: If the collection does not contain the specified element
* * *
## How the contains Method Works
The `contains` method traverses all elements in the `Vector` and uses the `equals` method to compare each element with the target element for equality. When the first matching element is found, the method immediately returns `true`; if no match is found after traversing all elements, it returns `false`.
### Underlying Implementation
In Java's source code, the `contains` method of `Vector` actually calls the `indexOf` method:
## Example
public boolean contains(Object o){
return indexOf(o, 0)>=0;
}
The `indexOf` method searches for the element starting from the specified position, returning its index if found, otherwise returning -1.
* * *
## Usage Examples
Let's look at the usage of the `contains` method through a few practical examples.
### Example 1: Basic Usage
## Example
Vector colors =new Vector();
colors.add("Red");
colors.add("Green");
colors.add("Blue");
System.out.println(colors.contains("Green"));// Output: true
System.out.println(colors.contains("Yellow"));// Output: false
### Example 2: Custom Objects
When using custom objects, it is necessary to correctly implement the `equals` method; otherwise, the `contains` method may not work as expected.
## Example
class Person {
String name;
int age;
public Person(String name, int age){
this.name= name;
this.age= age;
}
@Override
public boolean equals(Object obj){
if(this== obj)return true;
if(obj ==null|| getClass()!= obj.getClass())return false;
Person person =(Person) obj;
return age == person.age&& Objects.equals(name, person.name);
}
@Override
public int hashCode(){
return Objects.hash(name, age);
}
}
public class Main {
public static void main(String[] args){
Vector people =new Vector();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 30));
System.out.println(people.contains(new Person("Alice", 25)));// Output: true
System.out.println(people.contains(new Person("Charlie", 35)));// Output: false
}
}
* * *
## Performance Considerations
Since `Vector` is implemented based on an array, the time complexity of the `contains` method is O(n), i.e., linear time. This means that as the number of elements in the `Vector` increases, the lookup time will also increase linearly.
### Optimization Suggestions
If frequent containment checks are needed and the collection is large, consider the following optimization solutions:
1. **Use HashSet**: If order is not important and elements are unique, the `contains` method of `HashSet` has an average time complexity of O(1).
## Example
HashSet colors =new HashSet();
colors.add("Red");
colors.add("Green");
System.out.println(colors.contains("Green"));// Fast lookup
2. **Use Binary Search After Sorting**: If the `Vector` is ordered, it can first be sorted with `Collections.sort()`, and then use `Collections.binarySearch()` for lookup, with a time complexity of O(log n).
## Example
Vector sortedColors =new Vector();
sortedColors.add("Blue");
sortedColors.add("Green");
sortedColors.add("Red");
Collections.sort(sortedColors);
int index =Collections.binarySearch(sortedColors, "Green");
System.out.println(index >=0);// Output: true
* * *
## Frequently Asked Questions
### Q1: Is the contains method case-sensitive?
For strings, the `contains` method is case-sensitive because it relies on the `equals` method:
## Example
Vector words =new Vector();
words.add("Hello");
System.out.println(words.contains("hello"));// Output: false
If case-insensitive checking is needed, it can be implemented like this:
## Example
boolean containsIgnoreCase(Vector vector, String target){
for(String s : vector){
if(s.equalsIgnoreCase(target)){
return true;
}
}
return false;
}
### Q2: Can the contains method check for null values?
Yes, `Vector` allows storing `null` values, and the `contains` method can check for `null`:
## Example
Vector items =new Vector();
items.add(null);
System.out.println(items.contains(null));// Output: true
### Q3: What is the difference between the contains method and the indexOf method?
* `contains`: Returns a boolean value, only telling you whether the element exists
* `indexOf`: Returns the index position of the element, or -1 if it does not exist
## Example
Vector fruits =new Vector();
fruits.add("Apple");
fruits.add("Banana");
System.out.println(fruits.contains("Banana"));// Output: true
System.out.println(fruits.indexOf("Banana"));// Output: 1
* * *
## Summary
The `contains` method of `Vector` is a simple but powerful tool for checking whether a specific element exists in a collection. Understanding how it works and its performance characteristics is very important for writing efficient Java code. Remember the following points:
1. The `contains` method relies on the `equals` method for element comparison
2. For custom objects, the `equals` and `hashCode` methods must be correctly implemented
3. The time complexity of the `contains` method is O(n); for large collections, more efficient data structures may need to be considered
4. `Vector` is thread-safe, but if thread safety is not required, `ArrayList` might be a better choice
By using the `contains` method appropriately, you can manage and query data in collections more effectively.
[ Java Vector](#)
YouTip