BÁO CÁO THỰC HÀNH LẬP TRÌNH MẠNG DÙNG NGÔN NGỮ LẬP TRÌNH JAVA

ĐẠI HỌC ĐÀ NẴNG

TRƯỜNG ĐẠI HỌC BÁCH KHOA

KHOA CÔNG NGHỆ THÔNG TIN
Tel. (84-511) 736 949, Fax. (84-511) 842 771
Website: itf.ud.edu.vn, E-mail:

BÁO CÁO THỰC HÀNH

LẬP TRÌNH MẠNG
GVHD:
SINH VIÊN :
LỚP :
MSSV:
NHÓM:

ThS.NGUYỄN VĂN NGUYÊN
BÙI TẤN VIỆT
10T2
102152101166
11B

ĐÀ NẴNG, 3/2014


Mục Lục
Chương 1: CÁC BÀI TẬP THỰC HÀNH.......................................................................................................1
1.1 BÀI THỰC HÀNH BUỔI 1..................................................................................................................1
1.1.1 Bài tập 1..........................................................................................................................................1
1.1.2 Bài tập 2..........................................................................................................................................3

1.2 BÀI THỰC HÀNH BUỔI 2..................................................................................................................6
1.2.1 Đề bài:............................................................................................................................................6
1.2.2 Phần chương trình Client:...............................................................................................................6
1.2.3 Phần chương trình Server:..............................................................................................................7
1.2.4 Phần chương trình xử lý của Server:..............................................................................................7
1.2.5 Phần chương trình xử lý biểu thức:................................................................................................8
1.3 BÀI THỰC HÀNH BUỔI 3................................................................................................................14
1.3.1 Đề bài............................................................................................................................................14
1.3.2 Tạo các class tính toán ma trận.....................................................................................................14
1.3.3 Nhập ma trận:...............................................................................................................................14
1.3.4 Cộng, trừ ma trận..........................................................................................................................15
1.3.5 Nhân 2 ma trận.............................................................................................................................16
1.3.6 Chia 2 ma trận..............................................................................................................................17
1.3.7 Chương trình Client......................................................................................................................22
1.3.8 Chương trình Server:....................................................................................................................25
1.3.9 Demo............................................................................................................................................28
Chương 2: BÀI TẬP LÀM THÊM................................................................................................................30
2.1 ĐỀ BÀI................................................................................................................................................30
2.2 CHƯƠNG TRÌNH THÊM, SỬA, XÓA DANH SÁCH ĐẦU VÀO...................................................30
2.2.1 Chuẩn bị........................................................................................................................................30
2.2.2 Tìm kiếm trong danh sách............................................................................................................30
2.2.3 Sửa dữ liệu....................................................................................................................................31
2.2.4 Xóa dữ liệu...................................................................................................................................33
2.2.5 Thêm dữ liệu.................................................................................................................................34
2.2.6 Kiểm tra dữ liệu............................................................................................................................36
2.3 TRUYỀN NHẬN dỮ LIỆU GIỮA CLIENT – SERVER...................................................................37
2.3.1 Bên Client.....................................................................................................................................37
Page | 1

2.3.2 Bên Server....................................................................................................................................40
2.4 XỬ LÝ CỦA CLIENT.........................................................................................................................42
2.5 XỬ LÝ CỦA SERVER........................................................................................................................43
2.6 THUẬT TOÁN PHÂN CÔNG GIÁO VIÊN COI THI.......................................................................44
2.6.1 Lưu danh sách giáo viên và phòng thi..........................................................................................44
2.6.2 Sắp xếp giám thị...........................................................................................................................44
2.7 DEMO..................................................................................................................................................46

Page | 2


LỜI NÓI ĐẦU
Lập trình mạng là một trong những nhiệm vụ quan trong trong việc phát triển các ứng dụng doanh
nghiệp. Một chương trình mạng được viết ra để các chương trình trên các máy tính khác nhau có thể truyền
tin với nhau một cách hiệu quả và an toàn cho dù chúng được cài đặt trên mạng LAN, WAN hay mạng toàn
cầu Internet, đây là điều căn bản đối với sự thành công của nhiều hệ thông.
Java là ngôn ngữ lập trình hướng đối tượng thuần thúy với nhiều đặc trưng ưu việt so với các ngôn
ngữ lập trình hướng đối tượng khác như tính độc lập với nền, tính bảo mật,… Java là ngôn ngữ ngay từ khi
ra đời đã hướng đến lập trình mạng nên việc viết một chương trình lập trình mạng bằng Java dễ dàng hơn
nhiều so với các ngôn ngữ khác.

Page | 3


CHƯƠNG 1: CÁC

BÀI TẬP THỰC HÀNH

1.1 BÀI THỰC HÀNH BUỔI 1
1.1.1 Bài tập 1

1.1.1.1 Đề bài:
Dùng Java xây dựng chương trình lấy dữ liệu sinh viên từ Access và xuất ra bảng.

1.1.1.2 Thuật toán:
B1: Nạp trình điều khiển:
Lớp DriverManager chịu trách nhiệm nạp driver và tạo kết nối đến csdl: Class.forName(String)
Với String là "sun.jdbc.odbc.JdbcOdbcDriver"
B2: Tạo thông tin kết nối và đối tượng Connection:
Với Access: Connection con = DriverManager.getConnection("jdbc:odbc:testDB");
B3: Tạo đối tượng Statement để thực thi các lệnh sql.
Statement stmt = (java.sql.Statement) con.createStatement();
String sql = "Select * from SinhVien";
ResultSet rs = ((java.sql.Statement) stmt).executeQuery(sql);
ResultSetMetaData rsmd = rs.getMetaData();

