Java cung cấp cho ta khả năng ghi toànbộ đối tượng xuống tập tin(đối
tượng đang ở một trạng thái nào đó). Sau đó ta có thể đem tập tin chứa đối
tượng đi khắp nơi nếu cần thì khôi phục đối tượngvề trạng thái ban đầu, đưa
đối tượng vào bộ nhớ sử dụng đúng y như tình tràn trước khi nó được lưu
xuống đĩa. Các đối tượng có khả năng này được gọi là tuần tự hóa
(serialization)
132 trang |
Chia sẻ: lylyngoc | Lượt xem: 2423 | Lượt tải: 0
Bạn đang xem trước 20 trang tài liệu Đề tài Giải pháp nân cao hiệu quả hoạt động huy động vốn của Ngân hàng thương mại Việt Nam, để xem tài liệu hoàn chỉnh bạn click vào nút DOWNLOAD ở trên
riển kinh tế đúng đắn : Chính phủ cần có các chính
sách ngoại giao, tiết kiệm và đầu tư một cách phù hợp, giảm bớt hệ thống quản
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
31
lý hành chính cồng kềnh, tăng cường tính độc lập của NHVN trong thực thi
chính sách tiền tệ quốc gia sao cho phù hợp và gắn liền với thực tiễn. Bên cạnh
đó, Nhà nước cũng cần nâng cao hiệu quả sử dụng vốn, đặc biệt là ở các doanh
nghiệp Nhà nước bằng cách đẩy mạnh tiến trình cổ phần hoá doanh nghiệp.
Tránh tình trạng đầu tư dàn trải, tham ô, lãng phí, lãi giả lỗ thật,… làm giảm lòng
tin của quần chúng nhân dân với chính sách phát triển kinh tế của Đảng và Nhà
nước.
* Củng cố lại hệ thống NHTM Việt Nam.
Để nâng cao chất lượng hoạt động và tiến tới hội nhập với NHTM trong
khu vực và thế giới thì việc cải cách và củng cố lại hệ thống NHTM Việt Nam là
rất cần thiết. Nhà nước cần củng cố theo hướng sau:
- Đối với NHTMQD : Nhà nước cần cấp đủ, bổ sung thêm vốn điều lệ để
tăng năng lực tài chính cũng như tăng sức mạnh cạnh tranh để hoà nhập vơí xu
thế chung của các NHTM trong khu vực, cần có sự tách bạch giữa cho vay chính
sách và cho vay thương mại, trừ một số trường hợp nhất định (phải được Bộ tài
chính bảo lãnh); việc tái cấp vốn phải căn cứ vào thực trạng hoạt động của
NHTM theo tiêu chuẩn quốc tế để có báo cáo chính xác với NHNN và Bộ tài
chính
- Đối với các NHTM ngoài quốc doanh : Nhà nước cần có sự quản lý, thanh
tra giám sát chặt chẽ hoạt động kinh doanh của các NHTM này.
3.2.2. Đối với Ngân hàng nhà nước.
Nhằm hướng tới mở rộng huy động vốn trong nền kinh tế, đặc biệt là
“kênh” qua NHTM thì NHNN cần có những chính sách mềm dẻo, linh hoạt theo
hướng sau :
* Khởi thảo và thực thi chính sách tiền tệ quốc gia một cách linh hoạt.
Trong đó cần khuyến khích tiết kiệm, tập trung vốn nhàn rỗi đầu tư cho sản xuất
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
32
kinh doanh, thúc đẩy các NHTM và TCTD cạnh tranh lành mạnh, tự chủ trong
kinh doanh. NHNN cần dùng lãi suất làm “đòn bẩy” thúc đẩy các NHTM chú
trọng huy độngvốn.
* NHNN cần tăng cường phối hợp tốt với các ngành quản lý quỹ đầu tư
nước ngoài, quỹ viện trợ từ các tổ chức Chính phủ và phi chính phủ nước ngoài,
nhằm động viên mọi nguồn vốn nước ngoài chảy qua “kênh” NHTM.
* NHNN cần có những hướng dẫn cụ thể về các hình thức huy động vốn
như: Tiết kiệm bằng vàng, tiết kiệm đảm bảo giá trị theo vàng,… cần có những
quy định cụ thể về áp dụng lãi suất đối với các khoản tiền gửi có kỳ hạn dài như
10 năm, 20 năm.
* NHNN cần quy định cụ thể các thông tin, số liệu về hoạt động mà các
TCTD bắt buộc phải công khai cho công chúng biết theo hướng phù hợp với
thông lệ quốc tế. Qua đó nhằm giúp khách hàng có được hướng giải quyết đúng
đắn trong việc đầu tư, giao dịch với Ngân hàng.
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
33
PHẦN KẾT LUẬN
Cùng với sự đổi mới của đất nước, ngành ngân hàng trong hơn 10 năm qua
cũng đã không ngừng đổi mới và phát triển, luôn luôn hoàn thành tốt nhiệm vụ
của mình góp phần to lớn trong việc tạo nguồn vốn đầu tư phục vụ cho hoạt
động sản xuất, kinh doanh nhằm phát triển kinh tế, xã hội.
Các NHTM Việt nam trong những năm qua đã đạt được rất nhiều thành
công trong hoạt động kinh doanh, đặc biệt là trong hoạt động huy động vốn góp
phần to lớn vào việc điều hoà vốn kinh doanh cho toàn bộ hệ thống và đáp ứng
nhu cầu về vốn cho phát triển kinh tế xã hội.
Trong phạm vi giới hạn về thời gian và trình độ nên bài viết không tránh
khỏi những thiếu sót, hạn chế. Em rất mong nhận được ý kiến đóng góp, giúp đỡ,
chỉ bảo của các thầy cô giáo để đề án được hoàn thiện hơn.
Một lần nữa em xin chân thành cảm ơn sự hướng dẫn tận tình của cô giáo:
Nguyễn Thuỳ Dường đã giúp đỡ em trong quá trình thực hiện đề án này
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
34
TÀI LIỆU THAM KHẢO
1. Giáo trình Lý thuyết tài chính tiền tệ. NXB Thống kê Hà nội năm 2002
2. Giáo trình Ngân hàng thương mại. NXB Thống kê Hà nội năm 2002
3. Tiền tệ Ngân hàng và thị trường tài chính của Predric S, Mishkin
4. Báo cáo thường niên năm 2002 của Ngân hàng Công thương Việt Nam
5. Báo cáo tài chính năm 2003 của Ngân hàng Ngoại thương Việt Nam
6. Báo cáo tống kết của NHNo&PTNT Việt Nam năm 2000,2001.2002
7. Mục tiêu chiến lược ổn định và phát triển kinh tế - xã hội đến năm 2010,
Nxb Sự thật, Hà Nội, 1991.
8. Tạp chí ngân hàng các số nă 2001,2002, 2003 và một số tài liệu có liên
quan khác
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
35
MỤC LỤC
TRANG
PHẦN MỞ ĐẦU ........................................................................................... 01
PHẦN NỘI DUNG ........................................................................................ 02
CHƯƠNG 1: LÝ LUẬN CHUNG VỀ HOẠT ĐỘNG ..................................... 02
1.1.Khái quát về NHTM ................................................................................ 02
1.1.1.Khái niệm và đặc điểm của NHTM ............................................. 02
11.2. Tài liệu tham khảo ai trò của NHTM ........................................... 03
1.1.2.1.Là thủ quỹ của Doanh nghiệp ................................................... 03
1.1.2.1.Tạo tiền trong quá trình hoạt động ............................................ 04
1.1.2.3. Là trung gian tài chính, trung gian tín dụng ............................. 05
1.1.3. Các hoạt động của NHTM. ......................................................... 06
1.1.3.1. Hoạt động huy động vốn. ......................................................... 06
1.1.3.2. Hoạt động sử dụng vốn ............................................................ 06
1.1.3.3. Các hoạt động trung gian của NHTM. ..................................... 06
1.2. Nguồn vốn của NHTM và các nhân tố ................................................... 07
1.2.1. Nguồn vốn của NHTM................................................................ 07
1.2.1.1. Tiền gửi. ................................................................................... 07
1.2.1.2. Vốn đi vay. ............................................................................... 08
1.2.1.3. Vốn tự có của NHTM. ............................................................ 09
1.2.1.4. Các nguồn vốn khác. ................................................................ 10
1.2.2. Vai trò của nguồn vốn đối với NHTM. ....................................... 10
§Ò ¸n LTTCTT Tr¬ng Anh B¾c – TCC 43A
Khoa: Ng©n hµng tµi chÝnh
36
1.2.3. Các nhân tố tác động đến hoạt động huy động vốn. ................... 12
1.2.3.1. Nhân tố khách quan. ................................................................. 13
1.2.3.1. Nhân tố chủ quan. .................................................................... 14
CHƯƠNG 2: THỰC TRẠNG HOẠT ĐỘNG HUY ĐỘNG VỐN ................... 16
2.1. Thực trạng huy động vốn của NHTM Việt Nam hiện nay. ..................... 16
2.1.1. Về các hình thức huy động. ......................................................... 16
2.1.2. Về khối lượng huy động .............................................................. 17
2.1.3. Về các chỉ tiêu đánh giá hiệu quả hoạt động huy động vốn……21
2.2. Đánh giá tình hình huy động vốn của NHTM Việt Nam hiện nay. ....... 23
2.2.1. Một số kết quả đạt được. ............................................................. 23
2.2.2. Một số hạn chế. ........................................................................... 24
CHƯƠNG 3: GIẢI PHÁP NÂNG CAO HIỆU QUẢ ........................................ 26
3.1. Giải pháp. ............................................................................................... 26
3.1.1. Đa dạng hoá các hình thức huy động vốn. .................................. 26
3.1.2. Xây dựng chính sách lãi suất hợp lý. .......................................... 27
3.1.3. Phát triển các hoạt động Marketing ............................................ 27
3.1.4. Mở rộng mạng lưới hoạt động .................................................... 28
3.1.5. Nâng cao trình độ đội ngũ cán bộ. .............................................. 28
3.2. Kiến nghị. ............................................................................................... 29
3.2.1. Đối với chính phủ. ....................................................................... 29
3.2.2. Đối với Ngân hàng nhà nước. ..................................................... 30
PHẦN KẾT LUẬN ......................................................................................................... 32
TÀI LIỆU THAM KHẢO .............................................................................................. 33
Đồ án: Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử
lý luồng và tập tin Java
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang1
Lời nói đầu
Ngôn ngữ lập trình, mô hình và thực tế thường không đi đôi với nhau, những
phương pháp và kỹ thuật chúng ta đang dùng sẽ nhanh chóng lỗi thời. Tuy nhiên,
chính nhờ sự phát triển mau lẹ này mà việc lập trình luôn mới mẻ và đầy hấp dẫn. Có
lẽ không có một ngôn ngữ lập trình nào minh họa tốt nhất cho điều trên bằng Java.
Chỉ trong vòng vài năm gần đây, Java phát triển từ mức độ khái niệm thành một ngôn
ngữ lập trình rất ưu việt.
Các lập trình viên đều sớm biết rằng hầu như các chương trình không thể đạt
trọn vẹn nếu không truy xuất dữ liệu bên ngoài. Đó là dữ liệu lấy về từ các nguồn
nhập. Kết quả chương trình cũng được gởi ra ngoài. Trong Java, các nguồn
nhập/xuất được định nghĩa rất mở rộng. Chương trình Java thực hiện việc nhập xuất
thông qua luồng. Luồng được Java đưa vào sử dụng gắn liền với bản thân ngôn ngữ,
nó thực hiện các thao tác nhập xuất thể hiện một cách trừu tượng hóa ở mức dữ liệu.
Luồng được sử dụng rất nhiều trong các chương trình ứng dụng Java nhất là các
chương trình truy xuất mạng và tập tin trên đĩa. Và đây là một vấn đề được quan tâm
nhiều trong lĩnh vực lập trình trên mạng. Và đó cũng là lý do để em thực hiện đồ án
này.
Đồ án Nguyên lý hệ điều hành với đề tài: Cơ chế xử lý luồng và tập tin tìm
hiểu về việc nhập xuất trong các chương trình Java thông qua luồng được thực hiện
như thế nào, cách quản lý File ra sao.
Đà Nẵng,Tháng 11/2004
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang2
MỤC LỤC
LỜI NÓI ĐẦU ......................................................................................................................... 1
MỤC LỤC................................................................................................................................ 2
I. KHÁI NIỆM LUỒNG ...................................................................................................... 3
1. Luồng (stream) ......................................................................................................... 3
2. Luồng byte và luồng ký tự ....................................................................................... 3
3. Các luồng chuẩn của Java ...................................................................................... 3
II. CÂY PHÂN CẤP CÁC LỚP TRONG GÓI JAVA.IO............................................................. 3
III. CÁC LỚP LUỒNG NHẬP XUẤT CƠ BẢN: ................................................................... 5
1. Các lớp luồng Byte ................................................................................................... 5
InputStream ........................................................................................................................ 5
OutputStream ..................................................................................................................... 6
FileInputStream và FileOutputStream .............................................................................. 7
ByteArrayInputStream và ByteArrayOutputStream ........................................................ 8
Các bộ lọc luồng xuất/nhập byte ........................................................................................ 8
FilterInputStream và FilterOutputStream .................................................................... 8
Stream vùng đệm byte ........................................................................................................ 8
BufferedInputStream ..................................................................................................... 9
BufferedOutputStream ................................................................................................... 9
PushbackInputStream .................................................................................................... 9
Nhập xuất bằng ống dẫn ................................................................................................... 10
PipedInputStream và PipedOutputStream .................................................................. 10
SequenceInputStream ....................................................................................................... 10
PrintStream ....................................................................................................................... 11
RandomAccessFile ............................................................................................................ 11
2. Các lớp luồng ký tự ................................................................................................ 11
Reader ............................................................................................................................... 12
Writer ................................................................................................................................ 13
Đọc từ thiết bị nhập .......................................................................................................... 14
Ghi ra thiết bị xuất ............................................................................................................ 14
IV. TẬP TIN (FILE) ....................................................................................................... 15
1. File .......................................................................................................................... 15
2. Thư mục ................................................................................................................. 16
3. FilenameFilter ....................................................................................................... 16
V. MỘT SỐ LỚP VÀ GIAO DIỆN KHÁC TRONG GÓI JAVA.IO .......................................... 17
1. StreamTokenizer .................................................................................................... 17
2. Serialization ............................................................................................................ 18
Serializable .................................................................................................................... 18
ObjectOutputStream .................................................................................................... 19
ObjectInputStream ....................................................................................................... 19
CHƯƠNG TRÌNH MINH HỌA .......................................................................................... 20
KẾT LUẬN ............................................................................................................................ 20
TÀI LIỆU THAM KHẢO .................................................................................................... 22
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang3
Cơ sở lý thuyết
I. Khái niệm luồng
1. Luồng (stream)
Luồng là một thực thể logic phát hoặc thu nhận thông tin. Hệ thống xuất
nhập Java liên kết một stream với một thiết bị vật lý. Tất cả các luồng đều hoạt
động cùng cách thức nên chúng ta có thể thao tác bất kỳ loại thiết bị dụng nào
theo cùng một cách. Luồng nhập có thể nhận nhiều loại thông tin khác nhau: từ
tập tin trên đĩa, từ bàn phím, từ mạng. Cũng tương tự như thế, luồng xuất có
thể liên hệ đến thiết bị như tập tin đĩa hay kết nối mạng. Luồng dùng giải quyết
việc nhập xuất mà không cần có đoạn lệnh khác nhau cho từng loại dữ liệu gắn
với từng loại thiết bị (bàn phím, mạng).
2. Luồng byte và luồng ký tự
Java định nghĩa hai kiểu luồng: luồng byte (byte stream) và luồng ký tự
(character stream). Luồng byte dùng nhập xuất dữ liệu dạng byte. Luồng byte
thường sử dụng nhất, ví dụ như việc đọc/viết dữ liệu nhị phân. Luồng byte thừa
kế từ hai lớp trừu tượng: InputStream và OutputStream. Luồng ký tự dùng
cho việc nhập xuất các ký tự theo bảng mã Unicode, vì vậy có thể dễ dàng
quốc tế hóa chương trình, ngoài ra trong một vài trường hợp khác, luồng ký tự
hiệu quả hơn là luồng byte. Luồng ký tự thừa kế từ hai lớp trừu tượng Reader
và Writer.
3. Các luồng chuẩn của Java
Tất cả các chương trình Java đều dùng gói java.lang. Gói này định
nghĩa lớp hệ thống - System - dùng quản lý môi trường Java. System định
nghĩa trước các biến luồng là in, out, err. Những biến này khai báo public và
static trong System nên có thể sử dụng chúng trong bất kỳ phần nào của
chương trình.
System.out là luồng xuất chuẩn, mặc định là màn hình (console).
System.in là luồng nhập chuẩn, mặc định là bàn phím. System.err là luồng lỗi
chuẩn, mặc định cũng là màn hình. Tuy nhiên những luồng lỗi này có thể liên
kết đến bất kỳ thiết bị nhập xuất tương thích nào.
System.in là đối tượng của InputStream, System.out và System.err là
những đối tượng của PrintStream. Các luồng này đều là byte dùng đọc viết ký
tự.
II. Cây phân cấp các lớp trong gói java.io
Mô hình cây sau đây thể hiện sự phân cấp các lớp trong gói java.io
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang4
java.io
InputStream
FilterInputStream
BufferedInputStream
DataInputStream
LineNumberInputStream
PushbackInputStream
ByteArrayInputStream
FileInputStream
ObjectInputStream
PipedInputStream
SequenceInputStream
StringBufferInputStream
OutputStream
FilterOutputStream
BufferedOutputStream
DataOutputStream
PrintStream
ByteArrayOutputStream
FileOutputStream
ObjectOutputStream
PipedOutputStream
Reader
BufferedReader
LineNumberReader
CharArrayReader
FilterReader
PushbackReader
InputStreamReader
FileReader
PipedReader
StringReader
Writer
BufferedWriter
CharArrayWriter
FilterWriter
InputStreamWriter
FileWriter
PipedWriter
PrintWriter
StringWriter
File
RandomAccessFile
FileDescriptor
FilePermission
ObjectStreamClass
ObjectStreamField
SerializablePermission
StreamTokenizer
Các lớp trong gói java.io
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang5
III. Các lớp luồng nhập xuất cơ bản:
1. Các lớp luồng Byte
Các lớp stream byte cung cấp môi trường mạnh quản lý nhập xuất theo
byte. Một stream byte có thể dùng với kiểu đối tượng bất kỳ, bao gồm dữ liệu
nhị phân. Tính linh hoạt này tạo ra nhiều stream quan trọng cho nhiều loại
chương trình khác nhau.
Lớp luồng Ý nghĩa
BufferedInputStream Luồng nhập đệm
BufferedOutputStream Luồng xuất đệm
ByteArrayInputStream Luồng nhập đọc từ mảng byte
ByteArrayOutputStream Luồng xuất để ghi lên mảng byte
DataInputStream Luồng nhập chứa các phương thức đọc các
kiểu dữ liệu Java chuẩn
FileInputStream Luồng nhập đọc từ tập tin
FileOutputStream Luồng xuất ghi lên tập tin
FilterInputStream Cài đặt InputStream
FilterOutputStream Cài đặt OutputStream
InputStream Lớp trừu tượng mô tả luồng nhập
OutputStream Lớp trừu tượng mô tả luồng xuất
PipedInputStream Đường dẫn nhập
PipedOutputStream Đường dẫn xuất
PrintStream Luồng xuất chứa hàm print() và println()
PushbackInputStream Luồng nhập hỗ trợ việc trả về một byte
RandomAccessFile Hỗ trợ truy xuất tập tin ngẫu nhiên
SequenceInputStream Luồng nhập kết hợp của hai hay nhiều hơn các
luồng nhập khác nhằm cho phép đọc tuần tự
từng luồng một.
Bảng 2. Các lớp luồng Byte
InputStream
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang6
Lớp InputStream là một lớp trừu tượng, định nghĩa phương thức luồng
nhập byte của Java. Tất cả các hàm trong lớp này sẽ phát sinh biệt lệ
IOException khi có lỗi.Bảng 2 trình bày các hàm của lớp này.
Hàm Mô tả
int available() trả về số các byte nhập sẵn sàng cho
việc đọc
void close() Đóng nguồn nhập. Nếu cố gắng đọc
sẽ phát sinh biệt lệ IOException.
void mark(int numBytes) Đặt một đánh dấu tại điểm hiện hành
trong luồng nhập sao cho nó vẫn hợp
lệ đến khi đọc được numBytes byte.
boolean markSupported() Trả về true nếu mark() / reset() được
hỗ trợ.
int read() Trả về số lượng byte (kiểu int) sẵn
sàng tiếp theo trong luồng nhập. Trả
về -1 nếu đến cuối tập tin.
int read(byte buffer[]) Đọc buffer.length byte vào buffer, và
trả về số byte thực sự đọc được. Trả
về -1 khi đến cuối tập tin.
int read(byte buffer[], int offset, int
numBytes)
Đọc numBytes byte vào buffer bắt
đầu tại vị trí offset, trả về số byte
thực sự đọc được. Trả về -1 khi đến
cuối tập tin.
void reset() Khởi động lại điểm đọc chỉ tới điểm
đánh dấu trước đó.
long skip(long numBytes) Bỏ qua numBytes byte. Trả về số
byte thực sự bỏ qua.
Bảng 3. Các phương thức của lớp InputStream
OutputStream
OutputStream là lớp định nghĩa phương thức luồng xuất byte của Java.
Tất cả các hàm trong lớp này trả về giá trị void và sẽ phát sinh biệt lệ
IOException trong trường hợp có lỗi. Bảng sau trình bày các hàm của lớp này
Hàm Mô tả
void close() Đóng nguồn xuất. Cố gắng ghi sẽ phát sinh biệt lệ
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang7
IOException
void flush() Kết thúc xuất và xoá các vùng đệm xuất.
void Write(int b) Ghi 1 byte ra stream xuất. Tham số kiểu int
void write(byte
buffer[])
Ghi mảng các byte buffer ra stream xuất.
void write(byte
buffer[], int offset, int
numBytes)
Ghi numBytes byte từ buffer bắt đầu tại vị trí offset
ra stream xuất.
Bảng 4. Các phương thức của lớp OutputStream
FileInputStream và FileOutputStream
Java cung cấp một số lớp và phương thức cho phép đọc và ghi tập tin.
Trong Java, tất cả tập tin là dãy các byte nên Java cung cấp phương thức đọc
và ghi byte từ tập tin. Hai trong số lớp luồng thường sử dụng đọc ghi tập tin là
FileInputStream và FileOutputStream, nó tạo luồng byte liên kết với các tập
tin. Để mở tập tin, đơn giản tạo chỉ định tên tập tin trong cấu tử:
FileInputStream(String fileName) throws FileNotFoundException
FileOutputStream(String fileName) throws FileNotFoundException
Ở đây, fileName xác định tên tập tin muốn mở. Khi tạo luồng nhập, nếu
tập tin đó không tồn tại sẽ phát sinh biệt lệ FileNotFoundException. Với
luồng xuất, nếu tập tin không tạo được, biệt lệ FileNotFoundException phát
sinh. Khi luồng xuất mở được, bất kỳ tập tin nào cùng tên tồn tại trước đó sẽ bị
xoá.
Khi đọc/ghi xong tập tin, ta phải đóng nó bằng cách gọi close(). Phương
thức này định nghĩa cho cả FileInputStream và FileOutputStream:
void close() throws IOException
Để đọc dữ liệu từ tập tin đã mở trước đó, sử dụng read() định nghĩa
trong FileInputStream:
int read() throws IOException
Mỗi lần được gọi, nó đọc một byte và trả về byte đó như giá trị integer.
read() trả về -1 khi đến cuối tập tin. Nó có thể phát sinh biệt lệ IOException.
Để ghi lên tập tin đã mở sẵn, sử dụng phương thức write() định nghĩa
trong FileOutputStream:
void write(int byteval) throws IOException
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang8
Phương thức này ghi byteval lên tập tin. byteval khai báo như một
integer, nhưng chỉ có 8 bit thấp được ghi xuống tập tin, nếu lỗi xảy ra trong
quá trình ghi tập tin sẽ phát sinh biệt lệ IOException.
ByteArrayInputStream và ByteArrayOutputStream
Việc thao tác và vận chuyển dữ liệu đôi khi ta chỉ muốn xử lý trên một
vùng nhớ nào đó thì hai lớp này sẽ giúp ta làm được việc đó.
ByteArrayInputStream là thể hiện của dòng nhập với bộ nguồn là mảng byte.
Lớp này có hai hàm khởi tạo, mỗi cách yêu cầu một mảng byte làm nguồn
cung cấp dữ liệu:
ByteArrayInputStream(byte array[])
ByteArrayInputStream(byte array[], int start, int numBytes)
Trong đó, array là nguồn nhập. Hàm khởi tạo thứ hai tạo ra dòng nhập
từ tập con trích ra từ mảng byte tại vị trí start và dài numBytes byte.
ByteArrayOutputStream kế thừa dòng xuất với đích xuất là mảng byte. Lớp
này có hai hàm khởi tạo, mỗi cách yêu cầu một mảng byte làm nguồn dữ liệu.
ByteArrayOutputStream()
ByteArrayOutputStream(int numBytes)
Trong hàm khởi tạo đầu, vùng đệm được tạo với kích thước numBytes
byte. Vùng đệm này đặt trong trường buf trong ByteArrayOutputStream.
Kích thước vùng đệm gia tăng tự động khi cần thiết. Số byte có thể có trong
vùng đệm lưu trong trường count của ByteArrayOutputStream. Cả hai
trường count và buf là các trường protected.
Các bộ lọc luồng xuất/nhập byte
FilterInputStream và FilterOutputStream
FilterInputStream và FilterOutputStream là các lớp nhập xuất trung
gian. Một trong những khả năng mạnh mẽ của việc sử dụng luồng là ta có thể
chuyển dữ liệu từ luồng này sang luồng khác. FilterInputStream và
FilterOutputStream là các lớp phủ các dòng nhập/ xuất cung cấp một số chức
năng mở rộng ứng dụng cho các dữ liệu đặc biệt khác: vùng đệm, chuyển ký
tự, chuyển dữ liệu thô. Phương thức khởi dựng cho đối tượng thuộc lớp
FilterInputStream và FilterOutputStream sẽ nhận bất cứ đối tượng nào
thuộc lớp InputStream và OutputStream làm đối số do luồng trung gian này
được thiết kế từ luồng cha là hai luồng trên. Hàm khởi tạo như sau:
FilterOutputStream(OutputStream os)
FilterInputStream(InputStream is)
Các hàm này có ý nghĩa như hàm khởi tạo của InputStream và
OutputStream.
Stream vùng đệm byte
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang9
Vùng đệm này cho phép Java thực hiện các thao tác nhập/xuất nhiều
byte trong cùng thời điểm, từ đó làm tăng tính linh hoạt của hệ thống. Vì có
vùng đệm sẵn sàng, việc bỏ qua, đánh dấu và khởi động lại các stream trở nên
thuận lợi. Các lớp stream byte được đệm hóa bằng BufferedInputStream và
BufferedOutputStream. PushbackInputStream cũng thể hiện stream được
đệm hóa.
BufferedInputStream
Việc tạo vùng đệm nhập/xuất là giải pháp tối ưu mạnh và rất thông
dụng. Lớp BufferedInputStream của Java cho phép “bao bọc” InputStream
vào stream được đệm hóa để có được những tiện ích hơn.
BufferedInputStream có hai hàm khởi tạo:
BufferedInputStream(InputStream inputStream)
BufferedInputStream(InputStream inputStream, int bufSize)
Hàm khởi tạo đầu tạo một stream đệm hóa sử dụng kích thước vùng
đệm mặc định. Hàm khởi tạo thứ hai tạo một stream đệm hóa có kích thước là
bufSize. Thông thường, kích thước vùng đệm thích hợp độc lập với hệ điều
hành, tổng bộ nhớ sẵn dùng và cấu hình máy như thế nào. Đệm hóa stream
nhập cũng đòi hỏi hỗ trợ việc di chuyển trên vùng đệm. Ngoài các hàm read()
và skip(), BufferedInputStream cũng hỗ trợ mark() và reset(). Sự hỗ trợ này
có nếu hàm BufferedInputStream.markSupport() trả về true.
BufferedOutputStream
BufferedOutputStream tương tự OutputStream, nó thêm vào hàm
flush(), hàm này dùng đảm bảo các vùng đệm dữ liệu được ghi vật lý thật sự
lên thiết bị xuất. Điểm hay của BufferedOutputStream là giảm số lần hệ
thống thực sự ghi dữ liệu, ta cần phải gọi flush() để ghi dữ liệu trên vùng đệm.
Không giống như bộ đệm nhập, bộ đệm xuất không cung cấp thêm tính năng
nào khác. Sau đây là hai hàm khởi tạo:
BufferedOutputStream(OutputStream OutputStream)
BufferedOutputStream(OutputStream OutputStream, int bufSize )
Hàm khởi tạo đầu tiên tạo stream có vùng đệm với kích thước 512 byte.
Hàm khởi tạo thứ hai tạo vùng đệm với kích thước bufSize byte.
PushbackInputStream
Đây là vùng đệm mới thực hiện khái niệm “đẩy lùi” dùng trên stream
nhập cho phép đọc một byte và sau đó “đẩy lùi” lại vào stream. Lớp
PushbackInputStream thực hiện ý tưởng này. Nó cung cấp cơ cấu để “lén
nhìn” những gì đến từ thiết bị nhập mà không phá vỡ nó.
PushbackInputStream có hai hàm khởi tạo:
PushbackInputStream(InputStream inputStream)
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang10
PushbackInputStream(InputStream inputStream, int numBytes)
Hàm khởi tạo đầu tiên tạo đối tượng stream cho phép một byte được trả
về nơi stream nhập. Hàm khởi tạo thứ hai tạo stream có vùng đệm đẩy lùi kích
thước là numBytes byte cho phép nhiều byte trả lại stream nhập.
Ngoài các hàm được kế thừa từ InputStream, PushbackInputStream
cung cấp các hàm unread():
void unread(int ch)
void unread(byte buffer[])
void unread(byte buffer[], int offset, int numChars)
Dạng thứ nhất đẩy ngược byte thấp của ch. Đây sẽ là byte tiếp theo
được trả về khi gọi read() sau đó. Dạng thứ hai đẩy các byte trong buffer.
Dạng thứ ba đẩy numChars byte bắt đầu tạo vị trí offset trong buffer. Biệt lệ
IOException phát sinh nếu cố gắng đẩy byte nào đó khi vùng đệm “đẩy lùi”
đầy.
Nhập xuất bằng ống dẫn
PipedInputStream và PipedOutputStream
Đối tượng của lớp PipedOutputStream có thể nối với một đối tượng
của lớp PipedInputStream để tạo thành một hệ thống luồng có liên kết (có thể
ghi dữ liệu vào đầu này và lấy dữ liệu ở đầu kia mà không phải thông qua 2
luồng riêng biệt). Thông thường, dữ liệu ghi vào PipedOutputStream bởi một
phân tuyến và dữ liệu đọc từ PipedInputStream nối với nó từ một phân tuyến
khác. Lớp PipedInputStream và PipedOutputStream là hai lớp con bình
thường của InputStream và OutputStream nhưng có thêm phương thức
connect() để kết nối. Các phương thức khởi tạo là:
PipedInputStream() throws IOException
PipedInputStream(PipedOutputStream src) throws IOException
PipedOutputStream() throws IOException
PipedOutputStream(PipedInputStream src) throws IOException
Hàm khởi tạo thứ nhất tạo một luồng PipedInputStream chưa được kết
nối. Nó phải được kết nối với PipedOutputStream trước khi được sử dụng.
Hàm thứ ba cũng tương tự nhưng ngược lại.
Hàm khởi tạo thứ hai tạo luồng PipedInputStream nối với luồng src đã
chỉ định. Và hàm thứ tư thì ngược lại.
SequenceInputStream
Lớp SequenceInputStream cho phép ta kết nối nhiều luồng nhập-
InputStream lại với nhau và xử lý như một luồng duy nhất. Có nhiều cách để
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang11
kết hợp các luồng. Một hàm khởi tạo SequenceInputStream sử dụng đối số là
cặp InputStream hoặc một Enumeration các InputStream.
SequenceInputStream(InputStream first, InputStream second)
SequenceInputStream(Enumeration streamEnum)
Lớp này đọc theo yêu cầu từ InputStream đầu tiên cho đến khi hết
stream này và chuyển qua stream thứ hai. Trong trường hợp Enumeration, nó
tiếp tục chuyển qua tất cả các InputStream cho đến điểm kết thúc stream cuối
cùng.
PrintStream
PrintStream được thiết kế cho việc xuất các dữ liệu dạng text. Lớp này
là kiểu đối tượng tham chiếu đến System.out. PrintStream có hai hàm khởi
tạo sau:
PrintStream(OutputStream outputStream)
PrintStream(OutputStream outputStream, boolean flushOnNewLine)
flushOnNewLine buộc Java có ghi vùng đệm lên dòng xuất hay không
khi ký hiệu dòng mới (\n) xuất hiện. Nếu flushOnNewLine true, Java sẽ ghi.
PrintStream không quản lý các ký tự Unicode và do vì vậy không có
khả năng quốc tế hóa.
RandomAccessFile
RandomAccessFile truy xuất tập tin ngẫu nhiên. Nó không dẫn xuất từ
InputStream hay OutputStream, mà nó thực thi các giao diện DataInput và
DataOutput, chúng định nghĩa các hàm xuất nhập cơ bản. Nó cũng hỗ trợ yêu
cầu định vị, nghĩa là có thể xác định vị trí điểm truy xuất tập tin. Lớp này có
hai hàm khởi tạo:
RandomAccessFile(File fileObj, String access) throws IOException
RandomAccessFile(String fileName, String access) throws IOException
Trong đó, access định kiểu truy xuất tập tin. Nếu nó là “r” - tập tin mở ở
chế độ đọc, không được ghi.Nếu là “rw” - tập tin mở ở chế độ đọc và ghi.
Hàm seek() dùng đặt vị trí hiện hành của con trỏ tập tin - vị trí truy xuất
tập tin: void seek(long newPos) throws IOException
newPos định vị trí mới (theo thứ tự byte) của con trỏ tập tin tính từ đầu
tập tin.
2. Các lớp luồng ký tự
Mặc dù các lớp stream byte cung cấp các chức năng quản lý nhập xuất,
nhưng chúng không thể làm việc trực tiếp trên các ký tự Unicode. Java hỗ trợ
triết lý “viết một lần, chạy bất kỳ nơi nào” nên rất cần các hỗ trợ xuất nhập trực
tiếp cho ký tự.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang12
Lớp luồng Ý nghĩa
BufferedReader Luồng ký tự nhập đệm
BufferedWriter Luồng ký tự xuất đệm
CharArrayReader Luồng nhập đọc từ mảng ký tự
CharArrayWriter Luồng xuất để ghi lên mảng ký tự
FileReader Luồng nhập đọc từ tập tin
FileWriter Luồng xuất ghi lên tập tin
FilterReader Bộ đọc được lọc
FilterWriter Bộ xuất được lọc
InputStreamReader Luồng nhập dùng để đổi các byte thành ký tự
LineNumberReader Luồng nhập đếm dòng
OutputStreamWriter Luồng xuất dùng để đổi ký tự thành byte.
PipedReader Đường dẫn nhập
PipedWriter Đường dẫn xuất
PrintWriter Luồng xuất chứa hàm print() và println()
PushbackReader Luồng nhập cho phép trả về ký tự.
Reader Lớp trừu tượng mô tả luồng nhập ký tự.
StringReader Luồng nhập đọc một chuỗi.
StringWriter Luồng xuất ghi một chuỗi.
Writer Lớp trừu tượng mô tả luồng xuất ký tự.
Bảng 5. Các lớp nhập xuất luồng ký tự
Reader
Reader là lớp ảo định nghĩa mô hình luồng nhập ký tự. Tất cả các
phương thức trong lớp này sẽ phát sinh biệt lệ IOException khi có lỗi. Bảng
sau trình bày tóm tắt các phương thức của Reader.
Hàm Mô tả
abstract void close() Đóng nguồn nhập. Nếu cố gắng đọc
sẽ phát sinh biệt lệ IOException.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang13
void mark(int numChars) Đánh dấu tại điểm hiện hành trong
luồng nhập để có thể quay về sau khi
numChars ký tự được đọc.
boolean markSupported() Trả về true nếu mark()/reset() được
hỗ trợ.
int read() Trả về số ký tự (kiểu int) sẵn sàng
tiếp theo trong luồng nhập. Trả về -1
nếu đến cuối tập tin.
int read(char buffer[]) Đọc buffer.length ký tự vào buffer,
và trả về số ký tự thực sự đọc được.
Trả về -1 khi đến cuối tập tin.
abstract int read(char buffer[], int offset,
int numChars)
Đọc numChars ký tự vào buffer bắt
đầu tại vị trí offset, trả về số ký tự
thực sự đọc được. Trả về -1 khi đến
cuối tập tin.
boolean ready() Trả về true nếu có thể đọc tiếp ngay,
không bị chờ đợi.
void reset() Khởi động lại điểm đọc chỉ tới điểm
đánh dấu trước đó.
long skip(long numChars) Bỏ qua numChars ký tự ở đầu vào.
Trả về số byte thực sự bỏ qua.
Bảng 6. Các hàm của lớp Reader
Writer
Writer là lớp ảo định nghĩa mô hình xuất ký tự. Tất cả các hàm trong
lớp này trả về giá trị void và phát sinh biệt lệ IOException khi có lỗi. Bảng
sau trình bày tóm tắt các phương thức của Writer.
Hàm Mô tả
abstract void close() Đóng nguồn xuất. Cố gắng ghi sẽ phát sinh
biệt lệ IOException
void flush() Kết thúc xuất và xoá các vùng đệm xuất.
void write(int ch) Ghi 1 ký tự ra stream xuất. Tham số kiểu int
void write(char buffer[]) Ghi mảng các ký tự buffer ra stream xuất.
void write(char buffer[], int
offset, int numChars)
Ghi numChars ký tự từ buffer bắt đầu tại vị
trí offset ra stream xuất.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang14
void write(String str) Ghi chuỗi str vào stream xuất.
void write(String str, int
offset, int numChars)
Ghi dãy numChars ký tự từ str bắt đầu tại vị
trí offset.
Bảng 7. Các hàm của lớp Writer
Đọc từ thiết bị nhập
Trong Java 1.0 chỉ có một cách nhập dữ liệu từ thiết bị là sử dụng luồng
byte. Ngày nay sử dụng luồng ký tự được ưa chuộng hơn và cách này làm cho
người lập trình dễ dàng quốc tế hóa và sử dụng lâu dài.
Dùng System.in đọc dữ liệu từ thiết bị bằng luồng nhập ký tự: ta nhúng
System.in vào đối tượng BufferedReader để tạo luồng ký tự BufferedReader
cung cấp một luồng vùng đệm nhập.
BufferReader(Reader inputReader)
Ở đây, inputReader là luồng liên kết với BufferReader. Reader là lớp
trừu tượng. Một trong những lớp con cụ thể của Reader là
InputStreamReader dùng chuyển dữ liệu kiểu byte sang ký tự. Để có một đối
tượng InputStreamReader nối với System.in, sử dụng cách khởi tạo sau:
InputStreamReader(InputStream inputStream)
Vì System.in tham khảo đến đối tượng kiểu InputStream nên nó có thể
sử dụng cho inputStream. Đoạn mã dưới đây tạo BufferReader nhận dữ liệu
từ bàn phím:
BufferReader br = new BufferReader(new InputStreamReader(System.in));
Sau dòng lệnh này br là luồng ký tự nối tới thiết bị gắn với System.in.
Đọc ký tự
Để đọc ký tự từ BufferReader, sử dụng read():
int read() throws IOException
Mỗi lần gọi read(), nó đọc một ký tự từ luồng nhập và nó trả về giá trị
integer. Trả về giá trị -1 khi phát hiện đã kết thúc luồng và phát sinh biệt lệ
IOException.
Đọc chuỗi
Để đọc chuỗi từ bàn phím, sử dụng readLine() là phương thức của lớp
BufferReader:
String readLine() throws IOException.
Ghi ra thiết bị xuất
Chúng ta dùng print(), println() in dữ liệu ra màn hình. Các phương thức
này định nghĩa trong lớp PrintStream. Tuy nhiên, trong các chương trình thật,
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang15
chúng ta nên sử dụng luồng PrintWriter. PrintWriter là một trong các luồng ký
tự. Như trên đã nói, khi sử dụng luồng ký tự cho thiết bị xuất sẽ dễ dàng quốc
tế hóa chương trình hơn. Hàm khởi tạo như sau:
PrintWriter(OutputStream outputStream, boolean flushOnNewLine)
Chức năng của PrintWriter giống như PrintStream mà ta đã thảo luận
như trên.
Các lớp còn lại của luồng ký tự đảm nhận vai trò tương tự như các lớp
tương ứng bên luồng Byte, nhưng thay vì xử lý trên luồng byte thì các lớp này
lại xử lý trên luồng ký tự. Reader tương ứng với InputStream, còn Writer tương
ứng với OutputStream.
IV. Tập tin (File)
1. File
Mặc dù hầu hết các lớp của java.io hoạt động trên các luồng, nhưng lớp
File thì không. Nó giao tiếp trực tiếp các file và hệ thống file. Lớp File không
xác định thông tin mang về hoặc được lưu trữ trên các tập tin như thế nào. Một
đối tượng File dùng giám sát và thao tác thông tin tương ứng với một tập tin
trên đĩa như thời gian, ngày tháng, đường dẫn thư mục và cây thư mục con.
Các tập tin là nguồn và đích chính của dữ liệu bên trong nhiều chương
trình. Mặc dù có nhiều hạn chế trong việc sử dụng chúng bên trong các applet.
Vì các lý do an toàn, tập tin vẫn là tài nguyên trọng yếu cho việc lưu trữ liên
tục và chia sẻ thông tin. Một thư mục xem như một tập tin trong Java với thuộc
tính thư mục.
Lớp File có các hàm khởi tạo sau:
File(String directoryPath)
File(String directoryPath, String fileName)
File(File dirObj, String fileName)
Trong đó, directoryPath là tên đường dẫn của tập tin, fileName là tên
tập tin, và dirObj là một đối tượng File xác định như thư mục.
Ví dụ sau tạo ra ba tập tin: f1,f2 và f3. Đối tượng File đầu tiên xây dựng
với một đường dẫn thư mục. Đối tượng thứ hai với đường dẫn và tên file. Đối
tượng thứ ba bao gồm đường dẫn của tập tin chỉ đến f1 và một tên tập tin; f3
chỉ đến cùng một tập tin như f2.
File f1 = new File(“/”);
File f2 = new File(“/”,”autoexec.bat”);
File f3 = new File(f1,”autoexec.bat”);
File định nghĩa nhiều phương thức lấy các thuộc tính chuẩn của đối
tượng File. Ví dụ, getName() trả về tên của file, getParent() trả về tên của thư
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang16
mục cha và exits() trả về true nếu file tồn tại. Tuy vậy, lớp File không có tính
đối xứng. Tức là có nhiều phương thức cho phép tham chiếu các thuộc tính của
một đối tượng file đơn giản, nhưng không có phương thức tương ứng để thay
đổi các thuộc tính đó. isFile() trả về true nếu đối tượng là tập tin thực sự, trả
về false nếu là thư mục. isFile() trả về false với các tập tin đặc biệt như là các
tập tin điều khiển thiết bị (driver) và các ống (pipe) (trong UNIX). Hàm
isAbsolute() trả về true nếu file có một đường dẫn tuyệt đối và false nếu đường
dẫn của nó là tương đối.
File cũng có hai phương thức tiện ích. Thứ nhất là renameTo():
boolean renameTo(File newName)
Trong đó, tên tập tin newName trở thành tên mới của đối tượng File. Nó
trả về true nếu đổi tên thành công, ngược lại trả về false (trường hợp cố gắng
đổi tên một tập tin đến mức nó di chuyển từ thư mục này sang thư mục khác
hoặc trùng tên với một tập tin khác đang tồn tại chẳng hạn).
Phương thức tiện ích thứ hai là delete(): xoá tập tin trên đĩa:
boolean delete()
Ta có thể sử dụng delete() xóa một thư mục nếu nó rỗng. delete() trả về
true nếu xóa thành công, ngược lại trả về false.
Hơn nữa, File hỗ trợ thể hiện giao diện Comparable, nên hàm
compareTo() cũng có mặt.
2. Thư mục
Thư mục là lớp File chứa danh sách các tập tin và thư mục khác. Khi
tạo đối tượng File và đặt nó là thư mục, hàm isDirectory() trả về true. Trong
trường hợp đó, ta có thể gọi list() để trích danh sách các file và thư mục khác
bên trong. Hàm này có hai dạng, thứ nhất là:
String[] list()
Danh sách các tập tin trả về trong mảng các String.
3. FilenameFilter
Ta thường muốn giới hạn số lượng tập tin do list() trả về, chỉ gồm các
tập tin có tên tương ứng với mẫu tên nào đó - bộ lọc. Để làm điều này, ta dùng
dạng thứ hai của hàm list():
String[] list(FilenameFilter FFObj)
Trong dạng này, FFObj là đối tượng của lớp thể hiện giao diện
FilenameFilter. FilenameFilter định nghĩa chỉ một phương thức đơn giản
accept(), nó gọi một lần cho từng tập tin trong một danh sách. Dạng mở rộng
của hàm này như sau:
boolean accept(File directory, String fileName)
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang17
Hàm accept() trả về true cho các tập tin trong thư mục directory và có
mặt trong danh sách (các tập tin tương xứng với filename).
Java 2 cung cấp thêm một dạng biến thể của list() là listFiles() rất hữu
ích. Các dạng của listFiles() như sau:
File[] listFiles()
File[] listFiles(FilenameFilter FFObj)
File[] listFiles(FileFilter FObj)
Các phương thức trên trả về mảng các đối tượng File thay vì mảng
chuỗi tên tập tin và hàm thứ hai trả về những file thỏa mãn FilenameFilter xác
định. Chỉ khác là trả về các đối tượng File, hai hàm đầu tiên làm việc tương tự
như các dạng hàm list() tương ứng.
Hàm thứ ba trả về các tập tin với đường dẫn thoả mãn FileFilter xác
định. FileFilter chỉ định nghĩa hàm đơn giản accept(), hàm này gọi một lần
cho mỗi tập tin trong danh sách. Dạng chung của nó sau đây:
boolean accept(File path)
Hàm accept() trả về true với các tập tin sẽ chứa trong danh sách.
Hai hàm tiện ích khác của File là mkdir() và mkdirs(). Hàm mkdir()
tạo ra một thư mục, trả về true nếu thành công. Trường hợp xảy ra lỗi khi
đường dẫn xác định trong đối tượng File đang tồn tại, hoặc là đường dẫn
không gồm tên thư mục cần tạo của File chưa tồn tại. Để tạo ra một thư mục
không cần có đường dẫn đã tồn tại ta dùng hàm mkdirs(), nó tạo ra một thư
mục và tất cả các thư mục cha của thư mục đó có mặt trong đường dẫn của
File.
V. Một số lớp và giao diện khác trong gói java.io
1. StreamTokenizer
Cách tốt hơn để nhận ra các mẫu dữ liệu trong stream nhập là dùng các
lớp xuất nhập khác của Java: StreamTokenizer. Tương tự như
StringTokenizer, StreamTokenizer ngắt InputStream thành nhiều từ (token).
Token là một nhóm ký tự biểu diễn một số hay một từ. StreamTokenizer có thể
nhận ra các chuỗi, số, định danh, hay chú thích. Kỹ thuật phân tích thành các
token được sử dụng rộng rãi trong phân tích cách viết, biên dịch, hoặc dùng
cho các chương trình xử lý ký tự vào.
Luồng này là luồng trung gian nên khởi dựng bằng cách tiếp nhận dữ
liệu từ một luồng InputStream khác:
StreamTokenizer(Reader inStream)
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang18
Sau khi dữ liệu có trong luồng, ta gọi phương thức public int
nextToken() throws IOExcetion để lấy ra từng Token. Nó trả về một trong
những giá trị sau:
Hằng Mô tả
TT_EO
F
Cuối file
ETT_E
OL
Cuối dòng
TT_NU
MBER
Token đã được
đọc là số
TT_W
ORD
Token đã được
đọc là từ
Lớp này sử dụng các biến nval, sval và ttype để lưu giá trị số, chuỗi, và kiểu
của token tương ứng.
2. Serialization
Java cung cấp cho ta khả năng ghi toàn bộ đối tượng xuống tập tin (đối
tượng đang ở một trạng thái nào đó). Sau đó ta có thể đem tập tin chứa đối
tượng đi khắp nơi nếu cần thì khôi phục đối tượng về trạng thái ban đầu, đưa
đối tượng vào bộ nhớ sử dụng đúng y như tình tràn trước khi nó được lưu
xuống đĩa. Các đối tượng có khả năng này được gọi là tuần tự hóa
(serialization)
Serialization là quá trình ghi trạng thái đối tượng vào stream byte. Điều
này rất tiện dụng khi ta muốn lưu trạng thái chương trình lâu bền, như vào tập
tin chẳng hạn. Một thời gian sau, ta có thể khôi phục lại các đối tượng đó bằng
quá trình ngược lại.
Serialization cần thiết để gọi hàm từ xa (Remote Method Invocation -
RMI). RMI cho phép một đối tượng Java trên máy này yêu cầu một hàm của
đối tượng Java trên máy khác. Đối tượng có thể xem như đối số cho các hàm từ
xa. Các máy gởi Serialization của đối tượng và chuyển chúng đi. Các máy
nhận sẽ giải ngược Serialization và khôi phục lại đối tượng.
Sau đây là một số lớp và giao diện hỗ trợ serialization.
Serializable
Trong Java các đối tượng muốn có khả năng ghi và lưu trữ được thành
tập tin thì phải cài đặt giao diện java.io.Serializable. Một đối tượng thể hiện
giao diện Serializable có thể lưu trữ và khôi phục trên nền tảng serialization.
Giao diện Serializable không định nghĩa gì cả. Nó chỉ đơn giản dùng chỉ ra đối
tượng nào được serialization. Nếu một lớp có tính serialization, tất cả các lớp
kế thừa của nó cũng vậy.
Các biến khai báo như một transient không thể serialization được. Các
biến static cũng vậy.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang19
ObjectOutputStream
Để ghi đối tượng xuống tập tin và hôm sau có thể đọc lại đối tượng đó
với trạng thái đã lưu lần trước, Java cung cấp cho ta lớp ObjectOutputStream
để thực hiện khả năng này. Lớp ObjectOutputStream ngoài khả năng ghi
được các kiểu dữ liệu sơ cấp như lớp DataOutputStream nó còn có khả năng
ghi được cả những đối tượng nhờ phương thức writeObject(),nó dùng ghi đối
tượng ra serialization, được khai báo như sau:
public void writeObject (Object obj) throws IOException
Tuy nhiên cần lưu ý là các đối tượng muốn ghi được xuống tập tin phải
thuộc lớp có cài đặt giao diện Serializable. Giao diện này quy định những ràng
buộc mà một đối tượng có thể được ghi xuống và đọc lên từ tập tin.
ObjectInputStream
Đối tác của lớp ObjectOutputStream là lớp ObjectInputStream, lớp
này để đọc các đối tượng trở lại.
Khả năng tuần tự hóa của đối tượng rất hữu dụng. Hầu như nó làm nền
tảng và được dùng xuyên suốt trong cơ chế hoạt động, truyền dữ liệu kiểu đối
tượng trong máy ảo Java và giữa những máy ảo Java với nhau trên mạng. Như
vậy, để truyền đối tượng đi trên mạng, bắt buộc chúng ta phải xây dựng đối
tượng với đặc tính Serializable.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang20
Chương trình minh họa
Khi đọc file: Chọn File->Open. Sẽ xuất hiện cửa sổ:
Sau đó chọn file cần mở. Nội dung của file sẽ được hiển thị lên vùng
TextArea. Khi click vào menu Edit thì sẽ xuất hiện cửa sổ sau:
Cho phép thao tác chỉnh sửa trên file mới mở. Và lưu lại thì vào File->Save
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang21
Kết luận
Sau thời gian nghiên cứu, tìm hiểu để thực hiện đồ án, được sự hướng
dẫn nhiệt tình của thầy giáo Nguyễn Tấn Khôi, em đã hoàn thành đề tài của
mình - đề tài Xử lý luồng và tập tin – đúng thời hạn. Những vấn đề đạt
được: Tìm hiểu được các luồng và cơ chế xử lý các luồng trong tập tin bằng
luồng. Có vị dụ minh họa.
Tuy nhiên, bên cạnh đó còn những hạn chế như: chương trình còn đơn
giản, không có nhiều chức năng.
Hướng phát triển: xây dựng chương trình hoàn thiện hơn và áp dụng
rộng rãi vấn đề nghiên cứu trong thực tiễn.
Đồ án Nguyên lý Hệ Điều Hành - Đề tài: Cơ chế xử lý luồng và tập tin trong Java
fanguoshou Trang22
Tài liệu tham khảo
v Java 2 Complete Reference
v Java 2 Certification Training Guide – NewRiders
v Java Help jdk141
v Giáo trình lý thuyết và thực hành – Java 2 Lập trình và ứng dụng –
Nhà xuất bản Thống kê – 2000
v Java lập trình mạng – Nguyễn Phương Lan – Hoàng Đức Hải – NXB
Giáo dục
Các file đính kèm theo tài liệu này:
- Luận văn tốt nghiệp- Giải pháp nâng cao hiệu quả hoạt động huy động vốn của Ngân hàng thương mại Việt Nam.pdf