kotlin 内置函数对数组进行各种操作

以下是一些常见的用法示例:

  • plus() 函数将两个数组合并成一个数组。plus() 函数是 Kotlin 标准库中的一个扩展函数,可以用于合并两个同类型的数组。
    fun main() {val array1 = arrayOf(1, 2, 3)val array2 = arrayOf(4, 5, 6)val mergedArray = array1.plus(array2)println(mergedArray.contentToString()) // 输出 [1, 2, 3, 4, 5, 6]
    }

  • 使用 minus() 函数从数组中移除指定元素,并返回新的数组
val array = arrayOf(1, 2, 3, 4, 5)
val newArray = array.minus(3) // 移除元素 3
println(newArray.contentToString()) // 输出 [1, 2, 4, 5]
  • 使用 slice() 函数获取数组中指定位置的元素,并返回新的数组:
val array = arrayOf(1, 2, 3, 4, 5)
val slicedArray = array.slice(1..3) // 获取索引为 1 到 3 的元素
println(slicedArray.contentToString()) // 输出 [2, 3, 4]
  • 使用 chunked() 函数将数组分成指定大小的块,并返回一个列表:
val array = arrayOf(1, 2, 3, 4, 5)
val chunkedList = array.chunked(2) // 将数组分成大小为 2 的块
println(chunkedList) // 输出 [[1, 2], [3, 4], [5]]
  • 使用 distinct() 函数获取数组中不同的元素,并返回新的数组
val array = arrayOf(1, 2, 2, 3, 3, 4, 5)
val distinctArray = array.distinct() // 获取不同的元素
println(distinctArray.contentToString()) // 输出 [1, 2, 3, 4, 5]

    find():用于在数组中查找符合指定条件的元素,并返回该元素

val numbers = listOf(1, 2, 3, 4, 5)val result = numbers.find { it % 2 == 0 }println(result) // 输出:2
  • joinToString():用于将数组中的元素连接成字符串,并返回该字符串。
fun main() {  val array = arrayOf("Hello", "World")  val result = array.joinToString()  println(result) // 输出 "HelloWorld"  
}
  • map():用于根据指定规则将数组中的元素进行映射,并返回一个新的数组。
fun String.toUpperCase(): String {  return this.toUpperCase()  
}  val strings = listOf("apple", "banana", "cherry")  // 使用自定义的 toUpperCase() 函数将字符串转换为大写  
val upperCaseStrings = strings.map { it.toUpperCase() }  println(upperCaseStrings) // 输出 [APPLE, BANANA, CHERRY]

  • sum():用于计算数组中所有元素的和。
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  // 使用 sum() 函数计算所有数字的总和  val sum = numbers.sum()  println("Sum of numbers: $sum") // 输出 "Sum of numbers: 15"  
}
  • first():返回第一个元素
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  // 使用 first() 函数获取第一个数字  val firstNumber = numbers.first()  println("First number: $firstNumber") // 输出 "First number: 1"  
}
  • last():返回最后一个元素
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  // 使用 last() 函数获取最后一个数字  val lastNumber = numbers.last()  println("Last number: $lastNumber") // 输出 "Last number: 5"  
}
  • firstOrNull():返回第一个元素,如果数组为空则返回null
  • lastOrNull():返回最后一个元素,如果数组为空则返回null
  • getOrNull():根据下标获取元素,如果下标越界则返回null
