27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
1/6
« Java [34] – Wyjątki, czyli jak nie wykrzaczyć programu
Java [36] – Klasy anonimowe i wyrażenia lam
Kategoria:
java
, Tagi:
csv
-
java
-
pliki tekstowe
-
programowanie
.
Java [35] – Zapis i odczyt plików tekstowych, pliki
CSV
Autor: Grzegorz, napisał dnia: Kwiecień 22nd, 2015
Programy pracujące z danymi zazwyczaj muszą mieć możliwość ich odczytywania i zapisywania na dysku. Najbardziej podstawowym sposobem zapisu danych są odpowiednio
sformatowane pliki tekstowe. Mają one także tą zaletę, że są uniwersalne, można je odczytać na wielu programach, włączając w to edytory tekstu.
Zapis prostej informacji do pliku tekstowego
Najpierw pokażę jak zapisać kilka linijek tekstu do pliku a następnie je odczytać. Sposobów zapisu informacji do plików jest kilka, zaczniemy od „tradycyjnego”. Poniższy program
zawiera metodę, w której znajduje się kod zapisujący trzy linijki mające po jednym słowie (możesz dopisać ich więcej) do pliku, metodę która ten plik odczytuje i metodę
main()
która wywołuje te metody a także wypisuje na ekranie odczytany tekst. Komentarze w kodzie wyjaśniają kolejne operacje.
Zauważ, że w powyższym kodzie użyliśmy obiekt typu
PrintWriter
, który po linijce zapisywał tekst do pliku, natomiast do odczytu posłużył nam stary znajomy
Scanner
, któr
tym razem jako argument konstruktora otrzymał obiekt typu
File
, w efekcie odczytywał dane z pliku zamiast z klawiatury (jak robił to w poprzednich programach). Po zapisie
danych do pliku plik należało zamknąć. Nie jest to konieczne jeśli wykorzystamy nowsze rozwiązania dostępne w Javie, co pokażę w kolejnym przykładzie.
Zapis danych w formacie CSV
W drugim przykładzie pokażę jak użyć nowszych mechanizmów zapisu plików a przy okazji zapoznamy się z formatem
CSV
. Jest to chyba najprostszy format służący zapisaniu
danych. W standardowej formie są to rzędy danych poprzedzielanych przecinkami, stąd nazwa
CSV
(ang. Comma Separated Values) i zwyczajowe przedłużenie nazw pliku:
.csv
. Na przykład taki plik może wyglądać tak:
2.3, 2.2, 2.1, 2.0, 1.8
2.2, 2.1, 2.1, 2.3, 2.0
2.2, 2.2, 2.1, 1.9, 1.8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package
pliki
;
import
java
.
io
.
File
;
import
java
.
io
.
FileNotFoundException
;
import
java
.
io
.
PrintWriter
;
import
java
.
util
.
Scanner
;
public
class
Pliki
{
public
static
void
main
(
String
[]
args
)
{
// Nazwa pliku do którego zapiszemy i z którego odczytamy tekst
String
nazwaPliku
=
"tekst.txt"
;
// Zapis pliku
zapiszPlik
(
nazwaPliku
);
// Odczyt pliku
String
odczytanyTekst
=
odczytajPlik
(
nazwaPliku
);
// Drukowanie treści odczytanej z pliku
System
.
out
.
println
(
"Odczytany tekst:\n"
+
odczytanyTekst
);
}
// Metoda zapisuje tekst w pliku tekstowym
public
static
void
zapiszPlik
(
String
nazwaPliku
)
{
// spróbuj...
try
{
// Tworzenie obiektu typu PrintWriter, jako argument
// zostaje podana nazwa pliku
PrintWriter
out
=
new
PrintWriter
(
nazwaPliku
);
// po kolei zapisywane są kolejne linijki tekstu
out
.
println
(
"Raz"
);
out
.
println
(
"Dwa"
);
out
.
println
(
"Trzy"
);
// po zapisaniu danych plik należy zamknąć
out
.
close
();
// jeśli się nie udało utworzyć pliku..
}
catch
(
FileNotFoundException
ex
)
{
System
.
out
.
println
(
"Niestety, nie mogę utworzyć pliku!"
);
}
}
// Metoda odczytuje tekst z pliku tekstowego,
public
static
String
odczytajPlik
(
String
nazwaPliku
)
{
// Deklarowanie i tworzenie obiektu typu File
File
plikDane
=
new
File
(
nazwaPliku
);
// Utworzenie obiektu typu String, który będzie
// przechowywał odczytany tekst
String
odczyt
=
""
;
try
{
// Utworzenie obiektu typu String
Scanner
skaner
=
new
Scanner
(
plikDane
);
// Odczytywanie kolejnych linii pliku dopóki są kolejne linie
while
(
skaner
.
hasNextLine
())
{
// Do łańcucha znaków dodawana jest zawartość kolejnej linii
// oraz znak \n oznaczający następną linię
odczyt
=
odczyt
+
skaner
.
nextLine
()
+
"\n"
;
}
// Jeśli nie udało się odczytać pliku
}
catch
(
FileNotFoundException
e
)
{
System
.
out
.
println
(
"Brak Pliku do odczytania!"
);
}
return
odczyt
;
}
}
Jav
We need your permission
Allow functional cookies ?
Allow
Deny
27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
2/6
Jak widać, te dane można by łatwo przedstawić w formie tabelarycznej, gdzie rząd danych odpowiadałby rzędowi w tabeli a kolejna liczba w rzędzie byłaby przyporządkowana d
kolejnej kolumny. W praktyce można zamiast przecinka wybrać inny znak, np. średnik czy hasz, jeśli chcemy przechowywać liczby zmiennoprzecinkowe w przyjętej m. in. w
Polsce notacji z przecinkiem zamiast kropki. Często stosuje się znak tabulatora co dodatkowo może zwiększać czytelność pliku. W tym ostatnim przypadku mówimy raczej o
plikach
TSV
(ang. Tab Separated Values). Jeśli dane pole zawiera tekst, zwłaszcza jeśli jest on dłuższy i zawiera znaki separatora to można go zamknąć w parze cudzysłowów.
Trzeba oczywiście wtedy zadbać, żeby program, który odczytuje taki plik to uwzględnił i potraktował np. przecinek w obrębie tekstu jako jego element a nie znak separatora.
Poniższy kod tworzy tablicę dwuwymiarową liczb
double
z powyższymi danymi, zapisuje je w pliku
dane.csv
, który znajdziesz po uruchomieniu programu w katalogu z
projektem a następnie odczytuje ten plik i odtwarza tablicę z liczbami typu
double
. Oczywiście dane w pliku tekstowym zapisywane są jako łańcuchy znaków a muszą przy
odczycie zostać przekonwertowane na liczby
double
.
W tym przykładzie pokazałem ja użyć sposobu zapisu pliku dostępnych w nowszych wydaniach Javy. Wykorzystują one m. in. klasy
Path
i
Files
, które oferują wiele
użytecznych metod statycznych służących do pracy z plikami i katalogami, ale nie będziemy ich tu szerzej omawiać, przynajmniej na razie.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package
danewpliku
;
import
java
.
io
.
IOException
;
import
java
.
nio
.
file
.
*
;
import
java
.
util
.
ArrayList
;
import
java
.
util
.
Arrays
;
public
class
DaneWPliku
{
public
static
void
main
(
String
[]
args
)
{
// Nazwa pliku do którego zapiszemy i z którego odczytamy tekst
String
nazwaPliku
=
"dane.csv"
;
// Tablica z danymi - 3 serie w rzędach po 5 liczb (np. pomiarów)
double
[][]
dane
=
{{
2.3
,
2.2
,
2.1
,
2.0
,
1.8
},
{
2.2
,
2.1
,
2.1
,
2.3
,
2.0
},
{
2.2
,
2.2
,
2.1
,
1.9
,
1.8
}
};
// Zapis pliku
zapiszPlik
(
nazwaPliku
,
dane
);
// Odczyt pliku i konwersja do tablicy
double
[][]
odczyt
=
odczytajPlik
(
nazwaPliku
);
// Coś robimy z odczytanymi danymi
obliczenia
(
odczyt
);
}
// Metoda zapisuje tekst w pliku tekstowym
public
static
void
zapiszPlik
(
String
nazwaPliku
,
double
[][]
dane
)
{
// Tworzymy obiekt typu Path
Path
sciezka
=
Paths
.
get
(
nazwaPliku
);
ArrayList
<String>
out
=
new
ArrayList
<>
();
// Pobranie kolejnego "rzędu" danych
for
(
double
[]
seria
:
dane
)
{
String
s
=
Arrays
.
toString
(
seria
);
// Arrays.toString(seria) zwraca dane w postaci:
// [2.3, 2.2, 2.1, 2.0, 1.8]
// trzeba usunąć znaki [ i ]
s
=
s
.
replace
(
"["
,
""
);
s
=
s
.
replace
(
"]"
,
""
);
// dodanie linijki z danymi do listy
out
.
add
(
s
);
}
try
{
Files
.
write
(
sciezka
,
out
);
}
catch
(
IOException
ex
)
{
System
.
out
.
println
(
"Nie mogę zapisać pliku!"
);
}
}
// Metoda odczytuje tekst z pliku tekstowego,
public
static
double
[][]
odczytajPlik
(
String
nazwaPliku
)
{
// Tworzymy obiekt typu Path
Path
sciezka
=
Paths
.
get
(
nazwaPliku
);
// Lista będzie przechowywała kolejne linie odczytane z pliku jako String
ArrayList
<String>
odczyt
=
new
ArrayList
<String>
();
try
{
// Od razu odczytane zostają wszystkie linie pliku
// i umieszczone w liście
odczyt
=
(
ArrayList
)
Files
.
readAllLines
(
sciezka
);
}
catch
(
IOException
ex
)
{
System
.
out
.
println
(
"Brak pliku!"
);
}
// Teraz trzeba łańcuchy znaków dla każdej linii przekonwertować
// na dane liczbowe i umieścić je w tablicy
// Tablica dla odczytanych danych
// Na razie wiemy tylko ile będzie "rzędów"
double
[][]
daneOdczytane
=
new
double
[
odczyt
.
size
()][];
// Będziemy potrzebowali indeksu linii
int
nrLinii
=
0
;
// Pobranie kolejnych linii z listy
for
(
String
linia
:
odczyt
)
{
// Rozbijamy linię na poszczególne linie (przedzielone przecinkami)
String
[]
liniaDaneString
=
linia
.
split
(
","
);
// Tablica do przechowania danych w fomie liczb double
double
[]
liniaDouble
=
new
double
[
liniaDaneString
.
length
];
// Pętla, która pobiera z tablicy String-ów po jednej liczbie,
// konwertuje ją na liczbę double i zapisuje w tablicy typu double[]
for
(
int
i
=
0
;
i
<
liniaDouble
.
length
;
i
++
)
{
liniaDouble
[
i
]
=
Double
.
parseDouble
(
liniaDaneString
[
i
]);
}
// Dodajemy tablicę z serią danych do tablicy z wszystkimi danymi
daneOdczytane
[
nrLinii
]
=
liniaDouble
;
// kolejna linia...
nrLinii
++
;
}
return
daneOdczytane
;
}
Jav
27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
3/6
Bardziej złożony przykład danych zapisanych w pliku
CSV
Plik
CSV
może zawierać dane różnego rodzaju, niekoniecznie liczbowe a także może zawierać linię z nagłówkami, co zobaczymy w kolejnym przykładzie. Tym razem dane będą
miały bardziej złożony charakter, tym razem punktem wyjścia będzie istniejący plik z danymi zawierającymi liczby chromosomów roślin.
Plik zawiera numer porządkowy, nazwę rodzaju, nazwę gatunkową, liczbę 2n chromosomów i liczbę x chromosomów. Pierwsza linia zawiera nagłówki.
Projekt będzie się składał z dwu plików: głównego, zawierającą metodę
main()
pliku
DaneZlozone.java
oraz klasy
Takson.java
. Obiekty typu
Takson
będą przechowywa
informacje dotyczące poszczególnych taksonów. Dane odczytane z jednej linii, będą umieszczane w poszczególnych polach obiektu. Kolejne obiekty
Takson
będą umieszczan
w liście (w klasie
DaneZlozone
).
Klasa
DaneZlozone.java
, poza metodą
main()
, zawiera metody służące do odczytu danych, wyświetlania menu i pobrania decyzji użytkownika, dodania nowego rekordu,
usunięcia rekordu, wypisania danych oraz oddzielną metodę, która będzie dokonywać konwersji danych z listy
String
-ów do listy obiektów. Będzie on pobierać po linii z listy a
następnie oddzielać poszczególne pola, dokonywać ich konwersji do liczb kiedy to koniecznie a w końcu ustawiać je jako wartości pól w obiektach, które skolekcjonuje w liście
obiektów
Takson
.
Plik:
dane_chromosomy.csv
Umieść powyższą treść w pliku i zapisz go np. pod nazwą
dane_chromosomy.csv
na dysku, najlepiej w miejscu do którego nie prowadzi zbyt długa ścieżka (np. bezpośrednio
w katalogu użytkownika), ponieważ będzie trzeba ją ręcznie wpisać po uruchomieniu programu.
Plik:
Takson.java
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// Robimy coś z danymi
public
static
void
obliczenia
(
double
[][]
dane
)
{
double
suma
=
0.0
;
// Pobranie kolejnej serii danych
for
(
double
[]
rzad
:
dane
)
{
// pobranie kolejnej danej i dodanie do sumy
for
(
double
dana
:
rzad
)
{
suma
+=
dana
;
}
// Wydruk danych, sumy i średniej dla serii
System
.
out
.
println
(
"Dane: "
+
Arrays
.
toString
(
rzad
)
+
" suma: "
+
suma
+
" średnia: "
+
suma
/
rzad
.
length
);
}
}
}
1
2
3
4
5
6
7
8
9
10
nr
,
rodzaj
,
gatunek
,
2n
,
x
1
,
Acer
,
negundo
,
26
,
13
2
,
Acer
,
saccharinum
,
52
,
13
3
,
Amaranthus
,
bouchonii
,
32
,
8
4
,
Amaranthus
,
chlorostachys
,
32
,
16
5
,
Amaranthus
,
lividus
,
34
,
17
6
,
Amaranthus
,
retroflexus
,
34
,
17
7
,
Anethum
,
graveolens
,
22
,
11
8
,
Heracleum
,
mantegazzianum
,
22
,
11
9
,
Heracleum
,
sosnovskii
,
22
,
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package
danezlozone
;
public
class
Takson
{
private
int
nr
;
private
String
rodzaj
;
private
String
gatunek
;
private
int
n2
;
private
int
x
;
public
Takson
(
int
nr
,
String
rodzaj
,
String
gatunek
,
int
n2
,
int
x
)
{
this
.
nr
=
nr
;
this
.
rodzaj
=
rodzaj
;
this
.
gatunek
=
gatunek
;
this
.
n2
=
n2
;
this
.
x
=
x
;
}
Jav
Jav
27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
4/6
Plik:
DaneZlozone.java
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public
Takson
(
int
nr
){
this
.
nr
=
nr
;
}
public
String
toString
(
String
separator
)
{
return
getNr
()
+
separator
+
getRodzaj
()
+
separator
+
getGatunek
()
+
separator
+
getN2
()
+
separator
+
getX
();
}
public
int
getNr
()
{
return
nr
;
}
public
void
setNr
(
int
nr
)
{
this
.
nr
=
nr
;
}
public
String
getRodzaj
()
{
return
rodzaj
;
}
public
void
setRodzaj
(
String
rodzaj
)
{
this
.
rodzaj
=
rodzaj
;
}
public
String
getGatunek
()
{
return
gatunek
;
}
public
void
setGatunek
(
String
gatunek
)
{
this
.
gatunek
=
gatunek
;
}
public
int
getN2
()
{
return
n2
;
}
public
void
setN2
(
int
n2
)
{
this
.
n2
=
n2
;
}
public
int
getX
()
{
return
x
;
}
public
void
setX
(
int
x
)
{
this
.
x
=
x
;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package
danezlozone
;
import
java
.
io
.
IOException
;
import
java
.
nio
.
file
.
Files
;
import
java
.
nio
.
file
.
Path
;
import
java
.
nio
.
file
.
Paths
;
import
java
.
util
.
ArrayList
;
import
java
.
util
.
Scanner
;
public
class
DaneZlozone
{
// Lista przechowująca taksony
static
ArrayList
<Takson>
listaTaksonow
=
new
ArrayList
<>
();
static
String
sciezka
;
static
String
naglowki
;
public
static
void
main
(
String
[]
args
)
{
Character
opcja
=
'x'
;
// Główna pętla programu
while
(
!
opcja
.
equals
(
'k'
))
{
// Jeżeli nie ma danych, to nalezy je najpierw wczytać
if
(
listaTaksonow
.
isEmpty
())
{
listaTaksonow
=
czytajPlik
();
}
// wydruk menu i pobranie decyzji użytkownika
opcja
=
menu
();
switch
(
opcja
)
{
case
'o'
:
listaTaksonow
=
czytajPlik
();
break
;
case
'w'
:
wypiszDane
();
break
;
case
'd'
:
dodajDane
();
break
;
case
'u'
:
usunDane
();
break
;
case
'z'
:
zapiszDane
();
break
;
case
'k'
:
System
.
out
.
println
(
"KONIEC"
);
break
;
default
:
System
.
out
.
println
(
"Nie rozumiem"
);
}
}
}
Jav
27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
5/6
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// Metoda wczytująca plik z danymi
public
static
ArrayList
<Takson>
czytajPlik
()
{
Scanner
skaner
=
new
Scanner
(
System
.
in
);
System
.
out
.
println
(
"Podaj ścieżkę do pliku: "
);
System
.
out
.
print
(
"> "
);
sciezka
=
skaner
.
nextLine
();
Path
sciezkaDoPliku
=
Paths
.
get
(
sciezka
);
// Lista będzie przechowywała kolejne linie odczytane z pliku jako String
ArrayList
<String>
odczyt
=
new
ArrayList
<String>
();
try
{
// Wczytanie wszystkich linii do listy
odczyt
=
(
ArrayList
)
Files
.
readAllLines
(
sciezkaDoPliku
);
}
catch
(
IOException
ex
)
{
System
.
out
.
println
(
"Brak pliku!"
);
}
// Pobranie pierwszej linii z nagłówkami...
naglowki
=
odczyt
.
get
(
0
);
// ... następnie usunięcie jej
odczyt
.
remove
(
0
);
// Wywołanie metody tworzącej obiekty i wypełniające je danymi z pliku
ArrayList
<Takson>
taksony
=
doObiektow
(
odczyt
);
return
taksony
;
}
// Metoda pobiera po serii danych, odpowiadających linii w pliku
// a następnie tworzy obiekty typu Takson i wypełnia je danymi
public
static
ArrayList
<Takson>
doObiektow
(
ArrayList
<String>
odczyt
)
{
ArrayList
<Takson>
taksony
=
new
ArrayList
<>
();
for
(
String
linia
:
odczyt
)
{
// Dzielenie na poszczególne pola (oodzielone przecinkami)
String
[]
l
=
linia
.
split
(
","
);
// Tworzenie obiektu i wywołanie konstruktora, który przyjmuje
// jako argumenty dane
Takson
takson
=
new
Takson
(
Integer
.
parseInt
(
l
[
0
]),
// nr
l
[
1
],
// rodzaj
l
[
2
],
// gatunek
Integer
.
parseInt
(
l
[
3
]),
// n2
Integer
.
parseInt
(
l
[
4
])
// x
);
taksony
.
add
(
takson
);
}
return
taksony
;
}
// Wypisanie danych
public
static
void
wypiszDane
()
{
// Zamiana przecinków na tabulatory w nagłówku - bardziej przejrzyste
System
.
out
.
println
(
naglowki
.
replace
(
","
,
"\t"
));
System
.
out
.
println
(
"==============================================="
);
// Pobieranie każdego taksonu i wywołanie metody toString przyjmującej
// jako argument rodzaj reparatora do wyświetlenia, tu jest to tabulator
for
(
Takson
takson
:
listaTaksonow
)
{
System
.
out
.
println
(
takson
.
toString
(
"\t"
));
}
}
// Dodane nowego taksonu
public
static
void
dodajDane
()
{
// numer nowego taksonu powinien być o 1 większy niż
// najwyższy obecnie istniejący
int
nowyId
=
znajdzMaxId
()
+
1
;
// Tworzenie obiektu, wykorzystanie konstruktora przyjmującego
// jako argument numer
Takson
nowy
=
new
Takson
(
nowyId
);
Scanner
skaner
=
new
Scanner
(
System
.
in
);
System
.
out
.
println
(
"Podaj rodzaj: "
);
nowy
.
setRodzaj
(
skaner
.
nextLine
());
System
.
out
.
println
(
"Podaj gatunek: "
);
nowy
.
setGatunek
(
skaner
.
nextLine
());
System
.
out
.
println
(
"Podaj 2n: "
);
nowy
.
setN2
(
Integer
.
parseInt
(
skaner
.
nextLine
()));
System
.
out
.
println
(
"Podaj x: "
);
nowy
.
setX
(
Integer
.
parseInt
(
skaner
.
nextLine
()));
// Dodanie taksonu do listy
listaTaksonow
.
add
(
nowy
);
}
// Metoda wyszukuje największy numer, przyda się do wyznaczenia numeru
// dla nowego taksonu
public
static
int
znajdzMaxId
()
{
int
max
=
0
;
for
(
Takson
t
:
listaTaksonow
)
{
if
(
t
.
getNr
()
>
max
)
{
max
=
t
.
getNr
();
}
}
return
max
;
}
// Wyświetlenie menu i pobranie decyzji od użytkownika
public
static
Character menu
()
{
Scanner
skaner
=
new
Scanner
(
System
.
in
);
Character
opcja
=
'x'
;
// Pętla działa dopóki uzytkownik nie wybierze zrozumiałej opcji
while
((
!
opcja
.
equals
(
'o'
)
&& !
opcja
.
equals
(
'w'
)
&& !
opcja
.
equals
(
'd'
)
&& !
opcja
.
equals
(
'u'
))
&& !
opcja
.
equals
(
'z'
)
&& !
opcja
.
equals
(
'k'
))
{
System
.
out
.
println
(
" *** Menu *** "
);
System
.
out
.
println
(
"o - otwórz plik"
);
System
.
out
.
println
(
"w - wypisz dane"
);
System
.
out
.
println
(
"d - dodaj takson"
);
System
.
out
.
println
(
"u - usuń takson"
);
27.09.2018
Java [35] – Zapis i odczyt plików tekstowych, pliki CSV « Grzegorz Góralski - strona własna
http://ggoralski.pl/?p=1934
6/6
« Java [34] – Wyjątki, czyli jak nie wykrzaczyć programu
Java [36] – Klasy anonimowe i wyrażenia lam
« Java [34] – Wyjątki, czyli jak nie wykrzaczyć programu
Java [36] – Klasy anonimowe i wyrażenia lam
Zadanie
Uzupełnij powyższy program o metodę, która umożliwi wyszukiwanie rodzajów lub gatunków w zestawie danych.
Podziel się:
Kwiecień 22nd, 2015 | Tags:
csv
,
java
,
pliki tekstowe
,
programowanie
| Category:
java, programowanie
|
Skomentuj
|
Oceń:
(2 votes, average: 5,00 out of 5)
| 51 111 odwiedzin(y)
Podobne
Java [42] – Aplikacja uruchamiana w wierszu
poleceń (CLI - command-line-interface) z
przekazywanymi opcjami
Java [01] - Pierwszy program w NetBeans
Java, Swing - otwieranie i zapisywanie plików.
23/05/2017
W "bioinformatyka"
09/10/2014
W "java"
14/06/2012
W "java"
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
System
.
out
.
println
(
"z - zapisz dane"
);
System
.
out
.
println
(
"k - koniec"
);
System
.
out
.
print
(
"> "
);
opcja
=
skaner
.
next
().
charAt
(
0
);
}
return
opcja
;
}
// Usuwanie taksonu z listy
private
static
void
usunDane
()
{
wypiszDane
();
System
.
out
.
println
(
"Podaj numer taksonu, który chcesz usunąć"
);
Scanner
skaner
=
new
Scanner
(
System
.
in
);
int
numer
=
Integer
.
parseInt
(
skaner
.
nextLine
());
boolean
usuniety
=
false
;
// Wyszukanie taksonu
for
(
int
i
=
0
;
i
<
listaTaksonow
.
size
();
i
++
)
{
Takson
takson
=
listaTaksonow
.
get
(
i
);
int
numerTaksonu
=
takson
.
getNr
();
if
(
numerTaksonu
==
numer
)
{
listaTaksonow
.
remove
(
i
);
// zaznacz jeśli dokonane zostało usunięcie
usuniety
=
true
;
break
;
}
}
if
(
usuniety
)
{
System
.
out
.
println
(
"Takson nr. "
+
numer
+
"usuniety"
);
}
else
{
System
.
out
.
println
(
"Nie ma taksonu o numerze "
+
numer
);
}
}
// Zapis danych
private
static
void
zapiszDane
()
{
Path
sciezkaDoPliku
=
Paths
.
get
(
sciezka
);
System
.
out
.
println
(
"Podaj ścieżkę i plik do zapisu \n"
+
"Jeśli chcesz zapisać do bieżącego pliku: \n"
+
sciezka
+
"\n wciśnij enter"
);
Scanner
skaner
=
new
Scanner
(
System
.
in
);
String
sc
=
skaner
.
nextLine
();
// Jeśli użytkownik wpisał ścieżkę
if
(
sc
.
length
()
>
0
)
{
sciezkaDoPliku
=
Paths
.
get
(
sc
);
}
ArrayList
<String>
out
=
new
ArrayList
<String>
();
out
.
add
(
naglowki
);
for
(
Takson
takson
:
listaTaksonow
)
{
out
.
add
(
takson
.
toString
(
","
));
}
try
{
Files
.
write
(
sciezkaDoPliku
,
out
);
}
catch
(
IOException
ex
)
{
System
.
out
.
println
(
"Niestety, nie mogę utworzyć pliku!"
);
}
}
}