En datatype er en klassifisering som kan identifisere data, i den forstand at datatypen bestemmer hvilke verdier dataene kan ha, hvilke operasjoner som kan gjøres med verdier av denne datatypen og tildels meningen med dataene. Det er viktig å merke seg at egendefinerte klasser også er datatyper, og at variabler kan referere til disse egendefinerte datatypene. Mer om klasser her.

Vi kan ofte dele datatypene inn i noen overordnede grupper:

Talldata:

Tall representeres ofte som integer eller double.

Integer

Dersom data er av typen integer, begrenser dette verdiene dataene kan ha til heltall.
Int-tallene ligger etter hverandre, som på en tallinje i begge retninger.
Av praktisk grunner er heltallene avgrenset til en minimum-/maksimum-verdi, som i java ser slik ut: MIN_VALUE ...-2,-1,0,1,2 ... Integer.MAX_VALUE

Hva kan vi gjøre med integer?

- Beregne nye tall: 1 + 2 – 3 * 4 / 5 % 6
- Sammenligne med andre tall: ==, !=, <, <=, >=, > 
- Operere på dem som binære tall med: &, | og ~ 
 

Integer i java
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

Dersom data er av typen double, kan dataene ha verdier som desimaltall. Faktisk vil selv heltallsverdier "omgjøres" til desimaltall.  
Med double kan man beregne nye tall, og sammenligne de med andre tall.

Double i java
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


Strengdata:

Når vi skal lagre tekst eller tegn brukes datatypene String eller char.


Char

Dersom vi har data bestående av en bokstav, et siffer eller et tegn kan dataene være av typen char
Teknisk sett ligger alle char-verdier etter hverandre på en tall linje, slik som integers. Alle char kan derav representeres som en tallverdi. Her er en oversikt over hvilken verdi hver char representerer.

Klassen Character bruker den primitive datatypen char og danner et objekt rundt. Klassen har mange metoder som er svært nyttig når vi skal behandle en char.

Hva kan man/er meningsfylt å gjøre med en char

- klassifisere data som som bokstav, stor/liten bokstav, siffer
- Gjøre om til stor/liten bokstav
- Konvertering mellom siffer og tall, f.eks. fra ‘1’ til 1
- Sammenligne med andre char-data

Char i java
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


String


Dersom vi har data bestående av tekst/flere tegn,siffer,bokstaver vil dataene være av typen String
En String kan sees på som en tabell med char-verdier. Dersom vi vil forandre på teksten tabellen lager, modifiserer vi enten hele tabellen, eller enkelte char-verdier i tabellen

Hva kan man/er meningsfylt å gjøre med en String
- Forandre hele, eller deler av teksten (store/små bokstaver)
- Hente deler av teksten
- Konvertere primitive datatyper til tekstform
- Sammenligne teksten med andre tekster

 

String i java
// 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
 
 


Logiske data
:

Logiske data kan bare ta en av to mulige verdier, true eller false. Logiske data er også kjent som boolsk data.
I mange språk kan true/false også representeres som  1/0 (evt null), eller streng-med-tegn/streng-uten-tegn. 

Boolean

Dersom vi har data som uttrykker en enten-eller-verdi er det hensiktsmessig å representere dataene som en boolean.
En boolean kan bare ta to verdier, true eller false, og boolske data brukes gjerne i kontrollstrukturer. 


Boolean i java
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


Tabelldata

Dersom vi har mange data som ønsker å strukturere og knytte sammen, vil det være naturlig å putte de i en tabell, eller datatypen array.

Array

Et array er datatype som kan holde på flere verdier av andre datatyper. Et array er som nevnt en tabell hvor vi kan legge inn nye data, forandre data, slette data eller lese av data som ligger der. 

   0     1      2     3

13371991


Et array er null-indeksert, som vil si at dersom vi vil lese av, slette, osv. data som finnes på den første plassen, refererer vi til plass 0. Det er viktig å skille mellom verdiene som finnes i tabellen, og indeksen.
Dersom vi spør "arrayet" ovenfor om hva som er elementet på plass 2, vil svaret være 19. 

I noen språk kan arrays innholde mange forskjellige datatyper slik som i python hvor dette er et gyldig array:

'?'54"Hei"12.21

Mens andre språk krever at alle elementene er samme datatype. Java er et slikt språk.

Array i java
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
 
 

 

 

  • No labels