val map = mapOf("apple" to 1, "banana" to 2, "orange" to 3)  // 获取键为 "apple" 的值,如果不存在则返回 null  
val appleValue = map.getOrNull("apple")  
println("Apple value: $appleValue") // 输出 "Apple value: 1"  // 获取键为 "grape" 的值,如果不存在则返回 null  
val grapeValue = map.getOrNull("grape")  
println("Grape value: $grapeValue") // 输出 "Grape value: null"
  • take():获取前n个元素
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  // 使用 take() 函数获取前三个数字  val result = numbers.take(3)  // 遍历并打印结果  for (num in result) {  println(num)  }  
    }
    我们使用循环遍历并打印结果。输出将为:1  
    2  
    3
    
  • takeLast():获取后n个元素
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  // 使用 takeLast() 函数获取最后三个数字  val result = numbers.takeLast(3)  // 遍历并打印结果  for (num in result) {  println(num)  }  
    }
    输出将为:7  
    8  
    9
    
  • drop():去除前n个元素
  •  val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)// 使用 drop() 函数删除前三个数字val result = numbers.drop(3)// 打印删除元素后的新序列println(result) // 输出 [4, 5, 6, 7, 8, 9, 10]

  • dropLast():去除后n个元素
  •                                                 
    var numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, // 使用 dropLast() 函数删除最后三个数字并将结果分配回原始列表          
    numbers = numbers.dropLast(3)                   // 打印修改后的原始列表                                   
    println(numbers) // 输出 [1, 2, 3, 4, 5, 6, 7]    

  • filter():根据条件筛选元素
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  // 使用 filter() 函数筛选出偶数并打印  val evenNumbers = numbers.filter { it % 2 == 0 }  println(evenNumbers)  // 输出:[2, 4, 6, 8, 10]  
    }

  • map():对每个元素执行指定操作
  • fun main() {  // 创建一个包含字符串的列表  val strings = listOf("apple", "banana", "orange")  // 使用 map() 函数将字符串转换为它们的长度,并打印结果  val lengths = strings.map { it.length }  println(lengths)  // 输出:[6, 6, 5]  
    }
  • flatMap():对每个元素执行指定操作,并将结果合并到一个列表中
  • fun main() {  val listOfLists = listOf(listOf(1, 2, 3), listOf(4, 5, 6), listOf(7, 8, 9))  val flattenedList = listOfLists.flatMap { it }  println(flattenedList) // 输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]  
    }

  • distinct():去除重复元素
    fun main() {  val numbers = listOf(1, 2, 2, 3, 4, 4, 5)  val uniqueNumbers = numbers.distinct()  println(uniqueNumbers) // 输出了 [1, 2, 3, 4, 5]  
    }

distinctBy():根据指定条件去除重复元素

fun main() {  val items = listOf("apple", "banana", "cherry", "date", "elderberry")  val distinctItems = items.distinctBy { it.length }  println(distinctItems) // 输出了 [apple, banana, cherry, date]  
}
  • contains():判断数组是否包含指定元素
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val containsThree = numbers.contains(3)  println(containsThree) // 输出:true  
}
  • indexOf():获取指定元素的下标,如果不存在则返回-1
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val index = numbers.indexOf(3)  println("The index of 3 is: $index") // 输出:The index of 3 is: 2  
}
我们打印出结果,显示数字 3 在列表中的位置。请注意,indexOf() 函数返回的是该元素在列表中的位置,索引从 0 开始。
  • lastIndexOf():获取指定元素的最后一个下标,如果不存在则返回-1
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5, 3)  val lastIndex = numbers.lastIndexOf(3)  println("The last index of 3 is: $lastIndex") // 输出:The last index of 3 is: 5  
    }

  • partition():根据条件分成两个数组
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val (evenNumbers, oddNumbers) = numbers.partition { it % 2 == 0 }  println("Even numbers: $evenNumbers") // 输出:[2, 4]  println("Odd numbers: $oddNumbers") // 输出:[1, 3, 5]  
    }

  • groupBy():根据条件将元素分组到不同的数组中
  • fun main() {  val items = listOf("apple", "banana", "cherry", "date", "elderberry")  val itemGroups = items.groupBy { it.length }  for ((key, value) in itemGroups) {  println("Items with length $key: $value")  }  
    }答案输出:
    Items with length 5: [apple]
    Items with length 6: [banana, cherry]
    Items with length 4: [date]
    Items with length 10: [elderberry]

  • sum():计算元素的总和
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val sum = numbers.sum()  println("The sum of the numbers is: $sum") // 输出:The sum of the numbers is: 15  
    }
  • average():计算元素的平均值
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val average = numbers.average()  println("The average of the numbers is: $average") // 输出:The average of the numbers is: 3.0  
    }
    
  • max():获取最大元素
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val maxNumber = numbers.max()  println("The maximum number is: $maxNumber") // 输出:The maximum number is: 5  
    }
  • min():获取最小元素
  • reduce():对元素进行累加
fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val result = numbers.reduce { acc, num -> acc + num }  println("The sum of the numbers is: $result") // 输出:The sum of the numbers is: 15  
}
  • fold():对元素进行累加,并可以指定初始值
  • fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val result = numbers.fold(0) { acc, num -> acc + num }  println("The sum of the numbers is: $result") // 输出:The sum of the numbers is: 15  
    }

  • forEach():遍历元素并执行指定操作
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  numbers.forEach { println(it) }  
    }
    将会输出以下内容:1  
    2  
    3  
    4  
    5
    

  • forEachIndexed():遍历元素并获取索引,执行指定操作
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  numbers.forEachIndexed { index, num -> println("Index $index: $num") }  
    }将会输出以下内容:Index 0: 1  
    Index 1: 2  
    Index 2: 3  
    Index 3: 4  
    Index 4: 5
    

  • zip():将两个数组合并成一个新数组,每个元素都是一对。
    fun main() {  val list1 = listOf("a", "b", "c")  val list2 = listOf(1, 2, 3)  val zippedList = list1.zip(list2) { a, b -> Pair(a, b) }  zippedList.forEach { println(it) }  
    }将会输出以下内容:复制代码
    Pair(a, 1)  
    Pair(b, 2)  
    Pair(c, 3)
    

  • all():判断所有元素是否都满足指定条件
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val allPositive = numbers.all { it > 0 }  println("All numbers are positive: $allPositive") // 输出:All numbers are positive: true  
    }

  • any():判断是否有任何元素满足指定条件
    fun main() {  val numbers = listOf(1, 2, -3, 4, 5)  val hasNegative = numbers.any { it < 0 }  println("Numbers have negative value: $hasNegative") // 输出:Numbers have negative value: true  
    }

  • none():判断是否所有元素都不满足指定条件
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val hasNegative = numbers.none { it < 0 }  println("Numbers have no negative value: $hasNegative") // 输出:Numbers have no negative value: true  
    }

  • associate():将每个元素转化为Pair对象,并返回一个Map
    fun main() {  val numbers = listOf(1, 2, 3, 4, 5)  val associatedMap = numbers.associate { it to it }  println("Associated map: $associatedMap")  
    }输出
    Associated map: {1=1, 2=2, 3=3, 4=4, 5=5}

  • associateBy():根据指定条件生成key,并将元素转化为value,返回一个Map
    fun main() {  val people = listOf("David", "Bob", "Charlie", "Alice")val associatedMap = people.associateBy { it.length }  println("Associated map: $associatedMap")  
    }Associated map: {5=Alice, 3=Bob, 7=Charlie}
    

  • associateWith():将每个元素转化为key,并根据指定条件生成value,返回一个Map
  •   val people = listOf("Alice", "Bob", "Charlie", "David") val associatedMap = people.associateWith { it.length }  println("Associated map: $associatedMap")               
    Associated map: {Alice=5, Bob=3, Charlie=7, David=5}

  • flatMapTo():将每个元素执行指定操作,并将结果合并到一个指定类型的列表中
  •  val numbers = listOf(1, 2, 3, 4, 5)  val flattened = numbers.flatMapTo(HashSet<Int>()) { setOf(it * 2) }println("Flattened list: $flattened")
    
  • mapTo():将每个元素执行指定操作,并将结果合并到一个指定类型的列表中
  • val numbers = listOf(1, 2, 3, 4, 5)    
    val squaredNumbers = numbers.mapTo(ArrayList<Int>()) { it * it }
    println("Squared numbers: $squaredNumbers")输出结果:Squared numbers: [1, 4, 9, 16, 25]
    

  • reduceIndexed():对元素进行累加,并可以访问索引
    val numbers = listOf(1, 2, 3, 4, 5)val result = numbers.reduceIndexed { index, acc, value ->if (index % 2 == 0) {acc + value} else {acc - value}
    }println("Result: $result")
    输出结果将会是:Result: 3

  • foldIndexed():对元素进行累加,并可以访问索引,并可以指定初始值
    val numbers = listOf(1, 2, 3, 4, 5)val result = numbers.foldIndexed(0) { index, acc, value ->if (index % 2 == 0) {acc + value} else {acc - value}
    }println("Result: $result")输出结果将会是:Result: 3
    

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/170347.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Ps:拾色器 - 选取专色

