โถ Map ์ธํฐํ์ด์ค
Map ์ธํฐํ์ด์ค๋ ์๋ฃ๋ฅผ ์์ผ๋ก ๊ด๋ฆฌํ๋ ๋ฐ ํ์ํ ๋ฉ์๋๊ฐ ์ ์๋์ด ์๋ค.
Key-value ์์ผ๋ก ์ด๋ฃจ์ด์ง ๊ฐ์ฒด์ key ๊ฐ์ ์ ์ผํ๋ฉฐ value ๊ฐ์ ์ค๋ณต๋ ์ ์๋ค.
Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ ๋ด๋ถ์ ์ผ๋ก ํด์ ์๊ณ ๋ฆฌ์ฆ์ ์ํด ๊ตฌํ๋์ด ์๋ค.
โ
โ
โ
*HashMap ํด๋์ค
HashMap์ Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค ์ค ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ค.
HashMap์์ ์๋ฃ๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐฉ์์ 'ํด์ ๋ฐฉ์'์ด๋ค.
ํด์ ๋ฐฉ์์ ์๋ฃ๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ์ 'ํด์ ํ ์ด๋ธ'์ด๋ผ ํ๋ค.
key ๊ฐ์ด ์ ํด์ง๋ฉด ๊ทธ์ ๋์ํ๋ ํด์ ํ ์ด๋ธ์ ์ ์ฅ ์์น๊ฐ ์ ํด์ง๋๋ฐ ์ด๋ฐ ์์น๋ฅผ ๊ณ์ฐํ๋ ํจ์๊ฐ 'ํด์ ํจ์'์ด๋ค.
์๋ฃ ์ถ๊ฐ ์๋๋ ๊ฒ์ ์๋๊ฐ ์๋นํ ๋น ๋ฅด๋ค๋ ์ฅ์ ์ด ์๋ค.
์๋ก ๋ค๋ฅธ key ๊ฐ์ ๊ฐ์ index(์ ์ฅ ์์น)๊ฐ ๋ฐํ๋๋ ์ถฉ๋์ด ๋ฐ์ํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ๋ฐ๋ผ์ ํด์ ํ ์ด๋ธ์ ๋ฐ์ดํฐ๋ฅผ ๊ฝ ์ฑ์ฐ์ง ์๊ณ ์ ์ ์์ค์ด ๋๋ฉด ํ ์ด๋ธ์ ํ์ฅํด ์ถฉ๋ ๋ฐ์ ํ๋ฅ ์ ๋ฎ์ถ๋ค.
๋ํ, Map ์ธํฐํ์ด์ค์์ ์ฌ์ฉํ๋ key ๊ฐ์ ์ค๋ณต๋ ์ ์์ผ๋ฏ๋ก equals( ) ๋ฉ์๋์ hashcode( ) ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
โ
โ key ๊ฐ์ ์ค๋ณต๋ ์ ์๊ณ value ๊ฐ์ ์ค๋ณต๋ ์ ์๋ค.
โ
โ
โ
*HashMap์ ํ์ฉํด ํ์ ๊ด๋ฆฌ ํ๋ก๊ทธ๋จ ๊ตฌํํ๊ธฐ
โ
MemberHashMap.java
package map.hashmap;
import java.util.HashMap;
import java.util.Iterator;
import collection.Member;
public class MemberHashMap {
private HashMap<Integer, Member> hashMap;
public MemberHashMap() {
hashMap = new HashMap<Integer, Member>();
}
public void addMember(Member member) { // key-value ์์ผ๋ก ์ถ๊ฐ
hashMap.put(member.getMemberID(), member); // HashMap์ ํ์์ ์ถ๊ฐํ๋ ๋ฉ์๋
}
public boolean removeMember(int memberID) { // HashMap์์ ํ์์ ์ญ์ ํ๋ ๋ฉ์๋
if (hashMap.containsKey(memberID)) { // HashMap์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ํค ๊ฐ์ธ ํ์ ์์ด๋๊ฐ ์๋ค๋ฉด
hashMap.remove(memberID); // ํด๋น ํ์ ์ญ์
return true;
}
System.out.println(memberID + "๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.");
return false;
}
public void showAllMember() { // Iterator๋ฅผ ์ฌ์ฉํด ์ ์ฒด ํ์์ ์ถ๋ ฅํ๋ ๋ฉ์๋
Iterator<Integer> ir = hashMap.keySet().iterator();
while (ir.hasNext()) { // ๋ค์ key๊ฐ ์์ผ๋ฉด
int key = ir.next(); // key ๊ฐ์ ๊ฐ์ ธ์์
Member member = hashMap.get(key); // key๋ก๋ถํฐ value ๊ฐ์ ธ์ค๊ธฐ
System.out.println(member);
}
System.out.println();
}
}
MemberHashMapTest.java
package map.hashmap;
import collection.Member;
public class MemberHashMapTest {
public static void main(String[] args) {
MemberHashMap memberHashMap = new MemberHashMap();
Member memberLee = new Member(1001, "์ด์ง์");
Member memberSon = new Member(1002, "์๋ฏผ๊ตญ");
Member memberPark = new Member(1003, "๋ฐ์ํค");
Member memberHong = new Member(1004, "ํ๊ธธ๋");
memberHashMap.addMember(memberLee);
memberHashMap.addMember(memberSon);
memberHashMap.addMember(memberPark);
memberHashMap.addMember(memberHong);
memberHashMap.showAllMember();
memberHashMap.removeMember(1004); // ํ์ ์์ด๋(key ๊ฐ)๊ฐ 1004์ธ ํ์ ์ญ์
memberHashMap.showAllMember();
}
}
<์คํ ๊ฒฐ๊ณผ>
โ
โโ
โ
*TreeMap ํด๋์ค
Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค ์ค key ๊ฐ์ผ๋ก ์๋ฃ๋ฅผ ์ ๋ ฌํ๋ ค๋ฉด TreeMap์ ์ฌ์ฉํ ์ ์๋ค.
TreeMap์ TreeSet๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ก ๊ตฌํ๋์๋ค.
key ๊ฐ์ผ๋ก ์ ๋ ฌํ๋ฏ๋ก key ๊ฐ์ ํด๋นํ๋ ํด๋์ค์ Comparable์ด๋ Comparator ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด์ผ ํ๋ค.
โโ
MemberTreeMap.java
package map.treemap;
import java.util.Iterator;
import java.util.TreeMap;
import collection.Member;
public class MemberTreeMap {
private TreeMap<Integer, Member> treeMap;
public MemberTreeMap() {
treeMap = new TreeMap<Integer, Member>();
}
public void addMember(Member member) {
treeMap.put(member.getMemberID(), member); // key-value ์์ผ๋ก ์ถ๊ฐ
}
public boolean removeMember(int memberID) {
if (treeMap.containsKey(memberID)) {
treeMap.remove(memberID); // key ๊ฐ์ ๋ง๋ ์๋ฃ ์ญ์
return true;
}
System.out.println(memberID + "๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.");
return false;
}
public void showAllMember() {
Iterator<Integer> ir = treeMap.keySet().iterator();
while (ir.hasNext()) {
int key = ir.next();
Member member = treeMap.get(key);
System.out.println(member);
}
System.out.println();
}
}
-ํค ๊ฐ์ keySet( ) ํจ์๋ฅผ ํตํด ๋ฝ์ Iterator๋ฅผ ์ด์ฉํ์ฌ ์ ์ฅ๋ ๊ฐ์ ๋ฝ์ ์ธ ์ ์๋ค.
โ
โ
MemberTreeMapTest.java
package map.treemap;
import collection.Member;
public class MemberTreeMapTest {
public static void main(String[] args) {
MemberTreeMap memberTreeMap = new MemberTreeMap();
Member memberPark = new Member(1003, "๋ฐ์ํค");
Member memberLee = new Member(1001, "์ด์ง์");
Member memberHong = new Member(1004, "ํ๊ธธ๋");
Member memberSon = new Member(1002, "์๋ฏผ๊ตญ"); // ํ์ ์์ด๋ ์์์ ์๊ด์์ด ํ์ ์ถ๊ฐ
memberTreeMap.addMember(memberPark);
memberTreeMap.addMember(memberLee);
memberTreeMap.addMember(memberHong);
memberTreeMap.addMember(memberSon);
memberTreeMap.showAllMember();
memberTreeMap.removeMember(1004); // ํ์ ์์ด๋(key ๊ฐ)๊ฐ 1004์ธ ํ์ ์ญ์
memberTreeMap.showAllMember();
}
}
<์คํ ๊ฒฐ๊ณผ>
์ฐ์ต๋ฌธ์ Q5) StudentTest์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๊ฐ ๋ค์์ฒ๋ผ ๋์ค๋๋ก Student ํด๋์ค๋ฅผ ๊ตฌํํด๋ณด๋ผ.
์กฐ๊ฑด. 100:์ก์ค๊ธฐ ๊ฐ ์ถ๋ ฅ๋์ง์๊ฒ ํ ๊ฒ |
โ
1. studentID ๋ฅผ int ํ์ผ๋ก ํ๊ธฐ
โโ
Student.java
package test;
public class Student {
private String studentID;
private String studentName;
public Student(String studentID, String studentName) {
this.studentID = studentID;
this.studentName = studentName;
}
public int hashCode() {
return studentID;
}
public String toString() {
return studentID + ":" + studentName;
}
public boolean equals(Object obj) {
if (obj instanceof Student) {
Student student = (Student) obj;
if (this.studentID == student.studentID)
return true;
else
return false;
}
return false;
}
}
StudentTest.java
package test;
import java.util.HashSet;
public class StudentTest {
public static void main(String[] args) {
HashSet<Student> set = new HashSet<Student>();
set.add(new Student("100", "ํ๊ธธ๋"));
set.add(new Student("200", "๊ฐ๊ฐ์ฐฌ"));
set.add(new Student("300", "์ด์์ "));
set.add(new Student("400", "์ ์ฝ์ฉ"));
set.add(new Student("100", "์ก์ค๊ธฐ"));
System.out.println(set);
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โโ
2. studentID๋ฅผ Stringํ์ผ๋ก ํ๊ธฐ
โโ
Student.java
package test;
public class Student {
private String studentID;
private String studentName;
public Student(String studentID, String studentName) {
this.studentID = studentID;
this.studentName = studentName;
}
public int hashCode() {
return Integer.parseInt(studentID);
}
public String toString() {
return studentID + ":" + studentName;
}
public boolean equals(Object obj) {
if (obj instanceof Student) {
Student student = (Student) obj;
if (this.studentID.equals(student.studentID))
return true;
else
return false;
}
return false;
}
}
StudentTest.java
package test;
import java.util.HashSet;
public class StudentTest {
public static void main(String[] args) {
HashSet<Student> set = new HashSet<Student>();
set.add(new Student("100", "ํ๊ธธ๋"));
set.add(new Student("200", "๊ฐ๊ฐ์ฐฌ"));
set.add(new Student("300", "์ด์์ "));
set.add(new Student("400", "์ ์ฝ์ฉ"));
set.add(new Student("100", "์ก์ค๊ธฐ"));
System.out.println(set);
}
}
<์คํ ๊ฒฐ๊ณผ>
์ฐ์ต๋ฌธ์ Q6) ๋ค์ ์ฝ๋์์ CarTest์ ํ ์คํธ ๊ฒฐ๊ณผ๊ฐ true, true, false๊ฐ ๋๋๋ก HashMap์ ์ฌ์ฉํ์ฌ CarFactory ํด๋์ค๋ฅผ ๊ตฌํํด ๋ณด๋ผ.
โ
์๋์ CarTest ํด๋์ค๋ฅผ ํ ๋๋ก ์์ฑ..
package test;
public class CarTest {
public static void main(String[] args) {
CarFactory factory = CarFactory.getInstance();
Car sonata1 = factory.createCar("์ฐ์ ์ฐจ");
Car sonata2 = factory.createCar("์ฐ์ ์ฐจ");
System.out.println(sonata1 == sonata2); // true
Car avante1 = factory.createCar("์น์ฐ ์ฐจ");
Car avante2 = factory.createCar("์น์ฐ ์ฐจ");
System.out.println(avante1 == avante2); // true
System.out.println(sonata1 == avante1); // false
}
}
<๋ด๊ฐ ํ ๊ฒ>
package test;
import java.util.HashMap;
public class CarFactory {
private HashMap<String, Car> hashMap = new HashMap<>();
private static CarFactory instance = new CarFactory(); // ์ฑ๊ธํค
public CarFactory() {
hashMap = new HashMap<String, Car>();
}
public Car createCar(String name) {
if (hashMap.containsKey(key)) // hashMap์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ํค ๊ฐ์ด ์๋ค๋ฉด
return hashMap.get(name); // ์ด๋ฆ ๊ฐ์ ธ์ค๊ธฐ
}
return false;
}
public static CarFactory getInstance() {
return instance;
}
}
-์ด๋ ต๋ค.. ์ผ์ธ๋ ์์ง ์ฐ๋ฆฌ๋ ๋ฒจ์์ ์ด๋ ค์ด ๋ฌธ์ ๋ผ๊ณ ํ์ จ์....
โ
<์ ์๋์ด ํ ๊ฒ>
package test;
import java.util.HashMap;
public class CarFactory {
private HashMap<String, Car> hashMap = new HashMap<String, Car>();
private static CarFactory carFactory; // ์ฑ๊ธํค
public Car createCar(String key) {
Car car = null;
if (!hashMap.containsKey(key)) // hashMap์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ํค ๊ฐ์ด ์๋ค๋ฉด
hashMap.put(key, new Car(key)); // ํค ๊ฐ ์ง์ด๋ฃ๊ธฐ
car = hashMap.get(key); // ํค ๊ฐ ๊ฐ์ ธ์ค๊ธฐ
return car;
}
public static CarFactory getInstance() { // ์ฑ๊ธํค
if (carFactory == null) // carFactory๊ฐ null๊ฐ์ด๋ฉด
carFactory = new CarFactory(); // ์ธ์คํด์ค ์์ฑ?
return carFactory;
}
}
-์ ๊ทผ์ ํ์์ธ private์ ๊ฐ์ฒด ์ธ๋ถ์์์ ์ ๊ทผ์ ๋ง๋๋ค.
์ด๋ ๊ฒ ๊ฐ์ฒด ์์ฑ์ด ๋ถ๊ฐ๋ฅํ๊ฒ ๋ง๋๋ ๊ฒฝ์ฐ๋ ๋๊ฒ ์ธ์คํด์คํ๊ฐ ๋ถํ์ํ ๊ฒฝ์ฐ์ด๋ค.
ํ์ง๋ง ์ด์ ๊ฐ์ด ์ธ์คํด์คํ ์์ด ๊ฐ์ฒด์ ๋ฉค๋ฒ ๋ณ์๋ ๋ฉค๋ฒ ํจ์๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋ฐ๋์ ํด๋น ๋ณ์ ๋๋ ํจ์๊ฐ static ์์ญ์ ์์ด์ผํ๋ค.
(static ๋ณ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ๋๋ง ํ ๋น๋๋ฏ๋ก ์ธ์คํด์ค๊ฐ ์ฌ๋ฌ๊ฐ ์์ฑ๋์ด๋ ํ๋์ ๋ณ์๋ฅผ ๊ณต์ ํ๋ค.)
์ด๋ฌํ private์ static์ ํน์ฑ์ ์ด์ฉํ์ฌ ๋ค์ํ ๋ฐฉ์์ผ๋ก singleton ํจํด๋ฅผ ๊ตฌํ ํ ์ ์๋ค.
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java-๊ธฐ์ด] ๋๋ค์ (0) | 2021.02.22 |
---|---|
[Java-๊ธฐ์ด] ๋ด๋ถ ํด๋์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] Comparable ์ธํฐํ์ด์ค์ Comparator ์ธํฐํ์ด์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] set ์ธํฐํ์ด์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] Iterator๋ฅผ ์ฌ์ฉํ์ฌ ์์๋ฅผ ์ํํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋ (0) | 2021.02.22 |
๋๊ธ