Java 中的 Stream noneMatch() 方法及示例

2025年1月7日 | 阅读 6 分钟

Java Stream API 中的 noneMatch() 方法是一个重要函数，用于评估给定流中的所有元素是否都不满足特定条件。当我们需要证明集合中的所有项都不满足某个谓词时，此方法特别有用，该方法返回 'true' 或 'false'，具体取决于是否有项符合指定条件。

方法签名

boolean：如果流中没有元素与给定的谓词匹配，则 noneMatch() 方法返回布尔值 true，否则返回 false。

noneMatch：这是方法名，表示该方法在 Stream API 中执行的操作。

Predicate<? super T>：参数 predicate 是 Java util.function 包中的一个函数式接口。它定义了一个名为 test() 的单一方法，该方法接受一个类型为 T（或其超类型）的参数并返回一个布尔值。

示例 1：检查所有字符串是否非空

在此示例中，我们有一个包含 "Assam"、"Banglore" 和 "Chennai" 的单词列表。使用 words.stream()，我们将列表转换为流。noneMatch(String::isEmpty) 使用对 String::isEmpty 的方法引用检查流中是否没有空字符串。输出将为 true，因为 words 中的所有字符串都非空。

文件名： NoneMatchStringExample.java

 
import java.util.Arrays;
import java.util.List;
public class NoneMatchStringExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("Assam", "Banglore", "Chennai");
        // Check if none of the words are empty strings
        boolean noneEmpty = words.stream()
                                 .noneMatch(String::isEmpty);
        System.out.println("None of the words are empty: " + noneEmpty);
    }
}   

输出

 
None of the words are empty: true

示例 2：检查是否有员工年龄小于 18 岁

在此示例中，我们定义了一个具有 name 和 age 属性的 Employee 类。我们创建了三个代表不同年龄的 Employee 实例。employees.stream() 将员工列表转换为流。noneMatch(emp -> emp.getAge() < 18) 使用 lambda 表达式作为谓词来检查是否有员工年龄小于 18 岁。输出将为 false，因为有一个员工（Bob）未成年（年龄 < 18）。

