Java和JS中常用的遍历整理

简单记录一下java和js常用的遍历方法，供参考

一、Java

1、String

（1）普通for循环

String str = "abc";
for (int i=0; i<str.length(); i++) {
    char c = str.charAt(i);
    System.out.println(c);
}

String str = "abc";
char[] cArr = str.toCharArray();
for (int i=0; i<cArr.length; i++) {
    char c = cArr[i];
    System.out.println(c);
}

（2）增强for循环

String str = "abc";
for (char c : str.toCharArray()) {
    System.out.println(c);
}

（3）while循环

String str = "abc";
int i = 0;
while (i < str.length()) {
    char c = str.charAt(i);
    System.out.println(c);
    i++;
}

（4）Iterator

String str = "abc";
Iterator<Character> iterator = str.chars().mapToObj(c -> (char) c).iterator();
while (iterator.hasNext()) {
    char c = iterator.next();
    System.out.println(c);
}

（5）substring方法

String str = "abc";
for (int i=0; i<str.length(); i++) {
    System.out.println(str.substring(i, i+1));
}

2、数组

下列数组以String[]为例

（1）普通for循环

String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    String str = s[i];
    System.out.println(str);
}

（2）增强for循环

String[] s = {"aaa", "bbb", "ccc"};
for (String str : s) {
    System.out.println(str);
}

（3）while循环

String[] s = {"aaa", "bbb", "ccc"};
int i = 0;
while (i < s.length) {
    String str = s[i];
    System.out.println(str);
    i++;
}

（4）Iterator

String[] s = {"aaa", "bbb", "ccc"};
Iterator<String> iterator = Arrays.stream(s).iterator();
while (iterator.hasNext()) {
    String str = iterator.next();
    System.out.println(str);
}

（5）Stream

String[] s = {"aaa", "bbb", "ccc"};
Arrays.stream(s).forEach(str -> System.out.println(str));

（6）并行Stream

String[] s = {"aaa", "bbb", "ccc"};
Stream<String> parallelStream = Arrays.stream(s).parallel();
if (parallelStream.isParallel()) {
    parallelStream.forEach(str -> System.out.println(str));
}

（7）asList()+forEach()

String[] s = {"aaa", "bbb", "ccc"};
List<String> list = Arrays.asList(s);
list.forEach(str -> System.out.println(str));

3、List

下列List以List<String>为例

（1）普通for循环

List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for (int i=0; i<list.size(); i++) {
    String str = list.get(i);
    System.out.println(str);
}

（2）增强for循环

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
for (String str : list) {
    System.out.println(str);
}

（3）while循环

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
int i = 0;
while (i < list.size()) {
    String str = list.get(i);
    System.out.println(str);
    i++;
}

（4）Iterator

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String str = iterator.next();
    System.out.println(str);
}

（5）ListIterator

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String str = listIterator.next();
    System.out.println(str);
}

（6）Stream

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.stream().forEach(str -> System.out.println(str));

（8）并行Stream

大数据量无序遍历可提高效率

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
Stream<String> parallelStream = list.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(str -> System.out.println(str));
}

（9）forEach()

List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.forEach(str -> System.out.println(str));

4、Set

下列数组以Set<String>为例

因为set为无序集合，没有下标，不能用普通for循环遍历

（1）增强for循环

Set<String> set = new HashSet<>();
String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    set.add(s[i]);
}
for (String str : set) {
    System.out.println(str);
}

（2）Iterator

Set<String> set = new HashSet<>();
String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    set.add(s[i]);
}
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    String str = iterator.next();
    System.out.println(str);
}

（3）Stream

Set<String> set = new HashSet<>();
String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    set.add(s[i]);
}
set.stream().forEach(str -> System.out.println(str));

（4）并行Stream

Set<String> set = new HashSet<>();
String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    set.add(s[i]);
}
Stream<String> parallelStream = set.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(str -> System.out.println(str));
}

（5）forEach()

Set<String> set = new HashSet<>();
String[] s = {"aaa", "bbb", "ccc"};
for (int i=0; i<s.length; i++) {
    set.add(s[i]);
}
set.forEach(str -> System.out.println(str));

5、Map

下列数组以Map<String, String>为例

