Föreläsning 5: Javas standardbibliotek

the past sure is tense (captain beefheart)

måndag börjar på lördag!

1. Standard in och Standard out
   • 1.1 Att skriva till Standard out
   • 1.2 Att läsa information från standard in
2. Filer
   • 2.1 Att läsa filer
   • 2.2 Att skriva filer
3. Serialisering av objekt
4. Reguljära uttryck
   • 4.1 Matcher
   • 4.2 Pattern

1. Standard in och Standard out

Med Standard out och Standard in menas vanligen:

• Skärm
• Tangentbord

java.lang.System innehåller statiska fält och metoder vilket innebär:

• Vi behöver ej skapa objekt.
• InputStream in är standard input.
• PrintStream out är standard out
• PrintStream err är standard error

1.1 Att skriva till Standard out

Har vi redan gjort! Kom ihåg:

• System.out.println och System.out.print

I java.io.printStream finns metoder för att skriva ut typer med eller utan radbrytningstecken. Jämför

• print. Skriver ut det vi ber metoden utan att avsluta raden med ett radbrytningstecken.
• println. Skriver ut det vi ber metoden med ett avslutande radbrytningstecken.

1.2 Att läsa från Standard in

Ett exempel, till att börja med:

import java.io.*;

public class lasin {
    public static void main(String[] args) {    
        String rad;
        
        // Skapar en ny 'läsare' med en indataströmsläsare som argument...
        // (implicit deklaration av ett objekt...
        BufferedReader lasare = new BufferedReader(
                                                   new InputStreamReader(System.in)
                                                   );
        // en prompt...
        System.out.print("$ ");
        try {

            while( (rad = lasare.readLine()) != null) {
                System.out.println("Du skrev: " + rad);
                System.out.print("$ ");
            }
        }
        catch(IOException e ) {
            System.out.println("Hoppsan, det blev fel (" +
                               e.toString() + ")");
        }
   }
}

Läs i manualen om BufferedReader! Läs mer i Skansholms bok och Thinking in Java.

2. Filer

2.1 Att läsa filer

Följer det vanliga schemat:

1. Försök att öppna filen för läsning
2. Läs till dess att filen är slut
3. Stäng filen

Tänk på att ni måste ta hand om eventuella undantag som uppstår (try/catch/finally).

Exempel:

import java.io.*;

public class fillasare {
    public static void main(String[] args) {
	if( args.length != 1 ) {
	    System.out.println("Ange en fil som argument!");
	    System.exit(1);
	}

	String filnamn = args[0];

	System.out.println("Filnamn -->" + filnamn);

	try {
	    // Skapa en ny filläsare
	    FileReader fr = new FileReader(new File(filnamn));

	    int a = fr.read();
	    char b;
	    while(a != -1) {
		b = (char)a;
		System.out.print(b);
		a = fr.read();
	    }

	    // Stäng filen
	    fr.close();	
	}
	catch(FileNotFoundException e) {
	    System.out.println("Hittade inte filen (" + e.toString() + ")");
	}
	catch(IOException e) {
	    System.out.println("Hoppsan! (" + e.toString() + ")");
	}

	System.out.println();
    }
}

Ett mer raffinerat sätt att läsa filer på:

import java.io.*;

public class fillasare2 {
    public static void main(String[] args) {
	if(args.length != 1) {
	    System.out.println("Du måste ange ett argument (en fil)");
	    System.exit(1);
	}
	
	String filnamn = args[0];
	String rad;
	int i = 0;

	System.out.println("Filnamn -->" + filnamn);

	try {
	    BufferedReader br = new BufferedReader(new FileReader(filnamn));
	    
	    i = 1;
	    rad = br.readLine();
	    while(rad != null) {
		System.out.println("[" + i + "]" + rad);
		rad = br.readLine();
		i++;
	    }

	    br.close();
	}
	catch(FileNotFoundException e) {
	    System.out.println("Hittade inte filen (" + e.toString() + ")");
	}
	catch(IOException e) {
	    System.out.println("Hoppsan! (" + e.toString() + ")");
	}
    }
}

2.2 Att skriva till filer

Följer också det vanliga schemat:

1. Försök att öppna filen för skrivning till den.
2. Skriv det ni vill till den!
3. Stäng filen.

Även här måste vi tänka på att fånga eventuella undantag som kastas!

Ett exempel:

import java.io.*;

