diff --git a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/RestCodec.java b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/RestCodec.java
index e879c20..b3ab4c7 100644
--- a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/RestCodec.java
+++ b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/RestCodec.java
@@ -57,19 +57,18 @@
     List<RestParam> paramList = restOperation.getParamList();
 
     Map<String, Object> paramValues = new HashMap<>();
-    for (int idx = 0; idx < paramList.size(); idx++) {
-      RestParam param = paramList.get(idx);
+    for (RestParam param : paramList) {
       try {
         paramValues.put(param.getParamName(), param.getParamProcessor().getValue(request));
       } catch (Exception e) {
         // Avoid information leak of user input, and add option for debug use.
         String message = String
-            .format("Parameter is not valid for operation [%s]. Parameter is [%s]. Processor is [%s].",
-                restOperation.getOperationMeta().getMicroserviceQualifiedName(),
-                param.getParamName(),
-                param.getParamProcessor().getProcessorType());
+                .format("Parameter is not valid for operation [%s]. Parameter is [%s]. Processor is [%s].",
+                        restOperation.getOperationMeta().getMicroserviceQualifiedName(),
+                        param.getParamName(),
+                        param.getParamProcessor().getProcessorType());
         if (DynamicPropertyFactory.getInstance().getBooleanProperty(
-            RestConst.PRINT_CODEC_ERROR_MESSGAGE, false).get()) {
+                RestConst.PRINT_CODEC_ERROR_MESSGAGE, false).get()) {
           LOG.error(message, e);
         } else {
           LOG.error("{} Add {}=true to print the details.", message, RestConst.PRINT_CODEC_ERROR_MESSGAGE);
diff --git a/handlers/handler-bizkeeper/src/main/java/org/apache/servicecomb/bizkeeper/CustomizeCommandGroupKey.java b/handlers/handler-bizkeeper/src/main/java/org/apache/servicecomb/bizkeeper/CustomizeCommandGroupKey.java
index 80b6e97..63165eb 100644
--- a/handlers/handler-bizkeeper/src/main/java/org/apache/servicecomb/bizkeeper/CustomizeCommandGroupKey.java
+++ b/handlers/handler-bizkeeper/src/main/java/org/apache/servicecomb/bizkeeper/CustomizeCommandGroupKey.java
@@ -35,13 +35,7 @@
   }
 
   private static final InternMap<String, CustomizeCommandGroupKey> intern =
-      new InternMap<>(
-          new InternMap.ValueConstructor<String, CustomizeCommandGroupKey>() {
-            @Override
-            public CustomizeCommandGroupKey create(String key) {
-              return new CustomizeCommandGroupKey(key);
-            }
-          });
+      new InternMap<>(CustomizeCommandGroupKey::new);
 
   public static HystrixCommandGroupKey asKey(String key, Invocation invocation) {
     CustomizeCommandGroupKey result = intern.interned(key);
diff --git a/integration-tests/it-producer/src/main/java/org/apache/servicecomb/it/schema/UploadJaxrsSchema.java b/integration-tests/it-producer/src/main/java/org/apache/servicecomb/it/schema/UploadJaxrsSchema.java
index 9ea52fd..97a18a9 100644
--- a/integration-tests/it-producer/src/main/java/org/apache/servicecomb/it/schema/UploadJaxrsSchema.java
+++ b/integration-tests/it-producer/src/main/java/org/apache/servicecomb/it/schema/UploadJaxrsSchema.java
@@ -54,8 +54,8 @@
   @Produces(MediaType.TEXT_PLAIN)
   public String uploadArray1(@FormParam("file1") Part[] file1, @FormParam("file2") Part file2) throws IOException {
     StringBuilder stringBuilder = new StringBuilder();
-    for (int i = 0; i < file1.length; i++) {
-      stringBuilder.append(getStrFromPart(file1[i]));
+    for (Part part : file1) {
+      stringBuilder.append(getStrFromPart(part));
     }
     return stringBuilder.append(getStrFromPart(file2)).toString();
   }
@@ -93,8 +93,8 @@
   public String uploadArray2(@FormParam("file1") Part[] file1, @FormParam("message") String message)
       throws IOException {
     StringBuilder stringBuilder = new StringBuilder();
-    for (int i = 0; i < file1.length; i++) {
-      stringBuilder.append(getStrFromPart(file1[i]));
+    for (Part part : file1) {
+      stringBuilder.append(getStrFromPart(part));
     }
     return stringBuilder.append(message).toString();
   }
@@ -115,8 +115,8 @@
       @FormParam("message") String message) {
     StringBuilder stringBuilder = new StringBuilder();
     file1.forEach(part -> stringBuilder.append(getStrFromPart(part)));
-    for (int i = 0; i < file2.length; i++) {
-      stringBuilder.append(getStrFromPart(file2[i]));
+    for (Part part : file2) {
+      stringBuilder.append(getStrFromPart(part));
     }
     return stringBuilder.append(message).toString();
   }
diff --git a/providers/provider-springmvc/src/main/java/org/apache/servicecomb/provider/springmvc/reference/CommonToHttpServletRequest.java b/providers/provider-springmvc/src/main/java/org/apache/servicecomb/provider/springmvc/reference/CommonToHttpServletRequest.java
index 64a60ac..0a8b80e 100644
--- a/providers/provider-springmvc/src/main/java/org/apache/servicecomb/provider/springmvc/reference/CommonToHttpServletRequest.java
+++ b/providers/provider-springmvc/src/main/java/org/apache/servicecomb/provider/springmvc/reference/CommonToHttpServletRequest.java
@@ -197,8 +197,8 @@
       }
       if (value.getClass().isArray()) {
         Object[] params = (Object[]) value;
-        for (int i = 0; i < params.length; i++) {
-          partList.add(getSinglePart(key, params[i]));
+        for (Object param : params) {
+          partList.add(getSinglePart(key, param));
         }
         continue;
       }
diff --git a/swagger/swagger-generator/generator-core/src/test/java/org/apache/servicecomb/swagger/generator/core/TestSwaggerUtils.java b/swagger/swagger-generator/generator-core/src/test/java/org/apache/servicecomb/swagger/generator/core/TestSwaggerUtils.java
index 439cc5a..0be165b 100644
--- a/swagger/swagger-generator/generator-core/src/test/java/org/apache/servicecomb/swagger/generator/core/TestSwaggerUtils.java
+++ b/swagger/swagger-generator/generator-core/src/test/java/org/apache/servicecomb/swagger/generator/core/TestSwaggerUtils.java
@@ -336,13 +336,13 @@
   public void testAddDefinitions() {
     Field[] fields1 = AllTypeTest1.class.getDeclaredFields();
     Field[] fields2 = AllTypeTest2.class.getDeclaredFields();
-    for (int i = 0; i < fields1.length; i++) {
-      for (int j = 0; j < fields2.length; j++) {
-        if (fields1[i].isSynthetic() || fields2[j].isSynthetic()) {
+    for (Field value : fields1) {
+      for (Field field : fields2) {
+        if (value.isSynthetic() || field.isSynthetic()) {
           continue;
         }
         try {
-          testExcep(fields1[i].getGenericType(), fields2[j].getGenericType());
+          testExcep(value.getGenericType(), field.getGenericType());
           fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
           MatcherAssert.assertThat(e.getMessage(), containsString("duplicate param model:"));
diff --git a/swagger/swagger-generator/generator-spring-data/src/main/java/org/apache/servicecomb/swagger/generator/springdata/SpringDataModule.java b/swagger/swagger-generator/generator-spring-data/src/main/java/org/apache/servicecomb/swagger/generator/springdata/SpringDataModule.java
index 7a56e72..b2fb8cc 100644
--- a/swagger/swagger-generator/generator-spring-data/src/main/java/org/apache/servicecomb/swagger/generator/springdata/SpringDataModule.java
+++ b/swagger/swagger-generator/generator-spring-data/src/main/java/org/apache/servicecomb/swagger/generator/springdata/SpringDataModule.java
@@ -17,7 +17,6 @@
 package org.apache.servicecomb.swagger.generator.springdata;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 import org.apache.servicecomb.foundation.common.utils.SPIOrder;
@@ -81,9 +80,8 @@
     @Override
     public SortMixin convert(Sort value) {
       List<String> properties = new ArrayList<>();
-      Iterator<Order> iterator = value.iterator();
-      while (iterator.hasNext()) {
-        properties.add(iterator.next().getProperty());
+      for (Order order : value) {
+        properties.add(order.getProperty());
       }
       SortMixin result = new SortMixin();
       result.setProperties(properties.toArray(new String[0]));
