Replace lambda with method reference

buildSrc/src/main/java/org/springframework/boot/build/antora/AntoraAsciidocAttributes.java

@@ -56,7 +56,7 @@ public class AntoraAsciidocAttributes {
 	public AntoraAsciidocAttributes(Project project, BomExtension dependencyBom,
 			Map<String, String> dependencyVersions) {
 		this.version = String.valueOf(project.getVersion());
-		this.latestVersion = Boolean.valueOf(String.valueOf(project.findProperty("latestVersion")));
+		this.latestVersion = Boolean.parseBoolean(String.valueOf(project.findProperty("latestVersion")));
 		this.artifactRelease = ArtifactRelease.forProject(project);
 		this.libraries = dependencyBom.getLibraries();
 		this.dependencyVersions = dependencyVersions;

buildSrc/src/main/java/org/springframework/boot/build/bom/UpgradePolicy.java

@@ -35,12 +35,12 @@ public enum UpgradePolicy implements BiPredicate<DependencyVersion, DependencyVe
 	/**
 	 * Minor versions of the current major version.
 	 */
-	SAME_MAJOR_VERSION((candidate, current) -> candidate.isSameMajor(current)),
+	SAME_MAJOR_VERSION(DependencyVersion::isSameMajor),
 
 	/**
 	 * Patch versions of the current minor version.
 	 */
-	SAME_MINOR_VERSION((candidate, current) -> candidate.isSameMinor(current));
+	SAME_MINOR_VERSION(DependencyVersion::isSameMinor);
 
 	private final BiPredicate<DependencyVersion, DependencyVersion> delegate;
 

buildSrc/src/main/java/org/springframework/boot/build/classpath/CheckClasspathForProhibitedDependencies.java

@@ -70,20 +70,13 @@ public void checkForProhibitedDependencies() {
 
 	private boolean prohibited(ModuleVersionIdentifier id) {
 		String group = id.getGroup();
-		if (group.equals("javax.batch")) {
-			return false;
-		}
-		if (group.equals("javax.cache")) {
-			return false;
-		}
-		if (group.equals("javax.money")) {
-			return false;
-		}
-		if (group.equals("org.codehaus.groovy")) {
-			return true;
-		}
-		if (group.equals("org.eclipse.jetty.toolchain")) {
-			return true;
+		switch (group) {
+			case "javax.batch", "javax.cache", "javax.money" -> {
+				return false;
+			}
+			case "org.codehaus.groovy", "org.eclipse.jetty.toolchain" -> {
+				return true;
+			}
 		}
 		if (group.startsWith("javax")) {
 			return true;

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/quartz/QuartzEndpoint.java

@@ -46,6 +46,7 @@
 import org.quartz.Trigger.TriggerState;
 import org.quartz.TriggerKey;
 import org.quartz.impl.matchers.GroupMatcher;
+import org.quartz.utils.Key;
 
 import org.springframework.boot.actuate.endpoint.OperationResponseBody;
 import org.springframework.boot.actuate.endpoint.SanitizableData;
@@ -100,7 +101,7 @@ public QuartzGroupsDescriptor quartzJobGroups() throws SchedulerException {
 		for (String groupName : this.scheduler.getJobGroupNames()) {
 			List<String> jobs = this.scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))
 				.stream()
-				.map((key) -> key.getName())
+				.map(Key::getName)
 				.toList();
 			result.put(groupName, Collections.singletonMap("jobs", jobs));
 		}
@@ -121,7 +122,7 @@ public QuartzGroupsDescriptor quartzTriggerGroups() throws SchedulerException {
 			groupDetails.put("triggers",
 					this.scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(groupName))
 						.stream()
-						.map((key) -> key.getName())
+						.map(Key::getName)
 						.toList());
 			result.put(groupName, groupDetails);
 		}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/flyway/FlywayAutoConfiguration.java

@@ -232,95 +232,94 @@ private void configureProperties(FluentConfiguration configuration, FlywayProper
 				.toArray(new String[0]);
 			configuration.locations(locations);
 			map.from(properties.isFailOnMissingLocations())
-				.to((failOnMissingLocations) -> configuration.failOnMissingLocations(failOnMissingLocations));
-			map.from(properties.getEncoding()).to((encoding) -> configuration.encoding(encoding));
+				.to(configuration::failOnMissingLocations);
+			map.from(properties.getEncoding()).to(configuration::encoding);
 			map.from(properties.getConnectRetries())
-				.to((connectRetries) -> configuration.connectRetries(connectRetries));
+				.to(configuration::connectRetries);
 			map.from(properties.getConnectRetriesInterval())
 				.as(Duration::getSeconds)
 				.as(Long::intValue)
-				.to((connectRetriesInterval) -> configuration.connectRetriesInterval(connectRetriesInterval));
+				.to(configuration::connectRetriesInterval);
 			map.from(properties.getLockRetryCount())
-				.to((lockRetryCount) -> configuration.lockRetryCount(lockRetryCount));
-			map.from(properties.getDefaultSchema()).to((schema) -> configuration.defaultSchema(schema));
+				.to(configuration::lockRetryCount);
+			map.from(properties.getDefaultSchema()).to(configuration::defaultSchema);
 			map.from(properties.getSchemas())
 				.as(StringUtils::toStringArray)
-				.to((schemas) -> configuration.schemas(schemas));
-			map.from(properties.isCreateSchemas()).to((createSchemas) -> configuration.createSchemas(createSchemas));
-			map.from(properties.getTable()).to((table) -> configuration.table(table));
-			map.from(properties.getTablespace()).to((tablespace) -> configuration.tablespace(tablespace));
+				.to(configuration::schemas);
+			map.from(properties.isCreateSchemas()).to(configuration::createSchemas);
+			map.from(properties.getTable()).to(configuration::table);
+			map.from(properties.getTablespace()).to(configuration::tablespace);
 			map.from(properties.getBaselineDescription())
-				.to((baselineDescription) -> configuration.baselineDescription(baselineDescription));
+				.to(configuration::baselineDescription);
 			map.from(properties.getBaselineVersion())
-				.to((baselineVersion) -> configuration.baselineVersion(baselineVersion));
-			map.from(properties.getInstalledBy()).to((installedBy) -> configuration.installedBy(installedBy));
-			map.from(properties.getPlaceholders()).to((placeholders) -> configuration.placeholders(placeholders));
+				.to(configuration::baselineVersion);
+			map.from(properties.getInstalledBy()).to(configuration::installedBy);
+			map.from(properties.getPlaceholders()).to(configuration::placeholders);
 			map.from(properties.getPlaceholderPrefix())
-				.to((placeholderPrefix) -> configuration.placeholderPrefix(placeholderPrefix));
+				.to(configuration::placeholderPrefix);
 			map.from(properties.getPlaceholderSuffix())
-				.to((placeholderSuffix) -> configuration.placeholderSuffix(placeholderSuffix));
+				.to(configuration::placeholderSuffix);
 			map.from(properties.getPlaceholderSeparator())
-				.to((placeHolderSeparator) -> configuration.placeholderSeparator(placeHolderSeparator));
+				.to(configuration::placeholderSeparator);
 			map.from(properties.isPlaceholderReplacement())
-				.to((placeholderReplacement) -> configuration.placeholderReplacement(placeholderReplacement));
+				.to(configuration::placeholderReplacement);
 			map.from(properties.getSqlMigrationPrefix())
-				.to((sqlMigrationPrefix) -> configuration.sqlMigrationPrefix(sqlMigrationPrefix));
+				.to(configuration::sqlMigrationPrefix);
 			map.from(properties.getSqlMigrationSuffixes())
 				.as(StringUtils::toStringArray)
-				.to((sqlMigrationSuffixes) -> configuration.sqlMigrationSuffixes(sqlMigrationSuffixes));
+				.to(configuration::sqlMigrationSuffixes);
 			map.from(properties.getSqlMigrationSeparator())
-				.to((sqlMigrationSeparator) -> configuration.sqlMigrationSeparator(sqlMigrationSeparator));
+				.to(configuration::sqlMigrationSeparator);
 			map.from(properties.getRepeatableSqlMigrationPrefix())
-				.to((repeatableSqlMigrationPrefix) -> configuration
-					.repeatableSqlMigrationPrefix(repeatableSqlMigrationPrefix));
-			map.from(properties.getTarget()).to((target) -> configuration.target(target));
+				.to(configuration::repeatableSqlMigrationPrefix);
+			map.from(properties.getTarget()).to(configuration::target);
 			map.from(properties.isBaselineOnMigrate())
-				.to((baselineOnMigrate) -> configuration.baselineOnMigrate(baselineOnMigrate));
-			map.from(properties.isCleanDisabled()).to((cleanDisabled) -> configuration.cleanDisabled(cleanDisabled));
+				.to(configuration::baselineOnMigrate);
+			map.from(properties.isCleanDisabled()).to(configuration::cleanDisabled);
 			map.from(properties.isCleanOnValidationError())
-				.to((cleanOnValidationError) -> configuration.cleanOnValidationError(cleanOnValidationError));
-			map.from(properties.isGroup()).to((group) -> configuration.group(group));
-			map.from(properties.isMixed()).to((mixed) -> configuration.mixed(mixed));
-			map.from(properties.isOutOfOrder()).to((outOfOrder) -> configuration.outOfOrder(outOfOrder));
+				.to(configuration::cleanOnValidationError);
+			map.from(properties.isGroup()).to(configuration::group);
+			map.from(properties.isMixed()).to(configuration::mixed);
+			map.from(properties.isOutOfOrder()).to(configuration::outOfOrder);
 			map.from(properties.isSkipDefaultCallbacks())
-				.to((skipDefaultCallbacks) -> configuration.skipDefaultCallbacks(skipDefaultCallbacks));
+				.to(configuration::skipDefaultCallbacks);
 			map.from(properties.isSkipDefaultResolvers())
-				.to((skipDefaultResolvers) -> configuration.skipDefaultResolvers(skipDefaultResolvers));
+				.to(configuration::skipDefaultResolvers);
 			map.from(properties.isValidateMigrationNaming())
-				.to((validateMigrationNaming) -> configuration.validateMigrationNaming(validateMigrationNaming));
+				.to(configuration::validateMigrationNaming);
 			map.from(properties.isValidateOnMigrate())
-				.to((validateOnMigrate) -> configuration.validateOnMigrate(validateOnMigrate));
+				.to(configuration::validateOnMigrate);
 			map.from(properties.getInitSqls())
 				.whenNot(CollectionUtils::isEmpty)
 				.as((initSqls) -> StringUtils.collectionToDelimitedString(initSqls, "\n"))
-				.to((initSql) -> configuration.initSql(initSql));
+				.to(configuration::initSql);
 			map.from(properties.getScriptPlaceholderPrefix())
-				.to((prefix) -> configuration.scriptPlaceholderPrefix(prefix));
+				.to(configuration::scriptPlaceholderPrefix);
 			map.from(properties.getScriptPlaceholderSuffix())
-				.to((suffix) -> configuration.scriptPlaceholderSuffix(suffix));
+				.to(configuration::scriptPlaceholderSuffix);
 			configureExecuteInTransaction(configuration, properties, map);
-			map.from(properties::getLoggers).to((loggers) -> configuration.loggers(loggers));
+			map.from(properties::getLoggers).to(configuration::loggers);
 			// Flyway Teams properties
-			map.from(properties.getBatch()).to((batch) -> configuration.batch(batch));
-			map.from(properties.getDryRunOutput()).to((dryRunOutput) -> configuration.dryRunOutput(dryRunOutput));
+			map.from(properties.getBatch()).to(configuration::batch);
+			map.from(properties.getDryRunOutput()).to(configuration::dryRunOutput);
 			map.from(properties.getErrorOverrides())
-				.to((errorOverrides) -> configuration.errorOverrides(errorOverrides));
-			map.from(properties.getStream()).to((stream) -> configuration.stream(stream));
+				.to(configuration::errorOverrides);
+			map.from(properties.getStream()).to(configuration::stream);
 			map.from(properties.getJdbcProperties())
 				.whenNot(Map::isEmpty)
-				.to((jdbcProperties) -> configuration.jdbcProperties(jdbcProperties));
+				.to(configuration::jdbcProperties);
 			map.from(properties.getKerberosConfigFile())
-				.to((configFile) -> configuration.kerberosConfigFile(configFile));
+				.to(configuration::kerberosConfigFile);
 			map.from(properties.getOutputQueryResults())
-				.to((outputQueryResults) -> configuration.outputQueryResults(outputQueryResults));
+				.to(configuration::outputQueryResults);
 			map.from(properties.getSkipExecutingMigrations())
-				.to((skipExecutingMigrations) -> configuration.skipExecutingMigrations(skipExecutingMigrations));
+				.to(configuration::skipExecutingMigrations);
 			map.from(properties.getIgnoreMigrationPatterns())
 				.whenNot(List::isEmpty)
 				.to((ignoreMigrationPatterns) -> configuration
 					.ignoreMigrationPatterns(ignoreMigrationPatterns.toArray(new String[0])));
 			map.from(properties.getDetectEncoding())
-				.to((detectEncoding) -> configuration.detectEncoding(detectEncoding));
+				.to(configuration::detectEncoding);
 		}
 
 		private void configureExecuteInTransaction(FluentConfiguration configuration, FlywayProperties properties,
@@ -509,13 +508,13 @@ public void customize(FluentConfiguration configuration) {
 					OracleConfigurationExtension.class, "Oracle");
 			Oracle properties = this.properties.getOracle();
 			PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
-			map.from(properties::getSqlplus).to(extension.via((ext, sqlplus) -> ext.setSqlplus(sqlplus)));
+			map.from(properties::getSqlplus).to(extension.via(OracleConfigurationExtension::setSqlplus));
 			map.from(properties::getSqlplusWarn)
-				.to(extension.via((ext, sqlplusWarn) -> ext.setSqlplusWarn(sqlplusWarn)));
+				.to(extension.via(OracleConfigurationExtension::setSqlplusWarn));
 			map.from(properties::getWalletLocation)
-				.to(extension.via((ext, walletLocation) -> ext.setWalletLocation(walletLocation)));
+				.to(extension.via(OracleConfigurationExtension::setWalletLocation));
 			map.from(properties::getKerberosCacheFile)
-				.to(extension.via((ext, kerberosCacheFile) -> ext.setKerberosCacheFile(kerberosCacheFile)));
+				.to(extension.via(OracleConfigurationExtension::setKerberosCacheFile));
 		}
 
 	}
@@ -536,7 +535,7 @@ public void customize(FluentConfiguration configuration) {
 			Postgresql properties = this.properties.getPostgresql();
 			PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
 			map.from(properties::getTransactionalLock)
-				.to(extension.via((ext, transactionalLock) -> ext.setTransactionalLock(transactionalLock)));
+				.to(extension.via(PostgreSQLConfigurationExtension::setTransactionalLock));
 		}
 
 	}
@@ -572,7 +571,7 @@ private void setKerberosLoginFile(SQLServerConfigurationExtension configuration,
 	 */
 	static class Extension<E extends ConfigurationExtension> {
 
-		private SingletonSupplier<E> extension;
+		private final SingletonSupplier<E> extension;
 
 		Extension(FluentConfiguration configuration, Class<E> type, String name) {
 			this.extension = SingletonSupplier.of(() -> {

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateProperties.java

@@ -148,9 +148,9 @@ public void setPhysicalStrategy(String physicalStrategy) {
 
 		private void applyNamingStrategies(Map<String, Object> properties) {
 			applyNamingStrategy(properties, AvailableSettings.IMPLICIT_NAMING_STRATEGY, this.implicitStrategy,
-					() -> SpringImplicitNamingStrategy.class.getName());
+					SpringImplicitNamingStrategy.class::getName);
 			applyNamingStrategy(properties, AvailableSettings.PHYSICAL_NAMING_STRATEGY, this.physicalStrategy,
-					() -> CamelCaseToUnderscoresNamingStrategy.class.getName());
+					CamelCaseToUnderscoresNamingStrategy.class::getName);
 		}
 
 		private void applyNamingStrategy(Map<String, Object> properties, String key, Object strategy,

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/graphql/security/GraphQlWebFluxSecurityAutoConfigurationTests.java

@@ -45,6 +45,7 @@
 import org.springframework.security.config.annotation.method.configuration.EnableReactiveMethodSecurity;
 import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
 import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.config.web.server.ServerHttpSecurity.CsrfSpec;
 import org.springframework.security.core.userdetails.MapReactiveUserDetailsService;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetails;
@@ -161,7 +162,7 @@ static class SecurityConfig {
 
 		@Bean
 		SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) {
-			return http.csrf((spec) -> spec.disable())
+			return http.csrf(CsrfSpec::disable)
 				// Demonstrate that method security works
 				// Best practice to use both for defense in depth
 				.authorizeExchange((requests) -> requests.anyExchange().permitAll())

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/graphql/security/GraphQlWebMvcSecurityAutoConfigurationTests.java

@@ -41,6 +41,7 @@
 import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.provisioning.InMemoryUserDetailsManager;
@@ -154,7 +155,7 @@ static class SecurityConfig {
 
 		@Bean
 		DefaultSecurityFilterChain springWebFilterChain(HttpSecurity http) throws Exception {
-			return http.csrf((c) -> c.disable())
+			return http.csrf(AbstractHttpConfigurer::disable)
 				// Demonstrate that method security works
 				// Best practice to use both for defense in depth
 				.authorizeHttpRequests((requests) -> requests.anyRequest().permitAll())

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLoggingListenerTests.java

@@ -58,7 +58,7 @@ void logsDebugOnContextRefresh(CapturedOutput output) {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 		this.initializer.initialize(context);
 		context.register(Config.class);
-		withDebugLogging(() -> context.refresh());
+		withDebugLogging(context::refresh);
 		assertThat(output).contains("CONDITIONS EVALUATION REPORT");
 	}
 

spring-boot-project/spring-boot-devtools/src/main/java/org/springframework/boot/devtools/autoconfigure/RemoteDevtoolsSecurityConfiguration.java

@@ -23,6 +23,7 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.annotation.Order;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 
@@ -49,7 +50,7 @@ class RemoteDevtoolsSecurityConfiguration {
 	SecurityFilterChain devtoolsSecurityFilterChain(HttpSecurity http) throws Exception {
 		http.securityMatcher(new AntPathRequestMatcher(this.url));
 		http.authorizeHttpRequests((requests) -> requests.anyRequest().anonymous());
-		http.csrf((csrf) -> csrf.disable());
+		http.csrf(AbstractHttpConfigurer::disable);
 		return http.build();
 	}
 

spring-boot-project/spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FileSystemWatcherTests.java

@@ -297,7 +297,7 @@ private void setupWatcher(long pollingInterval, long quietPeriod) {
 	private void setupWatcher(long pollingInterval, long quietPeriod, SnapshotStateRepository snapshotStateRepository) {
 		this.watcher = new FileSystemWatcher(false, Duration.ofMillis(pollingInterval), Duration.ofMillis(quietPeriod),
 				snapshotStateRepository);
-		this.watcher.addListener((changeSet) -> FileSystemWatcherTests.this.changes.add(changeSet));
+		this.watcher.addListener(FileSystemWatcherTests.this.changes::add);
 	}
 
 	private File startWithNewDirectory() {

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/DefaultRunningServiceTests.java

@@ -115,7 +115,7 @@ void toStringReturnsServiceName() {
 	}
 
 	private DefaultRunningService createRunningService(boolean psResponseHasImage) {
-		DockerHost host = DockerHost.get("192.168.1.1", () -> Collections.emptyList());
+		DockerHost host = DockerHost.get("192.168.1.1", Collections::emptyList);
 		String id = "123";
 		String name = "my-service";
 		String image = "redis";

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/DockerHostTests.java

@@ -52,7 +52,7 @@ class DockerHostTests {
 
 	private static final Function<String, String> NO_SYSTEM_ENV = (key) -> null;
 
-	private static final Supplier<List<DockerCliContextResponse>> NO_CONTEXT = () -> Collections.emptyList();
+	private static final Supplier<List<DockerCliContextResponse>> NO_CONTEXT = Collections::emptyList;
 
 	@Test
 	void getWhenHasHost() {

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/lifecycle/TcpConnectServiceReadinessCheckTests.java

@@ -58,14 +58,14 @@ void setup() {
 
 	@Test
 	void checkWhenServerWritesData() throws Exception {
-		withServer((socket) -> socket.getOutputStream().write('!'), (port) -> check(port));
+		withServer((socket) -> socket.getOutputStream().write('!'), this::check);
 	}
 
 	@Test
 	void checkWhenNoSocketOutput() throws Exception {
 		// Simulate waiting for traffic from client to server. The sleep duration must
 		// be longer than the read timeout of the ready check!
-		withServer((socket) -> sleep(Duration.ofSeconds(10)), (port) -> check(port));
+		withServer((socket) -> sleep(Duration.ofSeconds(10)), this::check);
 	}
 
 	@Test