【Kotlin List运用】编写Kotlin程序，实现对学生成绩的简单分析

于 2020-04-13 11:31:38 发布
阅读量1k 收藏 1
点赞数 2
分类专栏： kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38304672/article/details/105484240
版权

一.查看需求

  1. 按学生成绩从高到低顺序打印：学号、姓名、成绩
  2. 打印学生的最高成绩、最低成绩、平均成绩
  3. 分优秀（ [90,100] ）、良好（ [80,90) ）、中等（ [70,80) ）、及格（ [60,70) ）、不及格（ <60 ）五档，分别打印其学生个数和占比

二.boat

  1. kotlin与list普通测试
    样例:
    List的size是计数器，从1开始
import java.text.DecimalFormat
import java.util.*
import java.util.zip.CheckedOutputStream

//创建成绩类


fun main(args:Array<String>){

//1.建立普通list与MutableList
    val mList: List<Int> = listOf(0,1,2,2,3)
    var courselist:MutableList<Int> = mutableListOf()//创建一个初始为空具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
//2.添加操作
    //courselist.add(0,6)//坐标直接替换
    courselist?.add(1)
    courselist?.add(2)
    courselist?.add(3)//插入尾部
    courselist.addAll(mList)//和list结合addall很方便 前提是类型相同
 
//3.1打印全部测试
    println("测试1:"+courselist)

//3.2rang打印测试
    print("测试2:")
    for(i in 0 .. 7){//for循环赋值存入
        print(" "+courselist[i])
    }
//3.3size打印测试

}

结果展示

  1. kotlin与list类测试

import java.text.DecimalFormat
import java.util.*

//创建成绩类
public class Student(var name:String,var sno:String,var grade:Int)//主构造器 var出来 tostring就可以直接用了
{
 /*   override fun toString(): String {
        return "Student(name='$name', sno='$sno', grade=$grade)"
    }*/

}


fun main(args:Array<String>){
    //创建成绩列表
    var courselist= mutableListOf<Student>()//创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

    

    var student1:Student=Student("天河","201701014145",90)
    var student2:Student=Student("紫英","201701014146",80)
    var student3:Student=Student("菱纱","201701014147",70)
    var student4:Student=Student("小白","201701014148",50)
    courselist.add(student1)
    courselist.add(student2)
    courselist.add(student3)
    courselist.add(student4)

    println(courselist)//有tostri会自动调用
}