public class filskrivare {
    public static void main(String[] args) {
	if(args.length != 1) {
	    System.out.println("Ange ett argument");
	    System.exit(1);
	}
	String filnamn = args[0];

	String rad;
	String resultat = "";
	System.out.println("** Skriv så länge du orkar **");
	System.out.println("** Avsluta med 'stop'      **");

	try {
	    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	    
	    System.out.print("$ ");
	    rad = br.readLine();
	    while(!rad.equals("stop")) {
		resultat += rad;
		resultat += '\n';
		System.out.print("$ ");
		rad = br.readLine();
	    }
	    
	    FileWriter fw = new FileWriter(new File(filnamn));

	    fw.write(resultat);

	    fw.close();	    
	}
	catch(IOException e) {
	    System.out.println("Hoppsan (" + e.toString() + ")");
	}
    }
}

Ett till exempel på att skriva filer

import java.io.*;

public class filskrivare2 {
    public static void main(String[] args) {
	if(args.length != 1) {
	    System.out.println("Ange ett argument");
	    System.exit(1);
	}
	String filnamn = args[0];

	String rad;
	String resultat = "";
	System.out.println("** Skriv sŽå lŽänge du orkar **");
	System.out.println("** Avsluta med 'stop'      **");

	try {
	    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	    
	    System.out.print("$ ");
	    rad = br.readLine();
	    while(!rad.equals("stop")) {
		resultat += rad;
		resultat += '\n';
		System.out.print("$ ");
		rad = br.readLine();
	    }

	    BufferedWriter bf = new BufferedWriter(new FileWriter(filnamn));
	    
	    bf.write(resultat,0,resultat.length()-1);
	    bf.close();
	}
	catch(IOException e) {
	    System.out.println("Hoppsan (" + e.toString() + ")");
	}
    }
}

3. Serialisering av objekt

• Alla objekt kan serialiseras
  • Data i ett objekt skrivs till en utdataström.
  • Sammansatta objekt serialiseras rekursivt
  • Fält som deklarerats som transient kommer ej att bli serialiserade!
• Ett enkelt sätt att spara och återhämta information!
  • Data skrivs i ett dokumenterat binärt format
  • Klasser som skall kunna serialiseras måste implementera gränssnittet java.io.Serializable
    • Inga metoder att fylla i för er! Serialisering sköts automagiskt!
    • De flesta klasser i standardbiblioteket implementerar gränssnittet!
• Anppassad serialisering är också möjlig
  • Implementera gränssnittet java.io.Externalizable
  • Metoderna writeExternal och readExternal måste implementeras.

Exempel: Klassen A:

import java.io.*;

public class A implements Serializable {
    private int a;
    private int b;

    public A() {
	a = b = 0;
    }
    
    public A(int a, int b) {
	this.a = a;
	this.b = b;
    }

    public int returnSum() {
	return a + b;
    }

    public int returnProduct() {
	return a * b;
    }

    public String toString() {
	String tmp = "a:" + a;
	tmp += " b:";
	tmp += b;

	return tmp;
    }
}

Klassen Asaver:

import java.io.*;

public class Asaver {
    public static void main(String[] args) {
	A aTest = new A(1,2);
	A bTest = new A(434343,3);
	A cTest = new A(4343,4);
	A dTest = new A(43,5);
	A eTest = new A(43,6);
	A fTest = new A(54,7);

	System.out.println("aTest -->" + aTest.toString());
	System.out.println("bTest -->" + bTest.toString());
	System.out.println("cTest -->" + cTest.toString());
	System.out.println("dTest -->" + dTest.toString());
	System.out.println("eTest -->" + eTest.toString());
	System.out.println("fTest -->" + fTest.toString());

	try {
	    ObjectOutputStream oos;
	    oos = new ObjectOutputStream(new FileOutputStream("minaan.ser"));
	    
	    oos.writeObject(aTest);
	    oos.writeObject(bTest);
	    oos.writeObject(cTest);
	    oos.writeObject(dTest);
	    oos.writeObject(eTest);
	    oos.writeObject(fTest);
	    
	    oos.close();
	}
	catch(IOException e) {
	    System.out.println("Hoppsan! (" + e.toString() + ")");
	}
    }
}

Klassen Areader:

import java.io.*;

public class Areader {
    public static void main(String[] args) {
	A aTest;

	try {
	    ObjectInputStream ois;
	    ois = new ObjectInputStream(new FileInputStream("minaan.ser"));	    
	    	    
	    aTest = (A)ois.readObject();
	    while(aTest != null) {			
		System.out.println("aTest: " + aTest.toString());
		aTest = (A)ois.readObject();
	    }

	    ois.close();
	}
	catch(IOException e) {
	    System.out.println("Hoppsan (" + e.toString() + ")");
	}
	catch(ClassNotFoundException e) {
	    System.out.println("Hoppsan (" + e.toString() + ")");
	}	
    }
}