B4: Lấy số cột của bảng và tên các cột lưu vào mảng Object header[];
B5: Lấy số dòng trong bảng:
B5.1: Biến rows = 0;
B5.2: Di chuyển tới hàng tiếp theo trong bảng, mỗi lần di chuyển thì tăng rows lên 1. Lặp cho
đến khi hết dòng.
B6: Tạo mảng dữ liệu 2 chiều có số hàng và số cột như trong bảng Access:
Object[][] data = new Object[rows][numberOfColumns];

B7: Di chuyển trên từng dòng bảng của Access, đọc dữ liệu của các trường và gán dữ liệu vào vị trí
tương ứng trên mảng data. Lặp cho đến khi hết dòng.
B8: Tạo đối tượng JTable để hiển thị dữ liệu trong data, có nội dung header chứa trong header[], có
thanh trượt JScrollBar và gắn vào 1 đối tượng JFrame để hiển thị.

1.1.1.3 Cài đặt
import

import
import
import
import
import
import
import
import

java.sql.Connection;
java.sql.DriverManager;
java.sql.ResultSet;
java.sql.ResultSetMetaData;
java.sql.SQLException;
java.sql.Statement;
javax.swing.JFrame;
javax.swing.JScrollPane;
javax.swing.JTable;

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 1


Báo cáo thực hành lập trình mạng

2014

