So sánh khác trong java
|
So sánh chuỗi trong java Show Chúng ta có thể so sánh chuỗi trong java trên cơ sở nội dung và tham chiếu của nó. Nó được sử dụng trong xác thực (bởi phương thức equals()), sắp xếp (theo phương thức compareTo()), so sánh tham chiếu(với toán tử ==), vv Có ba cách để so sánh chuỗi trong java:
1) So sánh chuỗi bằng phương thức equals() Phương thức equals() được sử dụng để so sánh nội dung của 2 chuỗi. Lớp String cung cấp 2 phương thức equals():
Ví dụ 1: public class Teststringcomparison1 { public static void main(String[] args) { // TODO Auto-generated method stub String s1 = "Hello"; String s2 = "Hello"; String s3 = new String("Hello"); String s4 = "Hallo"; System.out.println(s1.equals(s2));//true System.out.println(s1.equals(s3));//true System.out.println(s1.equals(s4));//false } }Kết quả:  Ví dụ 2: public class Teststringcomparison2 { public static void main(String[] args) { // TODO Auto-generated method stub String s1 = "Hello"; String s2 = "HELLO"; System.out.println(s1.equals(s2));//false System.out.println(s1.equalsIgnoreCase(s2));//true } }Kết quả: 2) So sánh chuỗi bằng toán tử == Toán tử == được sử dụng để so sánh tham chiếu (không phải giá trị) của 2 chuỗi. Ví dụ 3: public class Teststringcomparison3 { public static void main(String[] args) { // TODO Auto-generated method stub String s1 = "Hello"; String s2 = "Hello"; String s3 = new String("Hello"); System.out.println(s1 == s2);//true (vì cả 2 cùng tham chiếu instance giống nhau) System.out.println(s1 == s3);//false(vì s3 tham chiếu instance mà không ở trong Pool) } }Kết quả: 3) So sánh chuỗi bằng phương thức compareTo() Phương thức compareTo () so sánh các giá trị theo thứ tự từ điển và trả về một giá trị số nguyên mô tả nếu chuỗi đầu tiên nhỏ hơn, bằng hoặc lớn hơn chuỗi thứ hai. Giả sử s1 và s2 là hai biến chuỗi. Nếu:
Ví dụ 4: public class Teststringcomparison4 { public static void main(String[] args) { // TODO Auto-generated method stub String s1 = "Hello"; String s2 = "Hello"; String s3 = "Java"; System.out.println(s1.compareTo(s2)); System.out.println(s1.compareTo(s3)); System.out.println(s3.compareTo(s1)); } }Kết quả:
Chúng ta có thể so sánh chuỗi trong Java dựa trên cơ sở nội dung và tham chiếu. Nó được sử dụng trong sự xác nhận bởi phương thức equal(), sắp xếp bởi phương thức compareTo(), so khớp tham chiếu bởi toán tử ==, … So sánh chuỗi bởi phương thức equals() trong JavaPhương thức equals() so sánh nội dung ban đầu của chuỗi. Nó so sánh tính cân bằng của các giá trị chuỗi. Lớp String cung cấp hai phương thức:
Ví dụ 1 class Sosanhchuoi1{ public static void main(String args[]){ String s1="Vietjack"; String s2="Vietjack"; String s3=new String("Vietjack"); String s4="Vietjackteam"; System.out.println(s1.equals(s2));//true System.out.println(s1.equals(s3));//true System.out.println(s1.equals(s4));//false } }Quảng cáo Ví dụ 2 class Sosanhchuoi2{ public static void main(String args[]){ String s1="Vietjack"; String s2="VIETJACK"; System.out.println(s1.equals(s2));//false System.out.println(s1.equalsIgnoreCase(s3));//true } }So sánh chuỗi với toán tử == trong JavaToán tử == trong Java so sánh các tham chiếu chứ không phải so sánh các giá trị. Ví dụ: class Sosanhchuoi3{ public static void main(String args[]){ String s1="Vietjack"; String s2="Vietjack"; String s3=new String("Vietjack"); System.out.println(s1==s2);//true (boi vi ca hai cung tham chieu toi cung instance) System.out.println(s1==s3);//false(boi vi s3 tham chieu toi instance duoc tao khong phai trong Pool) } }So sánh chuỗi bởi phương thức compareTo() trong JavaPhương thức compateTo() so sánh các giá trị theo từ điển và trả về một giá trị nguyên miêu tả rằng nếu chuỗi đầu tiên là nhỏ hơn, bằng hoặc lớn hơn chuỗi thứ hai. Giả sử s1 và s2 là hai chuỗi. Nếu:
Quảng cáo class Teststringcomparison4{ public static void main(String args[]){ String s1="Vietjack"; String s2="Vietjack"; String s3="Doan"; System.out.println(s1.compareTo(s2));//0 System.out.println(s1.compareTo(s3));//1(boi vi s1 > s3) System.out.println(s3.compareTo(s1));//-1(boi vi s3 < s1 ) } }
Đã có app VietJack trên điện thoại, giải bài tập SGK, SBT Soạn văn, Văn mẫu, Thi online, Bài giảng....miễn phí. Tải ngay ứng dụng trên Android và iOS.
Các bạn có thể mua thêm khóa học JAVA CORE ONLINE VÀ ỨNG DỤNG cực hay, giúp các bạn vượt qua các dự án trên trường và đi thực tập Java. Khóa học có giá chỉ 300K, nhằm ưu đãi, tạo điều kiện cho sinh viên cho thể mua khóa học. Nội dung khóa học gồm 16 chuơng và 100 video cực hay, học trực tiếp tại https://www.udemy.com/tu-tin-di-lam-voi-kien-thuc-ve-java-core-toan-tap/ Bạn nào có nhu cầu mua, inbox trực tiếp a Tuyền, cựu sinh viên Bách Khoa K53, fb: https://www.facebook.com/tuyen.vietjack Loạt bài hướng dẫn của chúng tôi dựa một phần trên nguồn tài liệu của: Tutorialspoint.com Follow facebook cá nhân Nguyễn Thanh Tuyền https://www.facebook.com/tuyen.vietjack để tiếp tục theo dõi các loạt bài mới nhất về Java,C,C++,Javascript,HTML,Python,Database,Mobile.... mới nhất của chúng tôi.
Trước hết chúng ta cần phân biệt kiểu nguyên thủy (Primitive type) và kiểu tham chiếu (reference type) trong java. Trong Java chúng ta có 8 kiểu nguyên thủy.
Tất cả các kiểu khác đều mở rộng từ Object, chúng là các kiểu tham chiếu. Trước hết bạn phải hiểu rằng, Java không đảm bảo rằng mỗi biến sẽ tương ứng với một vị trí trên bộ nhớ. chẳng hạn Java sẽ tối ưu theo cách biến 'i' sẽ được lưu trữ trên bộ đăng ký (register), hoặc thậm trí không được lưu trữ ở đâu cả, nếu trình biên dịch nhận thấy rằng bạn không bao giờ sử dụng giá trị của nó, hoặc nó có thể được dõi theo thông qua code và sử dụng các giá trị phù hợp một cách trực tiếp. // Tạo biến 'a', và gán giá trị 100. int a = 100; // Gán giá trị mới cho 'a' a = 200; // Tạo biến 'b', gán b = a. int b = a; Khi đó Java thực hiện các thao tác sau:
Khi bạn sử dụng toán tử new (Ví dụ new Object()), Java sẽ tạo ra một thực thể mới trên bộ nhớ. Bạn khai báo một biến và khởi tạo giá trị của nó thông qua toán tử new, chẳng hạn Object a = new Object(); Java sẽ tạo ra một thực thể mới trong bộ nhớ, và một tham chiếu 'a' trỏ tới vị trí bộ nhớ của thực thể vừa được tạo ra. Khi bạn khai báo một biến b Object b = a; không có thực thể nào được tạo ra trong bộ nhớ, Java chỉ tạo ra một tham chiếu 'b', trỏ tới vị cùng vị trí mà 'a' đang trỏ tới. // Khai báo và khởi tạo đối tượng. Object a = new Object(); // Gán giá trị mới cho đối tượng 'a'. a = new String("Text"); // Khai báo đối tượng 'b', và gán 'a' cho nó. Object b = a;
Trong Java có 2 kiểu so sánh:
Toán tử equals(..) là một phương thức chỉ dùng cho các kiểu tham chiếu. Với kiểu nguyên thủy chúng ta chỉ có duy nhất một cách so sánh bằng toán tử ==, các kiểu nguyên thủy so sánh với nhau thông qua giá trị của chúng. // Tạo ra một biến 'a', gán bởi giá trị 200 cho nó. // Một vùng bộ nhớ (1) được tạo ra chứa giá trị 200. int a = 200; // Tạo ra một biến 'b', gán giá trị 200 cho nó. // Một vùng bộ nhớ (2) được tạo ra chứa giá trị 200. int b = 200; // Mặc dù 'a' và 'b' trỏ tới 2 vùng bộ nhớ khác nhau. // So sánh a == b sẽ cho kết quả true. // Vì kiểu nguyên thủy so sánh với nhau dựa trên giá trị. boolean c = (a == b);
Khi bạn so sánh 2 đối tượng tham chiếu theo toán tử ==, có nghĩa là so sánh vị trí mà 2 đối tượng tham chiếu này trỏ tới. Về bản chất là kiểm tra xem 2 tham chiếu đó có cùng trỏ tới một thực thể trên bộ nhớ hay không. package org.o7planning.tutorial.comparation; public class ReferenceEeDemo { public static void main(String[] args) { // Chú ý: Với String 2 cách khởi tạo đối tượng dưới đây là không giống nhau: String str1 = "String 1"; String str2 = new String("String 1"); // Toán tử 'new' tạo ra vùng bộ nhớ (1) // chứa String "This is text" // Và 's1' là một tham chiếu trỏ đến vùng (1). String s1 = new String("This is text"); // Toán tử 'new' tạo ra vùng bộ nhớ (2) // Chứa String "This is text" // Và 's2' là một tham chiếu trỏ đến (2) String s2 = new String("This is text"); // Sử dụng toán tử == so sánh 's1' và 's2'. // Kết quả ra false. // Nó rõ ràng khác với suy nghĩ của bạn. // Lý do là với kiểu tham chiếu // toán tử == so sánh vị trí trên bộ nhớ mà chúng trỏ tới. boolean e1 = (s1 == s2); // false System.out.println("s1 == s2 ? " + e1); // Không có toán tử 'new' nào. // Java tạo ra một tham chiếu có tên 'obj' // Và trỏ tới vùng bộ nhớ mà 's1' đang trỏ tới. Object obj = s1; // 2 tham chiếu 'obj' và 's1' đang cùng trỏ tới 1 vùng bộ nhớ. // Kết quả trả về là true. boolean e2 = (obj == s1); // true System.out.println("obj == s1 ? " + e2); } } Kết quả chạy chương trình s1 == s2 ? false obj == s1 ? true
StringComparationDemo.java package org.o7planning.tutorial.comparation; public class StringComparationDemo { public static void main(String[] args) { String s1 = new String("This is text"); String s2 = new String("This is text"); // So sánh s1 và s2 thông qua phương thức equals(..) boolean e1 = s1.equals(s2); // Kết quả sẽ là true System.out.println("first comparation: s1 equals s2 ? " + e1); s2 = new String("New s2 text"); boolean e2 = s1.equals(s2); // Kết quả sẽ là false System.out.println("second comparation: s1 equals s2 ? " + e2); } }Kết quả chạy chương trình: first comparation: s1 equals s2 ? true second comparation: s1 equals s2 ? false Phương thức equals(Object) là phương thức có sẵn của class Object, mọi class con đều được thừa kế method này. Trong một số tình huống bạn có thể ghi đè method này tại class con. package org.o7planning.tutorial.comparation.equals; // Số lượng Huy chương public class NumberOfMedals { // Số huy chương vàng private int goldCount; // Số huy chương bạc. private int silverCount; // Số huy chương đồng private int bronzeCount; public NumberOfMedals(int goldCount, int silverCount, int bronzeCount) { this.goldCount = goldCount; this.silverCount = silverCount; this.bronzeCount = bronzeCount; } public int getGoldCount() { return goldCount; } public int getSilverCount() { return silverCount; } public int getBronzeCount() { return bronzeCount; } // Ghi đè phương thức equals(Object) của lớp Object. @Override public boolean equals(Object other) { // Nếu other = null thì trả về false. if (other == null) { return false; } // Nếu 'other' không phải là kiểu NumberOfMedals // thì trả về false. if (!(other instanceof NumberOfMedals)) { return false; } NumberOfMedals otherNoM = (NumberOfMedals) other; if (this.goldCount == otherNoM.goldCount && this.silverCount == otherNoM.silverCount && this.bronzeCount == otherNoM.bronzeCount) { return true; } return false; } }
NumberOfMedalsComparationDemo.java package org.o7planning.tutorial.comparation.equals; public class NumberOfMedalsComparationDemo { public static void main(String[] args) { // Thành tích của đội Mỹ. NumberOfMedals american = new NumberOfMedals(40, 15, 15); // Thành tích của đội Nhật. NumberOfMedals japan = new NumberOfMedals(10, 5, 20); // Thành tích của đội Hàn Quốc NumberOfMedals korea = new NumberOfMedals(10, 5, 20); System.out.println("Medals of American equals Japan ? " + american.equals(japan)); System.out.println("Medals of Korea equals Japan ? " + korea.equals(japan)); } }Medals of American equals Japan ? false Medals of Korea equals Japan ? true String vốn là một class mà các đối tượng của nó có thể so sánh với nhau, theo quy tắc chữ cái. Ví dụ sau đây minh họa cách sắp xếp một mảng String sử dụng các phương thức tiện ích có sẵn trong Java.
StringArraySortingDemo.java package org.o7planning.tutorial.sorting; import java.util.Arrays; public class StringArraySortingDemo { public static void main(String[] args) { String[] fruits = new String[] { "Pineapple", "Apple", "Orange", "Banana" }; // Sử dụng phương thức tĩnh của lớp Arrays để sắp xếp. // Arrays.sort(Object[]) Arrays.sort(fruits); for (int i = 0; i < fruits.length; i++) { System.out.println("fruits " + i + " : " + fruits[i]); } } }fruits 0 : Apple fruits 1 : Banana fruits 2 : Orange fruits 3 : Pineapple // Bạn viết một lớp mô phỏng một diễn viên (Actor). // Bạn muốn sắp xếp thứ tự các diễn viên theo nguyên tắc: // So sánh họ (lastName) trước, rồi so sánh theo tên (firstName). public class Actor { // Tên private String firstName; // Họ private String lastName; }
package org.o7planning.tutorial.sorting;
// Để so sánh được với nhau, lớp Actor cần thi hành interface Comparable.
public class Actor implements Comparable package org.o7planning.tutorial.sorting; public class ActorSortingDemo { public static void main(String[] args) { Actor actor1 = new Actor("Mischa", "Barton"); Actor actor2 = new Actor("Christian", "Bale"); Actor actor3 = new Actor("Joan", "Collins"); Actor actor4 = new Actor("Gemma", "Arterton"); Actor actor5 = new Actor("Daniel", "Craig"); Actor[] actors = new Actor[] { actor1, actor2, actor3, actor4, actor5 }; // Sử dụng một thuật toán để sắp xếp lại mảng trên. // Sắp xếp tăng dần các đối tượng Actor. for (int i = 0; i < actors.length; i++) { for (int j = i + 1; j < actors.length; j++) { // Nếu actors[j] < actors[i] // Thì thực hiện việc tráo đổi vị trí với nhau. if (actors[j].compareTo(actors[i]) < 0) { // Sử dụng một biến tạm thời. Actor temp = actors[j]; actors[j] = actors[i]; actors[i] = temp; } } } // On ra các phần tử mảng. for (int i = 0; i < actors.length; i++) { System.out.println(actors[i].getFirstName() + " " + actors[i].getLastName()); } } } Gemma Arterton Christian Bale Mischa Barton Joan Collins Daniel Craig Sử dụng Arrays.sort(Object[]) để sắp xếp ví dụ trên: package org.o7planning.tutorial.sorting; import java.util.Arrays; public class ActorSortingDemo2 { public static void main(String[] args) { Actor actor1 = new Actor("Mischa", "Barton"); Actor actor2 = new Actor("Christian", "Bale"); Actor actor3 = new Actor("Joan", "Collins"); Actor actor4 = new Actor("Gemma", "Arterton"); Actor actor5 = new Actor("Daniel", "Craig"); Actor[] actors = new Actor[] { actor1, actor2, actor3, actor4, actor5 }; // Sử dụng Arrays.sort(Object[]) để sắp xếp. Arrays.sort(actors); // In ra các phần tử mảng. for (int i = 0; i < actors.length; i++) { System.out.println(actors[i].getFirstName() + " " + actors[i].getLastName()); } } } Bạn có thể tham khảo thêm tài liệu Java Collection Framework tại:
package org.o7planning.tutorial.sorting;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ListSortingDemo {
public static void main(String[] args) {
Actor actor1 = new Actor("Mischa", "Barton");
Actor actor2 = new Actor("Christian", "Bale");
Actor actor3 = new Actor("Joan", "Collins");
Actor actor4 = new Actor("Gemma", "Arterton");
Actor actor5 = new Actor("Daniel", "Craig");
// Một danh sách chứa các phần tử có khả năng so sánh với nhau.
// (Comparable)
List Các ví dụ trên chúng ta sắp xếp một mảng hoặc một danh sách. Bản thân các phần tử của nó có khả năng so sánh với nhau (Do thi hành interface Comparable). Câu hỏi đặt ra với các đối tượng mà class của nó không thi hành interface Comparable, thì có thể sắp xếp được không. Trong trường hợp này bạn cần cung cấp 1 bộ so sánh (Comparator) nó là quy tắc để sắp xếp các đối tượng kia. package org.o7planning.tutorial.comparator; public class Person { private int age; private String fullName; public Person(String fullName, int age) { this.fullName = fullName; this.age = age; } public int getAge() { return age; } public String getFullName() { return fullName; } }
package org.o7planning.tutorial.comparator;
import java.util.Comparator;
// Lớp này thực hiện interface Comparator
ComparatorSortingDemo.java package org.o7planning.tutorial.comparator; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class ComparatorSortingDemo { public static void main(String[] args) { Person person1 = new Person("Marry", 20); Person person2 = new Person("Tom", 21); Person person3 = new Person("Daniel", 21); Person person4 = new Person("Mischa", 18); Person person5 = new Person("Christian", 20); // Một mảng chưa được sắp xếp. Person[] array = new Person[] { person1, person2, person3, person4, person5 }; // Sắp xếp mảng, sử dụng:Person: 18 / Mischa Person: 20 / Christian Person: 20 / Marry Person: 21 / Daniel Person: 21 / Tom ------------------------ Person: 18 / Mischa Person: 20 / Christian Person: 20 / Marry Person: 21 / Daniel Person: 21 / Tom |