文件名： NoneMatchEmployeeExample.java

 
import java.util.Arrays;
import java.util.List;
public class NoneMatchEmployeeExample {
    public static void main(String[] args) {
        Employee emp1 = new Employee("John", 25);
        Employee emp2 = new Employee("Alice", 30);
        Employee emp3 = new Employee("Bob", 17);
        List<Employee> employees = Arrays.asList(emp1, emp2, emp3);
        // Check if none of the employees are underage (age < 18)
        boolean noneUnderage = employees.stream()
                                       .noneMatch(emp -> emp.getAge() < 18);
        System.out.println("None of the employees are underage: " + noneUnderage);
    }
    static class Employee {
        private String name;
        private int age;
        public Employee(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
    }
}   

输出

 
None of the employees are underage: false

示例 3：检查书籍列表是否包含特定类型

在此示例中，我们定义了一个具有 title 和 genre 属性的 Book 类。我们创建了三个代表不同类型的 Book 实例。books.stream() 将书籍列表转换为流。noneMatch(book -> book.getGenre().equals(genreToCheck)) 使用 lambda 表达式作为谓词来检查流中的书籍是否都不属于指定的类型。输出将为 true，因为 books 中的书籍都不属于 "科幻" 类型。

文件名： NoneMatchBookExample.java

 
import java.util.Arrays;
import java.util.List;
public class NoneMatchBookExample {
    public static void main(String[] args) {
        Book book1 = new Book("Java Programming", "Programming");
        Book book2 = new Book("Clean Code", "Software Development");
        Book book3 = new Book("Data Structures and Algorithms", "Programming");
        List<Book> books = Arrays.asList(book1, book2, book3);
        String genreToCheck = "Science Fiction";
        // Check if none of the books belong to the specified genre
        boolean noneInGenre = books.stream()
                                   .noneMatch(book -> book.getGenre().equals(genreToCheck));
        System.out.println("None of the books are in the genre '" + genreToCheck + "': " + noneInGenre);
    }
    static class Book {
        private String title;
        private String genre;
        public Book(String title, String genre) {
            this.title = title;
            this.genre = genre;
        }
        public String getTitle() {
            return title;
        }
        public String getGenre() {
            return genre;
        }
    }
}   

输出

 
None of the books are in the genre 'Science Fiction': true

示例 4：检查所有成绩是否高于某个阈值

我们有一个包含双精度值的 grades 列表，代表学生的成绩。noneMatch(grade -> grade < passThreshold) 使用 lambda 表达式作为谓词来检查流中的成绩是否没有低于及格阈值。输出将为 true，因为 grades 中的所有成绩都高于 70.0。

文件名： NoneMatchGradeExample.java

 
import java.util.Arrays;
import java.util.List;
public class NoneMatchGradeExample {
    public static void main(String[] args) {
        List<Double> grades = Arrays.asList(85.5, 91.2, 79.8, 88.0);
        double passThreshold = 70.0;
        // Check if none of the grades are below the pass threshold
        boolean noneBelowThreshold = grades.stream()
                                          .noneMatch(grade -> grade < passThreshold);
        System.out.println("None of the grades are below " + passThreshold + ": " + noneBelowThreshold);
    }
}   

输出

 
None of the grades are below 70.0: true

示例 5：检查所有交易是否高于某个金额

在此示例中，我们定义了一个带有 id 和 amount 属性的嵌套 Transaction 类。我们创建了一个包含 Transaction 实例的交易列表。transactions.stream() 将交易列表转换为流。noneMatch(transaction -> transaction.getAmount() < thresholdAmount) 使用 lambda 表达式作为谓词来检查流中是否没有交易金额低于 thresholdAmount。输出将为 false，因为交易 "T3" 的金额低于 $100.0。

文件名： TransactionExample.java

 
import java.util.Arrays;
import java.util.List;
public class TransactionExample {
    static class Transaction {
        private String id;
        private double amount;
        public Transaction(String id, double amount) {
            this.id = id;
            this.amount = amount;
        }
        public String getId() {
            return id;
        }
        public double getAmount() {
            return amount;
        }
    }
    public static void main(String[] args) {
        List<Transaction> transactions = Arrays.asList(
                new Transaction("T1", 150.75),
                new Transaction("T2", 230.50),
                new Transaction("T3", 50.25),
                new Transaction("T4", 80.90)
        );
        double thresholdAmount = 100.0;
        // Check if none of the transactions are below the threshold amount
        boolean noneBelowThreshold = transactions.stream()
                .noneMatch(transaction -> transaction.getAmount() < thresholdAmount);
        System.out.println("None of the transactions are below $" + thresholdAmount + ": " + noneBelowThreshold);
    }
}   

输出

 
None of the transactions are below $100.0: false

示例 6：检查任务列表是否都已标记为完成

在此示例中，我们定义了一个带有 description 和 isCompleted 属性的嵌套 Task 类。我们创建了一个包含 Task 实例的任务列表。tasks.stream() 将任务列表转换为流。noneMatch(task -> !task.isCompleted()) 使用 lambda 表达式作为谓词来检查流中的任务是否没有未完成的。输出将为 false，因为 "Review code" 未完成。

文件名： TaskCompletionExample.java

 
import java.util.Arrays;
import java.util.List;
public class TaskCompletionExample {
    static class Task {
        private String description;
        private boolean isCompleted;
        public Task(String description, boolean isCompleted) {
            this.description = description;
            this.isCompleted = isCompleted;
        }
        public String getDescription() {
            return description;
        }
        public boolean isCompleted() {
            return isCompleted;
        }
    }
    public static void main(String[] args) {
        List<Task> tasks = Arrays.asList(
                new Task("Write report", true),
                new Task("Submit assignment", true),
                new Task("Review code", false),
                new Task("Attend meeting", true)
        );
        // Check if none of the tasks are pending
        boolean allCompleted = tasks.stream()
                                    .noneMatch(task -> !task.isCompleted());
        System.out.println("All tasks are completed: " + allCompleted);
    }
}   

输出

 
All tasks are completed: false

示例 7：检查预约列表是否都已确认

在此示例中，我们定义了一个带有 time 和 isConfirmed 属性的嵌套 Appointment 类。我们创建了一个包含 Appointment 实例的预约列表。appointments.stream() 将预约列表转换为流。noneMatch(appointment -> !appointment.isConfirmed()) 使用 lambda 表达式作为谓词来检查流中的预约是否没有未确认的。输出将为 false，因为 "11:00 AM" 的预约未被确认。

文件名： AppointmentConfirmationExample.java

 
import java.util.Arrays;
import java.util.List;
public class AppointmentConfirmationExample {
    static class Appointment {
        private String time;
        private boolean isConfirmed;
        public Appointment(String time, boolean isConfirmed) {
            this.time = time;
            this.isConfirmed = isConfirmed;
        }
        public String getTime() {
            return time;
        }
        public boolean isConfirmed() {
            return isConfirmed;
        }
    }
    public static void main(String[] args) {
        List<Appointment> appointments = Arrays.asList(
                new Appointment("09:00 AM", true),
                new Appointment("10:00 AM", true),
                new Appointment("11:00 AM", false),
                new Appointment("12:00 PM", true)
        );
        // Check if none of the appointments are unconfirmed
        boolean allConfirmed = appointments.stream()
                                           .noneMatch(appointment -> !appointment.isConfirmed());
        System.out.println("All appointments are confirmed: " + allConfirmed);
    }
}   

输出

 
All appointments are confirmed: false

下一个主题Java 中的 Stream-skip 方法及示例

Java 中的 Stream noneMatch() 方法及示例

方法签名

示例 1：检查所有字符串是否非空

示例 2：检查是否有员工年龄小于 18 岁

示例 3：检查书籍列表是否包含特定类型

示例 4：检查所有成绩是否高于某个阈值

示例 5：检查所有交易是否高于某个金额

示例 6：检查任务列表是否都已标记为完成

示例 7：检查预约列表是否都已确认

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的 Stream noneMatch() 方法及示例

方法签名

示例 1：检查所有字符串是否非空

示例 2：检查是否有员工年龄小于 18 岁

示例 3：检查书籍列表是否包含特定类型

示例 4：检查所有成绩是否高于某个阈值

示例 5：检查所有交易是否高于某个金额

示例 6：检查任务列表是否都已标记为完成

示例 7：检查预约列表是否都已确认

相关帖子

在线将 JSON 转换为 Java 对象

Java 中设置默认关闭操作

Java 中的 extends vs. implements

Java 中的串行通信

Program to Invert Bits of a Number Efficiently in Java

Java 中的 DoubleBuffer compact() 方法及示例

在 Java 中多次执行 main() 方法

使用中平方法在 Java 中生成随机数

Java 8 ExecutionException

如何在 Java 中创建表

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器