不同语言数组操作对比

1. map

   fun main() {
       //kotlin
       val user = User(1, "zhangsan")
       val list = mutableListOf<User>()
       list.add(user)
       val newList = list.map { item ->
           item.name = "lisi"
           item//最后一行代表返回
       }
       val newListTwo = list.mapTo(mutableListOf()) { item ->
           item.name = "wangwu"
           item
       }
       println(list)//[{User id=1, name=wangwu}]
       println(newList)//[{User id=1, name=wangwu}] 集合的操作其实是不影响原数组的，只是因为这里是对象
       println(newListTwo)//[{User id=1, name=wangwu}]
   
       val numbers = listOf("one", "two", "three", "four")
       val length = numbers.map {
          it.length
       }
       val newLength = numbers.mapTo(hashSetOf()){it.length}//可以直接去重
       println(numbers)//[one, two, three, four] 此处证明不影响原数组
       println(length)//[3, 3, 5, 4]
       println(newLength)//[3, 4, 5]
   }
   

   public static void main(String[] args) { 
       //java
       List<String> names = Arrays.asList("John", "Jane", "Jack", "Dennis"); 
       List<String> collect = names.stream()                                 
               .map(it -> it.toUpperCase(Locale.getDefault()))               
               .collect(Collectors.toList());                                
       System.out.println(collect);//[JOHN, JANE, JACK, DENNIS]              
                                                                             
   }                                                                         
   

   <script>
       //JavaScript
       let a = [{
           id:1,
           content:"是的"
       }]
       let b = a.map(el => el)
       b.forEach(item => item.name="修改")
       console.log(a)//[{id: 1, content: '是的', name: '修改'}]，这里影响了原数组是因为对象
       console.log(b)//[{id: 1, content: '是的', name: '修改'}]
       let numbers = ["one","two","three","four"]
       let fLength = numbers.map(item => item.length)//lambda 只有一行代码会隐式return,lamdba表达式有{}必须显示返回
       console.log(numbers)//['one', 'two', 'three', 'four'] 集合的操作其实也是不会影响原数组的
       console.log(fLength)//[3, 3, 5, 4]
   </script>
   

2. sort排序

   fun main() {
       val numbers = mutableListOf("one", "two", "three", "four")
       val sorted = numbers.sorted()//有返回值，
       println(numbers == sorted)//false
       numbers.sort()//无返回值
       println(numbers)//[four, one, three, two]
       println(sorted)//[four, one, three, two]
       println(numbers == sorted)//true
   
       val list = mutableListOf<User>()
       list.add(User(1, "zhangsan"))
       list.add(User(2, "lisi"))
       list.add(User(3, "王五"))
   //    list.sortByDescending { it.id }//按照某个字段降序，和sortWith
   //    list.sortBy { it.id }//按照某个字段升序,无返回值
       val newList = list.sortedBy { it.id }
       println(list)
       println(newList)
       println(list == newList)//true
       list.sortWith { o1, o2 -> o1.id-o2.id }//可以定义自己的排序规则,(前面的元素(第一个参数)和后面的元素(第二个参数)比较，大于0，则交换位置)
   
       val arr = arrayListOf(1,30,4,21,100000)
       arr.sort()//[1, 4, 21, 30, 100000]
       println(arr)
   }
   

   public static void main(String[] args) {
       int[] arr = new int[]{1, 30, 4, 21, 100000};
       Arrays.sort(arr);
       for (int i : arr) {
           System.out.println(i);//1,4,21,30,100000
       }
   }
   

   <script>
    let arr = ["one","two","three","four"]
    arr.sort()//默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值
    console.log(arr)//[four, one, three, two]
    const array1 = [1, 30, 4, 21, 100000];
    array1.sort()//[1, 100000, 21, 30, 4]
    array1.sort((v1,v2) => v1-v2)//[1, 4, 21, 30, 100000]
    console.log(array1)//[1, 100000, 21, 30, 4]
   
    const  arr3 = [1,4,2,9]
    arr3.sort()
    console.log(arr3);//[1, 2, 4, 9]
   
    let lessons = [
        { title: "媒体查询响应式布局", click: 78 },
        { title: "FLEX 弹性盒模型", click: 12 },
        { title: "MYSQL多表查询随意操作", click: 99 }
    ];
   
    let sortLessons = lessons.sort((v1, v2) => v2.click - v1.click);
    console.log(sortLessons);//[{ title: "MYSQL多表查询随意操作", click: 99 },{ title: "媒体查询响应式布局", click: 78 },{ title: "FLEX 弹性盒模型", click: 12 }]
   </script>
   

