[refactor] Java5: use enhanced for loops

dizzzz · dizzzz · commit 20813357b962 · 2025-03-11T12:57:33.000+01:00
diff --git a/exist-core-jmh/src/main/java/org/exist/xquery/utils/StringJoinBenchmark.java b/exist-core-jmh/src/main/java/org/exist/xquery/utils/StringJoinBenchmark.java
@@ -94,8 +94,8 @@ public StringBuilder forApproachRadek(/*final BuilderState builderState*/) {
 //        final StringBuilder builder = builderState.builder;
         final StringBuilder builder = new StringBuilder();
 
-        for (int i = 0; i < strings.size(); i++) {
-            builder.append(strings.get(i));
+        for (String string : strings) {
+            builder.append(string);
             builder.append(", ");
         }
 
diff --git a/exist-core/src/main/java/org/exist/collections/triggers/TriggerStatePerThread.java b/exist-core/src/main/java/org/exist/collections/triggers/TriggerStatePerThread.java
@@ -59,38 +59,38 @@ public static void setAndTest(final Trigger trigger, final TriggerPhase triggerP
 
 				int skipBefores = 0;
 
-				for (final Iterator<TriggerState> it = states.iterator(); it.hasNext(); ) {
-					prevState = it.next();
-
-					// travel up, first "Before" we encounter - we should check if (a) that we complete it, and/or (b) is non-cyclic (if not we are also cyclic)
-					if (prevState.triggerPhase == TriggerPhase.BEFORE) {
-
-						if (skipBefores > 0) {
-							skipBefores--;
-
-						} else {
-							if (prevState.isCompletedBy(trigger, triggerPhase, triggerEvent, src, dst)) {
-								if (prevState instanceof PossibleCyclicTriggerState) {
-									// if the Before phase is a PossibleCyclicTriggerState then this completing After phase must also be a PossibleCyclicTriggerState
-									final TriggerState newState = new PossibleCyclicTriggerState(trigger, triggerPhase, triggerEvent, src, dst);
-									states.addFirst(newState);
-
-									throw new CyclicTriggerException("Detected Matching possible cyclic trigger event for After phase (" + newState + ") of previous Before phase (" + prevState + ")");
-
-								} else {
-									// if the Before Phase is NOT a PossibleCyclicTriggerState, then neither is this completing After phase...
-									states.addFirst(new TriggerState(trigger, triggerPhase, triggerEvent, src, dst));
-									return;
-								}
-
-							} else {
-								throw new IllegalStateException("Cannot interleave Trigger states");
-							}
-						}
-					} else if (prevState.triggerPhase == TriggerPhase.AFTER) {
-						skipBefores++;
-					}
-				}
+                for (TriggerState state : states) {
+                    prevState = state;
+
+                    // travel up, first "Before" we encounter - we should check if (a) that we complete it, and/or (b) is non-cyclic (if not we are also cyclic)
+                    if (prevState.triggerPhase == TriggerPhase.BEFORE) {
+
+                        if (skipBefores > 0) {
+                            skipBefores--;
+
+                        } else {
+                            if (prevState.isCompletedBy(trigger, triggerPhase, triggerEvent, src, dst)) {
+                                if (prevState instanceof PossibleCyclicTriggerState) {
+                                    // if the Before phase is a PossibleCyclicTriggerState then this completing After phase must also be a PossibleCyclicTriggerState
+                                    final TriggerState newState = new PossibleCyclicTriggerState(trigger, triggerPhase, triggerEvent, src, dst);
+                                    states.addFirst(newState);
+
+                                    throw new CyclicTriggerException("Detected Matching possible cyclic trigger event for After phase (" + newState + ") of previous Before phase (" + prevState + ")");
+
+                                } else {
+                                    // if the Before Phase is NOT a PossibleCyclicTriggerState, then neither is this completing After phase...
+                                    states.addFirst(new TriggerState(trigger, triggerPhase, triggerEvent, src, dst));
+                                    return;
+                                }
+
+                            } else {
+                                throw new IllegalStateException("Cannot interleave Trigger states");
+                            }
+                        }
+                    } else if (prevState.triggerPhase == TriggerPhase.AFTER) {
+                        skipBefores++;
+                    }
+                }
 
 				throw new IllegalStateException("Could not find a matching Before phase for After phase");
 
diff --git a/exist-core/src/main/java/org/exist/xquery/functions/map/MapType.java b/exist-core/src/main/java/org/exist/xquery/functions/map/MapType.java
@@ -279,8 +279,7 @@ public boolean contains(AtomicValue key) {
 
     @Override
     public boolean containsReference(final Item item) {
-        for (final Iterator<Sequence> it = map.values().iterator(); it.hasNext();) {
-            final Sequence value = it.next();
+        for (final Sequence value : map.values()) {
             if (value == item || value.containsReference(item)) {
                 return true;
             }
@@ -290,8 +289,7 @@ public boolean containsReference(final Item item) {
 
     @Override
     public boolean contains(final Item item) {
-        for (final Iterator<Sequence> it = map.values().iterator(); it.hasNext();) {
-            final Sequence value = it.next();
+        for (final Sequence value : map.values()) {
             if (value.equals(item) || value.contains(item)) {
                 return true;
             }
diff --git a/exist-core/src/main/java/org/exist/xquery/value/ArrayListValueSequence.java b/exist-core/src/main/java/org/exist/xquery/value/ArrayListValueSequence.java
@@ -240,8 +240,7 @@ public boolean isPersistentSet() {
 
     @Override
     public boolean containsReference(final Item item) {
-        for (final Iterator<Item> it = values.iterator(); it.hasNext(); ) {
-            final Item value = it.next();
+        for (final Item value : values) {
             if (value == item) {
                 return true;
             }
diff --git a/exist-core/src/main/java/org/exist/xquery/value/OrderedValueSequence.java b/exist-core/src/main/java/org/exist/xquery/value/OrderedValueSequence.java
@@ -200,8 +200,8 @@ public void coerceTypesForOrderBy() throws XPathException {
 
     private int countSetBits(final BitSet bitSet, final int... bitIndex) {
         int setBitsCount = 0;
-        for (int i = 0; i < bitIndex.length; i++) {
-            if (bitSet.get(bitIndex[i])) {
+        for (int index : bitIndex) {
+            if (bitSet.get(index)) {
                 setBitsCount++;
             }
         }
diff --git a/exist-core/src/main/java/org/exist/xslt/TransformerFactoryAllocator.java b/exist-core/src/main/java/org/exist/xslt/TransformerFactoryAllocator.java
@@ -91,9 +91,7 @@ public static SAXTransformerFactory getTransformerFactory(final BrokerPool pool)
                     LOG.debug("Set transformer factory: {}", transformerFactoryClassName);
                 }
                 final Hashtable<String, Object> attributes = (Hashtable<String, Object>) pool.getConfiguration().getProperty(PROPERTY_TRANSFORMER_ATTRIBUTES);
-                final Iterator<String> iterator = attributes.keySet().iterator();
-                while (iterator.hasNext()) {
-                    final String name = iterator.next();
+                for (String name : attributes.keySet()) {
                     final Object value = attributes.get(name);
                     try {
                         factory.setAttribute(name, value);
diff --git a/exist-start/src/main/java/org/exist/start/CompatibleJavaVersionCheck.java b/exist-start/src/main/java/org/exist/start/CompatibleJavaVersionCheck.java
@@ -82,9 +82,7 @@ static void checkForCompatibleJavaVersion(final Optional<String> checkJavaVersio
         /* @Nullable */ final Integer minorJavaVersion = javaVersionComponents.length > 1 ? javaVersionComponents[1] : null;
         /* @Nullable */ final Integer patchJavaVersion = javaVersionComponents.length > 2 ? javaVersionComponents[2] : null;
 
-        for (int i = 0; i < INCOMPATIBLE_JAVA_VERSIONS.length; i++) {
-            final IncompatibleJavaVersion incompatibleJavaVersion = INCOMPATIBLE_JAVA_VERSIONS[i];
-
+        for (final IncompatibleJavaVersion incompatibleJavaVersion : INCOMPATIBLE_JAVA_VERSIONS) {
             // compare major versions
             if (majorJavaVersion == incompatibleJavaVersion.major) {
 

Original file line number	Diff line number	Diff line change
`@@ -94,8 +94,8 @@ public StringBuilder forApproachRadek(/final BuilderState builderState/) {`
`94`	`94`	`// final StringBuilder builder = builderState.builder;`
`95`	`95`	`final StringBuilder builder = new StringBuilder();`
`96`	`96`
`97`		`- for (int i = 0; i < strings.size(); i++) {`
`98`		`- builder.append(strings.get(i));`
	`97`	`+ for (String string : strings) {`
	`98`	`+ builder.append(string);`
`99`	`99`	`builder.append(", ");`
`100`	`100`	`}`
`101`	`101`
Original file line number	Diff line number	Diff line change
`@@ -240,8 +240,7 @@ public boolean isPersistentSet() {`
`240`	`240`
`241`	`241`	`@Override`
`242`	`242`	`public boolean containsReference(final Item item) {`
`243`		`- for (final Iterator<Item> it = values.iterator(); it.hasNext(); ) {`
`244`		`- final Item value = it.next();`
	`243`	`+ for (final Item value : values) {`
`245`	`244`	`if (value == item) {`
`246`	`245`	`return true;`
`247`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,8 +200,8 @@ public void coerceTypesForOrderBy() throws XPathException {`
`200`	`200`
`201`	`201`	`private int countSetBits(final BitSet bitSet, final int... bitIndex) {`
`202`	`202`	`int setBitsCount = 0;`
`203`		`- for (int i = 0; i < bitIndex.length; i++) {`
`204`		`- if (bitSet.get(bitIndex[i])) {`
	`203`	`+ for (int index : bitIndex) {`
	`204`	`+ if (bitSet.get(index)) {`
`205`	`205`	`setBitsCount++;`
`206`	`206`	`}`
`207`	`207`	`}`