public class Database {
public static void main(String arg[]) {
Object header[];
Object data[][];

int rows, i, j;
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection("jdbc:odbc:testDB");
Statement stmt = (java.sql.Statement) con.createStatement();
String sql = "Select * from SinhVien";
ResultSet rs = ((java.sql.Statement) stmt).executeQuery(sql);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
header = new Object[numberOfColumns];
for (j = 1; j <= numberOfColumns; j++) {
header[j - 1] = rsmd.getColumnLabel(j);
}
rows = 0;
while (rs.next())
rows++;
data = new Object[rows][numberOfColumns];
i = 0;
rs = ((java.sql.Statement) stmt).executeQuery(sql);
while (rs.next()) {
for (j = 1; j <= numberOfColumns; j++) {
data[i][j - 1] = rs.getObject(j);
i++;
}
rs.close();
stmt.close();
JFrame frame = new JFrame("Hiển thị cơ sở dữ liệu");
JTable tb = new JTable(data, header);
tb.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
JScrollPane jsp = new JScrollPane(tb);

frame.add(jsp);
frame.setVisible(true);
frame.setSize(300, 300);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}

Page 2

}


1.1.1.4 Demo
Dữ liệu trong Access

Dữ liệu xuất ra bảng:

1.1.2 Bài tập 2
1.1.2.1 Đề bài:
Dùng Java xây dựng giao diện của chương trình scan IP.

1.1.2.2 Cài đặt:
import java.awt.*;
import javax.swing.*;
public class ScanIP extends JFrame {
JTextField myIP, IP1_1, IP1_2, IP1_3, IP1_4, IP2_1, IP2_2, IP2_3, IP2_4;
JTextArea result;

JScrollPane jsp;
JButton scanbt, cancelbt, exitbt;
JRadioButton jrb1, jrb2, jrb3;
ButtonGroup bg;
JPanel pn, pn1, pn2, pn3, pn4, pn5;
public ScanIP(String a) {
super(a);
myIP = new JTextField("192.168.1.3");
myIP.setPreferredSize(new Dimension(200, 25));
myIP.setEditable(false);
pn1 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn1.setPreferredSize(new Dimension(550, 35));
pn1.add(new JLabel("Địa chỉ IP của máy: "));
pn1.add(myIP);
IP1_1 = new JTextField();
IP1_1.setPreferredSize(new Dimension(35, 25));
IP1_2 = new JTextField();
IP1_2.setPreferredSize(new Dimension(35, 25));

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 3


Báo cáo thực hành lập trình mạng

IP1_3 = new JTextField();
IP1_3.setPreferredSize(new Dimension(35, 25));
IP1_4 = new JTextField();
IP1_4.setPreferredSize(new Dimension(35, 25));
IP2_1 = new JTextField();
IP2_1.setPreferredSize(new Dimension(35, 25));

IP2_2 = new JTextField();
IP2_2.setPreferredSize(new Dimension(35, 25));
IP2_3 = new JTextField();
IP2_3.setPreferredSize(new Dimension(35, 25));
IP2_4 = new JTextField();
IP2_4.setPreferredSize(new Dimension(35, 25));
pn2 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn2.setPreferredSize(new Dimension(550, 40));
pn2.add(new JLabel("Từ địa chỉ: "));
pn2.add(IP1_1);
pn2.add(new JLabel(":"));
pn2.add(IP1_2);
pn2.add(new JLabel(":"));
pn2.add(IP1_3);
pn2.add(new JLabel(":"));
pn2.add(IP1_4);
pn2.add(new JLabel(" Đến địa chỉ: "));
pn2.add(IP2_1);
pn2.add(new JLabel(":"));
pn2.add(IP2_2);
pn2.add(new JLabel(":"));
pn2.add(IP2_3);
pn2.add(new JLabel(":"));
pn2.add(IP2_4);
jrb1 = new JRadioButton("Sử dụng 16 thread", true);
jrb1.setPreferredSize(new Dimension(150, 35));
jrb2 = new JRadioButton("Sử dụng 32 thread");
jrb2.setPreferredSize(new Dimension(150, 35));
jrb3 = new JRadioButton("Sử dụng 64 thread");
jrb3.setPreferredSize(new Dimension(150, 35));

bg = new ButtonGroup();
bg.add(jrb1);
bg.add(jrb2);
bg.add(jrb3);
pn3 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn3.setPreferredSize(new Dimension(550, 35));
pn3.add(jrb1);
pn3.add(jrb2);
pn3.add(jrb3);
result = new JTextArea();
result.setPreferredSize(new Dimension(500, 120));
result.setEditable(false);
jsp = new JScrollPane(result,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
pn4 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn4.setPreferredSize(new Dimension(520, 170));
pn4.add(new JLabel("Trình hiển thị kết quả scan:"));
pn4.add(jsp);
scanbt = new JButton("Scan");
scanbt.setPreferredSize(new Dimension(100, 30));
cancelbt = new JButton("Cancel");
cancelbt.setPreferredSize(new Dimension(100, 30));
exitbt = new JButton("Exit");
exitbt.setPreferredSize(new Dimension(100, 30));

Page 4

2014

pn5 = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn5.setPreferredSize(new Dimension(520, 170));
pn5.add(scanbt);
pn5.add(cancelbt);
pn5.add(exitbt);
pn = new JPanel(new FlowLayout(FlowLayout.CENTER));
pn.add(pn1);
pn.add(pn2);
pn.add(new JLabel("Lựa chọn số thread để thực hiện công việc"));
pn.add(pn3);
pn.add(pn4);
pn.add(pn5);
add(pn);
setTitle("Chương trình scan ip mạng lan");
setSize(550, 400);
setResizable(false);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setVisible(true);
}
public static void main(String arg[]) {
ScanIP tmp = new ScanIP("Scan ip");

}

}

1.1.2.3 Demo:

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 5


Báo cáo thực hành lập trình mạng

2014

1.2 BÀI THỰC HÀNH BUỔI 2
1.2.1 Đề bài:
Sửa lại chương trình có sẵn để Client có thể gửi 1 biểu thức cho sẵn với các toán tử “+, -, *, /,
sin, cos, tan, cot” lên cho Server xử lý và Server trả về kết quả cho Client.

1.2.2 Phần chương trình Client:
1.2.2.1 Thuật toán:
B1: Tạo giao diện GUI và socket để kết nối đến Server có địa chỉ IP và cổng cho trước.
B2: Tạo dòng vào ra dữ liệu vào ra gắn vào socket.
B3: Lấy chuỗi biểu thức nhập vào.
B4: Gửi cả chuỗi biểu thức qua Server và chờ kết quả nhận về.
B5: Hiển thị kết quả nhận về.

1.2.2.2 Cài đặt:
import
import
import
import

java.io.*;
java.net.*;
java.awt.*;
java.awt.event.*;

public class client implements ActionListener {
public static Panel pn1, pn2, pn3, pn;
public static TextField tfnhap = new TextField(5);
public static TextField tfkq = new TextField();
public static Label lbnhap = new Label();
public static Label lbkq = new Label();
public static Button bt1, bt2;
public static String s = "";
Socket socket;
DataOutputStream outputStream;
DataInputStream inputStream;
public client() throws UnknownHostException, IOException {
JFrame fr = new JFrame("Client");
fr.setSize(400, 200);
fr.setLayout(new GridLayout());
lbnhap.setText("Nhap vao chuoi can tinh toan");
lbkq.setText("Ket qua");
pn = new Panel(new GridLayout(5, 1));
pn1 = new Panel(new GridBagLayout());
bt1 = new Button("send");
bt2 = new Button("Exit");
pn.add(lbnhap);
pn.add(tfnhap);
pn.add(lbkq);
pn.add(tfkq);
pn1.add(bt1);
pn1.add(bt2);
pn.add(pn1);
fr.add(pn);

bt1.addActionListener(this);
bt2.addActionListener(this);
fr.show();

}

Page 6

socket = new Socket("127.0.0.1", 7777);
outputStream = new DataOutputStream(socket.getOutputStream());
inputStream = new DataInputStream(socket.getInputStream());


@Override
public void actionPerformed(ActionEvent e) {
double nhan;
if (e.getSource() == bt1) {
try {
String s = tfnhap.getText();
outputStream.writeUTF(s);
nhan = inputStream.readDouble();
tfkq.setText("" + nhan);
} catch (UnknownHostException e1) {
} catch (IOException e1) {}
}
if (e.getSource() == bt2)
System.exit(0);
}

}

1.2.3 Phần chương trình Server:
1.2.3.1 Thuật toán:
B1: Tạo ServerSocket kết nối với cổng cho sẵn.
B2: Server lắng nghe liên tục để chờ các client kết nối tới.
B2.1: Khi có Client kết nối tới thì Server sẽ tạo socket để giao tiếp, đồng thời tạo 1 đối tượng sử
dụng thread để xử lý yêu cầu.

1.2.3.2 Cài đặt:
import java.net.*;
public class server {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(7777);
while (true) {
Socket socket = serverSocket.accept();
server_Process t = new server_Process(socket);
t.start();
}
}
}

1.2.4 Phần chương trình xử lý của Server:
1.2.4.1 Thuật toán:
B1: Tạo dòng vào ra kết nối với socket.
B2: Chờ liên tục để nhận dữ liệu từ Client:
B2.1: Khi nhận được dữ liệu từ Client thì sẽ tiến hành xử lý tính toán lấy kết quả.
B2.2: Truyền kết quả cho Client.

1.2.4.2 Cài đặt:

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 7


Báo cáo thực hành lập trình mạng

2014

import java.io.*;
class server_Process extends Thread {
Socket socket;
public server_Process(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
DataInputStream inputStream;
DataOutputStream outputStream;
double kq;
try {

inputStream = new DataInputStream(socket.getInputStream());
outputStream = new DataOutputStream(socket.getOutputStream());
while (true) {
String snhan;
try {
snhan = inputStream.readUTF();
TinhBieuThuc t = new TinhBieuThuc();
kq = t.TinhToan(snhan);
outputStream.writeDouble(kq);
} catch (IOException ex) {

Logger.getLogger(server_Process.class.getName()).log(
Level.SEVERE, null, ex);
}
}
} catch (IOException ex) {
Logger.getLogger(server_Process.class.getName()).log(Level.SEVERE,
null, ex);
}
}
}

1.2.5 Phần chương trình xử lý biểu thức:
1.2.5.1 Thuật toán:
Để tính biểu thức nhập vào ta ứng dụng “kí pháp nghịch đảo Ba Lan”
B1: Ta chuyển biểu thức dạng trung tố nhập vào thành dạng hậu tố.
B2: Tính toán biểu thức hậu tố theo kí pháp nghịch đảo Ba Lan.
-

Chuyển từ biểu thức trung tố sang biểu thức hậu tố:

1.2.5.2 Thuật toán:
Thuật toán chuyển đổi này được phát minh bởi Edsger Dijkstra. Thuật toán dựa theo cơ chế
ngăn xếp. Ý tưởng chung của thuật toán là duyệt biểu thức từ trái sang phải.
B1: Nếu gặp một toán hạng (con số hoặc biến) thì nó ghi vào chuỗi kết quả.
B2: Nếu gặp dấu mở ngoặc, đưa nó vào ngăn xếp.
B3: Nếu gặp một toán tử O1, thực hiện theo 2 bước:

Page 8

B3.1: Chừng nào còn có một toán tử O2 ở đỉnh ngăn xếp và độ ưu tiên của O1 ≤ độ ưu tiên của
O2 thì lấy O2 ra khỏi ngăn xếp và ghi vào kết quả.
B3.2: Push O1 vào ngăn xếp
B4: Nếu gặp dấu “)” thì cứ lấy các toán tử trong ngăn xếp ra và ghi vào chuỗi kết quả cho đến khi
lấy được dấu “(“ ra khỏi ngăn xếp.
B5: Khi đã duyệt hết biểu thức trung tố, lần lượt lấy tất cả toán hạng (nếu có) từ ngăn xếp ra và ghi
vào chuỗi kết quả.
Ví dụ: Chuyển đổi biểu thức: 3 + sin(4) * 2
Phần tử

Thao tác

Stack

Chuỗi hậu tố

3

Ghi 3 vào kết quả

3

+

Push +

+

3

sin

Push sin

+ sin

3

(

Push (

+ sin (

3

4

Ghi 4 vào kết quả

+ sin (

34

)

Pop cho đến khi lấy
được ( ra khỏi ngăn
+ sin
xếp. Kết quả pop rag hi

vào kết quả

34

*

Pop sin ghi vào kết quả
+*
và push *

3 4 sin

2

Ghi 2 vào kết quả

3 4 sin 2

+*

Pop tất cả toán tử

3 4 sin 2 * +

1.2.5.3 Cài đặt:
public ArrayList<String> ChuyenDoi_HauTo(String str) {
String[] toanTu = { "+", "-", "*", "/", "sin", "cos", "tan",
"cot" };
// Loại bỏ tất cả dấu cách
str = str.replaceAll("\\s", "");

// Tách biểu thức thành các phần tử
StringTokenizer tk = new StringTokenizer(str, "()+-*/", true);
// Danh sách lưu các phần tử
ArrayList<String> tkList = new ArrayList<String>();
// Lấy danh sách các toán tử
List<String> operatorList = Arrays.asList(toanTu);
// Tạo ngăn xếp
Stack<String> stack = new Stack<String>();
// Tạo mảng kết quả
ArrayList<String> resultList = new ArrayList<String>();
// Lấy các phần tử cắt ra đưa vào danh sách
while (tk.hasMoreTokens()) {
tkList.add(tk.nextToken());
}

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 9


Báo cáo thực hành lập trình mạng

2014

// Chuyển đổi
for (String s : tkList) { // Lấy lần lượt các phần tử
if (operatorList.contains(s)) { // Toán tử
while (!stack.isEmpty() && DoUuTien(stack.peek()) > 0
&& DoUuTien(stack.peek()) >= DoUuTien(s)) {
resultList.add(stack.pop());
}
stack.push(s);

} else if (s.equals("(")) { // '('
stack.push(s);
} else if (s.equals(")")) { // ')'
// Lấy tất cả toán tử trong ngăn xếp cho đến khi gặp '('
while (!stack.peek().equals("("))
resultList.add(stack.pop());
stack.pop();
} else { // Toán hạng
resultList.add(s);
}
}
while (!stack.isEmpty()) {
// Đưa các toán tử còn lại trong ngăn xếp vào kết quả
resultList.add(stack.pop());
}
return resultList;
}
public int DoUuTien(String toanTu) {
if (toanTu.equals("+") || toanTu.equals("-"))
return 1;
if (toanTu.equals("*") || toanTu.equals("/"))
return 2;
if (toanTu.equals("sin") || toanTu.equals("cos")
|| toanTu.equals("tan") || toanTu.equals("cot"))
return 3;
return 0;
}

-

Tính toán biểu thức hậu tố:

1.2.5.4 Thuật toán:
Quá trình tính toán biểu thức hậu tố là đọc biểu thức từ trái sang phải:
B1: Nếu gặp một toán hạng (số hoặc là biến) thì push toán hạng đó vào ngăn xếp;
B2: Nếu gặp toán tử:
B2.1: Nếu là toán tử 1 ngôi thì pop 1 toán hạng ra khỏi ngăn xếp, push kết quả của toán hạng
với toán tử đó vào ngăn xếp.
B2.2: Nếu là toán tử 2 ngôi thì pop 2 toán hạng ra khỏi ngăn xếp, push kết quả của 2 toán hạng
với toán tử đó vào ngăn xếp.
B3: Quá trình tính kết thúc khi con số cuối cùng còn lại trong ngăn xếp chính là giá trị của biểu thức
đó.
Ví dụ: Tính biểu thức: 3 4 sin 2 * +

Page 10


Phần tử

Thao tác

Stack

3

Push 3

3

4

Push 4

34

Tính sin(4), push hết quả

3 [sin(4)]

2

Push 2

3 [sin(4)] 2

*

Tính sin(4)*2, push kết quả

3 [sin(4)*2]

+

Tính sin(4)*2 + 3, push kết quả

[sin(4)*2+3]

sin

1.2.5.5 Cài đặt:

public double TinhToan(String str) {
ArrayList<String> hauTo = ChuyenDoi_HauTo(str);
Stack<String> stack = new Stack<String>();
for (String token : hauTo) {
int priority = DoUuTien(token);
if (priority == 3) { // toán tử: sin cos tan cot
String o = stack.pop();
stack.push(Double.toString(TinhLuongGiac(token, o)));
} else if (priority == 1 || priority == 2) {
String o2 = stack.pop();
String o1 = stack.pop();
stack.push(Double.toString(Tinh(token, o1, o2)));
} else {
stack.push(token);
}

}

}
return Double.parseDouble(stack.pop());

public double TinhLuongGiac(String toanTu, String toanHang) {
if (toanTu.equals("sin")) {
return sin(Double.parseDouble(toanHang));
}
if (toanTu.equals("cos")) {
return cos(Double.parseDouble(toanHang));
}
if (toanTu.equals("tan")) {
return (sin(Double.parseDouble(toanHang)) / cos(Double

.parseDouble(toanHang)));
}
if (toanTu.equals("cot")) {
return (cos(Double.parseDouble(toanHang)) / sin(Double
.parseDouble(toanHang)));
}
return 0;
}
public double Tinh(String toanTu, String toanHang1, String toanHang2) {
if (toanTu.equals("+")) {
return Double.parseDouble(toanHang1) +
Double.parseDouble(toanHang2);
}

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 11


Báo cáo thực hành lập trình mạng

2014

if (toanTu.equals("-")) {
return Double.parseDouble(toanHang1) Double.parseDouble(toanHang2);
}
if (toanTu.equals("*")) {
return Double.parseDouble(toanHang1) *
Double.parseDouble(toanHang2);
}
if (toanTu.equals("/")) {
return Double.parseDouble(toanHang1) /

Double.parseDouble(toanHang2);
}
return 0;
}

-

Tính lượng giác sin(x):

Thuật toán:
Ta có công thức triển khai tính sin(x):
Ta sử dụng 1 biến temp để tính giá trị từng phân tử, sau đó cộng vào kết quả chung, kết quả tính
được của phần tử trước sẽ được sử dụng để tính tiếp phần tử phía sau, thuật toán được triển khai theo
công thức:

Việc tìm kết quả bằng cách trên sẽ lặp liên tục và kết thúc khi:
Cài đặt:
public double sin(double x) {
double ketQua = 0;
double temp = x, i = 1;
do {

ketQua += temp;
temp = (-1) * temp * x * x / ((++i) * (++i));
} while (temp > 10E-10 || temp < -10E-10);
return ketQua;
}

-

Tính lượng giác cos(x):

Thuật toán:
Ta có công thức triển khai tính cos(x):

Page 12


Ta sử dụng 1 biến temp để tính giá trị từng phân tử, sau đó cộng vào kết quả chung, kết quả tính
được của phần tử trước sẽ được sử dụng để tính tiếp phần tử phía sau, thuật toán được triển khai theo
công thức:

Việc tìm kết quả bằng cách trên sẽ lặp liên tục và kết thúc khi:
Cài đặt:
public double cos(double x) {
double ketQua = 0;
double temp = 1, i = 0;
do {

ketQua += temp;
temp = (-1) * temp * x * x / ((++i) * (++i));
} while (temp > 10E-10 || temp < -10E-10);
return ketQua;
}

-

Tính lượng giác tan(x) và cot:

Thuật toán:

Tan(x) và cot(x) được suy ra từ sin(x) và cos(x) từ công thức:

1.2.5.6 Demo:
Chương trình Client:

1.3 BÀI THỰC HÀNH BUỔI 3
1.3.1 Đề bài
Gửi 2 ma trận từ Client qua Server. Server tính toán +, -, *, / 2 ma trận rồi gửi kết quả về cho
Client.

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 13


Báo cáo thực hành lập trình mạng

2014

1.3.2 Tạo các class tính toán ma trận
Để tiện cho việc thực hiện bài toán, ta sẽ định nghĩa 2 lớp là MaTran và PhepToan_MaTran:

1.3.2.1 Cài đặt:
a) Lớp MaTran được định nghĩa như sau:
class MaTran {
double maTran[][];
int n, m; // Số dòng, số cột
public
public
public
public

MaTran(int dong, int cot) {}
MaTran(File file){}
void Nhap_MaTran() {}
void In_MaTran() {}

}

b) Lớp PhepToan_MaTran được định nghĩa như sau:
public class
public
public
public
public
public
public
public
public
}

PhepToan_MaTran {
MaTran Cong(MaTran A, MaTran B) {}
MaTran Tru(MaTran A, MaTran B) {}
MaTran Nhan(MaTran A, MaTran B) {}
MaTran DoiDong(int i, int j, MaTran X) {}
double DinhThuc(MaTran Ori) {}
double PhanTu_MaTran_PhuHop(MaTran B, int i, int j) {}
MaTran ChuyenVi(MaTran C) {}
MaTran Chia(MaTran A, MaTran B) {}

1.3.3 Nhập ma trận:

Nhập bằng file: Trong file, các số ngăn cách nhau bởi kí tự tab - ‘\t’ - và mỗi hàng phân biệt
nhau bởi enter.

1.3.3.1 Thuật toán:
B1: Lấy 1 file chỉ định.
B2: Tạo 1 luồng đọc vào của file được chọn.
B3: Tạo 1 bộ đệm để lưu dữ liệu cho luồng đọc vào đó.
// Tiếp theo, đọc từng dòng trong bộ đệm để lấy dữ liệu dưới dạng chuỗi:
B4: Đọc dòng đầu tiên trong bộ đệm để lấy giá trị hàng và cột.
B4.1: Cắt chuỗi đọc vào dựa theo kí tự tab ‘\t’ để tách số, lưu vào mảng String token;
B4.2: Đổi các phần tử trong mảng token thành kiểu số thích hợp rồi gán vào số hàng, số cột.
B5: Tạo ma trận có số hàng và số cột đó.
B6: Cho i = 0. Đọc 1 dòng trong bộ đệm cho mỗi lần lặp.
Lặp khi đọc chưa tới dòng cuối cùng trong bộ đệm và (i < số hàng):

Page 14


B6.1: Cắt chuỗi đọc vào dựa theo kí tự tab ‘\t’ để tách số, lưu vào token;
B6.2: Cho j = 0. Lặp khi (j < số cột) và (j < độ dài mảng của token):
B6.2.1: Đổi kiểu số cho phần tử token[j] và gán vào phần tử maTran[i][j].
B6.2.2: j++;
B6.3: i++;

1.3.3.2 Cài đặt:
public void Nhap_MaTran(File file) {
Reader in;
BufferedReader br;
String token[],temp;
try {

in = new InputStreamReader(new FileInputStream(file.getPath()), "UTF-

8");

br = new BufferedReader(in);
temp = br.readLine();
token = temp.split("\t");
m = Integer.parseInt(token[0]);
n = Integer.parseInt(token[1]);

}
}

}
}
}
}

