Skip to content
Snippets Groups Projects
Commit 6f56025f authored by dagk's avatar dagk
Browse files

Nye filer IO, uke 9

parent 0125b995
No related branches found
No related tags found
No related merge requests found
Showing with 332 additions and 4 deletions
# IO Streams - ikke det samme som Java 8 strems ("lambda-streams")
- Vi skiller mellom **byte-data** og **char-data** (tegn). Et tegn kan bestå av flere bytes.
- Noen IO-klasser opererer med bytes (binære data), andre med chars (tekst-data).
## Ascii-koder, samme som starten på Unicode-koder
| ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation | ASCII Value | Name/Representation |
|-------------|---------------------|-------------|---------------------|-------------|---------------------|-------------|---------------------|-------------|---------------------|-------------|---------------------|-------------|---------------------|-------------|---------------------|
| 0 | NUL (Null char) | 1 | SOH (Start of Heading)| 2 | STX (Start of Text) | 3 | ETX (End of Text) | 4 | EOT (End of Transmission) | 5 | ENQ (Enquiry) | 6 | ACK (Acknowledge) | 7 | BEL (Bell) |
| 8 | BS (Backspace) | 9 | TAB (Horizontal Tab)| 10 | LF (Line Feed) | 11 | VT (Vertical Tab) | 12 | FF (Form Feed) | 13 | CR (Carriage Return)| 14 | SO (Shift Out) | 15 | SI (Shift In) |
| 16 | DLE (Data Link Escape) | 17 | DC1 (Device Control 1) | 18 | DC2 (Device Control 2) | 19 | DC3 (Device Control 3) | 20 | DC4 (Device Control 4) | 21 | NAK (Negative Acknowledge) | 22 | SYN (Synchronous Idle) | 23 | ETB (End of Trans. Block) |
| 24 | CAN (Cancel) | 25 | EM (End of Medium) | 26 | SUB (Substitute) | 27 | ESC (Escape) | 28 | FS (File Separator) | 29 | GS (Group Separator)| 30 | RS (Record Separator)| 31 | US (Unit Separator) |
| ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol | ASCII Value | Symbol |
|-------------|--------|-------------|--------|-------------|--------|-------------|--------|-------------|--------|-------------|--------|-------------|--------|-------------|--------|
| 32 | (Space)| 33 | ! | 34 | " | 35 | # | 36 | $ | 37 | % | 38 | & | 39 | ' |
| 40 | ( | 41 | ) | 42 | * | 43 | + | 44 | , | 45 | - | 46 | . | 47 | / |
| 48 | 0 | 49 | 1 | 50 | 2 | 51 | 3 | 52 | 4 | 53 | 5 | 54 | 6 | 55 | 7 |
| 56 | 8 | 57 | 9 | 58 | : | 59 | ; | 60 | < | 61 | = | 62 | > | 63 | ? |
| 64 | @ | 65 | A | 66 | B | 67 | C | 68 | D | 69 | E | 70 | F | 71 | G |
| 72 | H | 73 | I | 74 | J | 75 | K | 76 | L | 77 | M | 78 | N | 79 | O |
| 80 | P | 81 | Q | 82 | R | 83 | S | 84 | T | 85 | U | 86 | V | 87 | W |
| 88 | X | 89 | Y | 90 | Z | 91 | [ | 92 | \ | 93 | ] | 94 | ^ | 95 | _ |
| 96 | ` | 97 | a | 98 | b | 99 | c | 100 | d | 101 | e | 102 | f | 103 | g |
| 104 | h | 105 | i | 106 | j | 107 | k | 108 | l | 109 | m | 110 | n | 111 | o |
| 112 | p | 113 | q | 114 | r | 115 | s | 116 | t | 117 | u | 118 | v | 119 | w |
| 120 | x | 121 | y | 122 | z | 123 | { | 124 | \| | 125 | } | 126 | ~ | | |
## InputStream
Vi kjenner allerede et eksempel: System.in. InputStream leser bytes, ikke chars.
## InputStreamReader
Denne legger til mekanisme for å tolke byte-strømmen som chars:
[BrukInputStreamReader](iostrems/BrukInputStreamReader.java)
## FileReader
Lager en input-stream av chars fra fil:
[BrukFileReader](iostreams/BrukFileReader.java)
## BufferedReader
For ytelse, så er det ofte å foretrekke IO med *buffere*, dvs. som leser/skriver større pakker data om gangen.
BufferedReader tar inn en Reader, og "dekorerer" den med buffer.
[BrukBufferedReader](iostreams/BrukBufferedReader.java)
## Oversikt over CharacterStream klasser
- BufferedReader
- FileReader
- InputStreamReader
- OutputStreamReader
- Reader
- PrintWriter
- Writer
- BufferedWriter
- FileWriter
## Scanner
package uke9.iostreams;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BrukBufferedReader {
public static void main(String[] args) {
//Her ser dere pathen skrevet på Windows-vis. Backslash må "escapes", dvs. skrives \\
String filePath = "C:\\4100\\tdt4100-students-24\\foreksempel\\src\\main\\java\\uke9\\iostreams\\BrukBufferedReader.java";
try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = br.readLine())!= null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
package uke9.iostreams;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
public class BrukFileReader {
public static void main(String[] args) {
/* FileReader arver fra InputStreamReader som arver fra Reader:
- public class InputStreamReader extends Reader {}
- public class FileReader extends InputStreamReader {}
FileReader-konstruktøren deklarerer en såkalt "checked exception":
Vi får kompileringsfeil hvis vi ikke håndterer den, eller deklarerer
en checked exception.
Vi bruker en try-with-resources, som også automatisk lukker strømmen.
Oppsettet vår er slik at "current working directory" er prosjektmappen,
Her bruker vi relativ sti til filen, fra TDT4100-STUDENTS-24
*/
try (Reader reader = new FileReader("foreksempel/src/main/java/uke9/iostreams/test.txt")) {
// Lese ett og ett tegn:
int c;
while ((c = reader.read()) != -1) {
System.out.println(Character.toString((char) c) + " tallverdi = " + c);
}
}
catch (IOException e) {
e.printStackTrace();
}
// La oss lese filen på nytt, og nå lese en større bolk i en go.
try (Reader reader = new FileReader("foreksempel/src/main/java/uke9/iostreams/test.txt")) {
// Vi kan lese inn flere tegn, som vi legger i en.
char[] buffer = new char[100]; // Leser 100 tegn eller til slutten av filen.
int charCount = reader.read(buffer);
System.out.println("Antall tegn lest: " + charCount);
System.out.print(buffer);
}
catch (IOException e) {
e.printStackTrace();
}
}
}
package uke9.iostreams;
import java.io.IOException;
import java.io.InputStreamReader;
public class BrukInputStreamReader {
public static void main(String[] args) {
// Henter kun en BYTE fra terminal
try {
int c = System.in.read();
System.out.print((char) c);
}
catch (IOException e) {
e.printStackTrace();
}
// Vi pakkser System.in i en InputStreamReader. Denne legger til mekanismer
// for å lese tegn fra byte-strømmen.
try (InputStreamReader isr = new InputStreamReader(System.in)) {
int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
package uke9.iostreams;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
public class BrukPrintStream {
public static void main(String[] args) {
String tekst = "Skriv dette til fil. \nNy linje \u0880";
try (FileOutputStream fos = new FileOutputStream("c:/temp/utfil.txt")) {
PrintStream output = new PrintStream(fos);
output.println(tekst);
// output.close(); // Ikke nødvendig siden den lukker automatisk
} catch (IOException e) {
e.printStackTrace();
}
PrintStream out = System.out;
}
}
package uke9.iostreams;
import java.io.Serializable;
public class Dyr implements Serializable{
private static final long serialVersionUID = 1L;
String type;
String lyd;
int bein;
public Dyr(String type, String lyd, int bein) {
super();
this.type = type;
this.lyd = lyd;
this.bein = bein;
}
@Override
public String toString() {
return type + " sier " + lyd + " og har " + bein + " bein.";
}
}
package uke9.iostreams;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
/*
* En av flere måter en kan lagre til fil - denne utnytter grensesnittet Serializable
* Tilsvarer Python sin pickle
*/
public class Dyrehage implements Serializable{
private static final long serialVersionUID = 1L;
private Collection<Dyr> dyr = new ArrayList<>();
public void leggTil(Dyr dyr) {
this.dyr.add(dyr);
}
@Override
public String toString() {
String tmp = "";
for (Dyr dyr2 : dyr) {
tmp += dyr2 + "\n";
}
return tmp;
}
public void readObjectFromFile(String filepath) {
try (
FileInputStream fileIn = new FileInputStream(filepath);
ObjectInputStream objectIn = new ObjectInputStream(fileIn)) {
Object obj = objectIn.readObject();
System.out.println("The Object has been read from the file");
this.dyr = (Collection<Dyr>) obj;
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void writeObjectToFile(Object serObj) {
try {
FileOutputStream fileOut = new FileOutputStream("C:/temp/dyrehage.binary");
ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);
objectOut.writeObject(serObj);
objectOut.close();
System.out.println("Alle dyrene lagret til fil!");
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
Dyrehage dh = new Dyrehage();
dh.leggTil(new Dyr("Ku", "mø", 4));
dh.leggTil(new Dyr("Katt", "mjau", 4));
dh.leggTil(new Dyr("Flaggermus", "pip", 2));
System.out.println(dh);
dh.writeObjectToFile(dh.dyr);
Dyrehage dhFraFil = new Dyrehage();
dhFraFil.readObjectFromFile("C:/temp/dyrehage.binary");
System.out.println(dhFraFil);
}
}
package uke9.iostreams;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;
public class IoLambda {
public static void main(String[] args) {
// Create file
String currentDirectory = System.getProperty("user.dir");
System.out.println("Current working directory: " + currentDirectory);
Path path = Paths.get(currentDirectory + "/minegenkode/src/main/java/uke9/data.txt");
try (Stream<String> streamOfStrings = Files.lines(path)) {
streamOfStrings.forEach(System.out::println);
} catch (Exception e) {
e.printStackTrace();
}
int numberOfLinesToBeRead = 2;
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
Stream<String> stream = in.lines().limit(numberOfLinesToBeRead);
stream.forEach(System.out::println);
}
}
Første.
Andre
Spesialtegn: Ͱ
......@@ -5,7 +5,9 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class Pipeline {
......@@ -16,6 +18,7 @@ public class Pipeline {
Collection<Score> scores = ids.stream().map(name -> new Score(name)).collect(Collectors.toList());
System.out.println(scores);
// Vi kan også lage stream fra en Array på samme måte.
// Vi kan også forenkle skrivemåten for å generere listen.
String[] names = new String[] {"Per", "Ida", "Live", "Pål"};
......@@ -32,21 +35,25 @@ public class Pipeline {
for (Score s : scores) {
s.setValue(rnd.nextInt(3));
}
System.out.println(scores);
// En fordel med stream, er at den er designet for å lett koble sammen flere operasjoner
long noWithScore2 = scores.stream().filter(s-> s.getValue() == 2).count();
System.out.println(noWithScore2);
// Hvem hadde score 2?
Collection<String> scorers = scores.stream().filter(s-> s.getValue() == 2).map(s->s.getId()).toList();
System.out.println(scorers);
// La oss lage en map fra id til sum av scores
Map<Integer, List<Score>> scoresAsMap = scores.stream().collect(Collectors.groupingBy(Score::getValue));
System.out.println(scoresAsMap);
// Mange metoder kan brukes direkte på collections
List<String> nyeNavn = Arrays.asList("Ada", "Bo", "Eva");
nyeNavn.forEach(System.out::println);
// En bruker ikke streams til å slette noe fra input.
nyeNavn.removeIf(n -> n.contains("a"));
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment