Initial Commit

Learning basics of kotlin, these include functions and their uses varaible manipulation array, list, map uses and manipulation basic loops basic if/when(switch) statements

Author: Danlough96

Kotlin Projects/HelloKotlin/HelloKotlin.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+ <component name="NewModuleRootManager" inherit-compiler-output="true">
+ <exclude-output />
+ <content url="file://$MODULE_DIR$">
+ <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+ </content>
+ <orderEntry type="inheritedJdk" />
+ <orderEntry type="sourceFolder" forTests="false" />
+ <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+ </component>
+</module>

Kotlin Projects/HelloKotlin/out/production/HelloKotlin/CollectionsIterationsKt$main$4.class

@@ -0,0 +1,63 @@
+fun sayHello(greeting:String, itemToGreet:List<String>){
+ //this works just like the other for loops
+ itemToGreet.forEach { itemToGreet ->
+ //itemToGreet is defined in the main function
+ println("$greeting $itemToGreet")
+ }
+}
+//start going down here before top function
+fun main(){
+ //as soon as string is added via "" array can defer that the values are strings
+ val interestingThings = arrayOf("kotlin", "programming", "chicken nuggets")
+ //this prints size of array
+ println(interestingThings.size)
+ //calls num 2 in array
+ println(interestingThings[2])
+ //works same as above 1
+ println(interestingThings.get(0))
+ //for loop to print our array
+ for (interestingThings in interestingThings){
+ println(interestingThings)
+ }
+ //This works much like a for loop, however it is a pre made function in the base library
+ //interestingThings.forEach {it: String
+ //println(it)
+ //}
+
+ //you can also rename the it value to make it less confusing e.g.
+ interestingThings.forEach {interestingThing -> //this will rename the 'it' to a string of your choice
+ println(interestingThing)
+ }
+ //However what if we want to find out what index our strings are in? well we use the for each index to do this e.g. below:
+ interestingThings.forEachIndexed { index, interestingThingIndexed ->
+ println("$interestingThingIndexed is at index $index")
+ }
+ //all that can be used in arrays can be used in lists as well
+ val interestingThingsList = mutableListOf("example 1", "example 2", "example 3") //was originally listOf changed to mutableListOf
+ interestingThingsList.get(2)
+ interestingThingsList[0]
+ interestingThingsList.forEach { interestingList ->
+ println(interestingList)
+ }
+
+ //We can also use a type called a map. a map works by taking pair values e.g. below:
+ //This means that you can pair two varaibels together e.g. 1 can = a meaning that the value 1 has a string value of a
+ val map = mapOf(1 to "a", 2 to "b", 3 to "c")
+ //when it comes to finding in the index the number is the space in the index and the string is what will be shown
+ //e.g. if i called index 0, it would be null because i havent assigned a pair value to it
+ //but if i call index 1 it will display an 'a'
+ println(map[1])
+
+ map.forEach { key, value -> println("$key -> $value") }
+
+ //Now lets look at how to add to the index
+ //first to do this it has to be a mutable of e.g.lists: mutableListOf this shows that it can mutate, or change
+ interestingThingsList.add("example 4")
+ //same works for map however instead of add its put
+ //this is a list i made to use this
+ val otherFunctionList = listOf("Chicken", "Dog", "Cat")
+ //Now lets use it with a function the function that this will work with has already been pre called above
+ sayHello("Hello", otherFunctionList)
+ //This can be used with an array but will have to be defined in function parameters
+
+}

Kotlin Projects/HelloKotlin/out/production/HelloKotlin/CollectionsIterationsKt.class

@@ -0,0 +1,28 @@
+//This is an example of a function, you can assign the return type just like you assign a var
+//You can also set parameters inside ()
+fun getGreeting(): String {
+ return "Hello Kotlin!"
+}
+//How do you change from a function? you use function parameters e.g. below
+fun sayHello(itemToGreet:String) {
+ //as you can see itemToGreet was set as a string above, this means that msg when printed will print the value plus pre defined text. This can be altered n this function or
+ //the main funciton
+ //val msg = "Hello" + itemToGreet This is one way to do it but kotlin allows you to input parameter values into a string e.g.
+ val msg = "Hello $itemToGreet"//this is for convenience and a way of shortening code
+ println(msg)
+
+}
+
+//Multiple parameters in function Below:
+fun multiHello(first:String, second:String) = println("$first $second")
+
+fun main(){
+ println("Hello World!")
+ //You can call a function just like you would in java, here we are printing what it returns
+ println(getGreeting())
+ //Here it has been edited
+ sayHello(itemToGreet = "Myself")
+
+ //setting multi param here. You will have to set both if they are not already set
+ multiHello(first = "Hello", second = "Universe")
+}

Kotlin Projects/HelloKotlin/out/production/HelloKotlin/FunctionsKt.class

@@ -0,0 +1,57 @@
+val toplvl: String = "Example of top level"
+//You could also place variables outside of the main function. these are called top level. Top lvl var's can also be altered inside of the main. they work just like they do
+//inside the main
+
+var nullstring: String? = "mike"
+//above is an example of a null string. in kotlin variables are all set to non null unless you make it so YOU CAN STILL ASIGN VALUES TO NULL STRINGS!
+
+//kotlin can figure out what type of varaible your using so technically you dont have to use it e.g. is below
+val num1 = 2
+//as you can see it doesnt have the type of var but it still works if run
+fun main(){
+ //Var works to define variables that can be change
+
+ //val variables cannot be changed
+ val name: String = "Daniel"
+
+ //now the name variable cannot be re defined
+ var varname: String = "Mike"
+ varname = "Shaun"
+ println(name)
+
+ println(varname)
+ //Once Run you can see that the Mike value has changed to shaun. InteliJ helps you see this by greying out the Mike string
+ println(toplvl)
+ println(nullstring)
+ nullstring = null
+ println(nullstring)
+ println(num1)
+ //now lets look at control flow
+ var controltest: String? = null
+ if(controltest != null){
+ println(controltest)
+ } else{
+ println("Test for control")
+ }
+ //this is an example of if/else statements to control when variables are called.
+ //When statements
+ //When statements work just like switch statements from java example below
+ var whentest: String? = null
+ when(whentest){
+ null -> println("Hi")
+ else -> println(whentest)
+ }
+ //when whentest is null it will print hi. otherwise it will print whatever string is assigned
+
+ //If and when can be used as expression to assign a value depending on conditions e.g. below
+ var assignTest: String? = null
+ // assignTest = "It Works" Remove this test and '//' to prove it works
+ val assignTestToPrint = if (assignTest != null) assignTest else "Value Is NULL"
+ println(assignTestToPrint)
+ //this is another way we can assign different values depending on parameters the same works for when and is layed out the same
+
+ 
+
+
+
+}