Datatyper

int heltall;

heltall = 1337; // Lovlig verdi for integer-variabelen
heltall = 10.3; // Ulovlig
heltall = 5/2;  // Lovlig (heltallsdivisjon)
heltall = 5.0/2; // Ulovlig 

heltall = 2;
heltall < 3.2; // true
 

double desimaltall;

desimaltall = 13.37; // Lovlig verdi for double-variabelen
desimaltall =  10;  // Lovlig, tolkes som 10.0
 
double annetDesimaltall = desimaltall/2.3; // Lovlig
 
desimaltall == 10; // true, siden de er samme faktiske verdi
desimaltall != 3; // true

char tegn;

tegn = 'A'; // I java defineres en char med enkle apostrofer.
Character.isLetter(tegn); // returnerer true siden 'A' er en bokstav
Character.isDigit(tegn); // returnerer false siden 'A' ikke er et siffer
tegn = Character.toLowerCase(tegn); // tegn settes lik 'a' ved hjelp av en forhåndsdefinert metode som finnes i java
 
 
tegn = '#'; // Lovlig char-verdi
tegn = 't5'; // Ulovlig char-verdi, kan ikke bestå av flere tegn. Se String i stedet
tegn = '\''; // Setter tegn lik '. Backslash sørger for at neste tegn blir tolket som et vanlig symbol istedet for en del av syntaxen.
 
tegn = '2'; // Lovlig char-verdi
tegn == 2; // false, da int og char ikke er like, selv om verdien ser lik ut.


//Konvertering mellom char og int krever litt triksing:


// 1) Hvis man forsøke caste en char til int, vil dette gi svært rare resultater:

int heltall = (int) tegn;  // heltall settes lik 50?? 

// Dette skyldes, som nevnt ovenfor, at alle char-verdier ligger på en tall-linje. Vi vet nå at '2' er representert på plass 50 langs denne tall-linjen.

// 2) I java må vi konvertere char-verdien til en String, og deretter "parse" String-verdien til et integer. Det kan gjøres slik
 
String s = Character.toString(tegn); // Bruker en ny forhåndsdefinert metode i java
int heltall = Integer.parseInt(s); // heltall settes nå lik integer-verdien 2.
 
//Sammenligne chars
char tegn1 = 'a';
char tegn2 = 'e';
int svar1;
int svar2;

svar1 = Character.compare(tegn1, tegn2);//Nyttig hvis man vil vite hvilken bokstav som er først i alfabetet for eksempel. Neste linje viser hvordan det funker.
svar2 = tegn1-tegn2;//Trekker desimal verdien til tegn2 fra tegn1. Viktig at char'ene har samme "case", Upper eller Lower
System.out.println(svar1)//printer ut -4
svar1 == svar2 //Dette vil alltid være true

// Det er verdt å merke seg at 1) og 2) nedenfor er ekvivalente. Dette sier noe om hvordan en String er bygd opp

// 1)  
String str = "abc";
 
// 2) 
char data[] = {'a', 'b', 'c'};
String str = new String(data);


// Andre egenskaper ved String

String tekst;
String tekst2; 
 
tekst = "hEi"; // I java defineres en String-verdi med doble apostrofer
tekst2 = "HeI";
tekst == tekst2; // false, det skilles mellom store og små bokstaver.

 
 
//forandre på en String
 
tekst = String.toLowerCase(tekst); // Hele tekst gjøres liten
 
gammelTekst = "Hello World";
nyTekst = gammelTekst.replace('l','r'); //nyTekst har nå verdien "Herro Worrd"
 
String kontonr = "1234.78.4567";
kontonr.split("."); //Vil dele opp teksten på stringen "." og returnere et String-Array: {"1234","78","4567"}
 
 
//hente ut deler av en tekst
String navn = "Ola Normann";
 
int telling = navn.length(); // Teller tegn i strengen. Merk at whitespace er også et tegn

// Om vi vil hente fornavnet til Ola kan det gjøres ved å tenke på navn som en tabell.
String fornavn = navn.substring(0,3); // Henter de tre første elementene i "tabellen"
char initial = fornavn.charAt(0); // Setter initial lik 'O'
 
navn.indexOf("a"); returnerer 2, altså første gang strengen "a" forekommer i teksten
navn.indexOf("d"); returnerer -1, altså vet vi at det ikke finnes en "d" i Normann. OBS. metoden er case-sensitiv
 
 
//Konverting fra primitive datatyper til String-objekter. Her bruker vi den statiske metoden valueOf()
int tall = 1;
String.valueOf(tall)// gir "1"
boolean bool = true;
String.valueOf(bool)// gir "true"
char tegn = 'a'
String.valueOf(tegn)// gir "a"
//Dette gjøres i mange tilfeller automatisk
String tallSomTekst = "" + 1; //tallSomTekst har nå verdien "1"
String tallSomTekst2 = 1 + 4 + ""//tallSomTekst har nå verdien "5" 
String tallSomTekst3 = "" + 1 + 4;//dette vil faktisk gi verdien "14"
 
 
//Sammenligne tekster
 
String tekst1 = new String("abc")
String tekst2 = new String ("abc")
tekst1 == tekst2 //gir false, dette er fordi på objekter så sammenlignes pekeren ved bruk av == og ikke verdien.
tekst1.equals(tekst2) // gir true
//OBS!
tekst1 = "abc";
tekst2 = "abc";
tekst1 == tekst2 //dette vil gi true pga. hvordan compileren behandler denne typen instantiering og bruker derfor samme peker. Sammeligne tekster slik fører ofte til bugs og frarådes
 
 

boolean isBroken;

isBroken = false;
// Knuser noe
isBroken = true;

// Kan brukes i kontrollstrukturer

if (isBroken) { 
	...Reparer...
	...Reparert...
	isBroken = false;	 
} 

// Når vi gjør sammenligninger returneres en boolsk-verdi vi kan ta vare på i en variabel

int heltall = 5;
boolean isLess = heltall < 10; // Setter isLess lik true

// Vi kan også bruke logiske operatorer på boolske data

boolean b = isBroken && isLess; // b settes lik false, siden isBroken er false

double[] desimalTabell; // Klammene definerer at dette er et array som skal holde på double-verdier

// Vi må bestemme hvor stor tabellen skal være før vi kan sette elementer i den

desimalTabell = new double[10]; // Denne linjen allokerer minne til 10 desimaltall fra plass 0 til 9

desimalTabell[0] = 100.23; // Setter 100.23 inn på index-plass 0 i tabellen

// Vi kan sette inn verdier hvor vi vil, og forandre de når vi vil

desimalTabell[8] = 96.3; 
desimalTabell[10] = 77.77; // Ikke gyldig operasjon, da vi bare har allokert minne til 10 desimaltall på plassene 0 til 9
desimalTabell[4] = 0.45; 
desimalTabell[8] = desimaltabell[8] - 6.1; // Setter index-plass 8 i tabellen lik 90.2


// Vi kan også ha arrays i arrays
 
int[][] multi;
		
multi = new int[3][5]; // Setter den "ytterste" tabellen til å holde 3 tabeller som kan holde 5 integers hver

multi[0][0] = 5;
multi[2][3] = 678;
..
.. 
// Antar at en fult initialisert tabell ser slik ut
// [5,3,4,67,19],[95,57,345,0,2],[78,34,678,23,21] 
 
// Vi kan nå traversere hele tabellen på denne måten
 
for (int i = 0; i < multi.length; i++) {
	for (int j = 0; j < multi[i].length; j++) {
		System.out.println(multi[i][j]);
	}
}
 
// Som vil skrive ut tallene i den rekkefølgen de kan leses ovenfor