1） 这里我们可以发现他储存的是一个地址，是一个“指针”索引
打印地址
2）将tostring方法取消注释后，打印list我们直接就可以拿到储存对象数据kotlin会自动调用tostring方法，有没有感觉这个结构和json返回数据很像
![(https://img-blog.csdnimg.cn/20200413113442360.png)

三.上手(借鉴了其他up的代码，链接没保存，有机会看到补上)

1）原思路


import java.text.DecimalFormat
import java.util.*

//创建成绩类
public class Student(var name:String,var sno:String,var grade:Int)
{
    override fun toString(): String {
        return "Student(name='$name', sno='$sno', grade=$grade)"
    }

}


fun main(args:Array<String>){
    //创建成绩列表
    var courselist= mutableListOf<Student>()//创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。



    var student1:Student=Student("天河","201701014145",90)
    var student2:Student=Student("紫英","201701014146",80)
    var student3:Student=Student("菱纱","201701014147",70)
    var student4:Student=Student("小白","201701014148",50)

    courselist.add(student1)
    courselist.add(student2)
    courselist.add(student3)
    courselist.add(student4)

  /*  println(courselist)//有tostri会自动调用*/
    //从高到低排序并返回排序好的成绩列表
    courselist=gradesorts(courselist)//先将其排序
    //求最高成绩，最低成绩，平均成绩
    gradeviews(courselist)
    //各个档次学生个数和比例
    gradelvs(courselist)

}

//方法1 冒泡排序
fun gradesorts(courselists: MutableList<Student>): MutableList<Student> {
    var course=Student("1","1",1)
    println("按学生成绩从高到低排序：")
    

    for(i in 0..courselists.size-2)
        for(j in 0 ..courselists.size-2-i){
            if(courselists[j].grade<courselists[j+1].grade){
                course=courselists[j+1]
                courselists[j+1]=courselists[j]
                courselists[j]=course
            }
        }
    }

    for(i in 0..courselists.size-1){
        println(courselists[i].sno+" "+courselists[i].name+" "+courselists[i].grade)
    }
    return courselists
}
//方法2 等级
fun gradelvs(courselists: MutableList<Student>) {

    var a=0
    var b=0
    var c=0
    var d=0
    var e=0
    for (i in 0.. courselists.size-1){
        /*   var x=-1
           if(courselist[i].grade>=60){
               x=(courselist[i].grade-60)/10
           }
           else{
               e++
           }*/
        var x=courselists[i].grade/10
        when(x){
            10 -> a++
            9 -> a++
            8 -> b++
            7 -> c++
            6 -> d++
            else ->
                e++
        }
    }

    println("各类成绩个数以及比例为：\n" +
            " 优秀（90-100） ：${a}个 （${String.format("%.2f",a*1.0 / courselists.size*100)}%）\n" +
            " 良好（ 80-90 ）：${b}个 （${String.format("%.2f",b*1.0 / courselists.size*100)}%）\n" +
            " 中等（ 70-80 ）：${c}个 （${String.format("%.2f",c*1.0 / courselists.size*100)}%）\n" +
            " 及格（ 60-70 ）：${d}个 （${String.format("%.2f",d*1.0 / courselists.size*100)}%）\n" +
            " 不及格（60以下）：${e}个 （${String.format("%.2f",e*1.0 / courselists.size*100)}%）")
}
//方法3 获取成绩分布
fun gradeviews(courselists: MutableList<Student>) {
    var sum=0
    for(i in 0..courselists.size-1){
        sum=sum+courselists[i].grade
    }
    
    var average=sum*1.0/courselists.size
    println("最高成绩为：${courselists[0].grade}分，" +
            "最低成绩为：${courselists[courselists.size-1].grade}分，" +
            "平均成绩为：${String.format("%.2f",average)}分")
}

2）此时发现，这种写法，量级比较小好像，成员一多重复代码也太多了吧，抽取list，批处理

import java.text.DecimalFormat
import java.util.*

//创建成绩类
public class Course()
{
    var name:String?=null
    var sno:String?=null
    var grade:Int=0
}

fun main(args:Array<String>){
    //1.创建成绩列表
    var courselist:MutableList<Course>= mutableListOf<Course>()

    //2.创建录入数据两层Array我也是服气的。。
    var courseArray:Array<Array<Any>> = arrayOf(//二维数组 装一个any类型容器
        arrayOf("天河","201701014145",90),
        arrayOf("紫英","201701014146",80),
        arrayOf("菱纱","201701014147",70),
        arrayOf("小白","201701014148",50)
    )


    //将测试样例存入成绩列表
    for(i in 0 until courseArray.size){//for循环赋值存入
        var course=Course()
        course.name=courseArray[i][0].toString()
        course.sno= courseArray[i][1] as String
        course.grade=courseArray[i][2].toString().toInt()
        courselist.add(i,course)//由于这边类型不同 不能直接addall

    }
    //从高到低排序并返回排序好的成绩列表
    courselist=gradesort(courselist)//先将其排序
    //求最高成绩，最低成绩，平均成绩
    gradeview(courselist)
    //各个档次学生个数和比例
    gradelv(courselist)

}
//方法1 排序
fun gradesort(courselist: MutableList<Course>): MutableList<Course> {
    var course=Course()
    println("按学生成绩从高到低排序：")
    for(i in 0..courselist.size-2){

        for(j in 0 ..courselist.size-2-i){
            if(courselist[j].grade<courselist[j+1].grade){
                course=courselist[j+1]
                courselist[j+1]=courselist[j]
                courselist[j]=course
            }
        }
    }

    for(i in 0..courselist.size-1){
        println(courselist[i].sno+" "+courselist[i].name+" "+courselist[i].grade)
    }
    return courselist
}
//方法2 等级
fun gradelv(courselist: MutableList<Course>) {

    var a=0
    var b=0
    var c=0
    var d=0
    var e=0
    for (i in 0.. courselist.size-1){
   
        var x=courselist[i].grade/10
        when(x){
            10 -> a++
            9 -> a++
            8 -> b++
            7 -> c++
            6 -> d++
            else ->
                e++
        }
    }

    println("各类成绩个数以及比例为：\n" +
            " 优秀（90-100） ：${a}个 （${String.format("%.2f",a*1.0 / courselist.size*100)}%）\n" +
            " 良好（ 80-90 ）：${b}个 （${String.format("%.2f",b*1.0 / courselist.size*100)}%）\n" +
            " 中等（ 70-80 ）：${c}个 （${String.format("%.2f",c*1.0 / courselist.size*100)}%）\n" +
            " 及格（ 60-70 ）：${d}个 （${String.format("%.2f",d*1.0 / courselist.size*100)}%）\n" +
            " 不及格（60以下）：${e}个 （${String.format("%.2f",e*1.0 / courselist.size*100)}%）")
}
//方法3 获取成绩分布
fun gradeview(courselist: MutableList<Course>) {
    var sum=0
    for(i in 0..courselist.size-1){
        sum=sum+courselist[i].grade
    }
    var average=sum*1.0/courselist.size
    println("最高成绩为：${courselist[0].grade}分，" +
            "最低成绩为：${courselist[courselist.size-1].grade}分，" +
            "平均成绩为：${String.format("%.2f",average)}分")
}

四.示例代码，额。。大佬出手就是不一样（符老师）

data class Student(val Id:String,val name:String,var score:Int){
override fun toString()="%12s\t%8s\t%4d".format(Id,name,score)
}

fun getStudents()= listOf(
Student("1","zhang1",82),
Student("2","zhang2",77),
Student("3","zhang3",65),
Student("4","zhang4",45),
Student("5","zhang5",88),
Student("6","zhang6",96),
Student("7","zhang7",78),
Student("8","zhang8",65),
Student("9","zhang9",77),
Student("10","zhang10",0),
Student("11","zhang11",45),
Student("12","zhang12",88),
Student("13","zhang13",82),
Student("14","zhang14",98),
Student("15","zhang15",66),
Student("16","zhang16",77)
)
fun main(){
println("%12s\t%8s\t%4s".format("学号    ","姓名    ","分数"))
val students=getStudents()
students.sortedByDescending{it.score}.forEach(::println)
val scores=students.map{it.score}
println("最高分：${scores.max()}\t最低分：${scores.min()}\t平均分：${scores.average()} ")

val scoreGroups=scores.groupingBy(){
when(it){
in 90..100 -> "1.优秀"
in 80..89  -> "2.良好"
in 70..79  -> "3.中等"
in 60..69  -> "4.及格"
else  -> "5.不及格"
}
}.eachCount().toSortedMap()
//  scoreGroups
// println(scoreGroups)
val numberOfStudent=students.count()
// println(numberOfStudent)
println("")
println("各分数段分布情况：")
println("分数段\t       人数\t占比")
for( it in scoreGroups.keys){
val cnt=scoreGroups[it]?:0
val ratio=100.0*cnt/numberOfStudent
println("$it: \t$cnt\t$ratio%" )
}

}
输出结果：
     学号      姓名      分数
         14 zhang14  98
          6  zhang6  96
          5  zhang5  88
         12 zhang12  88
          1  zhang1  82
         13 zhang13  82
          7  zhang7  78
          2  zhang2  77
          9  zhang9  77
         16 zhang16  77
         15 zhang15  66
          3  zhang3  65
          8  zhang8  65
          4  zhang4  45
         11 zhang11  45
         10 zhang10   0
最高分：98 最低分：0 平均分：70.5625
各分数段分布情况：
分数段       人数 占比
1.优秀: 2 12.5%
2.良好: 4 25.0%
3.中等: 4 25.0%
4.及格: 3 18.75%
5.不及格: 3 18.75%
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值