3. zip

   fun main() {
       //kotlin
       //js官方没有zip的api
       val colors = listOf("red", "brown", "grey")
       val animals = listOf("fox", "bear", "wolf")
       val list = colors zip animals//返回Pair对象的list
       println(list)//[(red, fox), (brown, bear), (grey, wolf)]
       println(list[0].first)//red
   
       val twoAnimals = listOf("fox", "bear")
       println(colors.zip(twoAnimals))//[(red, fox), (brown, bear)]
       val zipList = list zip twoAnimals
       println(zipList)//[((red, fox), fox), ((brown, bear), bear)]
       println(zipList[0].first.first)//red
           
       val numberPairs = listOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    println(numberPairs.unzip())
   }
   
   

   public class TestJava {
   //java8
       public static void main(String[] args) {
           List<String> names = new ArrayList<>(Arrays.asList("John", "Jane", "Jack", "Dennis"));
   
           List<Integer> ages = new ArrayList<>(Arrays.asList(24, 25, 27));
           List<Pair<String,Integer>> collect = IntStream
                   .range(0, Math.min(names.size(), ages.size()))
                   .mapToObj(i -> new Pair<String,Integer>(names.get(i),ages.get(i)))
                   .collect(Collectors.toList());
           collect.forEach(item ->{
               System.out.println(item.getKey()+":"+item.getValue());
           });
       }
   }
   

4. flat系列

   fun main() {
       //flat就是把嵌套集合并成一个数组
       val containers = listOf(
               listOf("one", "two", "three"),
               listOf("four", "five", "six"),
               listOf("seven", "eight")
       )
       val newList = containers.flatten()//只支持一级集合嵌套
       println(newList)//[one, two, three, four, five, six, seven, eight]
       val list = containers.flatMap { item ->
           item.map { el -> "${el}suffix" }
       }
       println(list)
       //[onesuffix, twosuffix, threesuffix, foursuffix, fivesuffix, sixsuffix, sevensuffix, eightsuffix]
   }
   

   public static void main(String[] args) {                                                                                                                 
       List<List<String>> names = Arrays.asList(Collections.singletonList("a,b,c"), Collections.singletonList("d,e"), Collections.singletonList("f"));      
       List<String> collect = names.stream()                                                                                                                
               .flatMap(it -> it.stream().map(item -> item.toUpperCase(Locale.getDefault())))                                                               
               .collect(Collectors.toList());                                                                                                               
       System.out.println(collect);//[A,B,C, D,E, F]                                                                                                        
       //stream api 的 flatMap方法接受一个lambda表达式函数， 函数的返回值必须也是一个stream类型                                                                                        
   

    <script>
          const arr = [1, 2, [3, 4]];
          console.log(arr.flat())//[1,2,3,4]不影响原数组
          // is equivalent to
          arr.reduce((acc, val) => acc.concat(val), []); // [1, 2, 3, 4]
          arr.flat(2)//[1,2,3,4]
          const arr2 = [0, 1, 2, [[[3, 4]]]];
          console.log(arr2.flat(2))//[1,2,3,4,[3,4]]//指定要提取嵌套数组的结构深度是2，默认值为 1。
          const arr3 = [1,2,3,4]
          const  result = arr3.flatMap((x, index) => [x * 2])
          console.log(result)
      </script>
   

5. 集合转string系列

    public static void main(String[] args) { 
        //java
        List<String> stringList = Arrays.asList("a", "b", "c");
        String join = String.join("-", stringList);            
        System.out.println(join);                              
    }                                                          
   

   fun main() {
       //kotlin
       val colors = listOf("red", "brown", "grey")
       val joinToString = colors.joinToString(",")
       println(joinToString)
   }
   

   <script>
       const arr3 = [1,2,3,4]
       console.log(arr3.join())//1,2,3,4,默认是,号分割
   </script>
   

6. reduce系列—见另一篇文章Kotlin,JavaScript,Dart,Java数组reduce操作对比