（1）增强for循环

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
for (String key : map.keySet()) {
    String value = map.get(key);
    System.out.println(key + " = " + value);
}

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
for (Map.Entry<String, String> entry:map.entrySet()) {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + " = " + value);
}

（2）Iterator

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    String value = map.get(key);
    System.out.println(key + " = " + value);
}

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, String> entry = iterator.next();
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + " = " + value);
}

（3）Stream

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<String> set = map.keySet();
set.stream().forEach(key -> {
    String value = map.get(key);
    System.out.println(key + " = " + value);
});

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<Map.Entry<String, String>> set = map.entrySet();
set.stream().forEach(entry -> {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + " = " + value);
});

（4）并行Stream

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<String> set = map.keySet();
Stream<String> parallelStream = set.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(key -> {
        String value = map.get(key);
        System.out.println(key + " = " + value);
    });
}

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<Map.Entry<String, String>> set = map.entrySet();
Stream<Map.Entry<String, String>> parallelStream = set.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(entry -> {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + " = " + value);
    });
}

（5）forEach()

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<String> set = map.keySet();
set.forEach(key -> {
    String value = map.get(key);
    System.out.println(key + " = " + value);
});

Map<String, String> map = new HashMap<>();
map.put("name", "Jorn");
map.put("age", "19");
Set<Map.Entry<String, String>> set = map.entrySet();
set.forEach(entry -> {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + " = " + value);
});

6、JSONObject（fastjson）

（1）增强for循环

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
for (String key : jsonObject.keySet()) {
    Object value = jsonObject.get(key);
    System.out.println(key + ":" + value);
}

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
    System.out.println(key + ":" + value);
}

（2）Iterator

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Iterator<String> keys = jsonObject.keySet().iterator();
while(keys.hasNext()) {
    String key = keys.next();
    Object value = jsonObject.get(key);
    System.out.println(key + ":" + value);
}

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Iterator<Map.Entry<String, Object>> entryIterator = jsonObject.entrySet().iterator();
while(entryIterator.hasNext()) {
    Map.Entry<String, Object> entry = entryIterator.next();
    String key = entry.getKey();
    Object value = entry.getValue();
    System.out.println(key + ":" + value);
}

（3）Stream

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<String> keySet = jsonObject.keySet();
keySet.stream().forEach(key -> {
    Object value = jsonObject.get(key);
    System.out.println(key + ":" + value);
});

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<Map.Entry<String, Object>> entrySet = jsonObject.entrySet();
entrySet.stream().forEach(entry -> {
    String key = entry.getKey();
    Object value = entry.getValue();
    System.out.println(key + ":" + value);
});

（4）并行stream

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<String> keySet = jsonObject.keySet();
Stream<String> parallelStream = keySet.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(key -> {
        Object value = jsonObject.get(key);
        System.out.println(key + ":" + value);
    });
}

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<Map.Entry<String, Object>> entrySet = jsonObject.entrySet();
Stream<Map.Entry<String, Object>> parallelStream = entrySet.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(entry -> {
        String key = entry.getKey();
        Object value = entry.getValue();
        System.out.println(key + ":" + value);
    });
}

（5）forEach()

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<String> keySet = jsonObject.keySet();
keySet.forEach(key -> {
    Object value = jsonObject.get(key);
    System.out.println(key + ":" + value);
});

String jsonString = "{\"name\":\"张三\",\"age\":23}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
Set<Map.Entry<String, Object>> entrySet = jsonObject.entrySet();
entrySet.forEach(entry -> {
    String key = entry.getKey();
    Object value = entry.getValue();
    System.out.println(key + ":" + value);
});

7、JSONArray（fastjson）

（1）普通for循环

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
for (int i=0; i<jsonArray.size(); i++) {
    Object obj = jsonArray.get(i);
    System.out.println(obj);
}

（2）增强for循环

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
for (Object obj : jsonArray) {
    System.out.println(obj);
}

（3）while循环

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
int i = 0;
while (i < jsonArray.size()) {
    Object obj = jsonArray.get(i);
    System.out.println(obj);
    i++;
}

（4）Iterator

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
Iterator<Object> iterator = jsonArray.iterator();
while (iterator.hasNext()) {
    Object obj = iterator.next();
    System.out.println(obj);
}

（5）stream

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
jsonArray.stream().forEach(obj -> System.out.println(obj));