maTran = new double[m][n];
for (int i = 0; i < m && (temp = br.readLine()) != null; i++) {
token = temp.split("\t");
for (int j = 0; j < token.length && j < n; j++)
maTran[i][j] = Double.parseDouble(token[j]);
}
catch (NullPointerException e) {
catch (FileNotFoundException e) {
JOptionPane.showMessageDialog(null,
"Không tìm thấy file", "Loi!",
JOptionPane.ERROR_MESSAGE);
catch (UnsupportedEncodingException e) {

catch (NumberFormatException e) {
catch (IOException e) {

}

1.3.4 Cộng, trừ ma trận
1.3.4.1 Thuật toán:
Giả sử có sẵn 2 ma trận A và B và ma trận C dùng để lưu kết quả. Phép toán cộng và trừ 2 ma
trận có thuật toán tương tự nhau, chỉ khác nhau dấu phép toán.
B1: Kiểm tra số hàng và số cột của A và B có bằng nhau, nếu có:
B1.1: Tạo ma trận C[số hàng A][số cột A].
B1.2: Cho i = 0. Lặp khi (i < số hàng):
B1.2.1: Cho j = 0. Lặp khi (j < số cột):
B1.2.1.1: C[i][j] = A[i][j] +/- B[i][j];
B1.2.1.2: j++;

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 15


Báo cáo thực hành lập trình mạng

2014

B1.2.2: i++;
B2: Nếu không: 2 ma trận không thể thực hiện phép toán.

1.3.4.2 Cài đặt:
public MaTran Cong(MaTran A, MaTran B) {
MaTran C = new MaTran(0, 0);
if (A.n == B.n && A.m == B.m) {

C = new MaTran(A.m, A.n);
for (int i = 0; i < A.m; i++)
for (int j = 0; j < A.n; j++)
C.maTran[i][j] = A.maTran[i][j] + B.maTran[i][j];
} else {
System.out.println("Không thể thực hiện được phép cộng 2 ma trận vì
khác kích thước!");
}
return C;
}
public MaTran Tru(MaTran A, MaTran B) {
MaTran C = new MaTran(0, 0);
if (A.n == B.n && A.m == B.m) {
C = new MaTran(A.m, A.n);
for (int i = 0; i < A.m; i++)
for (int j = 0; j < A.n; j++)
C.maTran[i][j] = A.maTran[i][j] - B.maTran[i][j];
} else {
System.out.println("Không thể thực hiện được phép trừ 2 ma trận vì
khác kích thước!");
}
return C;
}

1.3.5 Nhân 2 ma trận
1.3.5.1 Thuật toán:
Giả sử có sẵn 2 ma trận A và B và ma trận C dùng để lưu kết quả. Phép toán nhân ma trận A với
ma trận B.
Phần tử C[i][k] của ma trận C được tính bằng công thức:
Khi đó để đảm bảo 2 ma trận A và B có thể nhân với nhau thì số cột A = số hàng B và ma trận C

được tạo ra sẽ có số hàng = số hàng A và số cột = số cột B.
B1: Nếu số cột ma trận A == số hàng ma trận B:
B1.1: Tạo ma trận C[số hàng A][số cột B].
B1.2: Cho i = 0. Lặp khi (i < số dòng A):
B1.2.1: Cho k = 0. Lặp khi (k < số cột B):

Page 16


B1.2.1.1: C[i][k] = 0;
B1.2.1.2: Cho j = 0. Lặp khi (j < số cột A):
B1.2.1.2.1: C[i][k] += A[i][j] * B[j][k];
B1.2.1.2.2: j++;
B1.2.1.3: k++;
B1.2.2: i++;
B2: Nếu không: 2 ma trận không thể thực hiện phép nhân.

1.3.5.2 Cài đặt:
public MaTran Nhan(MaTran A, MaTran B) {
MaTran C = new MaTran(0, 0);
if (A.n == B.m) {
C = new MaTran(A.m, B.n);
for (int i = 0; i < A.m; i++)
for (int k = 0; k < B.n; k++) {
C.maTran[i][k] = 0;
for (int j = 0; j < A.n; j++)
C.maTran[i][k] += A.maTran[i][j] * B.maTran[j][k];
}
} else {
System.out.println("Không thể thực hiện được phép trừ 2 ma trận vì số

cột ma trận A không bằng số hàng ma trận B!");
}
return C;
}

1.3.6 Chia 2 ma trận
Trong toán học, không có phép chia ma trận, nhưng ta có thể định nghĩa phép chia ma trận
thông qua phép nhân ma trận:
Phép chia ma trận A cho ma trận B:

1.3.6.1 Thuật toán:
Giả sử có sẵn 2 ma trận A và B và ma trận C dùng để lưu kết quả. Phép toán chia ma trận A với
ma trận B.
Cách tìm ma trận khả nghịch thông qua ma trận :

Trong đó:

là định thức của ma trận B.
là ma trận phụ hợp của B.
Ma trận B phải là ma trận vuông cấp n.

Ma trận B khả nghịch khi và chỉ khi định thức ma trận B != 0

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 17


Báo cáo thực hành lập trình mạng

2014

Ma trận vuông B cấp n, phần tử . Ma trận phụ hợp của B kí hiệu là và được xác định.

=
Trong đó:

là phần bù đại số của phần tử , nghĩa là
Ma trận là ma trận chuyển vị của ma trận X

là ma trận cấp n - 1 có được từ ma trận B bằng cách bỏ hàng i và cột j của B.
Ma trận chuyển vị bằng cách đổi hàng thành cột hoặc cột thành hàng của ma trận X.
a) Tính định thức của 1 ma trận vuông:
Ta chuyển ma trận vuông thành ma trận tam giác trên rồi tính tích đường chéo chính của ma trận
tam giác đó.
Giả sử với ma trận vuông A cấp n có phần tử aij.
B1: Biến đổi ma trận vuông A thành ma trận tam giác trên
B1.1: Lặp i = 1…n-:
B1.1.1: Nếu aij == 0:
public MaTran
DoiDong(int
i, int
X) {
B1.1.1.1:
Tìm j sao cho
aij �j,
0, MaTran
j = i+1…n
for (int k = 0; k < X.n; k++) {
X.maTran[i][k]
+=hoán
X.maTran[j][k];

B1.1.1.2:
Nếu j<= n thì
đổi dòng i và dòng j cho nhau
X.maTran[j][k] = X.maTran[i][k] - X.maTran[j][k];
B1.1.1.3:
Ngược lại kết
vì dữ liệu không hợp lệ
X.maTran[i][k]
-= thúc
X.maTran[j][k];
}
B1.1.2: Lặp
return
X; j = i+1…n
}
B1.1.2.1: m = -aij / aii
public double
DinhThuc(MaTran
{ ajk + aik * m
B1.1.2.2:
Lặp k = i…n: Ori)
ajk =
int i, j, k;
B2: Tínhdouble
định thức
m, dau = 1, dinhThuc;
// Sao chép ma trận
B2.1:
dt = 1
MaTran X = new MaTran(Ori.n, Ori.m);

for
0; i B2.2:
Lặp(ii == 1…n:
= dt *i++)
aii
for (j = 0; j < X.m; j++)
X.maTran[i][j] = Ori.maTran[i][j];
B3: Trả về kết quả:
dinhThuc = 1;
Cài đặt: for (i = 0; i < X.n - 1; i++) {
if (X.maTran[i][i] == 0) {
for (j = i + 1; j < X.n; j++)
if (X.maTran[j][i] != 0) {
X = DoiDong(i, j, X);
dau *= -1;
break;
}
if (j == X.n)
return 0;
}
for (j = i + 1; j < X.n; j++) {
m = -X.maTran[j][i] / X.maTran[i][i];
for (k = i; k < X.n; k++)
X.maTran[j][k] += m * X.maTran[i][k];
}
}
for (i = 0; i < X.n; i++)
dinhThuc *= X.maTran[i][i];
dinhThuc *= dau;

Page 18
}

return dinhThuc;


b) Tính :
Với ma trận vuông B cấp, loại bỏ hàng i và cột j ta sẽ có
B1: Nhập vào ma trận B, i và j là dòng và cột cần bỏ trong ma trận B.
B2: Tạo ma trận vuông temp cấp n – 1.
B3: Cho x = 0, z = -1. Lặp khi x < n:
B3.1: Nếu z != i: z++;
B3.2: Cho y = 0, t = 0. Lặp khi y < n:
B3.2.1: Nếu x != i và y != j
B3.2.1: temp[i][j] = B[i][j];
B3.2.2: ++t;
B3.3.2: ++y;
public
double
B3.3:
++x PhanTu_MaTran_PhuHop(MaTran B, int i, int j) {
MaTran temp = new MaTran(B.n - 1, B.n - 1);

B4: Nếu i + j lẻ trả về kết quả DinhThuc(temp);

(inttrảxvề
= kết
0, quả
z =- DinhThuc(temp);

-1; x < B.n; x++) {
B5: Nếufor
không,

Cài đặt:

if (x != i)
z++;
for (int y = 0, t = 0; y < B.n; y++) {
if (x != i && y != j) {
temp.maTran[z][t] = B.maTran[x][y];
t++;
}
}

}
if ((i + j) % 2 == 0)
return DinhThuc(temp);
else
return -DinhThuc(temp);

Họ}và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 19


Báo cáo thực hành lập trình mạng

2014

c) Tìm ma trận chuyển vi:
Với ma trận vuông C cấp n, ma trận chuyển vị của nó chính là ma trận được tạo thành bằng cách

đổi chỗ hàng và cột của C.
B1: Tạo ma trận vuông temp cấp n.
B2: Cho i = 0. Lặp khi i < n:
B2.1: Cho j = 0, k = 0. Lặp khi j < n:
B2.1.2: temp[i][j] = C[k][i];
B2.1.2: k++, j++;
B2.2: i++;
B3: trả về ma trận temp;
Cài đặt:
public MaTran ChuyenVi(MaTran C) {
MaTran temp = new MaTran(C.n, C.n);
for (int i = 0; i < C.n; i++) {
for (int j = 0, k = 0; j < C.n; j++, k++) {
temp.maTran[i][j] = C.maTran[k][i];
}
}
return temp;
}

Page 20


d) Chia 2 ma trận A và B:
B1: Tạo ma trận C(0, 0)
B2: Nếu B là ma trận vuông: // Tạo ma trận khả nghịch
B2.1: dinhThuc = Định thức ma trận B;
B2.2: Nếu dinhThuc != 0:
B2.2.1: Tạo mới ma trận C[B.n][B.n];
B2.2.1: Nếu B.n == 1: C[0][0] = (1 / C[0][0]) / dinhThuc;
B2.2.2: Ngược lại:

B2.2.2.1: Cho i = 0. Lặp khi i < B.n:
B2.2.2.1: Cho j = 0. Lặp khi j < B.n:
C[i][j] = PhanTu_MaTran_PhuHop(B, i, j) / dinhThuc;
B2.2.3: C= ChuyenVi(C);
B2.2.4: C = Nhan(A, C);
B3: Return C;
Cài đặt:
public MaTran Chia(MaTran A, MaTran B) {
double det;
MaTran C = new MaTran(0, 0);
if (B.n == B.m) {
det = DinhThuc(B);
if (det != 0) {
C = new MaTran(B.n, B.n);
if (B.n == 1)
C.maTran[0][0] = (1 / C.maTran[0][0]) / det ;
else {
for (int i = 0; i < B.n; i++) {
for (int j = 0; j < B.n; j++) {
C.maTran[i][j] = PhanTu_MaTran_PhuHop(B,i,j)
/ det;
}
}
}
C = ChuyenVi(C);
C = Nhan(A, C);
} else {
System.out.println("Không thể thực hiện được phép chia 2 ma trận
vì ma trận B không có ma trận nghịch đảo!");
}

} else {
System.out.println("Không thể thực hiện được phép chia 2 ma trận vì ma
trận B không không phải ma trận vuông!");
}
return C;
}

Họ và tên: Bùi Tấn Việt – Lớp: 10T2 – Nhóm 11BPage 21