You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by ch...@apache.org on 2024/03/23 03:44:11 UTC

(kafka) branch trunk updated: MINOR: Tuple2 replaced with Map.Entry (#15560)

This is an automated email from the ASF dual-hosted git repository.

chia7712 pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/trunk by this push:
     new 0f216b64487 MINOR: Tuple2 replaced with Map.Entry (#15560)
0f216b64487 is described below

commit 0f216b644874f2f89285f9d4736b50246cd5b0a2
Author: Nikolay <ni...@apache.org>
AuthorDate: Sat Mar 23 06:44:05 2024 +0300

    MINOR: Tuple2 replaced with Map.Entry (#15560)
    
    Reviewers: Chia-Ping Tsai <ch...@gmail.com>
---
 .../main/java/org/apache/kafka/tools/Tuple2.java   |  48 ------
 .../tools/consumer/group/ConsumerGroupCommand.java |  59 ++++----
 .../tools/reassign/ReassignPartitionsCommand.java  | 161 +++++++++++----------
 .../org/apache/kafka/tools/ToolsTestUtils.java     |  14 +-
 .../consumer/group/ConsumerGroupServiceTest.java   |  24 +--
 .../consumer/group/DeleteConsumerGroupsTest.java   |   4 +-
 ...OffsetsConsumerGroupCommandIntegrationTest.java |  12 +-
 .../consumer/group/DescribeConsumerGroupTest.java  | 156 ++++++++++----------
 .../tools/other/ReplicationQuotasTestRig.java      |   2 +-
 .../ReassignPartitionsIntegrationTest.java         |  11 +-
 .../tools/reassign/ReassignPartitionsUnitTest.java |  47 +++---
 11 files changed, 248 insertions(+), 290 deletions(-)

diff --git a/tools/src/main/java/org/apache/kafka/tools/Tuple2.java b/tools/src/main/java/org/apache/kafka/tools/Tuple2.java
deleted file mode 100644
index 02dd4bf3981..00000000000
--- a/tools/src/main/java/org/apache/kafka/tools/Tuple2.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.tools;
-
-import java.util.Objects;
-
-public final class Tuple2<V1, V2> {
-    public final V1 v1;
-
-    public final V2 v2;
-
-    public Tuple2(V1 v1, V2 v2) {
-        this.v1 = v1;
-        this.v2 = v2;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Tuple2<?, ?> tuple = (Tuple2<?, ?>) o;
-        return Objects.equals(v1, tuple.v1) && Objects.equals(v2, tuple.v2);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(v1, v2);
-    }
-
-    @Override
-    public String toString() {
-        return "Tuple2{v1=" + v1 + ", v2=" + v2 + '}';
-    }
-}
diff --git a/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java b/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
index 2b055de6161..35371ce75aa 100644
--- a/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
+++ b/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
@@ -53,7 +53,6 @@ import org.apache.kafka.common.requests.ListOffsetsResponse;
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.server.util.CommandLineUtils;
 import org.apache.kafka.tools.ToolsUtils;
-import org.apache.kafka.tools.Tuple2;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -61,6 +60,7 @@ import java.io.IOException;
 import java.text.ParseException;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -71,6 +71,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.OptionalInt;
 import java.util.Properties;
@@ -315,10 +316,10 @@ public class ConsumerGroupCommand {
             return colOpt.map(Collection::size);
         }
 
-        private void printOffsets(Map<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets) {
+        private void printOffsets(Map<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets) {
             offsets.forEach((groupId, tuple) -> {
-                Optional<String> state = tuple.v1;
-                Optional<Collection<PartitionAssignmentState>> assignments = tuple.v2;
+                Optional<String> state = tuple.getKey();
+                Optional<Collection<PartitionAssignmentState>> assignments = tuple.getValue();
 
                 if (shouldPrintMemberState(groupId, state, size(assignments))) {
                     String format = printOffsetFormat(assignments);
@@ -359,10 +360,10 @@ public class ConsumerGroupCommand {
             return format;
         }
 
-        private void printMembers(Map<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members, boolean verbose) {
+        private void printMembers(Map<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members, boolean verbose) {
             members.forEach((groupId, tuple) -> {
-                Optional<String> state = tuple.v1;
-                Optional<Collection<MemberAssignmentState>> assignments = tuple.v2;
+                Optional<String> state = tuple.getKey();
+                Optional<Collection<MemberAssignmentState>> assignments = tuple.getValue();
                 int maxGroupLen = 15, maxConsumerIdLen = 15, maxGroupInstanceIdLen = 17, maxHostLen = 15, maxClientIdLen = 15;
                 boolean includeGroupInstanceId = false;
 
@@ -448,11 +449,11 @@ public class ConsumerGroupCommand {
             long subActions = Stream.of(membersOptPresent, offsetsOptPresent, stateOptPresent).filter(x -> x).count();
 
             if (subActions == 0 || offsetsOptPresent) {
-                TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets
+                TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets
                     = collectGroupsOffsets(groupIds);
                 printOffsets(offsets);
             } else if (membersOptPresent) {
-                TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members
+                TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members
                     = collectGroupsMembers(groupIds, opts.options.has(opts.verboseOpt));
                 printMembers(members, opts.options.has(opts.verboseOpt));
             } else {
@@ -560,7 +561,7 @@ public class ConsumerGroupCommand {
             return result;
         }
 
-        Tuple2<Errors, Map<TopicPartition, Throwable>> deleteOffsets(String groupId, List<String> topics) {
+        Entry<Errors, Map<TopicPartition, Throwable>> deleteOffsets(String groupId, List<String> topics) {
             Map<TopicPartition, Throwable> partitionLevelResult = new HashMap<>();
             Set<String> topicWithPartitions = new HashSet<>();
             Set<String> topicWithoutPartitions = new HashSet<>();
@@ -617,17 +618,17 @@ public class ConsumerGroupCommand {
                 }
             });
 
-            return new Tuple2<>(topLevelException, partitionLevelResult);
+            return new SimpleImmutableEntry<>(topLevelException, partitionLevelResult);
         }
 
         void deleteOffsets() {
             String groupId = opts.options.valueOf(opts.groupOpt);
             List<String> topics = opts.options.valuesOf(opts.topicOpt);
 
-            Tuple2<Errors, Map<TopicPartition, Throwable>> res = deleteOffsets(groupId, topics);
+            Entry<Errors, Map<TopicPartition, Throwable>> res = deleteOffsets(groupId, topics);
 
-            Errors topLevelResult = res.v1;
-            Map<TopicPartition, Throwable> partitionLevelResult = res.v2;
+            Errors topLevelResult = res.getKey();
+            Map<TopicPartition, Throwable> partitionLevelResult = res.getValue();
 
             switch (topLevelResult) {
                 case NONE:
@@ -677,7 +678,7 @@ public class ConsumerGroupCommand {
                 withTimeoutMs(new DescribeConsumerGroupsOptions())
             ).describedGroups();
 
-            for (Map.Entry<String, KafkaFuture<ConsumerGroupDescription>> e : stringKafkaFutureMap.entrySet()) {
+            for (Entry<String, KafkaFuture<ConsumerGroupDescription>> e : stringKafkaFutureMap.entrySet()) {
                 res.put(e.getKey(), e.getValue().get());
             }
             return res;
@@ -686,16 +687,16 @@ public class ConsumerGroupCommand {
         /**
          * Returns the state of the specified consumer group and partition assignment states
          */
-        Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> collectGroupOffsets(String groupId) throws Exception {
-            return collectGroupsOffsets(Collections.singletonList(groupId)).getOrDefault(groupId, new Tuple2<>(Optional.empty(), Optional.empty()));
+        Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> collectGroupOffsets(String groupId) throws Exception {
+            return collectGroupsOffsets(Collections.singletonList(groupId)).getOrDefault(groupId, new SimpleImmutableEntry<>(Optional.empty(), Optional.empty()));
         }
 
         /**
          * Returns states of the specified consumer groups and partition assignment states
          */
-        TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> collectGroupsOffsets(Collection<String> groupIds) throws Exception {
+        TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> collectGroupsOffsets(Collection<String> groupIds) throws Exception {
             Map<String, ConsumerGroupDescription> consumerGroups = describeConsumerGroups(groupIds);
-            TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> groupOffsets = new TreeMap<>();
+            TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> groupOffsets = new TreeMap<>();
 
             consumerGroups.forEach((groupId, consumerGroup) -> {
                 ConsumerGroupState state = consumerGroup.state();
@@ -737,19 +738,19 @@ public class ConsumerGroupCommand {
 
                 rowsWithConsumer.addAll(rowsWithoutConsumer);
 
-                groupOffsets.put(groupId, new Tuple2<>(Optional.of(state.toString()), Optional.of(rowsWithConsumer)));
+                groupOffsets.put(groupId, new SimpleImmutableEntry<>(Optional.of(state.toString()), Optional.of(rowsWithConsumer)));
             });
 
             return groupOffsets;
         }
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> collectGroupMembers(String groupId, boolean verbose) throws Exception {
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> collectGroupMembers(String groupId, boolean verbose) throws Exception {
             return collectGroupsMembers(Collections.singleton(groupId), verbose).get(groupId);
         }
 
-        TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> collectGroupsMembers(Collection<String> groupIds, boolean verbose) throws Exception {
+        TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> collectGroupsMembers(Collection<String> groupIds, boolean verbose) throws Exception {
             Map<String, ConsumerGroupDescription> consumerGroups = describeConsumerGroups(groupIds);
-            TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> res = new TreeMap<>();
+            TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> res = new TreeMap<>();
 
             consumerGroups.forEach((groupId, consumerGroup) -> {
                 String state = consumerGroup.state().toString();
@@ -763,7 +764,7 @@ public class ConsumerGroupCommand {
                         consumer.assignment().topicPartitions().size(),
                         new ArrayList<>(verbose ? consumer.assignment().topicPartitions() : Collections.emptySet())
                 )).collect(Collectors.toList());
-                res.put(groupId, new Tuple2<>(Optional.of(state), Optional.of(memberAssignmentStates)));
+                res.put(groupId, new SimpleImmutableEntry<>(Optional.of(state), Optional.of(memberAssignmentStates)));
             });
             return res;
         }
@@ -836,7 +837,7 @@ public class ConsumerGroupCommand {
                 });
 
                 Map<TopicPartition, LogOffsetResult> successfulLogTimestampOffsets = successfulOffsetsForTimes.entrySet().stream()
-                    .collect(Collectors.toMap(Map.Entry::getKey, e -> new LogOffset(e.getValue().offset())));
+                    .collect(Collectors.toMap(Entry::getKey, e -> new LogOffset(e.getValue().offset())));
 
                 unsuccessfulOffsetsForTimes.forEach((tp, offsetResultInfo) ->
                     System.out.println("\nWarn: Partition " + tp.partition() + " from topic " + tp.topic() +
@@ -991,7 +992,7 @@ public class ConsumerGroupCommand {
             if (opts.options.has(opts.resetToOffsetOpt)) {
                 long offset = opts.options.valueOf(opts.resetToOffsetOpt);
                 return checkOffsetsRange(partitionsToReset.stream().collect(Collectors.toMap(Function.identity(), tp -> offset)))
-                    .entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+                    .entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
             } else if (opts.options.has(opts.resetToEarliestOpt)) {
                 Map<TopicPartition, LogOffsetResult> logStartOffsets = getLogStartOffsets(partitionsToReset);
                 return partitionsToReset.stream().collect(Collectors.toMap(Function.identity(), topicPartition -> {
@@ -1029,7 +1030,7 @@ public class ConsumerGroupCommand {
                     return currentOffset.offset() + shiftBy;
                 }));
                 return checkOffsetsRange(requestedOffsets).entrySet().stream()
-                    .collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+                    .collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
             } else if (opts.options.has(opts.resetToDatetimeOpt)) {
                 try {
                     long timestamp = Utils.getDateTime(opts.options.valueOf(opts.resetToDatetimeOpt));
@@ -1078,7 +1079,7 @@ public class ConsumerGroupCommand {
                         topicPartition -> resetPlanForGroup.get(topicPartition).offset()));
 
                     return checkOffsetsRange(requestedOffsets).entrySet().stream()
-                        .collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+                        .collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
                 }).orElseGet(Collections::emptyMap);
             } else if (opts.options.has(opts.resetToCurrentOpt)) {
                 Map<TopicPartition, OffsetAndMetadata> currentCommittedOffsets = getCommittedOffsets(groupId);
@@ -1104,7 +1105,7 @@ public class ConsumerGroupCommand {
                     }));
 
                 Map<TopicPartition, OffsetAndMetadata> preparedOffsetsForPartitionsWithoutCommittedOffset = getLogEndOffsets(partitionsToResetWithoutCommittedOffset)
-                    .entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> {
+                    .entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> {
                         if (!(e.getValue() instanceof LogOffset)) {
                             ToolsUtils.printUsageAndExit(opts.parser, "Error getting ending offset of topic partition: " + e.getKey());
                             return null;
diff --git a/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java b/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
index 36233469807..47c4a8234a1 100644
--- a/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
+++ b/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
@@ -49,9 +49,9 @@ import org.apache.kafka.server.util.json.JsonObject;
 import org.apache.kafka.server.util.json.JsonValue;
 import org.apache.kafka.tools.TerseException;
 import org.apache.kafka.tools.ToolsUtils;
-import org.apache.kafka.tools.Tuple2;
 
 import java.io.IOException;
+import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -62,6 +62,7 @@ import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
@@ -203,20 +204,20 @@ public class ReassignPartitionsCommand {
                                                    String jsonString,
                                                    Boolean preserveThrottles
     ) throws ExecutionException, InterruptedException, JsonProcessingException {
-        Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
+        Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
 
-        List<Tuple2<TopicPartition, List<Integer>>> targetParts = t0.v1;
-        Map<TopicPartitionReplica, String> targetLogDirs = t0.v2;
+        List<Entry<TopicPartition, List<Integer>>> targetParts = t0.getKey();
+        Map<TopicPartitionReplica, String> targetLogDirs = t0.getValue();
 
-        Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> t1 = verifyPartitionAssignments(adminClient, targetParts);
+        Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> t1 = verifyPartitionAssignments(adminClient, targetParts);
 
-        Map<TopicPartition, PartitionReassignmentState> partStates = t1.v1;
-        Boolean partsOngoing = t1.v2;
+        Map<TopicPartition, PartitionReassignmentState> partStates = t1.getKey();
+        Boolean partsOngoing = t1.getValue();
 
-        Tuple2<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> t2 = verifyReplicaMoves(adminClient, targetLogDirs);
+        Entry<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> t2 = verifyReplicaMoves(adminClient, targetLogDirs);
 
-        Map<TopicPartitionReplica, LogDirMoveState> moveStates = t2.v1;
-        Boolean movesOngoing = t2.v2;
+        Map<TopicPartitionReplica, LogDirMoveState> moveStates = t2.getKey();
+        Boolean movesOngoing = t2.getValue();
 
         if (!partsOngoing && !movesOngoing && !preserveThrottles) {
             // If the partition assignments and replica assignments are done, clear any throttles
@@ -240,11 +241,11 @@ public class ReassignPartitionsCommand {
      *                              reassignments (including reassignments not described
      *                              in the JSON file.)
      */
-    private static Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> verifyPartitionAssignments(Admin adminClient,
-                                                                                                               List<Tuple2<TopicPartition, List<Integer>>> targets
+    private static Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> verifyPartitionAssignments(Admin adminClient,
+                                                                                                               List<Entry<TopicPartition, List<Integer>>> targets
     ) throws ExecutionException, InterruptedException {
-        Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> t0 = findPartitionReassignmentStates(adminClient, targets);
-        System.out.println(partitionReassignmentStatesToString(t0.v1));
+        Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> t0 = findPartitionReassignmentStates(adminClient, targets);
+        System.out.println(partitionReassignmentStatesToString(t0.getKey()));
         return t0;
     }
 
@@ -301,27 +302,27 @@ public class ReassignPartitionsCommand {
      * @return                     A tuple containing the reassignment states for each topic
      *                             partition, plus whether there are any ongoing reassignments.
      */
-    static Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> findPartitionReassignmentStates(Admin adminClient,
-                                                                                                            List<Tuple2<TopicPartition,
+    static Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> findPartitionReassignmentStates(Admin adminClient,
+                                                                                                            List<Entry<TopicPartition,
                                                                                                             List<Integer>>> targetReassignments
     ) throws ExecutionException, InterruptedException {
         Map<TopicPartition, PartitionReassignment> currentReassignments = adminClient.
             listPartitionReassignments().reassignments().get();
 
-        List<Tuple2<TopicPartition, List<Integer>>> foundReassignments = new ArrayList<>();
-        List<Tuple2<TopicPartition, List<Integer>>> notFoundReassignments = new ArrayList<>();
+        List<Entry<TopicPartition, List<Integer>>> foundReassignments = new ArrayList<>();
+        List<Entry<TopicPartition, List<Integer>>> notFoundReassignments = new ArrayList<>();
 
         targetReassignments.forEach(reassignment -> {
-            if (currentReassignments.containsKey(reassignment.v1))
+            if (currentReassignments.containsKey(reassignment.getKey()))
                 foundReassignments.add(reassignment);
             else
                 notFoundReassignments.add(reassignment);
         });
 
-        List<Tuple2<TopicPartition, PartitionReassignmentState>> foundResults = foundReassignments.stream().map(e -> {
-            TopicPartition part = e.v1;
-            List<Integer> targetReplicas = e.v2;
-            return new Tuple2<>(part,
+        List<Entry<TopicPartition, PartitionReassignmentState>> foundResults = foundReassignments.stream().map(e -> {
+            TopicPartition part = e.getKey();
+            List<Integer> targetReplicas = e.getValue();
+            return new SimpleImmutableEntry<>(part,
                 new PartitionReassignmentState(
                     currentReassignments.get(part).replicas(),
                     targetReplicas,
@@ -329,7 +330,7 @@ public class ReassignPartitionsCommand {
         }).collect(Collectors.toList());
 
         Set<String> topicNamesToLookUp = notFoundReassignments.stream()
-            .map(e -> e.v1)
+            .map(e -> e.getKey())
             .filter(part -> !currentReassignments.containsKey(part))
             .map(TopicPartition::topic)
             .collect(Collectors.toSet());
@@ -337,28 +338,28 @@ public class ReassignPartitionsCommand {
         Map<String, KafkaFuture<TopicDescription>> topicDescriptions = adminClient.
             describeTopics(topicNamesToLookUp).topicNameValues();
 
-        List<Tuple2<TopicPartition, PartitionReassignmentState>> notFoundResults = new ArrayList<>();
-        for (Tuple2<TopicPartition, List<Integer>> e : notFoundReassignments) {
-            TopicPartition part = e.v1;
-            List<Integer> targetReplicas = e.v2;
+        List<Entry<TopicPartition, PartitionReassignmentState>> notFoundResults = new ArrayList<>();
+        for (Entry<TopicPartition, List<Integer>> e : notFoundReassignments) {
+            TopicPartition part = e.getKey();
+            List<Integer> targetReplicas = e.getValue();
 
             if (currentReassignments.containsKey(part)) {
                 PartitionReassignment reassignment = currentReassignments.get(part);
-                notFoundResults.add(new Tuple2<>(part, new PartitionReassignmentState(
+                notFoundResults.add(new SimpleImmutableEntry<>(part, new PartitionReassignmentState(
                     reassignment.replicas(),
                     targetReplicas,
                     false)));
             } else {
-                notFoundResults.add(new Tuple2<>(part, topicDescriptionFutureToState(part.partition(),
+                notFoundResults.add(new SimpleImmutableEntry<>(part, topicDescriptionFutureToState(part.partition(),
                     topicDescriptions.get(part.topic()), targetReplicas)));
             }
         }
 
         Map<TopicPartition, PartitionReassignmentState> allResults = new HashMap<>();
-        foundResults.forEach(e -> allResults.put(e.v1, e.v2));
-        notFoundResults.forEach(e -> allResults.put(e.v1, e.v2));
+        foundResults.forEach(e -> allResults.put(e.getKey(), e.getValue()));
+        notFoundResults.forEach(e -> allResults.put(e.getKey(), e.getValue()));
 
-        return new Tuple2<>(allResults, !currentReassignments.isEmpty());
+        return new SimpleImmutableEntry<>(allResults, !currentReassignments.isEmpty());
     }
 
     private static PartitionReassignmentState topicDescriptionFutureToState(int partition,
@@ -396,12 +397,12 @@ public class ReassignPartitionsCommand {
      *                              reassignments. (We don't have an efficient API that
      *                              returns all ongoing replica reassignments.)
      */
-    private static Tuple2<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> verifyReplicaMoves(Admin adminClient,
+    private static Entry<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> verifyReplicaMoves(Admin adminClient,
                                                                                                    Map<TopicPartitionReplica, String> targetReassignments
     ) throws ExecutionException, InterruptedException {
         Map<TopicPartitionReplica, LogDirMoveState> moveStates = findLogDirMoveStates(adminClient, targetReassignments);
         System.out.println(replicaMoveStatesToString(moveStates));
-        return new Tuple2<>(moveStates, !moveStates.values().stream().allMatch(LogDirMoveState::done));
+        return new SimpleImmutableEntry<>(moveStates, !moveStates.values().stream().allMatch(LogDirMoveState::done));
     }
 
     /**
@@ -420,7 +421,7 @@ public class ReassignPartitionsCommand {
         Map<TopicPartitionReplica, DescribeReplicaLogDirsResult.ReplicaLogDirInfo> replicaLogDirInfos = adminClient
             .describeReplicaLogDirs(targetMoves.keySet()).all().get();
 
-        return targetMoves.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> {
+        return targetMoves.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> {
             TopicPartitionReplica replica = e.getKey();
             String targetLogDir = e.getValue();
 
@@ -492,16 +493,16 @@ public class ReassignPartitionsCommand {
      * @param targetParts     The target partitions loaded from the JSON file.
      */
     private static void clearAllThrottles(Admin adminClient,
-                                          List<Tuple2<TopicPartition, List<Integer>>> targetParts
+                                          List<Entry<TopicPartition, List<Integer>>> targetParts
     ) throws ExecutionException, InterruptedException {
         Set<Integer> brokers = adminClient.describeCluster().nodes().get().stream().map(Node::id).collect(Collectors.toSet());
-        targetParts.forEach(t -> brokers.addAll(t.v2));
+        targetParts.forEach(t -> brokers.addAll(t.getValue()));
 
         System.out.printf("Clearing broker-level throttles on broker%s %s%n",
             brokers.size() == 1 ? "" : "s", Utils.join(brokers, ","));
         clearBrokerLevelThrottles(adminClient, brokers);
 
-        Set<String> topics = targetParts.stream().map(t -> t.v1.topic()).collect(Collectors.toSet());
+        Set<String> topics = targetParts.stream().map(t -> t.getKey().topic()).collect(Collectors.toSet());
         System.out.printf("Clearing topic-level throttles on topic%s %s%n",
             topics.size() == 1 ? "" : "s", Utils.join(topics, ","));
         clearTopicLevelThrottles(adminClient, topics);
@@ -550,15 +551,15 @@ public class ReassignPartitionsCommand {
      * @return                      A tuple containing the proposed assignment and the
      *                              current assignment.
      */
-    public static Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>> generateAssignment(Admin adminClient,
+    public static Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>> generateAssignment(Admin adminClient,
                                                                                                              String reassignmentJson,
                                                                                                              String brokerListString,
                                                                                                              Boolean enableRackAwareness
     ) throws ExecutionException, InterruptedException, JsonProcessingException {
-        Tuple2<List<Integer>, List<String>> t0 = parseGenerateAssignmentArgs(reassignmentJson, brokerListString);
+        Entry<List<Integer>, List<String>> t0 = parseGenerateAssignmentArgs(reassignmentJson, brokerListString);
 
-        List<Integer> brokersToReassign = t0.v1;
-        List<String> topicsToReassign = t0.v2;
+        List<Integer> brokersToReassign = t0.getKey();
+        List<String> topicsToReassign = t0.getValue();
 
         Map<TopicPartition, List<Integer>> currentAssignments = getReplicaAssignmentForTopics(adminClient, topicsToReassign);
         List<BrokerMetadata> brokerMetadatas = getBrokerMetadata(adminClient, brokersToReassign, enableRackAwareness);
@@ -567,7 +568,7 @@ public class ReassignPartitionsCommand {
             formatAsReassignmentJson(currentAssignments, Collections.emptyMap()));
         System.out.printf("Proposed partition reassignment configuration%n%s%n",
             formatAsReassignmentJson(proposedAssignments, Collections.emptyMap()));
-        return new Tuple2<>(proposedAssignments, currentAssignments);
+        return new SimpleImmutableEntry<>(proposedAssignments, currentAssignments);
     }
 
     /**
@@ -580,8 +581,8 @@ public class ReassignPartitionsCommand {
      */
     private static Map<TopicPartition, List<Integer>> calculateAssignment(Map<TopicPartition, List<Integer>> currentAssignment,
                                                                           List<BrokerMetadata> brokerMetadatas) {
-        Map<String, List<Map.Entry<TopicPartition, List<Integer>>>> groupedByTopic = new HashMap<>();
-        for (Map.Entry<TopicPartition, List<Integer>> e : currentAssignment.entrySet())
+        Map<String, List<Entry<TopicPartition, List<Integer>>>> groupedByTopic = new HashMap<>();
+        for (Entry<TopicPartition, List<Integer>> e : currentAssignment.entrySet())
             groupedByTopic.computeIfAbsent(e.getKey().topic(), k -> new ArrayList<>()).add(e);
         Map<TopicPartition, List<Integer>> proposedAssignments = new HashMap<>();
         groupedByTopic.forEach((topic, assignment) -> {
@@ -598,7 +599,7 @@ public class ReassignPartitionsCommand {
                                                                 Set<String> topics) throws ExecutionException, InterruptedException {
         Map<String, KafkaFuture<TopicDescription>> futures = adminClient.describeTopics(topics).topicNameValues();
         Map<String, TopicDescription> res = new HashMap<>();
-        for (Map.Entry<String, KafkaFuture<TopicDescription>> e : futures.entrySet()) {
+        for (Entry<String, KafkaFuture<TopicDescription>> e : futures.entrySet()) {
             String topicName = e.getKey();
             KafkaFuture<TopicDescription> topicDescriptionFuture = e.getValue();
             try {
@@ -695,7 +696,7 @@ public class ReassignPartitionsCommand {
      *
      * @return                       A tuple of brokers to reassign, topics to reassign
      */
-    static Tuple2<List<Integer>, List<String>> parseGenerateAssignmentArgs(String reassignmentJson,
+    static Entry<List<Integer>, List<String>> parseGenerateAssignmentArgs(String reassignmentJson,
                                                                            String brokerList) throws JsonMappingException {
         List<Integer> brokerListToReassign = Arrays.stream(brokerList.split(",")).map(Integer::parseInt).collect(Collectors.toList());
         Set<Integer> duplicateReassignments = ToolsUtils.duplicates(brokerListToReassign);
@@ -706,7 +707,7 @@ public class ReassignPartitionsCommand {
         if (!duplicateTopicsToReassign.isEmpty())
             throw new AdminCommandFailedException(String.format("List of topics to reassign contains duplicate entries: %s",
                 duplicateTopicsToReassign));
-        return new Tuple2<>(brokerListToReassign, topicsToReassign);
+        return new SimpleImmutableEntry<>(brokerListToReassign, topicsToReassign);
     }
 
     /**
@@ -731,10 +732,10 @@ public class ReassignPartitionsCommand {
                                   Long timeoutMs,
                                   Time time
     ) throws ExecutionException, InterruptedException, JsonProcessingException, TerseException {
-        Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> t0 = parseExecuteAssignmentArgs(reassignmentJson);
+        Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> t0 = parseExecuteAssignmentArgs(reassignmentJson);
 
-        Map<TopicPartition, List<Integer>> proposedParts = t0.v1;
-        Map<TopicPartitionReplica, String> proposedReplicas = t0.v2;
+        Map<TopicPartition, List<Integer>> proposedParts = t0.getKey();
+        Map<TopicPartitionReplica, String> proposedReplicas = t0.getValue();
         Map<TopicPartition, PartitionReassignment> currentReassignments = adminClient.
             listPartitionReassignments().reassignments().get();
         // If there is an existing assignment, check for --additional before proceeding.
@@ -901,7 +902,7 @@ public class ReassignPartitionsCommand {
                                                             Map<TopicPartition, List<Integer>> currentParts) throws JsonProcessingException {
         Map<TopicPartition, List<Integer>> partitionsToBeReassigned = currentParts.entrySet().stream()
             .filter(e -> proposedParts.containsKey(e.getKey()))
-            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+            .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
 
         return String.format("Current partition replica assignment%n%n%s%n%nSave this to use as the %s",
             formatAsReassignmentJson(partitionsToBeReassigned, Collections.emptyMap()),
@@ -921,7 +922,7 @@ public class ReassignPartitionsCommand {
         reassignments.forEach((part, replicas) -> args.put(part, Optional.of(new NewPartitionReassignment(replicas))));
         Map<TopicPartition, KafkaFuture<Void>> results = adminClient.alterPartitionReassignments(args).values();
         Map<TopicPartition, Throwable> errors = new HashMap<>();
-        for (Map.Entry<TopicPartition, KafkaFuture<Void>> e :  results.entrySet()) {
+        for (Entry<TopicPartition, KafkaFuture<Void>> e :  results.entrySet()) {
             try {
                 e.getValue().get();
             } catch (ExecutionException t) {
@@ -945,7 +946,7 @@ public class ReassignPartitionsCommand {
 
         Map<TopicPartition, KafkaFuture<Void>> results = adminClient.alterPartitionReassignments(args).values();
         Map<TopicPartition, Throwable> errors = new HashMap<>();
-        for (Map.Entry<TopicPartition, KafkaFuture<Void>> e :  results.entrySet()) {
+        for (Entry<TopicPartition, KafkaFuture<Void>> e :  results.entrySet()) {
             try {
                 e.getValue().get();
             } catch (ExecutionException t) {
@@ -993,7 +994,7 @@ public class ReassignPartitionsCommand {
                                                                              Map<TopicPartition, List<Integer>> proposedParts,
                                                                              Map<TopicPartition, List<Integer>> currentParts) {
         Map<String, Map<Integer, PartitionMove>> moveMap = calculateCurrentMoveMap(currentReassignments);
-        for (Map.Entry<TopicPartition, List<Integer>> e : proposedParts.entrySet()) {
+        for (Entry<TopicPartition, List<Integer>> e : proposedParts.entrySet()) {
             TopicPartition part = e.getKey();
             List<Integer> replicas = e.getValue();
             Map<Integer, PartitionMove> partMoves = moveMap.computeIfAbsent(part.topic(), k -> new HashMap<>());
@@ -1178,39 +1179,39 @@ public class ReassignPartitionsCommand {
      * @return                  A tuple of the partitions to be reassigned and the replicas
      *                          to be reassigned.
      */
-    static Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> parseExecuteAssignmentArgs(
+    static Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> parseExecuteAssignmentArgs(
         String reassignmentJson
     ) throws JsonProcessingException {
-        Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(reassignmentJson);
+        Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(reassignmentJson);
 
-        List<Tuple2<TopicPartition, List<Integer>>> partitionsToBeReassigned = t0.v1;
-        Map<TopicPartitionReplica, String> replicaAssignment = t0.v2;
+        List<Entry<TopicPartition, List<Integer>>> partitionsToBeReassigned = t0.getKey();
+        Map<TopicPartitionReplica, String> replicaAssignment = t0.getValue();
 
         if (partitionsToBeReassigned.isEmpty())
             throw new AdminCommandFailedException("Partition reassignment list cannot be empty");
-        if (partitionsToBeReassigned.stream().anyMatch(t -> t.v2.isEmpty())) {
+        if (partitionsToBeReassigned.stream().anyMatch(t -> t.getValue().isEmpty())) {
             throw new AdminCommandFailedException("Partition replica list cannot be empty");
         }
-        Set<TopicPartition> duplicateReassignedPartitions = ToolsUtils.duplicates(partitionsToBeReassigned.stream().map(t -> t.v1).collect(Collectors.toList()));
+        Set<TopicPartition> duplicateReassignedPartitions = ToolsUtils.duplicates(partitionsToBeReassigned.stream().map(t -> t.getKey()).collect(Collectors.toList()));
         if (!duplicateReassignedPartitions.isEmpty()) {
             throw new AdminCommandFailedException(String.format(
                 "Partition reassignment contains duplicate topic partitions: %s",
                 duplicateReassignedPartitions.stream().map(Object::toString).collect(Collectors.joining(",")))
             );
         }
-        List<Tuple2<TopicPartition, Set<Integer>>> duplicateEntries = partitionsToBeReassigned.stream()
-            .map(t -> new Tuple2<>(t.v1, ToolsUtils.duplicates(t.v2)))
-            .filter(t -> !t.v2.isEmpty())
+        List<Entry<TopicPartition, Set<Integer>>> duplicateEntries = partitionsToBeReassigned.stream()
+            .map(t -> new SimpleImmutableEntry<>(t.getKey(), ToolsUtils.duplicates(t.getValue())))
+            .filter(t -> !t.getValue().isEmpty())
             .collect(Collectors.toList());
         if (!duplicateEntries.isEmpty()) {
             String duplicatesMsg = duplicateEntries.stream().map(t ->
                 String.format("%s contains multiple entries for %s",
-                    t.v1,
-                    t.v2.stream().map(Object::toString).collect(Collectors.joining(",")))
+                    t.getKey(),
+                    t.getValue().stream().map(Object::toString).collect(Collectors.joining(",")))
             ).collect(Collectors.joining(". "));
             throw new AdminCommandFailedException(String.format("Partition replica lists may not contain duplicate entries: %s", duplicatesMsg));
         }
-        return new Tuple2<>(partitionsToBeReassigned.stream().collect(Collectors.toMap(t -> t.v1, t -> t.v2)), replicaAssignment);
+        return new SimpleImmutableEntry<>(partitionsToBeReassigned.stream().collect(Collectors.toMap(t -> t.getKey(), t -> t.getValue())), replicaAssignment);
     }
 
     /**
@@ -1226,17 +1227,17 @@ public class ReassignPartitionsCommand {
      * @return                      A tuple of the partition reassignments that were cancelled,
      *                              and the replica movements that were cancelled.
      */
-    static Tuple2<Set<TopicPartition>, Set<TopicPartitionReplica>> cancelAssignment(Admin adminClient,
+    static Entry<Set<TopicPartition>, Set<TopicPartitionReplica>> cancelAssignment(Admin adminClient,
                                                                                     String jsonString,
                                                                                     Boolean preserveThrottles,
                                                                                     Long timeoutMs,
                                                                                     Time time
     ) throws ExecutionException, InterruptedException, JsonProcessingException, TerseException {
-        Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
+        Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
 
-        List<Tuple2<TopicPartition, List<Integer>>> targetParts = t0.v1;
-        Map<TopicPartitionReplica, String> targetReplicas = t0.v2;
-        Set<TopicPartition> targetPartsSet = targetParts.stream().map(t -> t.v1).collect(Collectors.toSet());
+        List<Entry<TopicPartition, List<Integer>>> targetParts = t0.getKey();
+        Map<TopicPartitionReplica, String> targetReplicas = t0.getValue();
+        Set<TopicPartition> targetPartsSet = targetParts.stream().map(t -> t.getKey()).collect(Collectors.toSet());
         Set<TopicPartition> curReassigningParts = new HashSet<>();
         adminClient.listPartitionReassignments(targetPartsSet).reassignments().get().forEach((part, reassignment) -> {
             if (reassignment.addingReplicas().isEmpty() || !reassignment.removingReplicas().isEmpty())
@@ -1273,7 +1274,7 @@ public class ReassignPartitionsCommand {
         if (!preserveThrottles) {
             clearAllThrottles(adminClient, targetParts);
         }
-        return new Tuple2<>(curReassigningParts, curMovingParts.keySet());
+        return new SimpleImmutableEntry<>(curReassigningParts, curMovingParts.keySet());
     }
 
     public static String formatAsReassignmentJson(Map<TopicPartition, List<Integer>> partitionsToBeReassigned,
@@ -1330,7 +1331,7 @@ public class ReassignPartitionsCommand {
         }
     }
 
-    private static Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
+    private static Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
         String jsonData
     ) throws JsonProcessingException {
         JsonValue js;
@@ -1344,12 +1345,12 @@ public class ReassignPartitionsCommand {
     }
 
     // Parses without deduplicating keys so the data can be checked before allowing reassignment to proceed
-    private static Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
+    private static Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
         int version, JsonValue jsonData
     ) throws JsonMappingException {
         switch (version) {
             case 1:
-                List<Tuple2<TopicPartition, List<Integer>>> partitionAssignment = new ArrayList<>();
+                List<Entry<TopicPartition, List<Integer>>> partitionAssignment = new ArrayList<>();
                 Map<TopicPartitionReplica, String> replicaAssignment = new HashMap<>();
 
                 Optional<JsonValue> partitionsSeq = jsonData.asJsonObject().get("partitions");
@@ -1369,7 +1370,7 @@ public class ReassignPartitionsCommand {
                         if (newReplicas.size() != newLogDirs.size())
                             throw new AdminCommandFailedException("Size of replicas list " + newReplicas + " is different from " +
                                 "size of log dirs list " + newLogDirs + " for partition " + new TopicPartition(topic, partition));
-                        partitionAssignment.add(new Tuple2<>(new TopicPartition(topic, partition), newReplicas));
+                        partitionAssignment.add(new SimpleImmutableEntry<>(new TopicPartition(topic, partition), newReplicas));
                         for (int i = 0; i < newLogDirs.size(); i++) {
                             Integer replica = newReplicas.get(i);
                             String logDir = newLogDirs.get(i);
@@ -1382,7 +1383,7 @@ public class ReassignPartitionsCommand {
                     }
                 }
 
-                return new Tuple2<>(partitionAssignment, replicaAssignment);
+                return new SimpleImmutableEntry<>(partitionAssignment, replicaAssignment);
 
             default:
                 throw new AdminOperationException("Not supported version field value " + version);
@@ -1481,7 +1482,7 @@ public class ReassignPartitionsCommand {
         Set<TopicPartitionReplica> results = new HashSet<>();
         Map<TopicPartitionReplica, KafkaFuture<Void>> values = adminClient.alterReplicaLogDirs(assignment).values();
 
-        for (Map.Entry<TopicPartitionReplica, KafkaFuture<Void>> e : values.entrySet()) {
+        for (Entry<TopicPartitionReplica, KafkaFuture<Void>> e : values.entrySet()) {
             TopicPartitionReplica replica = e.getKey();
             KafkaFuture<Void> future = e.getValue();
             try {
diff --git a/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java b/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
index 0bb2c9c9d1b..d427828f2c7 100644
--- a/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
+++ b/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
@@ -31,12 +31,14 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintStream;
+import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
@@ -155,7 +157,7 @@ public class ToolsTestUtils {
     }
 
     public static void assignThrottledPartitionReplicas(Admin adminClient, Map<TopicPartition, List<Integer>> allReplicasByPartition) throws InterruptedException, ExecutionException {
-        Map<ConfigResource, List<Map.Entry<TopicPartition, List<Integer>>>> configResourceToPartitionReplicas =
+        Map<ConfigResource, List<Entry<TopicPartition, List<Integer>>>> configResourceToPartitionReplicas =
             allReplicasByPartition.entrySet().stream()
             .collect(Collectors.groupingBy(
                 topicPartitionListEntry -> new ConfigResource(ConfigResource.Type.TOPIC, topicPartitionListEntry.getKey().topic()))
@@ -163,10 +165,10 @@ public class ToolsTestUtils {
 
         Map<ConfigResource, List<AlterConfigOp>> throttles = configResourceToPartitionReplicas.entrySet().stream()
             .collect(
-                Collectors.toMap(Map.Entry::getKey, entry -> {
+                Collectors.toMap(Entry::getKey, entry -> {
                     List<AlterConfigOp> alterConfigOps = new ArrayList<>();
                     Map<TopicPartition, List<Integer>> replicaThrottle =
-                        entry.getValue().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                        entry.getValue().stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue));
                     alterConfigOps.add(new AlterConfigOp(
                         new ConfigEntry(LogConfig.LEADER_REPLICATION_THROTTLED_REPLICAS_CONFIG, formatReplicaThrottles(replicaThrottle)),
                         AlterConfigOp.OpType.SET));
@@ -204,7 +206,7 @@ public class ToolsTestUtils {
 
     public static File tempPropertiesFile(Map<String, String> properties) throws IOException {
         StringBuilder sb = new StringBuilder();
-        for (Map.Entry<String, String> entry : properties.entrySet()) {
+        for (Entry<String, String> entry : properties.entrySet()) {
             sb.append(entry.getKey() + "=" + entry.getValue() + System.lineSeparator());
         }
         return org.apache.kafka.test.TestUtils.tempFile(sb.toString());
@@ -249,7 +251,7 @@ public class ToolsTestUtils {
     /**
      * Capture both the console output and console error during the execution of the provided function.
      */
-    public static Tuple2<String, String> grabConsoleOutputAndError(Runnable f) {
+    public static Entry<String, String> grabConsoleOutputAndError(Runnable f) {
         ByteArrayOutputStream outBuf = new ByteArrayOutputStream();
         ByteArrayOutputStream errBuf = new ByteArrayOutputStream();
         PrintStream out = new PrintStream(outBuf);
@@ -267,7 +269,7 @@ public class ToolsTestUtils {
         }
         out.flush();
         err.flush();
-        return new Tuple2<>(outBuf.toString(), errBuf.toString());
+        return new SimpleImmutableEntry<>(outBuf.toString(), errBuf.toString());
     }
 
     public static class MockExitProcedure implements Exit.Procedure {
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
index b7583c1c44f..4fd7e3b9197 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
@@ -38,7 +38,6 @@ import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.TopicPartitionInfo;
 import org.apache.kafka.common.internals.KafkaFutureImpl;
 import org.apache.kafka.common.utils.Utils;
-import org.apache.kafka.tools.Tuple2;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatcher;
 import org.mockito.ArgumentMatchers;
@@ -49,11 +48,12 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -91,10 +91,10 @@ public class ConsumerGroupServiceTest {
         when(admin.listOffsets(offsetsArgMatcher(), any()))
                 .thenReturn(listOffsetsResult());
 
-        Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
-        assertEquals(Optional.of("Stable"), statesAndAssignments.v1);
-        assertTrue(statesAndAssignments.v2.isPresent());
-        assertEquals(TOPIC_PARTITIONS.size(), statesAndAssignments.v2.get().size());
+        Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
+        assertEquals(Optional.of("Stable"), statesAndAssignments.getKey());
+        assertTrue(statesAndAssignments.getValue().isPresent());
+        assertEquals(TOPIC_PARTITIONS.size(), statesAndAssignments.getValue().get().size());
 
         verify(admin, times(1)).describeConsumerGroups(ArgumentMatchers.eq(Collections.singletonList(GROUP)), any());
         verify(admin, times(1)).listConsumerGroupOffsets(ArgumentMatchers.eq(listConsumerGroupOffsetsSpec()), any());
@@ -157,16 +157,16 @@ public class ConsumerGroupServiceTest {
                 ArgumentMatchers.argThat(offsetsArgMatcher.apply(assignedTopicPartitions)),
                 any()
         )).thenReturn(new ListOffsetsResult(endOffsets.entrySet().stream().filter(e -> assignedTopicPartitions.contains(e.getKey()))
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))));
+                .collect(Collectors.toMap(Entry::getKey, Entry::getValue))));
         when(admin.listOffsets(
                 ArgumentMatchers.argThat(offsetsArgMatcher.apply(unassignedTopicPartitions)),
                 any()
         )).thenReturn(new ListOffsetsResult(endOffsets.entrySet().stream().filter(e -> unassignedTopicPartitions.contains(e.getKey()))
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))));
+                .collect(Collectors.toMap(Entry::getKey, Entry::getValue))));
 
-        Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
-        Optional<String> state = statesAndAssignments.v1;
-        Optional<Collection<PartitionAssignmentState>> assignments = statesAndAssignments.v2;
+        Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
+        Optional<String> state = statesAndAssignments.getKey();
+        Optional<Collection<PartitionAssignmentState>> assignments = statesAndAssignments.getValue();
 
         Map<TopicPartition, Optional<Long>> returnedOffsets = assignments.map(results ->
             results.stream().collect(Collectors.toMap(
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
index 95fe212c531..b8133433d64 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
@@ -92,7 +92,7 @@ public class DeleteConsumerGroupsTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(
-            () -> service.collectGroupMembers(GROUP, false).v2.get().size() == 1,
+            () -> service.collectGroupMembers(GROUP, false).getValue().get().size() == 1,
             "The group did not initialize as expected."
         );
 
@@ -112,7 +112,7 @@ public class DeleteConsumerGroupsTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(
-            () -> service.collectGroupMembers(GROUP, false).v2.get().size() == 1,
+            () -> service.collectGroupMembers(GROUP, false).getValue().get().size() == 1,
             "The group did not initialize as expected."
         );
 
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
index 05fd00071e1..292180b8af9 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
@@ -29,12 +29,12 @@ import org.apache.kafka.common.serialization.ByteArrayDeserializer;
 import org.apache.kafka.common.serialization.ByteArraySerializer;
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.server.config.Defaults;
-import org.apache.kafka.tools.Tuple2;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.Collections;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.concurrent.ExecutionException;
 
@@ -60,8 +60,8 @@ public class DeleteOffsetsConsumerGroupCommandIntegrationTest extends ConsumerGr
         String topic = "foo:1";
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(getArgs(group, topic));
 
-        Tuple2<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(group, Collections.singletonList(topic));
-        assertEquals(Errors.GROUP_ID_NOT_FOUND, res.v1);
+        Entry<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(group, Collections.singletonList(topic));
+        assertEquals(Errors.GROUP_ID_NOT_FOUND, res.getKey());
     }
 
     @ParameterizedTest(name = TEST_WITH_PARAMETERIZED_QUORUM_NAME)
@@ -145,9 +145,9 @@ public class DeleteOffsetsConsumerGroupCommandIntegrationTest extends ConsumerGr
         withConsumerGroup.accept(() -> {
             String topic = inputPartition >= 0 ? inputTopic + ":" + inputPartition : inputTopic;
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(getArgs(GROUP, topic));
-            Tuple2<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(GROUP, Collections.singletonList(topic));
-            Errors topLevelError = res.v1;
-            Map<TopicPartition, Throwable> partitions = res.v2;
+            Entry<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(GROUP, Collections.singletonList(topic));
+            Errors topLevelError = res.getKey();
+            Map<TopicPartition, Throwable> partitions = res.getValue();
             TopicPartition tp = new TopicPartition(inputTopic, expectedPartition);
             // Partition level error should propagate to top level, unless this is due to a missed partition attempt.
             if (inputPartition >= 0) {
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
index 85f9f5b836a..f1b6bba9ac1 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
@@ -24,7 +24,6 @@ import org.apache.kafka.common.errors.TimeoutException;
 import org.apache.kafka.common.utils.Exit;
 import org.apache.kafka.test.TestUtils;
 import org.apache.kafka.tools.ToolsTestUtils;
-import org.apache.kafka.tools.Tuple2;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
@@ -34,6 +33,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
@@ -138,8 +138,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         String[] cgcArgs = new String[]{"--bootstrap-server", bootstrapServers(listenerName()), "--describe", "--group", group};
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
-        Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(group);
-        assertTrue(res.v1.map(s -> s.contains("Dead")).orElse(false) && res.v2.map(Collection::isEmpty).orElse(false),
+        Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(group);
+        assertTrue(res.getKey().map(s -> s.contains("Dead")).orElse(false) && res.getValue().map(Collection::isEmpty).orElse(false),
             "Expected the state to be 'Dead', with no members in the group '" + group + "'.");
     }
 
@@ -155,12 +155,12 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         String[] cgcArgs = new String[]{"--bootstrap-server", bootstrapServers(listenerName()), "--describe", "--group", group};
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(group, false);
-        assertTrue(res.v1.map(s -> s.contains("Dead")).orElse(false) && res.v2.map(Collection::isEmpty).orElse(false),
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(group, false);
+        assertTrue(res.getKey().map(s -> s.contains("Dead")).orElse(false) && res.getValue().map(Collection::isEmpty).orElse(false),
             "Expected the state to be 'Dead', with no members in the group '" + group + "'.");
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res2 = service.collectGroupMembers(group, true);
-        assertTrue(res2.v1.map(s -> s.contains("Dead")).orElse(false) && res2.v2.map(Collection::isEmpty).orElse(false),
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res2 = service.collectGroupMembers(group, true);
+        assertTrue(res2.getKey().map(s -> s.contains("Dead")).orElse(false) && res2.getValue().map(Collection::isEmpty).orElse(false),
             "Expected the state to be 'Dead', with no members in the group '" + group + "' (verbose option).");
     }
 
@@ -197,8 +197,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
-                return res.v1.trim().split("\n").length == 2 && res.v2.isEmpty();
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                return res.getKey().trim().split("\n").length == 2 && res.getValue().isEmpty();
             }, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
         }
     }
@@ -226,9 +226,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
-                long numLines = Arrays.stream(res.v1.trim().split("\n")).filter(line -> !line.isEmpty()).count();
-                return (numLines == expectedNumLines) && res.v2.isEmpty();
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                long numLines = Arrays.stream(res.getKey().trim().split("\n")).filter(line -> !line.isEmpty()).count();
+                return (numLines == expectedNumLines) && res.getValue().isEmpty();
             }, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
         }
     }
@@ -252,9 +252,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
-                long numLines = Arrays.stream(res.v1.trim().split("\n")).filter(s -> !s.isEmpty()).count();
-                return (numLines == expectedNumLines) && res.v2.isEmpty();
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                long numLines = Arrays.stream(res.getKey().trim().split("\n")).filter(s -> !s.isEmpty()).count();
+                return (numLines == expectedNumLines) && res.getValue().isEmpty();
             }, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
         }
     }
@@ -271,9 +271,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
-            Optional<String> state = groupOffsets.v1;
-            Optional<Collection<PartitionAssignmentState>> assignments = groupOffsets.v2;
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
+            Optional<String> state = groupOffsets.getKey();
+            Optional<Collection<PartitionAssignmentState>> assignments = groupOffsets.getValue();
 
             Predicate<PartitionAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
 
@@ -307,9 +307,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> groupMembers = service.collectGroupMembers(GROUP, false);
-            Optional<String> state = groupMembers.v1;
-            Optional<Collection<MemberAssignmentState>> assignments = groupMembers.v2;
+            Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> groupMembers = service.collectGroupMembers(GROUP, false);
+            Optional<String> state = groupMembers.getKey();
+            Optional<Collection<MemberAssignmentState>> assignments = groupMembers.getValue();
 
             Predicate<MemberAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
 
@@ -331,10 +331,10 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
                 !Objects.equals(assignmentState.host, ConsumerGroupCommand.MISSING_COLUMN_VALUE);
         }, "Expected a 'Stable' group status, rows and valid member information for group " + GROUP + ".");
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
 
-        if (res.v2.isPresent()) {
-            assertTrue(res.v2.get().size() == 1 && res.v2.get().iterator().next().assignment.size() == 1,
+        if (res.getValue().isPresent()) {
+            assertTrue(res.getValue().get().size() == 1 && res.getValue().get().iterator().next().assignment.size() == 1,
                 "Expected a topic partition assigned to the single group member for group " + GROUP);
         } else {
             fail("Expected partition assignments for members of group " + GROUP);
@@ -407,8 +407,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
-                return res.v1.trim().split("\n").length == 2 && res.v2.isEmpty();
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                return res.getKey().trim().split("\n").length == 2 && res.getValue().isEmpty();
             }, "Expected describe group results with one data row for describe type '" + String.join(" ", describeType) + "'");
 
             // stop the consumer so the group has no active member anymore
@@ -431,18 +431,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
-            return res.v1.map(s -> s.contains("Stable")).orElse(false)
-                && res.v2.map(c -> c.stream().anyMatch(assignment -> Objects.equals(assignment.group, GROUP) && assignment.offset.isPresent())).orElse(false);
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+            return res.getKey().map(s -> s.contains("Stable")).orElse(false)
+                && res.getValue().map(c -> c.stream().anyMatch(assignment -> Objects.equals(assignment.group, GROUP) && assignment.offset.isPresent())).orElse(false);
         }, "Expected the group to initially become stable, and to find group in assignments after initial offset commit.");
 
         // stop the consumer so the group has no active member anymore
         executor.shutdown();
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> offsets = service.collectGroupOffsets(GROUP);
-            Optional<String> state = offsets.v1;
-            Optional<Collection<PartitionAssignmentState>> assignments = offsets.v2;
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> offsets = service.collectGroupOffsets(GROUP);
+            Optional<String> state = offsets.getKey();
+            Optional<Collection<PartitionAssignmentState>> assignments = offsets.getValue();
             List<PartitionAssignmentState> testGroupAssignments = assignments.get().stream().filter(a -> Objects.equals(a.group, GROUP)).collect(Collectors.toList());
             PartitionAssignmentState assignment = testGroupAssignments.get(0);
             return state.map(s -> s.contains("Empty")).orElse(false) &&
@@ -465,17 +465,17 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
-            return res.v1.map(s -> s.contains("Stable")).orElse(false)
-                && res.v2.map(c -> c.stream().anyMatch(m -> Objects.equals(m.group, GROUP))).orElse(false);
+            Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+            return res.getKey().map(s -> s.contains("Stable")).orElse(false)
+                && res.getValue().map(c -> c.stream().anyMatch(m -> Objects.equals(m.group, GROUP))).orElse(false);
         }, "Expected the group to initially become stable, and to find group in assignments after initial offset commit.");
 
         // stop the consumer so the group has no active member anymore
         executor.shutdown();
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
-            return res.v1.map(s -> s.contains("Empty")).orElse(false) && res.v2.isPresent() && res.v2.get().isEmpty();
+            Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+            return res.getKey().map(s -> s.contains("Empty")).orElse(false) && res.getValue().isPresent() && res.getValue().get().isEmpty();
         }, "Expected no member in describe group members results for group '" + GROUP + "'");
     }
 
@@ -521,9 +521,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
                 int expectedNumRows = DESCRIBE_TYPE_MEMBERS.contains(describeType) ? 3 : 2;
-                return res.v2.isEmpty() && res.v1.trim().split("\n").length == expectedNumRows;
+                return res.getValue().isEmpty() && res.getKey().trim().split("\n").length == expectedNumRows;
             }, "Expected a single data row in describe group result with describe type '" + String.join(" ", describeType) + "'");
         }
     }
@@ -540,11 +540,11 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
-            return res.v1.map(s -> s.contains("Stable")).isPresent() &&
-                res.v2.isPresent() &&
-                res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 1 &&
-                res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 1;
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+            return res.getKey().map(s -> s.contains("Stable")).isPresent() &&
+                res.getValue().isPresent() &&
+                res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 1 &&
+                res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 1;
         }, "Expected rows for consumers with no assigned partitions in describe group results");
     }
 
@@ -560,18 +560,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
-            return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
-                res.v2.isPresent() &&
-                res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
-                res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 1 &&
-                res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0).count() == 1 &&
-                res.v2.get().stream().allMatch(s -> s.assignment.isEmpty());
+            Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+            return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+                res.getValue().isPresent() &&
+                res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+                res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 1 &&
+                res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0).count() == 1 &&
+                res.getValue().get().stream().allMatch(s -> s.assignment.isEmpty());
         }, "Expected rows for consumers with no assigned partitions in describe group results");
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
-        assertTrue(res.v1.map(s -> s.contains("Stable")).orElse(false)
-                && res.v2.map(c -> c.stream().anyMatch(s -> !s.assignment.isEmpty())).orElse(false),
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+        assertTrue(res.getKey().map(s -> s.contains("Stable")).orElse(false)
+                && res.getValue().map(c -> c.stream().anyMatch(s -> !s.assignment.isEmpty())).orElse(false),
             "Expected additional columns in verbose version of describe members");
     }
 
@@ -608,9 +608,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
             ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
 
             TestUtils.waitForCondition(() -> {
-                Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+                Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
                 int expectedNumRows = DESCRIBE_TYPE_STATE.contains(describeType) ? 2 : 3;
-                return res.v2.isEmpty() && res.v1.trim().split("\n").length == expectedNumRows;
+                return res.getValue().isEmpty() && res.getKey().trim().split("\n").length == expectedNumRows;
             }, "Expected a single data row in describe group result with describe type '" + String.join(" ", describeType) + "'");
         }
     }
@@ -629,12 +629,12 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
-            return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
-                res.v2.isPresent() &&
-                res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
-                res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 2 &&
-                res.v2.get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && !x.partition.isPresent());
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+            return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+                res.getValue().isPresent() &&
+                res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+                res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 2 &&
+                res.getValue().get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && !x.partition.isPresent());
         }, "Expected two rows (one row per consumer) in describe group results.");
     }
 
@@ -652,16 +652,16 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
-            return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
-                res.v2.isPresent() &&
-                res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
-                res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 2 &&
-                res.v2.get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0);
+            Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+            return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+                res.getValue().isPresent() &&
+                res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+                res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 2 &&
+                res.getValue().get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0);
         }, "Expected two rows (one row per consumer) in describe group members results.");
 
-        Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
-        assertTrue(res.v1.map(s -> s.contains("Stable")).orElse(false) && res.v2.map(s -> s.stream().filter(x -> x.assignment.isEmpty()).count()).orElse(0L) == 0,
+        Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+        assertTrue(res.getKey().map(s -> s.contains("Stable")).orElse(false) && res.getValue().map(s -> s.stream().filter(x -> x.assignment.isEmpty()).count()).orElse(0L) == 0,
             "Expected additional columns in verbose version of describe members");
     }
 
@@ -698,9 +698,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
-            return res.v1.map(s -> s.contains("Empty")).orElse(false)
-                && res.v2.isPresent() && res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2;
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+            return res.getKey().map(s -> s.contains("Empty")).orElse(false)
+                && res.getValue().isPresent() && res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2;
         }, "Expected a stable group with two members in describe group state result.");
     }
 
@@ -798,18 +798,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
         ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
 
         TestUtils.waitForCondition(() -> {
-            Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
+            Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
 
             Predicate<PartitionAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
 
-            boolean res = groupOffsets.v1.map(s -> s.contains("Stable")).orElse(false) &&
-                groupOffsets.v2.isPresent() &&
-                groupOffsets.v2.get().stream().filter(isGrp).count() == 1;
+            boolean res = groupOffsets.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+                groupOffsets.getValue().isPresent() &&
+                groupOffsets.getValue().get().stream().filter(isGrp).count() == 1;
 
             if (!res)
                 return false;
 
-            Optional<PartitionAssignmentState> maybeAssignmentState = groupOffsets.v2.get().stream().filter(isGrp).findFirst();
+            Optional<PartitionAssignmentState> maybeAssignmentState = groupOffsets.getValue().get().stream().filter(isGrp).findFirst();
             if (!maybeAssignmentState.isPresent())
                 return false;
 
diff --git a/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java b/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
index 618cf972995..c7c4a4f35e6 100644
--- a/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
+++ b/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
@@ -217,7 +217,7 @@ public class ReplicationQuotasTestRig {
 
             System.out.println("Generating Reassignment");
             Map<TopicPartition, List<Integer>> newAssignment = ReassignPartitionsCommand.generateAssignment(adminClient,
-                json(TOPIC_NAME), brokers.stream().map(Object::toString).collect(Collectors.joining(",")), true).v1;
+                json(TOPIC_NAME), brokers.stream().map(Object::toString).collect(Collectors.joining(",")), true).getKey();
 
             System.out.println("Starting Reassignment");
             long start = System.currentTimeMillis();
diff --git a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
index 83fc665e3e4..0348aa24ffe 100644
--- a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
@@ -43,7 +43,6 @@ import org.apache.kafka.common.serialization.ByteArrayDeserializer;
 import org.apache.kafka.common.utils.Time;
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.tools.TerseException;
-import org.apache.kafka.tools.Tuple2;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -54,6 +53,7 @@ import scala.collection.JavaConverters;
 import scala.collection.Seq;
 
 import java.io.Closeable;
+import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -62,6 +62,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
@@ -395,11 +396,11 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
         waitForVerifyAssignment(cluster.adminClient, assignment, true,
             new VerifyAssignmentResult(partStates, true, Collections.emptyMap(), false));
         // Cancel the reassignment.
-        assertEquals(new Tuple2<>(new HashSet<>(asList(foo0, baz1)), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
+        assertEquals(new SimpleImmutableEntry<>(new HashSet<>(asList(foo0, baz1)), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
         // Broker throttles are still active because we passed --preserve-throttles
         waitForInterBrokerThrottle(asList(0, 1, 2, 3), interBrokerThrottle);
         // Cancelling the reassignment again should reveal nothing to cancel.
-        assertEquals(new Tuple2<>(Collections.emptySet(), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, false));
+        assertEquals(new SimpleImmutableEntry<>(Collections.emptySet(), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, false));
         // This time, the broker throttles were removed.
         waitForBrokerLevelThrottles(unthrottledBrokerConfigs);
         // Verify that there are no ongoing reassignments.
@@ -446,7 +447,7 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
         );
 
         // Now cancel the assignment and verify that the partition is removed from cancelled replicas
-        assertEquals(new Tuple2<>(Collections.singleton(foo0), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
+        assertEquals(new SimpleImmutableEntry<>(Collections.singleton(foo0), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
         verifyReplicaDeleted(foo0, 3);
         verifyReplicaDeleted(foo0, 4);
     }
@@ -708,7 +709,7 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
         }
     }
 
-    private Tuple2<Set<TopicPartition>, Set<TopicPartitionReplica>> runCancelAssignment(
+    private Entry<Set<TopicPartition>, Set<TopicPartitionReplica>> runCancelAssignment(
         Admin adminClient,
         String jsonString,
         Boolean preserveThrottles
diff --git a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
index 699e048fb20..c6f145d9a55 100644
--- a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
@@ -31,18 +31,19 @@ import org.apache.kafka.common.utils.Exit;
 import org.apache.kafka.common.utils.Time;
 import org.apache.kafka.server.common.AdminCommandFailedException;
 import org.apache.kafka.server.common.AdminOperationException;
-import org.apache.kafka.tools.Tuple2;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
+import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
@@ -174,14 +175,14 @@ public class ReassignPartitionsUnitTest {
             expStates.put(new TopicPartition("foo", 1),
                 new PartitionReassignmentState(asList(1, 2, 3), asList(1, 2, 3), true));
 
-            Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> actual =
+            Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> actual =
                 findPartitionReassignmentStates(adminClient, asList(
-                    new Tuple2<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
-                    new Tuple2<>(new TopicPartition("foo", 1), asList(1, 2, 3))
+                    new SimpleImmutableEntry<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
+                    new SimpleImmutableEntry<>(new TopicPartition("foo", 1), asList(1, 2, 3))
                 ));
 
-            assertEquals(expStates, actual.v1);
-            assertTrue(actual.v2);
+            assertEquals(expStates, actual.getKey());
+            assertTrue(actual.getValue());
 
             // Cancel the reassignment and test findPartitionReassignmentStates again.
             Map<TopicPartition, Throwable> cancelResult = cancelPartitionReassignments(adminClient,
@@ -198,12 +199,12 @@ public class ReassignPartitionsUnitTest {
                 new PartitionReassignmentState(asList(1, 2, 3), asList(1, 2, 3), true));
 
             actual = findPartitionReassignmentStates(adminClient, asList(
-                new Tuple2<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
-                new Tuple2<>(new TopicPartition("foo", 1), asList(1, 2, 3))
+                new SimpleImmutableEntry<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
+                new SimpleImmutableEntry<>(new TopicPartition("foo", 1), asList(1, 2, 3))
             ));
 
-            assertEquals(expStates, actual.v1);
-            assertFalse(actual.v2);
+            assertEquals(expStates, actual.getKey());
+            assertFalse(actual.getValue());
         }
     }
 
@@ -338,13 +339,13 @@ public class ReassignPartitionsUnitTest {
             assertThrows(AdminCommandFailedException.class, () -> parseGenerateAssignmentArgs(
                 "{\"topics\": [{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4,5"),
                 "Expected to detect duplicate broker list entries").getMessage());
-        assertEquals(new Tuple2<>(asList(5, 2, 3, 4), asList("foo")),
+        assertEquals(new SimpleImmutableEntry<>(asList(5, 2, 3, 4), asList("foo")),
             parseGenerateAssignmentArgs("{\"topics\": [{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4"));
         assertStartsWith("List of topics to reassign contains duplicate entries",
             assertThrows(AdminCommandFailedException.class, () -> parseGenerateAssignmentArgs(
                 "{\"topics\": [{\"topic\": \"foo\"},{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4"),
                 "Expected to detect duplicate topic entries").getMessage());
-        assertEquals(new Tuple2<>(asList(5, 3, 4), asList("foo", "bar")),
+        assertEquals(new SimpleImmutableEntry<>(asList(5, 3, 4), asList("foo", "bar")),
             parseGenerateAssignmentArgs(
                 "{\"topics\": [{\"topic\": \"foo\"},{\"topic\": \"bar\"}], \"version\":1}", "5,3,4"));
     }
@@ -389,7 +390,7 @@ public class ReassignPartitionsUnitTest {
                     () -> generateAssignment(adminClient, "{\"topics\":[{\"topic\":\"foo\"}]}", "0,1,2,3", true),
                     "Expected generateAssignment to fail").getMessage());
             // It should succeed when --disable-rack-aware is used.
-            Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
+            Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
                 proposedCurrent = generateAssignment(adminClient, "{\"topics\":[{\"topic\":\"foo\"}]}", "0,1,2,3", false);
 
             Map<TopicPartition, List<Integer>> expCurrent = new HashMap<>();
@@ -397,7 +398,7 @@ public class ReassignPartitionsUnitTest {
             expCurrent.put(new TopicPartition("foo", 0), asList(0, 1, 2));
             expCurrent.put(new TopicPartition("foo", 1), asList(1, 2, 3));
 
-            assertEquals(expCurrent, proposedCurrent.v2);
+            assertEquals(expCurrent, proposedCurrent.getValue());
         }
     }
 
@@ -407,7 +408,7 @@ public class ReassignPartitionsUnitTest {
             addTopics(adminClient);
             List<Integer> goalBrokers = asList(0, 1, 3);
 
-            Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
+            Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
                 proposedCurrent = generateAssignment(adminClient,
                     "{\"topics\":[{\"topic\":\"foo\"},{\"topic\":\"bar\"}]}",
                     goalBrokers.stream().map(Object::toString).collect(Collectors.joining(",")), false);
@@ -418,12 +419,12 @@ public class ReassignPartitionsUnitTest {
             expCurrent.put(new TopicPartition("foo", 1), asList(1, 2, 3));
             expCurrent.put(new TopicPartition("bar", 0), asList(2, 3, 0));
 
-            assertEquals(expCurrent, proposedCurrent.v2);
+            assertEquals(expCurrent, proposedCurrent.getValue());
 
             // The proposed assignment should only span the provided brokers
-            proposedCurrent.v1.values().forEach(replicas ->
+            proposedCurrent.getKey().values().forEach(replicas ->
                 assertTrue(goalBrokers.containsAll(replicas),
-                    "Proposed assignment " + proposedCurrent.v1 + " puts replicas on brokers other than " + goalBrokers)
+                    "Proposed assignment " + proposedCurrent.getKey() + " puts replicas on brokers other than " + goalBrokers)
             );
         }
     }
@@ -567,14 +568,14 @@ public class ReassignPartitionsUnitTest {
         partitionsToBeReassigned.put(new TopicPartition("foo", 0), asList(1, 2, 3));
         partitionsToBeReassigned.put(new TopicPartition("foo", 1), asList(3, 4, 5));
 
-        Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> actual = parseExecuteAssignmentArgs(
+        Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> actual = parseExecuteAssignmentArgs(
             "{\"version\":1,\"partitions\":" +
                 "[{\"topic\":\"foo\",\"partition\":0,\"replicas\":[1,2,3],\"log_dirs\":[\"any\",\"any\",\"any\"]}," +
                 "{\"topic\":\"foo\",\"partition\":1,\"replicas\":[3,4,5],\"log_dirs\":[\"any\",\"any\",\"any\"]}" +
                 "]}");
 
-        assertEquals(partitionsToBeReassigned, actual.v1);
-        assertTrue(actual.v2.isEmpty());
+        assertEquals(partitionsToBeReassigned, actual.getKey());
+        assertTrue(actual.getValue().isEmpty());
 
         Map<TopicPartitionReplica, String> replicaAssignment = new HashMap<>();
 
@@ -587,8 +588,8 @@ public class ReassignPartitionsUnitTest {
                 "[{\"topic\":\"foo\",\"partition\":0,\"replicas\":[1,2,3],\"log_dirs\":[\"/tmp/a\",\"/tmp/b\",\"/tmp/c\"]}" +
                 "]}");
 
-        assertEquals(Collections.singletonMap(new TopicPartition("foo", 0), asList(1, 2, 3)), actual.v1);
-        assertEquals(replicaAssignment, actual.v2);
+        assertEquals(Collections.singletonMap(new TopicPartition("foo", 0), asList(1, 2, 3)), actual.getKey());
+        assertEquals(replicaAssignment, actual.getValue());
     }
 
     @Test