Here is a pure-Kotlin truncation function.

It uses Duration.toComponents() to get the constituent components of the duration. It then converts each back into a Duration, depending on whether it is equal to or larger than the requested DurationUnit.

import kotlin.time.*
import kotlin.time.DurationUnit.*
import kotlin.time.Duration.Companion.days
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.microseconds
import kotlin.time.Duration.Companion.nanoseconds
import kotlin.time.Duration.Companion.seconds

/**
 * Truncates the duration to the specified [unit].
 *
 * Truncating the duration removes any time units smaller than the specified unit
 * and returns a new [Duration] with the truncated value.
 *
 * @param unit The duration unit to truncate to.
 * @returns a new [Duration] truncated to the specified [unit].
 */
private fun Duration.truncate(unit: DurationUnit): Duration {
  return toComponents { days: Long, hours: Int, minutes: Int, seconds: Int, nanoseconds: Int ->
    when (unit) {
      NANOSECONDS  -> this // there's no smaller unit than NANOSECONDS, so just return the current Duration
      MICROSECONDS -> days.days + hours.hours + minutes.minutes + seconds.seconds + nanoseconds.nanoseconds.inWholeMicroseconds.microseconds
      MILLISECONDS -> days.days + hours.hours + minutes.minutes + seconds.seconds + nanoseconds.nanoseconds.inWholeMilliseconds.milliseconds
      SECONDS      -> days.days + hours.hours + minutes.minutes + seconds.seconds
      MINUTES      -> days.days + hours.hours + minutes.minutes
      HOURS        -> days.days + hours.hours
      DAYS         -> days.days
    }
  }
}

Notes:

• nanoseconds is documented as being less than 1_000_000_000 (1 second), so there's no need to convert it to seconds.
• In order to round the nanoseconds to microseconds the nanoseconds value is first converted to a duration (nanoseconds.nanoseconds), then rounded to microseconds (inWholeMicroseconds) and then converted to a duration (.microseconds). The same process is used to round nanoseconds to milliseconds.

Example

Here's an example usage demonstrates the truncate() function applied to a duration using different time units. Each truncation removes all time units smaller than the specified unit.

import kotlin.time.*
import kotlin.time.DurationUnit.*
import kotlin.time.Duration.Companion.days
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.microseconds
import kotlin.time.Duration.Companion.nanoseconds
import kotlin.time.Duration.Companion.seconds

fun main() {
  // create a duration
  val duration = 1.hours + 30.minutes + 45.seconds + 2.milliseconds + 3.microseconds + 5.nanoseconds
  println(duration)                        // 1h 30m 45.002003005s
  println(duration.truncate(NANOSECONDS))  // 1h 30m 45.002003005s (no truncation - can't go smaller than the smallest unit)
  println(duration.truncate(MICROSECONDS)) // 1h 30m 45.002003s    (no nanoseconds)
  println(duration.truncate(MILLISECONDS)) // 1h 30m 45.002s       (no milliseconds or nanoseconds)
  println(duration.truncate(SECONDS))      // 1h 30m 45s     (milliseconds and smaller are truncated)
  println(duration.truncate(MINUTES))      // 1h 30m         (seconds and smaller are truncated)
  println(duration.truncate(HOURS))        // 1h             (minutes and smaller are truncated)
  println(duration.truncate(DAYS))         // 0s             (all units are zeroed)
}

1h 30m 45.002003005s
1h 30m 45.002003005s
1h 30m 45.002003s
1h 30m 45.002s
1h 30m 45s
1h 30m
1h
0s

Run in Kotlin Playground

StringUtils.abbreviate from Apache Commons Lang library could be your friend:

StringUtils.abbreviate("abcdefg", 6) = "abc..."
StringUtils.abbreviate("abcdefg", 7) = "abcdefg"
StringUtils.abbreviate("abcdefg", 8) = "abcdefg"
StringUtils.abbreviate("abcdefg", 4) = "a..."

Commons Lang3 even allow to set a custom String as replacement marker. With this you can for example set a single character ellipsis.

StringUtils.abbreviate("abcdefg", "\u2026", 6) = "abcde…"

use this roundToInt() in kotlin

import kotlin.math.roundToInt
fun main() {
    var r = 3.1416
    var c:Int =  r.roundToInt() 
    println(c)
}

list.subList(100, list.size()).clear();

or:

list.subList(0, 100);

Java's trim documentation says

Otherwise, if there is no character with a code greater than '\u0020' in the string, then a String object representing an empty string is returned.

Otherwise, let k be the index of the first character in the string whose code is greater than '\u0020', and let m be the index of the last character in the string whose code is greater than '\u0020'. A String object is returned, representing the substring of this string that begins with the character at index k and ends with the character at index m-that is, the result of this.substring(k, m + 1).

So the condition is exactly { it <= ' ' } (where it is a character in the string).

Kotlin instead uses

public fun CharSequence.trim(): CharSequence = trim(Char::isWhitespace)

which is true e.g. for non-breaking space \u00A0, Ogham space mark \u1680, etc. and false for some characters below ' ' (e.g. \u0001).