Kotlin 集合-- arrayOf

最新推荐文章于 2024-09-10 08:03:45 发布
最新推荐文章于 2024-09-10 08:03:45 发布
阅读量8.1k 收藏 2
点赞数 1
分类专栏： Android Kotlin Kotlin入门学习 文章标签： Android Kotlin 集合ArrayOf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xsg2357/article/details/80334946
版权 

package com.init.demo.demo1

fun main(args: Array<String>) {
    var nollStations = arrayOf("江北机场", "两路", "", "", "金童路", "重庆北站南广场", "龙头寺", "狮子坪", "红旗河沟",
            "观音桥", "牛角沱", "两路口", "工毛", "铜元局", "南平", "四公里", "九公里", "鱼洞")
    println("元素个数nollStations.size：${nollStations.size}或者元素个数nollStations.count()：${nollStations.count()}")
    println("第1个nollStations.first()：${nollStations.first()}")
    println("第1个nollStations.component1()：${nollStations.component1()}")
    println("第2个nollStations.component2()：${nollStations.component2()}")
    println("第3个nollStations.component3()：${nollStations.component3()}")
    println("第4个nollStations.component4()：${nollStations.component4()}")
    println("第5个nollStations.component5()：${nollStations.component5()}")
    println("最后1个ollStations.last()：${nollStations.last()}")
    println("其他元素的取出nollStations[x]：${nollStations[10]}")
    println("检查是否包含某个元素nollStations.contains():${nollStations.contains("四公里")}")
    println("查找元素nollStations.find { it.contains() }：${nollStations.find { it.contains("公") }}")
    println("查找最后一个匹配元素nollStations.findLast { it.contains() }：${nollStations.findLast { it.contains("公") }}")
    println("输出一个元素逗号分割形式的字符串nollStations.joinToString()：${nollStations.joinToString()}")
    println("输出一个元素逗号分割形式的字符串，末尾添加字符nollStations.joinToString{}：${nollStations.joinToString { it + "站" }}")
    /**
     * separator :分隔符
     * prefix：前后缀
     * limit : 元素限制
     */
    println("输出一个元素逗号分割形式的字符串，nollStations." +
            "joinToString() 版本增强函数：${nollStations.joinToString(separator = "->", prefix = "轻轨3号线：", limit = 4)}")
    println("丢弃前面x个元素丢弃nollStations.drop(x)：${nollStations.drop(4)}")
    println("丢弃前面不为空的元素丢弃ollStations.dropWhile{}：${nollStations.dropWhile { it.isNotEmpty() }}")
    println("丢弃最后x个元素nollStations.dropLast(x)：${nollStations.dropLast(10)}")
    println("丢弃最后不为空的元素丢弃nollStations.dropLastWhile{}：${nollStations.dropLastWhile { it.isNotEmpty() }}")
    println("取出前面x个元素丢弃nollStations.take(x)：${nollStations.take(4)}")
    println("取出后面x个元素丢弃nollStations.takeLast(x)：${nollStations.takeLast(4)}")
    println("切割数组--取出指定范围内元素nollStations.sliceArray(2..5).joinToString()：${nollStations.sliceArray(2..5).joinToString()}")
    println("数组反转1--将自身元素首尾顺序颠倒nollStations.reversed().joinToString()：${nollStations.reversed().joinToString()}")
    println("数组反转2--将自身元素首尾顺序颠倒nollStations.reversedArray().joinToString()：${nollStations.reversedArray().joinToString()}")

    println("**********************************************数字型的数组排序****************************************************")
    val numbers = arrayOf(0, -9, 10, 5, 89, 26, 34)
    println("数组排序-升序numbers.sorted().joinToString():${numbers.sorted().joinToString()}")
    println("数组排序-降序numbers.sorted().joinToString():${numbers.sortedArrayDescending().joinToString()}")
    println("地铁名按长度排序-升序nollStations.sortedBy{}:${nollStations.sortedBy { s -> s.length }}")
    println("地铁名按长度排序-升序nollStations.sortedBy{it.length}:${nollStations.sortedBy { it.length }}")
    println("地铁名按长度排序-降序nollStations.sortedByDescending{}:${nollStations.sortedByDescending { s -> s.length }}")
    println("地铁名按长度排序-降序nollStations.sortedByDescending{it.length}:${nollStations.sortedByDescending { it.length }}")
    println("数字型数组转换成字符串数组并加前缀numbers.map {}:${numbers.map { it -> "数字：" + it }}")
    println("数字型数组筛选numbers.filter{}:${numbers.filter { it % 2 == 0 }}")
    println("数字型数组最大值numbers.max():${numbers.max()}")
    println("数字型数组最小值{numbers.min():${numbers.min()}")
    println("地铁名最长的一个元素nollStations.maxBy { s->s.length }:${nollStations.maxBy { s -> s.length }}")
    println("地铁名最小的一个元素nollStations.minBy { s->s.length }:${nollStations.minBy { s -> s.length }}")
    println("地铁名长度不同的元素nollStations.distinctBy { s->s.length }:${nollStations.distinctBy { s -> s.length }}")
    println("返回删除重复元素的新数组nollStations.distinct():${nollStations.distinct()}")
    println("**********************************************数组判定****************************************************")
    println("数组中数字所有元素是否>0-numbers.all {  it > 0}:${numbers.all { it > 0 }}")
    println("数组中数字有元素是否<0-numbers.any {  it< 0}:${numbers.any { it < 0 }}")
    //all 和 any 相对应，all是所有元素都要满足才为true，any是要至少一个条件才为true，none是所有元素都不满足才为true
    println("数组中数字所有元素是否==0-numbers.none {  it == 0}:${numbers.none { it == 0 }}")
    println("**********************************************数组计算****************************************************")
    println("数组中数字所有元素总和numbers.sum():${numbers.sum()}")
    println("数组中数字每个元素+100_000总和numbers.sum{0_000 + it}:${numbers.sumBy { 10_000 + it }}")
    println("数组中数字平均值numbers.average():${numbers.average()}")
    println("**********************************************数组集成****************************************************")
    /**
     * s1 代表其中一个元素
     * s2 代表其中一个元素的下一个元素
     * 有点跟joinToString()想死
     * reduce  加前缀 reduceRight 加后缀
     * fold   加前缀额reduce foldRight 加后缀的reduceRight
     */
    println("把所有元素集成为一个值nollStations.reduce{ s1, s2 -> s1 + \",\" + s2 }:${nollStations.reduce{ s1, s2 -> s1 + "," + s2 }}")
    println("把所有元素集成为一个值，从又开始算nollStations.reduceRight{ s1, s2 -> s1 + \",\" + s2 }:${nollStations.reduceRight{ s1, s2 -> s1 + "," + s2 }}")
    println("把所有元素集成为一个值，从又开始算nollStations.fold(\"fold：\"){ s1, s2 -> s1 + \",\" + s2 }:${nollStations.fold("fold："){ s1, s2 -> s1 + "-" + s2 }}")
    println("把所有元素集成为一个值，从又开始算nollStations.fold(\"foldRight：\"){ s1, s2 -> s1 + \",\" + s2 }:${nollStations.foldRight("foldRight："){ s1, s2 -> s1 + "-" + s2 }}")
    println("**********************************************数组类型****************************************************")
    val numbers2 = arrayOf(1,23,5,89,-5,8,-78)
    val newStations = arrayOf("七星岗","小什字","解放碑","石桥铺")

    val twoNumbers = numbers.plus(numbers2)
    val twoStations = nollStations.plus(newStations)

    println(twoNumbers.joinToString())
    println(twoStations.joinToString())

    //使用+运算符，和plus方法完全同阶
    println((nollStations+newStations).joinToString())
    println((numbers+numbers2).joinToString())
    //zip配对
    println((numbers+numbers2).zip(nollStations+newStations))
    //zip配对 加强版
    println((numbers+numbers2).zip((nollStations+newStations)){s1, s2 -> "$s1" + ":" + s2 })
}