（6）并行stream

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
Stream<Object> parallelStream = jsonArray.parallelStream();
// 查看流是否支持并行遍历
if (parallelStream.isParallel()) {
    parallelStream.forEach(obj -> System.out.println(obj));
}

（7）forEach()

JSONArray jsonArray = new JSONArray();
jsonArray.add("Apple");
jsonArray.add("Banana");
jsonArray.add("Orange");
jsonArray.forEach(obj -> System.out.println(obj));

二、JavaScript

1、String

（1）普通for循环

var str = "abc";
for (var i=0; i<str.length; i++) {
    console.log(str[i]);
}

（2）for-in 循环

for-in 循环里循环的是字符串的下标

var str = "abc";
for (var i in str) {
    console.log(str[i]);
}

（3）for-of 循环

for-in 循环里循环的是字符串的元素

var str = "abc";
for (var char of str) {
    console.log(char);
}

（4）forEach()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var str = "abc";
Array.from(str).forEach( function (char) {
   console.log(char); 
});

var str = "abc";
Array.from(str).forEach( char => {
   console.log(char); 
});

（5）map映射

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var str = "abc";
Array.from(str).map(function (char) {
    console.log(char);
});

var str = "abc";
Array.from(str).map(char => {
    console.log(char);
});

var str = "abc";
str.split('').map(function (char) {
    console.log(char);
});

var str = "abc";
str.split('').map(char => {
    console.log(char);
});

2、数组 or List

（1）普通for循环

var s = [1, 2, 3, 4];
for (var i = 0; i < s.length; i++) {
  console.log(s[i]);
}

（2）for-in 循环

for-in 循环里循环的是数组的下标

var s= [1, 2, 3, 4];
for (var i in s) {
  console.log(s[i]);
}

（3）for-of 循环

for-of 循环里循环的是数组的元素

var s = [1, 2, 3, 4];
for (var item of s) {
  console.log(item);
}

（4）forEach()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.forEach( function(item) {
    console.log(item);
});

var s = [1, 2, 3, 4];
s.forEach(item => {
    console.log(item);
});

（5）map映射

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.map( function (item) {
    console.log(item);
});

var s = [1, 2, 3, 4];
s.map(item => {
    console.log(item);
});

map映射处理后会返回一个新数组，且不改变原有数组

var s = [1, 2, 3, 4];
var newS = s.map(item => {
    return item + 1;
});
console.log(s);
console.log(newS);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 新数组
(4) [2, 3, 4, 5]

（6）filter()过滤

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.filter( item => {
    console.log(item);
});

filter()过滤后会返回一个新数组，且不改变原有数组

• 遍历整个数组

• 返回的是布尔值，false过滤掉、true保留

• 如果没有满足的元素，则返回一个长度是0的空数组

var s = [1, 2, 3, 4];
var newS = s.filter( item => {
    return item > 1;
});
console.log(s);
console.log(newS);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 新数组
(3) [2, 3, 4]

（7）find()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.find( item => {
    console.log(item);
});

find()执行后会返回第一个符合条件的元素，且不改变原有数组

• 遍历整个数组，找到第一个符合条件的元素
• 如果没有符合条件的元素，会返回一个undefined的对象

var s = [1, 2, 3, 4];
var newItem = s.find( item => {
    return item > 1;
});
console.log(s);
console.log(newItem);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 第一个符合条件的元素
2

（8）findIndex()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.findIndex( item => {
    console.log(item);
});

findIndex()执行后会返回一个元素，且不改变原有数组

• 遍历整个数组

• 找到第一个符合条件的元素，并返回该元素；否则，返回-1

var s = [1, 2, 3, 4];
var newItem = s.findIndex( item => {
    return item > 1;
});
console.log(s);
console.log(newItem);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 第一个符合条件的元素
1

（9）every()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.every( item => {
    console.log(item);
    return 1;
});

every()执行后返回一个布尔值，且不改变原有数组

如果所有元素都满足判断条件，则返回true，否则为false

• 遍历数组直到不符合条件的元素
• 内部执行函数返回值为false时，停止遍历
• 内部执行函数无return时，默认返回false
• 如果一个空数组执行every()，返回true

var s = [1, 2, 3, 4];
var boolean = s.every( item => {
    return item < 3;
});
console.log(s);
console.log(boolean);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 数组中有元素不满足条件
false

