contains 是一个非常常用的方法，用于判断一个集合或字符串中是否包含某个特定的元素或子串，它的核心特点是返回一个布尔值：如果包含，返回 true；如果不包含，返回 false。

下面我们分两种主要情况来讲解：String.contains() 和 Collection.contains()。

String.contains() 方法

这个方法用于检查一个字符串是否包含另一个子字符串。

语法

public boolean contains(CharSequence s)

• 参数 s: 一个 CharSequence 对象，这意味着你不仅可以传入 String，还可以传入 StringBuilder、StringBuffer 等实现了 CharSequence 接口的对象。
• 返回值: boolean 类型，如果调用此方法的字符串中包含参数 s 指定的子串，则返回 true，否则返回 false。

重要特性

• 区分大小写: contains 方法是区分大小写的。"Hello".contains("hello") 会返回 false。
• 从左到右搜索: 它会从字符串的开头开始，查找子串第一次出现的位置，只要找到一次，就会立即返回 true,不会继续向后搜索。
• 性能: 对于长字符串，频繁使用 contains 可能会影响性能，如果需要复杂的模式匹配，应考虑使用正则表达式（Pattern 和 Matcher 类）。

示例代码

public class StringContainsExample {
    public static void main(String[] args) {
        String sentence = "Hello, welcome to the world of Java programming.";
        // 示例 1: 包含子串
        boolean hasJava = sentence.contains("Java");
        System.out.println("句子是否包含 'Java'? " + hasJava); // 输出: true
        // 示例 2: 不包含子串
        boolean hasPython = sentence.contains("Python");
        System.out.println("句子是否包含 'Python'? " + hasPython); // 输出: false
        // 示例 3: 区分大小写
        boolean hasjava = sentence.contains("java"); // 注意这里是小写
        System.out.println("句子是否包含 'java'? " + hasjava); // 输出: false
        // 示例 4: 使用 StringBuilder 作为参数
        StringBuilder sb = new StringBuilder("Java");
        boolean hasSbJava = sentence.contains(sb);
        System.out.println("句子是否包含 StringBuilder 'Java'? " + hasSbJava); // 输出: true
        // 示例 5: 检查一个词（注意空格）
        boolean hasWorld = sentence.contains("world");
        System.out.println("句子是否包含 'world'? " + hasWorld); // 输出: true
        boolean hasWorldWithSpace = sentence.contains(" world ");
        System.out.println("句子是否包含 ' world '? " + hasWorldWithSpace); // 输出: false
    }
}

实际应用场景

通常与 if 语句结合使用,进行条件判断。

String userInput = "I want to book a flight to Paris.";
if (userInput.contains("flight")) {
    System.out.println("用户想预订航班，开始处理...");
} else if (userInput.contains("hotel")) {
    System.out.println("用户想预订酒店，开始处理...");
} else {
    System.out.println("无法识别用户意图。");
}

Collection.contains() 方法

这个方法用于检查一个集合（如 List, Set, Queue）中是否包含某个指定的元素。

语法

public boolean contains(Object o)

• 参数 o: 要在集合中查找的元素，类型是 Object,所以可以是任何对象。
• 返回值: boolean 类型，如果集合中包含至少一个与 o 相等的元素，则返回 true，否则返回 false。

重要特性

• 依赖 equals() 方法: contains 方法的实现逻辑是遍历集合中的每一个元素，然后调用该元素的 equals() 方法与参数 o 进行比较，只要有一个元素的 equals() 方法返回 true，contains 就返回 true。
• 重写 equals() 和 hashCode(): 如果你将自定义类的对象放入集合，并且希望 contains 方法能正确工作，必须在你的自定义类中重写 equals() 方法，最好也一并重写 hashCode() 方法，以遵循 Java 的通用约定（如果两个对象 equals 相等，那么它们的 hashCode 也必须相等）。
• Set vs List:
  • 对于 List，它是一个有序的集合，contains 会按顺序查找。
  • 对于 Set（如 HashSet），它是一个无序的集合，contains 的查找效率通常更高，因为 HashSet 内部通过哈希表实现，查找时间复杂度接近 O(1)。

示例代码

示例 1: 使用基本数据类型的包装类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ListContainsExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 5, 8, 12, 20));
        // 示例 1: 集合中包含该元素
        boolean hasEight = numbers.contains(8);
        System.out.println("列表是否包含数字 8? " + hasEight); // 输出: true
        // 示例 2: 集合中不包含该元素
        boolean hasTen = numbers.contains(10);
        System.out.println("列表是否包含数字 10? " + hasTen); // 输出: false
    }
}

示例 2: 使用自定义类（必须重写 equals）

这是一个非常重要的例子。

import java.util.ArrayList;
import java.util.List;
// 1. 定义一个自定义类
class User {
    private String name;
    private int id;
    public User(String name, int id) {
        this.name = name;
        this.id = id;
    }
    // 2. 重写 equals() 方法
    @Override
    public boolean equals(Object o) {
        // 1. 检查是否是同一个对象
        if (this == o) return true;
        // 2. 检查 o 是否为 null 或是否是 User 的实例
        if (o == null || getClass() != o.getClass()) return false;
        // 3. 类型转换
        User user = (User) o;
        // 4. 比较关键属性，这里我们假设 id 是唯一的标识符。
        return id == user.id;
    }
    // 5. 重写 hashCode() 方法 (与 equals 配套)
    @Override
    public int hashCode() {
        return id; // 通常使用唯一标识符来生成哈希码
    }
    // 为了方便打印，重写 toString()
    @Override
    public String toString() {
        return "User{name='" + name + "', id=" + id + "}";
    }
}
public class CustomObjectContainsExample {
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("Alice", 101));
        users.add(new User("Bob", 102));
        users.add(new User("Charlie", 103));
        // 创建一个新对象，但拥有相同的 id
        User userToFind = new User("Unknown User", 102);
        // 检查列表中是否包含这个新对象
        // 因为 equals 方法比较的是 id，所以会返回 true
        boolean found = users.contains(userToFind);
        System.out.println("用户列表中是否包含 id 为 102 的用户? " + found); // 输出: true
        // 如果我们不重写 equals() 方法，它将使用 Object 类的 equals() 方法，
        // 该方法默认比较的是两个对象的内存地址（引用），所以会返回 false。
    }
}

总结与对比

最佳实践

1. 字符串检查: 当你需要判断一个字符串中是否包含另一个字符串时，String.contains() 是最直接、最简单的方法,记住它是区分大小写的。
2. 集合元素检查: 当你需要判断一个集合中是否存在某个对象时，使用 Collection.contains()，如果集合中存放的是自定义对象，请务必重写该对象的 equals() 和 hashCode() 方法,以确保逻辑正确和性能高效。
3. 性能考虑: 对于非常大的集合，ArrayList.contains() 的性能可能较差（时间复杂度 O(n)），如果需要频繁的“存在性”检查，优先考虑使用 HashSet 或 HashMap，它们的 contains() 操作平均时间复杂度为 O(1)。