Đề 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

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)

pdf132 trang | Chia sẻ: lylyngoc | Ngày: 16/11/2013 | Lượt xem: 1551 | Lượt tải: 0download
Bạn đang xem nội dung 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, để tải tài liệu về máy 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:

  • pdfLuậ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
Luận văn liên quan