（10）some()

函数支持3个参数，参数分别是item（当前每一项），index（索引值），self（原数组）

var s = [1, 2, 3, 4];
s.some( item => {
    console.log(item);
});

some()执行后返回一个布尔值，且不改变原有数组

如果存在元素满足判断条件，则返回true，若所有元素都不满足判断条件，则返回false

• 遍历数组直到符合条件的元素
• 内部执行函数返回值不为false时，停止遍历
• 内部执行函数无return时，默认返回false
• 如果一个空数组执行some()，返回false

var s = [1, 2, 3, 4];
var boolean = s.some( item => {
    return item > 2;
});
console.log(s);
console.log(boolean);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 数组中有元素满足条件
true

（11）reduce()

var s = [1, 2, 3, 4];
s.reduce( (total, item, index, self) => {
    console.log(item);
}, 0);

函数格式：

// s 		要遍历的数组
// total 	初始值或上次处理后的返回值
// item 	元素
// index 	元素下标
// self 	数组本身
// value	处理初始值
// 返回值为下次处理时的total
s.reduce( (total, item, index, self) => {
 	// 方法
}, value);

var s = [1, 2, 3, 4];
var resp = s.reduce( (total,item,index,self) => {
    return total + item;
}, 10);
console.log(s);
console.log(resp);

// 输出：

// 原数组
(4) [1, 2, 3, 4]
// 迭代处理后的返回结果
20

（12）reduceRight()

reduceRight()执行后会返回一个值，该值为方法体执行最后一次返回的值

• 数组遍历时从右往左（从最后一个开始往前遍历）

函数格式：

// s 				要遍历的数组
// total 			第一次调用时为数组最后一个元素，否则为上次处理后的返回值
// previousItem		前一个元素
// 返回值为下次处理时的total或者最终返回值
s.reduce( (total, previousItem) => {
    // 方法
});

var s = [1, 2, 3, 4];

// 求和
var resp = s.reduceRight( (x, y) => {
    return x + y;
});
console.log(resp)

// 输出：
10


// 求最大值
var resp = s.reduceRight( (x, y) => {
	return x > y ? x : y;
});
console.log(resp)

// 输出
4

3、Map

（1）for-of 循环

var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
for (var [key, value] of map) {
    console.log(key + " = " + value);
}

var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
for (var key of map.keys()) {
    console.log(key + " = " + map.get(key));
}

// 只遍历value
var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
for (var value of map.values()) {
	console.log(value);
}

（2）forEach()

var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
// 一个参数时为value
map.forEach(value => console.log(value));

var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
// 两个参数时为value、key
map.forEach((value, key) => console.log(key + " = " + value));

var map = new Map([
  [1, 'one'],
  [2, 'two']
]);
map.set(3,'three');
// 三个参数时为value、key、原map
map.forEach((value, key, map) => {
    console.log(key + " = " + value);
    console.log(map);
});

4、对象

（1）for-in 循环

for-in循环的是对象可被枚举的属性名

var obj = {
    name: "Tom",
    age: "18"
};
obj.sex = "man";
for (key in obj) {
    console.log(key + " = " + obj[key]);
}

（2）Object.keys()

Object.keys()返回的是包含对象所有可被枚举属性名的数组，所以可以使用Object.keys()配合遍历数组的所有方法来遍历对象

var obj = {
    name: "Tom",
    age: "18"
};
obj.sex = "man";
Object.keys(obj).forEach(key => {
    console.log(key + " = " + obj[key]);
});

（3）Object.values()

Object.values()返回的是包含对象所有可被枚举属性值的数组，所以该只能用于遍历属性值

var obj = {
    name: "Tom",
    age: "18"
};
obj.sex = "man";
Object.values(obj).forEach(value => {
    console.log(value);
});

（4）Object.entries()

Object.entries()返回一个二维数组，每个小数组结构为：[属性名，属性值]（可被枚举），整体结构为：[ [属性名，属性值], [属性名，属性值], …]，所以可以使用Object.entries()配合遍历数组的所有方法来遍历对象

var obj = {
    name: "Tom",
    age: "18"
};
obj.sex = "man";
Object.entries(obj).forEach(item => {
    console.log(item[0] + " = " + item[1]);
});