输出结果：

元素个数nollStations.size：18或者元素个数nollStations.count()：18
第1个nollStations.first()：江北机场
第1个nollStations.component1()：江北机场
第2个nollStations.component2()：两路
第3个nollStations.component3()：
第4个nollStations.component4()：
第5个nollStations.component5()：金童路
最后1个ollStations.last()：鱼洞
其他元素的取出nollStations[x]：牛角沱
检查是否包含某个元素nollStations.contains():true
查找元素nollStations.find { it.contains() }：四公里
查找最后一个匹配元素nollStations.findLast { it.contains() }：九公里
输出一个元素逗号分割形式的字符串nollStations.joinToString()：江北机场, 两路, , , 金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞
输出一个元素逗号分割形式的字符串，末尾添加字符nollStations.joinToString{}：江北机场站, 两路站, 站, 站, 金童路站, 重庆北站南广场站, 龙头寺站, 狮子坪站, 红旗河沟站, 观音桥站, 牛角沱站, 两路口站, 工毛站, 铜元局站, 南平站, 四公里站, 九公里站, 鱼洞站
输出一个元素逗号分割形式的字符串，nollStations.joinToString() 版本增强函数：轻轨3号线：江北机场->两路->->->...
丢弃前面x个元素丢弃nollStations.drop(x)：[金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞]
丢弃前面不为空的元素丢弃ollStations.dropWhile{}：[, , 金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞]
丢弃最后x个元素nollStations.dropLast(x)：[江北机场, 两路, , , 金童路, 重庆北站南广场, 龙头寺, 狮子坪]
丢弃最后不为空的元素丢弃nollStations.dropLastWhile{}：[江北机场, 两路, , ]
取出前面x个元素丢弃nollStations.take(x)：[江北机场, 两路, , ]
取出后面x个元素丢弃nollStations.takeLast(x)：[南平, 四公里, 九公里, 鱼洞]
切割数组--取出指定范围内元素nollStations.sliceArray(2..5).joinToString()：, , 金童路, 重庆北站南广场
数组反转1--将自身元素首尾顺序颠倒nollStations.reversed().joinToString()：鱼洞, 九公里, 四公里, 南平, 铜元局, 工毛, 两路口, 牛角沱, 观音桥, 红旗河沟, 狮子坪, 龙头寺, 重庆北站南广场, 金童路, , , 两路, 江北机场
数组反转2--将自身元素首尾顺序颠倒nollStations.reversedArray().joinToString()：鱼洞, 九公里, 四公里, 南平, 铜元局, 工毛, 两路口, 牛角沱, 观音桥, 红旗河沟, 狮子坪, 龙头寺, 重庆北站南广场, 金童路, , , 两路, 江北机场
**********************************************数字型的数组排序****************************************************
数组排序-升序numbers.sorted().joinToString():-9, 0, 5, 10, 26, 34, 89
数组排序-降序numbers.sorted().joinToString():89, 34, 26, 10, 5, 0, -9
地铁名按长度排序-升序nollStations.sortedBy{}:[, , 两路, 工毛, 南平, 鱼洞, 金童路, 龙头寺, 狮子坪, 观音桥, 牛角沱, 两路口, 铜元局, 四公里, 九公里, 江北机场, 红旗河沟, 重庆北站南广场]
地铁名按长度排序-升序nollStations.sortedBy{it.length}:[, , 两路, 工毛, 南平, 鱼洞, 金童路, 龙头寺, 狮子坪, 观音桥, 牛角沱, 两路口, 铜元局, 四公里, 九公里, 江北机场, 红旗河沟, 重庆北站南广场]
地铁名按长度排序-降序nollStations.sortedByDescending{}:[重庆北站南广场, 江北机场, 红旗河沟, 金童路, 龙头寺, 狮子坪, 观音桥, 牛角沱, 两路口, 铜元局, 四公里, 九公里, 两路, 工毛, 南平, 鱼洞, , ]
地铁名按长度排序-降序nollStations.sortedByDescending{it.length}:[重庆北站南广场, 江北机场, 红旗河沟, 金童路, 龙头寺, 狮子坪, 观音桥, 牛角沱, 两路口, 铜元局, 四公里, 九公里, 两路, 工毛, 南平, 鱼洞, , ]
数字型数组转换成字符串数组并加前缀numbers.map {}:[数字：0, 数字：-9, 数字：10, 数字：5, 数字：89, 数字：26, 数字：34]
数字型数组筛选numbers.filter{}:[0, 10, 26, 34]
数字型数组最大值numbers.max():89
数字型数组最小值{numbers.min():-9
地铁名最长的一个元素nollStations.maxBy { s->s.length }:重庆北站南广场
地铁名最小的一个元素nollStations.minBy { s->s.length }:
地铁名长度不同的元素nollStations.distinctBy { s->s.length }:[江北机场, 两路, , 金童路, 重庆北站南广场]
返回删除重复元素的新数组nollStations.distinct():[江北机场, 两路, , 金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞]
**********************************************数组判定****************************************************
数组中数字所有元素是否>0-numbers.all {  it > 0}:false
数组中数字有元素是否<0-numbers.any {  it< 0}:true
数组中数字所有元素是否==0-numbers.none {  it == 0}:false
**********************************************数组计算****************************************************
数组中数字所有元素总和numbers.sum():155
数组中数字每个元素+100_000总和numbers.sum{0_000 + it}:70155
数组中数字平均值numbers.average():22.142857142857142
**********************************************数组集成****************************************************
把所有元素集成为一个值nollStations.reduce{ s1, s2 -> s1 + "," + s2 }:江北机场,两路,,,金童路,重庆北站南广场,龙头寺,狮子坪,红旗河沟,观音桥,牛角沱,两路口,工毛,铜元局,南平,四公里,九公里,鱼洞
把所有元素集成为一个值，从又开始算nollStations.reduceRight{ s1, s2 -> s1 + "," + s2 }:江北机场,两路,,,金童路,重庆北站南广场,龙头寺,狮子坪,红旗河沟,观音桥,牛角沱,两路口,工毛,铜元局,南平,四公里,九公里,鱼洞
把所有元素集成为一个值，从又开始算nollStations.fold("fold："){ s1, s2 -> s1 + "," + s2 }:fold：-江北机场-两路---金童路-重庆北站南广场-龙头寺-狮子坪-红旗河沟-观音桥-牛角沱-两路口-工毛-铜元局-南平-四公里-九公里-鱼洞
把所有元素集成为一个值，从又开始算nollStations.fold("foldRight："){ s1, s2 -> s1 + "," + s2 }:江北机场-两路---金童路-重庆北站南广场-龙头寺-狮子坪-红旗河沟-观音桥-牛角沱-两路口-工毛-铜元局-南平-四公里-九公里-鱼洞-foldRight：
**********************************************数组类型****************************************************
0, -9, 10, 5, 89, 26, 34, 1, 23, 5, 89, -5, 8, -78
江北机场, 两路, , , 金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞, 七星岗, 小什字, 解放碑, 石桥铺
江北机场, 两路, , , 金童路, 重庆北站南广场, 龙头寺, 狮子坪, 红旗河沟, 观音桥, 牛角沱, 两路口, 工毛, 铜元局, 南平, 四公里, 九公里, 鱼洞, 七星岗, 小什字, 解放碑, 石桥铺
0, -9, 10, 5, 89, 26, 34, 1, 23, 5, 89, -5, 8, -78
[(0, 江北机场), (-9, 两路), (10, ), (5, ), (89, 金童路), (26, 重庆北站南广场), (34, 龙头寺), (1, 狮子坪), (23, 红旗河沟), (5, 观音桥), (89, 牛角沱), (-5, 两路口), (8, 工毛), (-78, 铜元局)]
[0:江北机场, -9:两路, 10:, 5:, 89:金童路, 26:重庆北站南广场, 34:龙头寺, 1:狮子坪, 23:红旗河沟, 5:观音桥, 89:牛角沱, -5:两路口, 8:工毛, -78:铜元局]

Process finished with exit code 0


慢羊羊的快发明
关注
专栏目录
kotlin-array
03-21
在 Kotlin 中，我们可以使用 `arrayOf` 函数或者通过数组类型和初始化器来创建数组。例如： ```kotlin val numbers = arrayOf(1, 2, 3, 4, 5) val stringArray = Array(5) { "Element $it" } ``` 第二种方式中...
Kotlin中数组和集合的使用
yxf0448的博客
03-21 920
kotlin中数组和集合的使用
怎么理解Kotlin中的数组？看完这篇必懂！
m0_56255097的博客
12-29 1844
Kotlin 是一种新型的静态类型编程语言，有超过 60% 的专业 Android 开发者在使用，它有助于提高工作效率、开发者满意度和代码安全性。不仅可以减少常见代码错误，还可以轻松集成到现有应用中。在这里为了方便大家系统的学习Kotlin，这里特意联合了阿里P7架构师和谷歌技术团队共同整理了一份**Kotlin全家桶学习资料（免费领取~）**。内容概要：Kotlin 入门教程指南、高级Kotlin强化实战和史上最详Android版kotlin协程入门进阶实战。
前端小知识：使用 Array.of() 轻松创建数组
最新发布
前端达人
09-10 326
小伙伴们！你在开发JavaScript的时候，有没有遇到过创建数组时踩“坑”的情况？比如说你想创建一个包含单个数字的数组，结果却莫名其妙生成了一个空数组。这种情况是不是很让人抓狂？别急，今天我们来聊聊专为解决这个问题设计的Array.of()方法，它让数组创建变得更直观、简单，还能避免那些让人头疼的"坑"。我们为什么需要Array.of()？????先给大家举个现实中的例子吧：想象一下，你在电商网站购物...
Kotlin避坑：在Kotlin中常见的隐藏性能开销
m0_64420071的博客
06-14 987
Kotlin在Android中的比重越来越高。已经从Java替代品发展成为一个完整的生态系统，Google也早已宣布支持Kotlin为Android头等支持语言，同时内部项目也在迁移Kotlin。
Kotlin入门-基本类型
yql_running的博客
07-15 426
在 Kotlin 中，基本类型包含：数字、字符、布尔和数组。
Kotlin基础语法-数组
pz1023_live的博客
04-25 1410
Kotlin基础语法-数组一、创建数组创建数组的两种方式： 一、创建数组 Kotlin创建数组就是创建Array类的实例，Kotlin即可允许通过Array类的构造器来创建实例，也可以通过arrayOf()等工具函数来创建实例。 创建数组的两种方式： 使用xxArrayOf()、arrayOf()、arrayOfNulls()、emptyArray()工具函数; 使用Array(size:Int...
Kotlin - Learning Kotlin
07-02
val array = arrayOf("one", "two", "three") ``` 2. **原始类型数组**： ```kotlin val array = intArrayOf(1, 2, 3) ``` 3. **扩展函数**：Kotlin 提供了丰富的扩展函数来操作数组。 ```kotlin val array...
dio-kotlin-arrays-list-collections
03-18
- **创建**：可以使用`arrayOf()`或`IntArray()`等函数创建数组，例如`val numbers = arrayOf(1, 2, 3)`或`val numbers = intArray(3) { it + 1 }`。 - **访问和修改**：通过索引访问数组元素，如`numbers[0]`，并...
arrays-kotlin
03-06
val array2 = arrayOf(4, 5, 6) val combined = array1 + array2 // 或 array1.plus(array2) ``` 2. 复制：使用`copy()`函数可以复制数组： ```kotlin val copy = array.copyOf() ``` 3. 排序：使用`sorted()`或`...
Kotlin-Arrays:Kotlin数组上的简单代码学习
03-19
在Kotlin编程语言中，数组是一种非常基础且重要的数据结构，它用于存储固定大小的同类型元素集合。本文将深入探讨Kotlin中的数组及其相关的概念、特性与操作，旨在帮助你更好地理解和应用Kotlin的数组功能。 首先，...
Array.of()方法
热门推荐
歪脖先生的博客
01-23 2万+
Array.of()方法 Array.of()方法用于将一组值，转换为数组。 Array.of(3, 11, 8) // [3,11,8]Array.of(3) // [3]Array.of(3).length // 1 这个方法的主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。 Array() // []Array(3) /
Kotlin 入门到精通 (九)
我很好
03-22 3574
🔥 Kotlin 数据容器 🔥 容器是用于存放数据的载体. 容器 分为 数组、集合 . 除了存储基本数据类型 , 还可以存储对象 . 数组 数组是一种初始化时指定容器大小 , 不可动态调整其大小的容器 . 元素顺序存储在一串连续的内存段上 . 例如 : 如果指定了数组的长度为10 , 那么它的大小就不可以变了 . 🔥 数组创建 🔥 arrayOf 创建数组 创建一个数组并传递元素值给它 , 集合中的元素可以时任意类型 arrayOfNulls 创建数组 创建一个指定大小的、所有元素都为空
kotlin ——数组
qq_26554909的博客
12-22 1233
3、动态创建数组(接受一个表达式)， Array 初始化为 [“0”, “1”, “4”, “9”, “16”,"36]6、创建一个固定值的数组{35,35,35,35,35}5、大小为5，值为{0，0，0，0，0}的整形数组。4、 forEach遍历数组。3、 便利元素(带索引)5、forEach增强版。6.1、初始化数组值。
Kotlin-数组
weixin_46362658的博客
01-12 726
可以通过Array来创建数组，也可以通过arrayOf()等工具创建数组。Kotlin中创建数组有两种方式。
Kotlin第五弹：数据容器
m0_58941767的博客
09-09 831
容器是用于存放数据的载体。容器分为数组、集合。Kotlin 作为一门全新的语言，肯定还是要有自己的容器类，不然哪天 Java 跟 Kotlin 划清界限，那麻烦就大了。Kotlin 也拥有三类基本的容器，分别是集合 Set、队列 List、映射 Map，每种 容器又分作只读与可变两种类型这是为了判断该容器能否进行增删改等变更操作。• Kotlin 数组• Kotlin 集合本节内容较多，难度并不大，希望大家可以好好消化一下。咱们下期见！
Kotlin基础-数据容器（数组）
06-10 435
数组是一种在初始化时指定容器大小，不可以动态调整其大小的容器，元素按顺序存储在一串连续的地址空间上。
Kotlin学习日志（二）数据类型，干货
04-01 534
Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。【Android高级架构视频学习资源】Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！
【Kotlin】Array简介
little_fat_sheep
03-24 1313
创建数组、初始化数组、访问数组元素、遍历元素、拼接数组、内容比较、包含判断、翻转元素、打乱元素顺序、元素排序、可变长参数函数、统计函数、二维数组
Kotlin编程实战技巧速查
使用 `arrayOf()` 或 `IntArray(size)` 等函数创建数组，可以指定数组的大小和初始值。 #### 4.4 使用闭包创建数组 可以使用 lambda 表达式或匿名函数初始化数组的所有元素，比如 `Array(size) { it * it }` 创建一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值