在 Adobe 拾色器中&#xff0c;可点击“颜色库” Color Libraries按钮来选取专色。 首先在色库 Book列表中选择对应的色库&#xff0c;然后在中间的色相条中选择需要的样本组&#xff0c;再从左侧颜色列表中选取颜色。 可以直接键入颜色名称来选择。比如&#xff0c;键入 13&am…

0001Java程序设计-springboot基于微信小程序批发零售业商品管理系统

文章目录 **摘 要****目录**系统实现开发环境 编程技术交流、源码分享、模板分享、网课分享 企鹅&#x1f427;裙&#xff1a;776871563 摘 要 本毕业设计的内容是设计并且实现一个基于微信小程序批发零售业商品管理系统。它是在Windows下&#xff0c;以MYSQL为数据库开发平台…

使用主成分分析之特征向量法求点云法向量

1. 原理简述 我们知道主成分分析会得到特征值、特征向量,最大的特征值及其对应的特征向量则为主成分,表示数据分布的主方向。 最小特征值对应的特征向量则可以认为是空间点云的法向量。 2. 代码实现 //in_cloud为点云,center为点云质心 Eigen::Vector3d normal(const PC…

C#,《小白学程序》第八课:列表(List)其二,编制《高铁列车时刻表》与时间DateTime

1 文本格式 /// <summary> /// 车站信息类 class /// </summary> public class Station { /// <summary> /// 编号 /// </summary> public int Id { get; set; } 0; /// <summary> /// 车站名 /// </summary&g…

物联网AI 无线连接学习之蓝牙基础篇 协议的发展

学物联网&#xff0c;来万物简单IoT物联网&#xff01;&#xff01; 蓝牙由来 “蓝牙”&#xff08;Bluetooth&#xff09;原是一位在10世纪统一丹麦的国王哈拉尔 (HaralBluetooth)&#xff0c;他将当时的瑞典、芬兰与丹麦统一起来。而将“蓝牙”与后来的无线通讯技术标准关联…

2023年第十六届中国系统架构师大会(SACC2023)-核心PPT资料下载

一、峰会简介 本届大会以“数字转型 架构演进”为主题&#xff0c; 涵盖多个热门领域&#xff0c;如多云多活、海量分布式存储、容器、云成本、AIGC大数据等&#xff0c;同时还关注系统架构在各个行业中的应用&#xff0c;如金融、制造业、互联网、教育等。 与往届相比&#…

点云从入门到精通技术详解100篇-基于深度学习的语义分割与室内稠密点云地图研究

目录 前言 国内外点云建图构建与语义分割研究现状 2传感器及神经网络基本概念

c++ 栈空间 堆空间

1 栈空间 int main() {Subclass1 subclass1;subclass1.xFunction();return 0; } 这种情况下,subclass1对象会直接在栈空间上创建,而不会在堆空间上动态分配。 但是这种栈上创建的对象有一定的限制: 1. 栈空间内存有限,对象过大可能会栈溢出 2. 出了作用域后对象会被自动销毁 3…

使用Ruby过滤目录容量大小

实际使用的&#xff0c;显示大于某种容量的目录或文件。 #encoding:utf-8input STDIN.read input.lines.each do |line|num line.gsub(/^([0-9\.])G.*$/,"\\1")if num.to_i > ARGV[0].to_iputs lineend end使用如下命令运行&#xff1a; $ du -hs * 2>/dev…

CSIT883系统分析与项目管理——Lecture3重点概念

一、前言 🎊🎊🎊关于如何计算NPV的方式在另外一篇博文哦,写的非常详细!感兴趣的同学强烈推荐去看看哦 二、重点概念 1.净现值(NPV)分析是一种计算项目的预期净货币收益或损失的方法贴现所有预期未来现金流入和流出当前时间点(“1”“>”1明天”(通货膨胀))…