Utdata (Asaver):

[tomas@bones f5]$ java Asaver 
aTest -->a:1 b:2
bTest -->a:434343 b:3
cTest -->a:4343 b:4
dTest -->a:43 b:5
eTest -->a:43 b:6
fTest -->a:54 b:7

Utdata (Areader)

[tomas@bones f5]$ java Areader 
aTest: a:1 b:2
aTest: a:434343 b:3
aTest: a:4343 b:4
aTest: a:43 b:5
aTest: a:43 b:6
aTest: a:54 b:7
Tog emot: java.io.EOFException

4. Reguljära uttryck

Ger oss möjlighet att använda reguljära uttryck för att tolka data (t.ex). Klasserna finns här: java.util.regex. Vi måste alltså importera paketet för att kunna använda klasserna i det... Se Java-dokumentationen för mer information om vilka uttryck du kan använda.

4.1 Pattern

Ger oss möjlighet att skapa ett reguljärt uttryck för vilket vi sedan kan testa strängar på.

Exempel:

import java.util.regex.*;

public class pattern1 {
    public static void main(String[] args) {

	if(Pattern.matches("[0-9]*","12343")) {
	    System.out.println("[1] sant");
	}
	else {
	    System.out.println("[1] falskt");
	}

	String s1 = "java";

	if( s1.matches("j[ava]*") ) {
	   System.out.println("[2] sant");
	}
	else {
	    System.out.println("[2] falskt");
	}

	String s2 = "12343";

	Pattern heltal = Pattern.compile("[0-9]+");
	Matcher m2 = heltal.matcher(s2);

	if(m2.matches()) {
	    System.out.println("[3] sant");
	}
	else {
	    System.out.println("[3] falskt");
	}
	
	String kolonstrang = "t:o:m:a:s";

	Pattern kolon = Pattern.compile(":");
	String[] fields = kolon.split(kolonstrang);

	for(int i=0;i<fields.length;i++) {
	    System.out.println("fields[" + i + "] -->" + fields[i]);
	}

	Pattern nonDigits = Pattern.compile("\\D");
	Pattern integer = Pattern.compile("^[+-]?\\d+$");
	Pattern decimal = Pattern.compile("^[+-]?(?:\\d+(?:\\.\\d*)+|\\.\\d+)$");
	
	Matcher m;

	for (int i = 0; i < args.length; i++) {
	    String s = args[i];
	 
	    if ((m = integer.matcher(s)).matches()) {
	     System.out.println(s + " ... är ett heltal.");
	    }
	    if ((m = decimal.matcher(s)).matches()) {
		System.out.println(s + " ... är ett decimaltal.");
	    }
	    if ((m = nonDigits.matcher(s)).find()) {
		System.out.println("find: " + s + " innehåller andra tecken än [0-9]");
	    }
	    if ((m = nonDigits.matcher(s)).lookingAt()) {
		System.out.println("lookingAt: " + s + " är en sträng som börjar med någonting annat än non-digit");
	    }
	    if ((m = nonDigits.matcher(s)).matches()) {
		System.out.println("matches: " + s + " är en sträng med endast ett tecken som inte är en siffra ");
	    }
	}

    }
}

Anrop:

java pattern1 5 9.6 B Ab 12345a.

Resultat:

5 ... är ett heltal.
9.6 ... är ett decimaltal.
find: 9.6 innehåller andra tecken än [0-9]
find: B innehåller andra tecken än [0-9]
lookingAt: B är en sträng som börjar med någonting annat än non-digit
matches: B är en sträng med endast ett tecken som inte är en siffra 
find: Ab innehåller andra tecken än [0-9]
lookingAt: Ab är en sträng som börjar med någonting annat än non-digit
find: 12345a. innehåller andra tecken än [0-9]

4.2 Matcher

Definieras som en motor som utför matchningsoperationer genom att tolka ett mönster (Pattern). Kan utföra tre slags matchningsoperationer:

• Metoden matches försöker att matcha hela indatasträngen gentemot det aktuella mönstret.
• Metoden lookingAt försöker att matcha indatasträngen gentemot mönstret genom att börja från början av strängen. Hela strängen behöver ej matchas!
• Metoden find söker igenom indatasträngen och letar efter nästa delsträng som matchar mönstret.