├── .gitignore ├── gradle.properties ├── settings.gradle.kts ├── README.md ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── src └── main │ └── kotlin │ ├── functions │ └── Functions.kt │ ├── conditional │ └── Conditional.kt │ ├── loops │ └── Loops.kt │ ├── nullability │ └── Nullability.kt │ ├── generics │ └── Generics.kt │ └── stdlib │ └── Variables.kt ├── gradlew.bat └── gradlew /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/* 2 | .gradle/* 3 | build/* -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | kotlin.code.style=official 2 | -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name = "ds-algo" 2 | 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### Kotlin Data Structure and Algorithms 2 | 3 | This is my public playground for practicing Data Structures and Algorithms using Kotlin -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jumaallan/kotlin-data-structures-algorithms/HEAD/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /src/main/kotlin/functions/Functions.kt: -------------------------------------------------------------------------------- 1 | package functions 2 | 3 | fun main() { 4 | 5 | /** 6 | * Functions are the smallest units of code that can be abstracted and re-used 7 | * 8 | * Are defined using the "fun" keyword, followed by the name of the function 9 | * 10 | * Can have a list of parameters, which include their data types. Can have no parameter. 11 | * 12 | * A func can have a return type, which is defined by a data type. A func cannot have more than one return type, but can miss a return type. 13 | */ 14 | 15 | fun max(a: Int, b: Int): Int { // compares 2 numbers and returns the higher one 16 | return if (a > b) a else b 17 | } 18 | 19 | fun printMax(c: Int, d: Int) { // has no return type 20 | println(max(c, d)) 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/kotlin/conditional/Conditional.kt: -------------------------------------------------------------------------------- 1 | @file:Suppress("LiftReturnOrAssignment", "MoveVariableDeclarationIntoWhen") 2 | 3 | package conditional 4 | 5 | fun main() { 6 | 7 | /** 8 | * Kotlin programs execute linearly, one line at a time. Sometimes, making decisions or repeating a step can come in handy. 9 | * 10 | * For decision-making, Kotlin has two constructs 11 | * * if-else 12 | * * when 13 | */ 14 | 15 | val a = 5 16 | val b = 12 17 | val max: Int 18 | 19 | if (a > b) { // Makes decision based on the condition inside the brackets () 20 | max = a // if a > b is true, this block is executed 21 | } else { 22 | max = b // else this is executed 23 | } 24 | 25 | println(max) // Prints 12 26 | 27 | /** 28 | * The else part in an if-else is optional. You might want to do something when the condition is true, but not when it's false 29 | * Instead of leaving the else block empty, you can omit it 30 | */ 31 | 32 | val size = 3 33 | when(size) { 34 | 1 -> println(1) 35 | 2 -> println(2) 36 | 3 -> { println(3) } 37 | else -> println("We didn't find what you're looking for") 38 | } 39 | 40 | /** 41 | * The when statement makes decision based on the "size". The else clause handles everything that isn't specified. 42 | * 43 | * The else can be optional if the compiler determines that you have already handled all possible values 44 | */ 45 | } -------------------------------------------------------------------------------- /src/main/kotlin/loops/Loops.kt: -------------------------------------------------------------------------------- 1 | package loops 2 | 3 | fun main() { 4 | 5 | /** 6 | * There are two types of loops in Kotlin, 7 | * * for 8 | * * while 9 | */ 10 | 11 | for (i in 1..100) { // 1..100 creates an int range, from 1 to 100 12 | println(i) 13 | } 14 | 15 | /** 16 | * for can iterate over any collection of data. 17 | * for (item in collection) println(item) 18 | */ 19 | 20 | var x = 10 21 | while (x > 0) { 22 | x-- 23 | println(x) 24 | } 25 | 26 | /** 27 | * The code starts with x having the value 10, and since 10 is greater than 0, it executes the code inside the block. 28 | * It keeps decreasing the value of x, and printing the current value of x, until it gets to 0, and the condition becomes false 29 | * 30 | * There is a variation of while, known as "do-while". The first loop executes and then checks the condition to continue. This ensures 31 | * the code is executed at least once. 32 | */ 33 | 34 | var y = 10 35 | do { 36 | y-- 37 | println(y) 38 | } while (y > 0) 39 | 40 | /** 41 | * With while loops, you can easily create an infinite loop. If you do, your program will get stuck and die in a pitiful StackOverflowException 42 | */ 43 | 44 | var z = 10 45 | while (z > 0) { 46 | z++ 47 | println(z) 48 | } 49 | println("We will never get here ") 50 | 51 | /** 52 | * The value is incremented everytime, and never gets less than 0, so the while loop has no reason to stop. The println() will never be called. 53 | */ 54 | } -------------------------------------------------------------------------------- /src/main/kotlin/nullability/Nullability.kt: -------------------------------------------------------------------------------- 1 | @file:Suppress("CanBeVal") 2 | 3 | package nullability 4 | 5 | // We create a variable to hold a car 6 | data class Car( 7 | val name: String, 8 | var doors: Int = 4 9 | ) 10 | 11 | fun main() { 12 | 13 | /** 14 | * Kotlin has a concept of null. You can assign a null to a variable whenever you want to signal that an object has no value 15 | */ 16 | 17 | var car: Car? = null // the "?" changes the variable type to optional, allowing us to set null as the value 18 | 19 | println("null car ${car?.name}") // prints null 20 | 21 | val benz = Car( // We can then re-assign the value later on 22 | name = "Mercedes Benz" 23 | ) 24 | 25 | println("car name ${benz.name}") 26 | println("car doors ${benz.doors}") // picks the default value that was assigned when creating the data class, unless changed - 4 27 | 28 | /** 29 | * The "?" operator tells the compiler that the object could contain a null value 30 | * 31 | * With the operator, we cannot use: 32 | * car.drive() 33 | * 34 | * Instead, we use the safe-call operator "?." 35 | * car?.drive() 36 | * 37 | * Using the safe-call operator means the function will only execute when the object is not null 38 | * 39 | * To assign values to variables that hold null values, we use "?:", known as the Elvis Operator 40 | * val car: Car = car ?: Car("BMW") 41 | * This code does a few things 42 | * * Creates an immutable variable, car, that cannot be reassigned 43 | * * The value now contains a real car 44 | * * The value can be a "car" or "BMW" if the car is null (not a real car) 45 | * 46 | * In some scenarios, you might not want to play by the rules. For example, you know a variable is not a null - even thought it's optional, 47 | * and you need to tell the compiler to use the value that it holds. 48 | * Kotlin provides the not-null assertion operator ("!!"). If the variable contains a null value, it'll throw an NPE. 49 | * car!!.drive() 50 | */ 51 | 52 | } -------------------------------------------------------------------------------- /src/main/kotlin/generics/Generics.kt: -------------------------------------------------------------------------------- 1 | package generics 2 | 3 | fun main() { 4 | 5 | /** 6 | * Generics are a great way to abstract your code whenever you can manipulate multiple data types in the same way. 7 | * 8 | * Consider a class that emulates a Box. With a box, you can: 9 | * * Put something into it 10 | * * Grab something from it 11 | * * Check if it's empty 12 | * 13 | */ 14 | 15 | 16 | 17 | /** 18 | * Your box can handle any data type you want, and you’ll be sure that whatever you put in it, 19 | * has the same data type when you remove it from the box. 20 | * 21 | * You can also apply generics at a function level, and there can be restrictions applied to the kind of data types 22 | * the generic will accept. In Kotlin, there’s a way to say “I want all functions to return this generic data type” 23 | * or “I want only the input parameters to be this generic type”. 24 | 25 | * There’s a lot to learn about Generics, and you’ll need to research it as you progress with your data structures 26 | * and algorithms. But for now, you’ll start with two of the most common generic data structures that are already 27 | * provided by the Kotlin Standard Library. 28 | */ 29 | 30 | val box = Sanduku() 31 | box.put(4) 32 | 33 | val boolBox = Sanduku() 34 | boolBox.put(true) 35 | boolBox.isEmpty() 36 | 37 | } 38 | 39 | /** 40 | * Once you put something into the box, you lose the knowledge of the object’s type since you had to use the 41 | * Any type to story any kind of object. 42 | */ 43 | class Box { 44 | 45 | var content: Any? = null 46 | 47 | fun put(content: Any?) { 48 | this.content = content 49 | } 50 | 51 | fun retrieve(): Any? { 52 | return content 53 | } 54 | 55 | fun isEmpty(): Boolean { 56 | return content == null 57 | } 58 | } 59 | 60 | 61 | /** 62 | * To get a more specialized box, you could replace Any with the data type you need; for example, a Cat or a Radio. 63 | * But you’d need to create a different type of Box for every type of object you’d want to store, 64 | * i.e. you’d have to create CatBox and RadioBox separately. 65 | * 66 | * Generics are an excellent way to keep the code abstract and let the objects specialize once instantiated. 67 | * To abstract Box, you can write it like this: 68 | */ 69 | 70 | class Sanduku { // Means Box in Swahili, since we can't have two classes with the same name here :) 71 | var content: T? = null 72 | fun put(content: T?) { 73 | this.content = content 74 | } 75 | 76 | fun retrieve(): T? { 77 | return content 78 | } 79 | 80 | fun isEmpty(): Boolean { 81 | return content == null 82 | } 83 | } 84 | 85 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%" == "" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%" == "" set DIRNAME=. 29 | set APP_BASE_NAME=%~n0 30 | set APP_HOME=%DIRNAME% 31 | 32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 34 | 35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 37 | 38 | @rem Find java.exe 39 | if defined JAVA_HOME goto findJavaFromJavaHome 40 | 41 | set JAVA_EXE=java.exe 42 | %JAVA_EXE% -version >NUL 2>&1 43 | if "%ERRORLEVEL%" == "0" goto execute 44 | 45 | echo. 46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 47 | echo. 48 | echo Please set the JAVA_HOME variable in your environment to match the 49 | echo location of your Java installation. 50 | 51 | goto fail 52 | 53 | :findJavaFromJavaHome 54 | set JAVA_HOME=%JAVA_HOME:"=% 55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 56 | 57 | if exist "%JAVA_EXE%" goto execute 58 | 59 | echo. 60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 61 | echo. 62 | echo Please set the JAVA_HOME variable in your environment to match the 63 | echo location of your Java installation. 64 | 65 | goto fail 66 | 67 | :execute 68 | @rem Setup the command line 69 | 70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 71 | 72 | 73 | @rem Execute Gradle 74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 75 | 76 | :end 77 | @rem End local scope for the variables with windows NT shell 78 | if "%ERRORLEVEL%"=="0" goto mainEnd 79 | 80 | :fail 81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 82 | rem the _cmd.exe /c_ return code! 83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 84 | exit /b 1 85 | 86 | :mainEnd 87 | if "%OS%"=="Windows_NT" endlocal 88 | 89 | :omega 90 | -------------------------------------------------------------------------------- /src/main/kotlin/stdlib/Variables.kt: -------------------------------------------------------------------------------- 1 | @file:Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE", "JoinDeclarationAndAssignment", "CanBeVal") 2 | 3 | package stdlib 4 | 5 | fun main() { 6 | 7 | /** 8 | * A variable is a way to store information. A variable has a name, and the data type 9 | * 10 | * Kotlin has two types of variables 11 | * 12 | * ::: var - value can be updated (Mutable) 13 | * ::: val - value cannot be updated (Immutable) 14 | * 15 | * The compiler can determine the data type of variable. This is called "type inference" 16 | * 17 | * If you need to declare a variable, but initialize it later, you need to explicitly define the data type 18 | */ 19 | 20 | // The compiler will use type inference to determine the data type 21 | val name = "Juma Allan" // value cannot be changed 22 | var country = "Kenya" // value can be updated 23 | 24 | println("name $name") 25 | println("country $country") 26 | 27 | // name = "Allan Juma" - would not compile, throws an error 28 | country = "Tanzania" // value is updated from "Kenya" to "Tanzania" 29 | 30 | println("updated country $country") 31 | 32 | // Explicitly defining the data type of variable - allows us to assign a value of type Int later 33 | var age: Int 34 | age = 26 // assign value (can only accept a type Int) 35 | 36 | println("age $age") 37 | 38 | /*** 39 | * Kotlin has several data types, but the basic types are: 40 | * 41 | * Numbers 42 | * Are either 43 | * Integer Types 44 | * * Long (to specify a Long explicitly, append the suffix "L") - 1L 45 | * * Int - 1 46 | * * Short 47 | * * Byte 48 | * Floating-point Types 49 | * * Double (16-16 decimal digits, 64 bits) - 2.7182818284 50 | * * Float (6-7 decimal digits, 32 bits)- 2.7182818284f, actual value is 2.7182817. Floats are tagged by "F" or "f" 51 | * 52 | * Characters 53 | * * Char - 'J' 54 | * * String - "Juma Allan" 55 | * Other 56 | * * Boolean - true 57 | * - Has build in operations 58 | * * || - disjuction (logical OR) - work lazily 59 | * * && - conjuction (logical AND) - work lazily 60 | * * ! - negation (logical NOT) 61 | * * Array 62 | * 63 | * 64 | * You can use underscores to make number constants more readable 65 | * val oneMillion = 1_000_000 66 | * val bytes = 0b11010010_01101001_10010100_10010010 67 | * val creditCardNumber = 1234_5678_9012_3456L 68 | * 69 | * All number types support conversions to other types 70 | * toByte() : Byte 71 | * toShort() : Short 72 | * toInt() : Int 73 | * toLong() : Long 74 | * toFloat() : Float 75 | * toDouble() : Double 76 | * toChar() : Char 77 | * 78 | * 79 | * 80 | */ 81 | 82 | } -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | # 4 | # Copyright 2015 the original author or authors. 5 | # 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 7 | # you may not use this file except in compliance with the License. 8 | # You may obtain a copy of the License at 9 | # 10 | # https://www.apache.org/licenses/LICENSE-2.0 11 | # 12 | # Unless required by applicable law or agreed to in writing, software 13 | # distributed under the License is distributed on an "AS IS" BASIS, 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | # See the License for the specific language governing permissions and 16 | # limitations under the License. 17 | # 18 | 19 | ############################################################################## 20 | ## 21 | ## Gradle start up script for UN*X 22 | ## 23 | ############################################################################## 24 | 25 | # Attempt to set APP_HOME 26 | # Resolve links: $0 may be a link 27 | PRG="$0" 28 | # Need this for relative symlinks. 29 | while [ -h "$PRG" ] ; do 30 | ls=`ls -ld "$PRG"` 31 | link=`expr "$ls" : '.*-> \(.*\)$'` 32 | if expr "$link" : '/.*' > /dev/null; then 33 | PRG="$link" 34 | else 35 | PRG=`dirname "$PRG"`"/$link" 36 | fi 37 | done 38 | SAVED="`pwd`" 39 | cd "`dirname \"$PRG\"`/" >/dev/null 40 | APP_HOME="`pwd -P`" 41 | cd "$SAVED" >/dev/null 42 | 43 | APP_NAME="Gradle" 44 | APP_BASE_NAME=`basename "$0"` 45 | 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' 48 | 49 | # Use the maximum available, or set MAX_FD != -1 to use that value. 50 | MAX_FD="maximum" 51 | 52 | warn () { 53 | echo "$*" 54 | } 55 | 56 | die () { 57 | echo 58 | echo "$*" 59 | echo 60 | exit 1 61 | } 62 | 63 | # OS specific support (must be 'true' or 'false'). 64 | cygwin=false 65 | msys=false 66 | darwin=false 67 | nonstop=false 68 | case "`uname`" in 69 | CYGWIN* ) 70 | cygwin=true 71 | ;; 72 | Darwin* ) 73 | darwin=true 74 | ;; 75 | MSYS* | MINGW* ) 76 | msys=true 77 | ;; 78 | NONSTOP* ) 79 | nonstop=true 80 | ;; 81 | esac 82 | 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 84 | 85 | 86 | # Determine the Java command to use to start the JVM. 87 | if [ -n "$JAVA_HOME" ] ; then 88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 89 | # IBM's JDK on AIX uses strange locations for the executables 90 | JAVACMD="$JAVA_HOME/jre/sh/java" 91 | else 92 | JAVACMD="$JAVA_HOME/bin/java" 93 | fi 94 | if [ ! -x "$JAVACMD" ] ; then 95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 96 | 97 | Please set the JAVA_HOME variable in your environment to match the 98 | location of your Java installation." 99 | fi 100 | else 101 | JAVACMD="java" 102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 103 | 104 | Please set the JAVA_HOME variable in your environment to match the 105 | location of your Java installation." 106 | fi 107 | 108 | # Increase the maximum file descriptors if we can. 109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then 110 | MAX_FD_LIMIT=`ulimit -H -n` 111 | if [ $? -eq 0 ] ; then 112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 113 | MAX_FD="$MAX_FD_LIMIT" 114 | fi 115 | ulimit -n $MAX_FD 116 | if [ $? -ne 0 ] ; then 117 | warn "Could not set maximum file descriptor limit: $MAX_FD" 118 | fi 119 | else 120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 121 | fi 122 | fi 123 | 124 | # For Darwin, add options to specify how the application appears in the dock 125 | if $darwin; then 126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 127 | fi 128 | 129 | # For Cygwin or MSYS, switch paths to Windows format before running java 130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then 131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 133 | 134 | JAVACMD=`cygpath --unix "$JAVACMD"` 135 | 136 | # We build the pattern for arguments to be converted via cygpath 137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 138 | SEP="" 139 | for dir in $ROOTDIRSRAW ; do 140 | ROOTDIRS="$ROOTDIRS$SEP$dir" 141 | SEP="|" 142 | done 143 | OURCYGPATTERN="(^($ROOTDIRS))" 144 | # Add a user-defined pattern to the cygpath arguments 145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 147 | fi 148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 149 | i=0 150 | for arg in "$@" ; do 151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 153 | 154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 156 | else 157 | eval `echo args$i`="\"$arg\"" 158 | fi 159 | i=`expr $i + 1` 160 | done 161 | case $i in 162 | 0) set -- ;; 163 | 1) set -- "$args0" ;; 164 | 2) set -- "$args0" "$args1" ;; 165 | 3) set -- "$args0" "$args1" "$args2" ;; 166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 172 | esac 173 | fi 174 | 175 | # Escape application args 176 | save () { 177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done 178 | echo " " 179 | } 180 | APP_ARGS=`save "$@"` 181 | 182 | # Collect all arguments for the java command, following the shell quoting and substitution rules 183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" 184 | 185 | exec "$JAVACMD" "$@" 186 | --------------------------------------------------------------------------------