简单记录一下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]);
});