Mục lục
Mục tiêu của bài học
Sau khi học xong bài học sinh viên có khả năng:
– Hiểu được khái niệm mảng, chuỗi và hàm trong Java.
– Vận dụng mảng, hàm và chuỗi giải được các bài toán đơn giản trong thực tế.
Mảng (array) là gì?
– Mảng là tập hợp các phần tử có cùng kiểu được cấp phát vùng nhớ liên tục.
– Truy xuất các phần tử mảng bằng chỉ số, bắt đầu là số 0.
Ví dụ: int[] x = {1,3,5,7,9,11}.
– Ưu điểm:
+ Sử dụng để lưu trữ nhiều giá trị thay vì phải khai báo nhiều biến.
+ Truy xuất bằng chỉ số mảng cũng dễ dàng, nhanh chóng.
+ Hỗ trợ việc truy xuất, sắp xếp dữ liệu đơn giản.
– Nhược điểm:
+ Do số phần tử không thay đổi nên khó bổ sung, thêm bớt.
+ Cần vùng nhớ liên tục lớn.
– Có 02 kiểu mảng: Mảng 1 chiều và mảng nhiều chiều
– Khai báo: <kiểu dữ liệu> <tên mảng>[];
<kiểu dữ liệu>[] <tên mảng>;
– Khởi tạo kích thước mảng
a = new datatype[size];
– Khai báo và khởi tạo kích thước mảng
datatype[] a = new datatype[size];
– Khai báo và khởi tạo các phần tử
datatype[] a = {element1, element2,…};
* Lưu ý: Dùng chỉ số của mảng để truy xuất từng phần tử và dùng thuộc tính length để xác định số phần tử của mảng.
Ví dụ:
int a[] = new int[5]; // Phần khai báo và khởi tạo
int a[] = {1, 2, 3, 4, 5}; // Khai báo, khởi tạo và khởi tạo
for (int i = 0; i<a.length; i++) // length thuộc tính lấy số phần tử của mảng
System.out.println(a[i]); // Truy xuất phần tử thứ i của mảng
Bài tập:
1- Viết chương trình nhập số nguyên n>0, sau đó cho xuất ra màn hình lập phương từng phần tử của dãy số từ 1 đến n.
2- Viết chương trình sắp xếp dãy số nguyên theo chiều tăng dần (hoặc giảm dần).
Gợi ý:
Bài 1
package edu.tvn;
import static java.lang.Math.pow;
import java.util.Scanner;
public class Array1D {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Nhập số nguyên n: ");
int n = input.nextInt();
do {
if (n < 0) {
System.out.print("n không đúng, nhập lại! ");
n = input.nextInt();
}
} while (n < 0);
int a[] = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = i + 1;
System.out.print(" " + (int) pow(a[i], 3));
}
System.out.println();
}
}
Bài 2
package edu.tvn;
public class ArraySort {
public static void main(String[] args) {
int a[] = {4, 2, 1, 7, 12, 8};
int temp = a[0];
for (int i = 0; i < a.length - 1; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[i] > a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for (int k = 0; k < a.length; k++) {
System.out.print(" " + a[k]);
}
System.out.println();
}
}
Mảng có thể copy?
Phương thức arraycopy của lớp System có thể sao chép một chuỗi này sang chuỗi khác, cú pháp: System.arraycopy(src, srcPos, dest, destPos, length).
+ src là mảng nguồn.
+ srcPos là vị trí bắt đầu copy.
+ dest là mảng đích.
+ destPos là vị trí bắt đầu của mảng đích.
+ length là số phần tử cần copy.
Ví dụ:
package edu.trannhuom;
public class CopyArraySample {
public static void main(String[] args) {
char[] Array1 = { 'h', 't', 't', 'p', 's',
':', '/', '/', 't', 'h', 'a', 'y', 'n','h','u','o','m' };
char[] Array2 = new char[10];
System.arraycopy(Array1, 8, Array2, 0, 9);
System.out.println(new String(Array2));
}
}
Một số phương thức cho mảng 1 chiều
Java cung cấp một số phương thức tĩnh tiện ích cho mảng, như: sắp xếp, gán các giá trị cho toàn bộ các phần tử của mảng, tìm kiếm, so sánh, … phương thức được định nghĩa trong lớp Arrays.
// Chuyển một mảng có kiểu T sang danh sách (List) có kiểu T
// T là kiểu đối tượng (Object)
public static <T> List<T> asList(T… a)
// Tìm kiếm chỉ số của một giá trị xuất hiện trong mảng.
// (Sử dụng thuật toán tìm kiếm nhị phân (binary search))
public static int binarySearch(type[] a, type key)
// Sắp xếp các giá trị của mảng tăng dần
public static void sort(type[] a)
// Copy các phần tử của một mảng để tạo một mảng mới với độ dài chỉ định
public static int[] copyOf(type[] original, type newLength)
// Copy một phạm vi chỉ định các phần tử của mảng để tạo một mảng mới
public static double[] copyOfRange(type[] original, int from, int to)
// So sánh hai mảng
public static boolean equals(type[] a, long[] a2)
// Gán cùng một giá trị cho tất cả các phần tử của mảng.
public static void fill(type[] a, type val)
// Chuyển một mảng thành chuỗi (string)
public static String toString(type[] a)
Ví dụ:
package edu.trannhuom;
import java.util.Arrays;
import java.util.List;
public class ArraysSample {
public static void main(String[] args) {
// Khai báo một mảng 5 phần tử kiểu nguyên thủy (primitive)
int[] arr = {15, 5, 10, 30, 25};
System.out.println("Gọi hàm toString để hiển thị mảng: ");
// Chuyển một mảng thành chuỗi (string)
System.out.println(Arrays.toString(arr));
// Sắp xếp các giá trị của mảng tăng dần
Arrays.sort(arr);
System.out.println("Sau khi gọi hàm sort: ");
// Chuyển một mảng thành chuỗi (string)
System.out.println(Arrays.toString(arr));
// Tìm kiếm chỉ số của một giá trị xuất hiện trong mảng.
// Mảng phải được sắp xếp trước khi gọi hàm binarySearch
int index = Arrays.binarySearch(arr, 30);
if (index < 0) {
System.out.println("Không tìm thấy giá trị");
} else {
System.out.println("Tìm thấy giá trị 30 tại index " + index);
}
// Gán cùng một giá trị cho tất cả các phần tử của mảng.
Arrays.fill(arr, 11);
System.out.println("Sau khi gọi hàm fill: ");
// Chuyển một mảng thành chuỗi (string)
System.out.println(Arrays.toString(arr));
// Khai báo một mảng 5 phần tử kiểu đối tượng (object)
Integer[] arr2 = {15, 5, 10, 30, 25};
// Chuyển một mảng có kiểu T sang danh sách (List) có kiểu T
// List: chỉ sử dụng được với object, không sử dụng kiểu nguyên thủy (primitive)
List<Integer> list = Arrays.asList(arr2);
System.out.println("Sau khi gọi hàm asList: ");
// Chuyển một mảng thành chuỗi (string)
System.out.println(list);
}
}
Mảng nhiều chiều
Mảng nhiều chiều là mảng của mảng
Khai báo của mảng 2 chiều, có 03 cách khai báo:
// Khai báo một mảng có 5 dòng, 10 cột
Kieu_du_lieu[][] ten_bien_1 = new Kieu_du_lieu[5][10];
// Khai báo một mảng 2 chiều có 5 dòng
// (Mảng của mảng)
Kieu_du_lieu[][] ten_bien_2 = new Kieu_du_lieu[5][];
// Khai báo một mảng 2 chiều, chỉ định giá trị các phần tử
Kieu_du_lieu[][] ten_bien_3 = new Kieu_du_lieu[][] {
{ value00, value01, value02 }
{ value10, value11, value12 }
};
i: tương ứng chỉ số của dòng
j: là chỉ số của cột trong mảng 2 chiều
Ví dụ:
package edu.trannhuom;
public class Array2D {
public static void main(String[] args)
{
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
System.out.print(" arr[" + i + "][" + j + "] = "+ arr[i][j]);
}
System.out.println(" \n");
}
}
}Bài tập: Vận dụng ví dụ trên để giải bài toán cộng 2 ma trận 3×3.
Gợi ý:
package edu.trannhuom;
public class ArrayPlusMatrix {
public static void main(String[] args)
{
int[][] mt1 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
int[][] mt2 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
int[][] mtkq = new int[3][3];
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
mtkq[i][j]=mt1[i][j]+mt2[i][j];
System.out.print(" [" + i + "][" + j + "] = "+ mtkq[i][j]);
}
System.out.println(" \n");
}
}
}Chuỗi (String) trong Java
– Trong những ngôn ngữ lập trình khác (C chẳng hạn), một chuỗi được xem như một xâu ký tự.
– Trong java thì khác, java cung cấp một class String để làm việc với đối tượng dữ liệu chuỗi cùng các thao tác trên đối tượng dữ liệu này.
– String là kiểu dữ liệu được sử dụng nhiều trong Java.
Thao tác với String
1.toLowerCase(): Đổi in thường
2.toUpperCase(): Đổi in hoa
3.trim(): Cắt các ký tự trắng 2 đầu chuỗi
4.length(): Lấy độ dài chuỗi
5.substring(): Lấy chuỗi con
6.charAt(index): Lấy ký tự tại vị trí
7.replaceAll(find, replace): Tìm kiếm và thay thế tất cả
8.Split(separator): Tách chuỗi thành mảng
9.equals(): So sánh bằng có phân biệt hoa/thường
10.equalsIgnoreCase(): So sánh không phân biệt hoa/thường
11.Contains(): Kiểm tra có chứa hay không
12.startsWith(): Kiểm tra có bắt đầu bởi hay không
13.endsWith(): Kiểm tra có kết thúc bởi hay không
14.matches(): So khớp với hay không?
15.indexOf(): Tìm vị trí xuất hiện đầu tiên của chuỗi con
16.lastIndexOf(): Tìm vị trí xuất hiện cuối cùng của chuỗi con
Ví dụ:
package edu.trannhuom;
public class MethodOfString {
public static void main(String[] args) {
String targetString = "Java is fun to learn";
String s1= "JAVA";
String s2= "Java";
String s3 = " Hello Java ";
System.out.println("Char at index 2(third position): " + targetString.charAt(2));
System.out.println("After Concat: "+ targetString.concat("-Enjoy-"));
System.out.println("Checking equals ignoring case: " +s2.equalsIgnoreCase(s1));
System.out.println("Checking equals with case: " +s2.equals(s1));
System.out.println("Checking Length: "+ targetString.length());
System.out.println("Replace function: "+ targetString.replace("fun", "easy"));
System.out.println("SubString of targetString: "+ targetString.substring(8));
System.out.println("SubString of targetString: "+ targetString.substring(8, 12));
System.out.println("Converting to lower case: "+ targetString.toLowerCase());
System.out.println("Converting to upper case: "+ targetString.toUpperCase());
System.out.println("Triming string: " + s3.trim());
System.out.println("searching s1 in targetString: " + targetString.contains(s1));
System.out.println("searching s2 in targetString: " + targetString.contains(s2));
char [] charArray = s2.toCharArray();
System.out.println("Size of char array: " + charArray.length);
System.out.println("Printing last element of array: " + charArray[3]);
}
}
Hàm là gì?
– Hàm có thể gọi là một đoạn mã nguồn thực hiện một công việc cụ thể nào đó. Ví dụ: Arrays.sort(array).
– Hàm có thể có hoặc không có tham số. Tham số là dữ liệu đầu vào để hàm thực hiện.
– Hàm có thể có kết quả trả về hoặc không.
– Hàm có thể có hàm dựng sẵn hoặc người sử dụng định nghĩa.
Cú pháp hàm do người dùng định nghĩa
Static <datatype> <name> ([<parameters>]){
<method body>
[return value]
}
<datatype>: kiểu dữ liệu trả về
<name>: tên hàm
[<parameters>]: danh sách tham số (có thể có hoặc không).
<method body>: thân hàm – mã thực hiện.
[return value]: trả kết quả về (có thể có hoặc không, nếu <datatype> là void thì không cần return, ngược lại bắt buộc phải có).
Ví dụ 1:
class MyClass {
static void sayHello() {
System.out.println("Hello World!");
}
public static void main(String[ ] args) {
sayHello();
}
}Ví dụ 2:
class MyClass {
static int sum(int val1, int val2) {
return val1 + val2;
}
public static void main(String[ ] args) {
int x = sum(2, 5);
System.out.println(x);
}
}Hàm toán học Math
JDK định nghĩa sẵn một số lớp tiện dụng, một trong số là lớp Math cung cấp các hàm về toán học. Bạn không cần phải tạo đối tượng lớp Math vì các hàm trong lớp đó là static, để gọi hàm chỉ đơn giản viết tên lớp Math và tên phương thức cần gọi.
Trước khi gọi các hàm Math, bạn có thể import package để khỏi phải viết đầy đủ tên pack, như sau:
import java.lang.Math;
Math.PI hằng số PI
double g45 = Math.PI/4;
Math.abs() trả về giá trị tuyệt đối của tham số
int a = Math.abs(10); // 10 int b = Math.abs(-20); // 20
Math.ceil() trả về giá trị double là số làm tròn tăng bằng giá trị số nguyên gần nhất
double c = Math.ceil(7.342); // 8.0
Math.floor() trả về double là số làm tròn giảm
double f = Math.floor(7.343); // 7.0
Math.max() lấy số lớn trong hai số
int m = Math.max(10, 20); // 20
Math.min lấy số nhỏ
int m = Math.min(10, 20); // 10
Math.pow lấy lũy thừa (cơ-số, số mũ)
double p = Math.pow(2, 3); // 8.0
Math.Math.sqrt() khai căn
double a = Math.sqrt(9);//3
Math.sin(), Math.cos() sin và cos của góc đơn vị radian
double s = Math.sin(Math.PI/2);//1
Math.random() sinh số double ngẫu nhiên từ 0 đến 1
double r = Math.random();
Math.toDegrees() đổi góc radian thành độ
double goc = Math.toDegrees(Math.PI/2); //90
Math.toRadians() đổi góc đơn vị độ ra radian
double goc = Math.toRadians(45);//0.7853981633974483
Tham chiếu (reference type), tham trị (value type) là gì?
Biến /tham số trong Java có hai kiểu là kiểu giá trị và kiểu tham chiếu
Kiểu biến/tham số tham trị thì giá trị của biến được lưu chính xác tại địa chỉ bộ nhớ (nói cách khác địa chỉ bộ nhớ có lưu giá trị). Do vậy, khi chuyển nó trong các tham số, các phép toán nó truyền giá trị chứ không truyền bản thân địa chỉ của biến trong bộ nhớ.
Ví dụ:
public class MyClass {
static void addOneTo(int num) {
num = num + 1;
}
public static void main(String[] args) {
int x = 5;
addOneTo(x);
System.out.println(x);
}
}Kiểu biến/tham số tham chiếu (Reference Type) nó lưu trữ bên trong nó một địa chỉ tham khảo (chứ không phải giá trị) mà địa chỉ đó sẽ dùng để truy cập bộ nhớ khi lưu / lấy dữ liệu của biến (chính là các đối tượng).
Khi bạn tạo ra đối tượng từ các lớp, bạn đã tạo ra một biến kiểu tham chiếu.
Ví dụ 1:
public class Person {
private String Name;
private int Age;
public Person(String name) {
this.Name = name;
}
public void setAge(int age) {
this.Age = age;
}
public int getAge() {
return this.Age;
}
}Ví dụ 2:
public class MyClass {
public static void main(String[] args) {
Person j;
j = new Person("John");
j.setAge(20);
// j là đối tượng do nó là tham số tham chiếu, hàm celebrateBirthday tương tác với chính đối tượng
// lớp Person mà biến trỏ tới
celebrateBirthday(j);
System.out.println(j.getAge());
}
static void celebrateBirthday(Person p) {
p.setAge(p.getAge() + 1);
}
}