基于ncurse实现的俄罗斯方块

1. 需求分析 方块的类型方块的变形方块的消除方块的存储方块的移动接受用户的输入 2. 概要设计 2.1 方块类型与变形 一共有七种&#xff0c;变换的方式如下。变换后的任意形状方块实际上可以存在一个4x4的矩阵中。 我们再压一下位&#xff0c;就可以存在16位中。 2.2 方块…

常用脚本-持续更新(文件重命名、视频抽帧、拆帧、删除冗余文件、yolo2xml、转换图片格式、修改xml)

所有代码位置&#xff1a;Learning-Notebook-Codes/Python/常用脚本 1. 文件重命名 脚本路径&#xff1a;codes/files_rename.py脚本说明&#xff1a;可以自动重命名某个文件夹下指定类型的文件。 修改前文件名称: img1.jpg修改后文件名称: Le0v1n-20231123-X-0001.jpg imp…

笔试编程题--打家劫舍

你是一个专业的小偷&#xff0c;计划偷窃沿街的房屋。每间房内都藏有一定的现金&#xff0c;影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统&#xff0c;如果两间相邻的房屋在同一晚上被小偷闯入&#xff0c;系统会自动报警。给定一个代表每个房屋存放金额的非…

leetcode每日一题33

86.分隔链表 因为对链表中的一个节点进行更换位置的操作需要知道该节点的上一个节点 所以建立一个虚拟头节点 ListNode* pnew ListNode(-201,head);根据题意&#xff0c;我们需要找到第一个大于x或等于x的节点large 并且将第一个大于或等于x的节点large后的所有小于x的节点都…

Java中的线程

在 Java 中&#xff0c;线程是程序执行的最小单元&#xff0c;它被包含在进程之中.是进程中的实际运作单位&#xff0c;允许程序并发执行多个任务&#xff0c;提高系统资源的利用率&#xff1b;比如.如果一个线程完成一个任务要 100 毫秒.那么用十个线程完成改任务只需 10 毫秒…

基于SpringBoot+Redis的前后端分离外卖项目-苍穹外卖(八)

套餐模块功能开发 1. 新增套餐1.1 需求分析和设计1.1.1产品原型&#xff1a;1.1.2接口设计&#xff1a;1.1.3数据库设计&#xff1a; 1.2 代码开发1.2.1 DishController层1.2.2 DishService接口类1.2.3 DishServiceImpl接口实现类1.2.4 DishMapper层1.2.5 DishMapper.xml1.2.6 …

Flutter与Android的混合跳转和通信

1、项目特点 项目是Flutter作为主工程&#xff0c;将Android module或SDK作为模块嵌入到flutter中&#xff0c;与通常所熟悉的Android&#xff08;或iOS&#xff09;工程将flutter 为module嵌入到工程中有所不同。 2、业务需求 任意界面间的跳转&#xff0c;不管是flutter页…

Spring Cache框架,实现了基于注解的缓存功能。

个人简介&#xff1a;Java领域新星创作者&#xff1b;阿里云技术博主、星级博主、专家博主&#xff1b;正在Java学习的路上摸爬滚打&#xff0c;记录学习的过程~ 个人主页&#xff1a;.29.的博客 学习社区&#xff1a;进去逛一逛~ Spring Cache框架 简介Spring Cache 环境准备S…

Android studio 引用framework.jar

framework.jar 引用目录 N/O&#xff1a; out/target/common/obj/JAVA_LIBRARY/framework_interminate/classes.jarAndroid 9/10: out/soong/.intermediates/frameworks/base/framework/android_common/combined/framework.jarAndroid 11: out/soong/.intermediates/framewo…

ArrayList和LinkedList的区别

List是我们才日常开发中一定会使用到的&#xff0c;它有两个实现&#xff0c;分别是ArrayList和LinkedList。本文主要来介绍一下它们之间的区别。 ArrayList和LinkedList都是Java中常见的集合类&#xff0c;它们之间有几个关键区别&#xff1a; // 创建一个ArrayList List<…