โถ List ์ธํฐํ์ด์ค
List ์ธํฐํ์ด์ค์๋ ๊ฐ์ฒด๋ฅผ ์์์ ๋ฐ๋ผ ์ ์ฅํ๊ณ ์ ์งํ๋๋ฐ ํ์ํ ๋ฉ์๋๊ฐ ์ ์ธ๋์ด์๋ค.
ArrayList, Vector, LinkedList
โ
โ
*ArrayList ํด๋์ค
๊ฐ์ฒด ์์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ฐจ์ ์ผ๋ก ์๋ฃ๋ฅผ ๊ด๋ฆฌํ๋ ํ๋ก๊ทธ๋จ์ ๊ตฌํํ ๋ ์ฌ์ฉํ๋ค.
โ
โMemberArrayList.java
package collection.arraylist;
import collection.Member;
import java.util.ArrayList;
public class MemberArrayList {
private ArrayList<Member> arrayList;
public MemberArrayList() {
arrayList = new ArrayList<Member>();
}
public void addMember(Member member) { // ArrayList์ ํ์์ ์ถ๊ฐํ๋ ๋ฉ์๋
arrayList.add(member);
}
public boolean removeMember(int memberID) { // ํด๋น ์์ด๋๋ฅผ ๊ฐ์ง ํ์์ ArrayList์์ ์ฐพ์ ์ ๊ฑฐํจ
for(int i = 0; i < arrayList.size(); i++) {
Member member = arrayList.get(i);
int tempId = member.getMemberID();
if (tempId == memberID) {
arrayList.remove(i);
return true;
}
}
System.out.println(memberID + " ๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค."); // ๋ฐ๋ณต๋ฌธ์ด ๋๋ ๋๊น์ง ํด๋น ์์ด๋๋ฅผ ์ฐพ์ง ๋ชปํ ๊ฒฝ์ฐ
return false;
}
public void showAllMember() { // ์ ์ฒด ํ์์ ์ถ๋ ฅํ๋ ๋ฉ์๋
for (Member member : arrayList) {
System.out.println(member);
}
System.out.println();
}
}
MemberArrayListTest.java
package collection.arraylist;
import collection.Member;
public class MemberArrayListTest {
public static void main(String[] args) {
MemberArrayList memberArrayList = new MemberArrayList();
Member memberLee = new Member(1001, "์ด์ง์");
Member memberSon = new Member(1002, "์๋ฏผ๊ตญ");
Member memberPark = new Member(1003, "๋ฐ์ํค");
Member memberHong = new Member(1004, "ํ๊ธธ๋");
memberArrayList.addMember(memberLee);
memberArrayList.addMember(memberSon);
memberArrayList.addMember(memberPark);
memberArrayList.addMember(memberHong);
memberArrayList.showAllMember();
memberArrayList.removeMember(memberHong.getMemberID()); // ํ๊ธธ๋ ํ์ ์ญ์
memberArrayList.showAllMember(); // ํ๊ธธ๋ ํ์์ ์ญ์ ํ ํ ๋ค์ ์ ์ฒด ํ์ ์ถ๋ ฅ
}
}
<์คํ ๊ฒฐ๊ณผ>
โ
๋ ํผ์ ์ฝ๋ฉ) ArrayList์ ํน์ ์์น์ ํ์ ์ถ๊ฐํ๊ธฐ
ํ์์ ์ถ๊ฐํ ๋ ๋งจ ๋ค๊ฐ ์๋ ํน์ ์์น์ ์ถ๊ฐํ๋ ๋ฉ์๋๋ฅผ ๋ง๋ค๊ณ , MemberArrayListTest ํด๋์ค์ ์ฝ๋๋ฅผ ์ถ๊ฐํ์ฌ ํ ์คํธํด๋ณด๋ผ.
ํํธ. public void insertMember(Member member, int index) ๊ฐ์ ๋ฉ์๋๋ฅผ MemberArrayList์ ๊ตฌํํด๋ณด๋ผ. ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ index ์์น์ ํ์์ ์ถ๊ฐํ๊ณ ์ ์ฒด ํ์์ ์ถ๋ ฅํ์ฌ ํ์ธํด ๋ณด์. |
MemberArrayList.java
package collection.arraylist;
import collection.Member;
import java.util.ArrayList;
import java.util.Iterator;
public class MemberArrayList {
private ArrayList<Member> arrayList;
public MemberArrayList() {
arrayList = new ArrayList<Member>(); // Member๋ก ์ ์ธํ ArrayList ์์ฑ
}
public void addMember(Member member) {
arrayList.add(member);
}
public boolean removeMember(int memberID) { // ๋ฉค๋ฒ ์์ด๋๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ญ์ ์ฌ๋ถ๋ฅผ ๋ฐํํจ
for(int i = 0; i < arrayList.size(); i++) { // ํด๋น ์์ด๋๋ฅผ ๊ฐ์ง ๋ฉค๋ฒ๋ฅผ ArrayList์์ ์ฐพ์
Member member = arrayList.get(i); // get() ๋ฉ์๋๋ก ํ์์ ์์ฐจ์ ์ผ๋ก ๊ฐ์ ธ์ด
int tempId = member.getMemberID();
if (tempId == memberID) { // ํ์ ์์ด๋๊ฐ ๋งค๊ฐ๋ณ์์ ์ผ์นํ๋ฉด
arrayList.remove(i); // ํด๋น ํ์์ ์ญ์
return true;
}
}
System.out.println(memberID + " ๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค."); // for๋ฌธ์ด ๋๋ ๋๊น์ง ๋ฐํ์ด ์๋ ๊ฒฝ์ฐ
return false;
}
public void showAllMember() {
for (Member member : arrayList) {
System.out.println(member);
}
System.out.println();
}
public void insertMember(Member member, int index) {
arrayList.add(index, member); // addMember() ๋ฉ์๋
}
}
<์คํ ๊ฒฐ๊ณผ>
*ArrayList์ Vector ํด๋์ค → ๋์ด ํฐ ์ฐจ์ด๋ ์์
Vector๋ ์๋ฐ 2 ์ด์ ๋ถํฐ ์ ๊ณตํ์ผ๋ฉฐ ArrayList์ฒ๋ผ ๋ฐฐ์ด์ ๊ตฌํํ ํด๋์ค.
ArrayList์ Vector์ ๊ฐ์ฅ ํฐ ์ฐจ์ด๋ ๋๊ธฐํ ์ง์ ์ฌ๋ถ์ด๋ค.
๋ ์์ ์ด ๋์์ ์คํ๋๋ ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์ด ์๋ ๊ฒฝ์ฐ์๋ ArrayList๋ฅผ ์ฌ์ฉํ๋๋ก ๊ถ์ฅํ๋ค. ์๋ํ๋ฉด ๋๊ธฐํ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋์์ ์์ ์ด ์ด๋ฃจ์ด์ง๋ ์์์ ๋ํด ์ ๊ธ์ ์ํํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ฆ ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋ฐฐ์ด ๊ฐ์ฒด์ ์ ๊ธ์ ํ๊ณ , ๋ฉ์๋ ์ํ์ด ๋๋๋ฉด ์ ๊ธ์ ํด์ ํ๋ค๋ ๋ป์ด๋ค. ์ด๋ ๊ฒ Vector์ ๋ชจ๋ ๋ฉ์๋๋ ํธ์ถ๋ ๋๋ง๋ค ์ ๊ธ๊ณผ ํด์ ๊ฐ ์ผ์ด๋๋ฏ๋ก ArrayList๋ณด๋ค ์ํ ์๋๊ฐ ๋๋ฆฌ๋ค. ArrayList๋ฅผ ์ฌ์ฉํด์ ๊ตฌํํ๋๋ฐ ๋์ค์ ํ๋ก๊ทธ๋จ์์ ๋๊ธฐํ๊ฐ ํ์ํ๋ค๋ฉด Vector๋ก ๋ฐ๊พธ์ง ์๊ณ ๋ค์๊ณผ ๊ฐ์ด ArrayList ์์ฑ ์ฝ๋๋ฅผ ์ฐ๋ฉด ๋๋ค.
*์ค๋ ๋์ ๋ฉํฐ์ค๋ ๋ ํ๋ก๊ทธ๋๋ฐ
์ค๋ ๋๋ ๊ฐ๋จํ ๋งํ๋ฉด ์์ ๋จ์์ด๋ค. ํ๋ก๊ทธ๋จ์ด ๋ฉ๋ชจ๋ฆฌ์์ ์ํ๋๋ ค๋ฉด ์ค๋ ๋ ์์ ์ด ์์ฑ๋์ด์ผํ๋ค. ์ด๋ ํ๋์ ์ค๋ ๋๋ง ์ํ๋๋ฉด ๋จ์ผ ์ค๋ ๋๋ผ๊ณ ํ๊ณ ๋ ๊ฐ ์ด์์ ์ค๋ ๋๊ฐ ๋์์ ์คํ๋๋ ๊ฒฝ์ฐ๋ฅผ ๋ฉํฐ์ค๋ ๋๋ผ๊ณ ํ๋ค. ๋ ๊ฐ ์ด์์ ์ค๋ ๋๊ฐ ๋์์ ์คํ๋๋ฉด ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ๊ทผํ๊ธฐ ๋๋ฌธ์ ๋ณ์ ๊ฐ์ด๋ ๋ฉ๋ชจ๋ฆฌ ์ํ์ ์ค๋ฅ๊ฐ ์๊ธธ ์ ์๋ค. ์ด ๋ ๋ฉ๋ชจ๋ฆฌ์ ๋์์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ์์๋ฅผ ๋ง์ถ๋ ๊ฒ์ด ๋๊ธฐํ์ด๋ค.
โ
MemberVector.java
package collection.arraylist;
import java.util.Vector;
import collection.Member;
public class MemberVector {
private Vector<Member> vector;
public MemberVector() {
vector = new Vector<Member>();
}
public void addMember(Member member) {
vector.add(member);
}
public boolean removeMember(int memberID) {
for (int i = 0; i < vector.size(); i++) {
Member member = vector.get(i);
int tempId = member.getMemberID();
if (tempId == memberID) {
vector.remove(i);
return true;
}
}
System.out.println(memberID + " ๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.");
return false;
}
public void showAllMember() {
for (Member member : vector) {
System.out.println(member);
}
System.out.println();
}
public void insertMember(Member member, int index) {
vector.add(index, member);
}
}
MemberVectorTest.java
package collection.arraylist;
import collection.Member;
public class MemberVectorTest {
public static void main(String[] args) {
MemberVector memberVector = new MemberVector();
Member memberLee = new Member(1001, "์ด์ง์");
Member memberSon = new Member(1002, "์๋ฏผ๊ตญ");
Member memberPark = new Member(1003, "๋ฐ์ํค");
Member memberHong = new Member(1004, "ํ๊ธธ๋");
memberVector.addMember(memberLee);
memberVector.addMember(memberSon);
memberVector.addMember(memberPark);
memberVector.addMember(memberHong);
memberVector.showAllMember();
memberVector.removeMember(memberHong.getMemberID());
memberVector.showAllMember();
memberVector.insertMember(memberHong, 1);
memberVector.showAllMember();
}
}
*LinkedList ํด๋์ค
ArrayList์ ๋จ์ ์ ๋ณด์ํ ํด๋์ค.
๊ฐ์ List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ArrayList์ ๋นํด ์ค๊ฐ์ ์๋ฃ๋ฅผ ๋ฃ๊ณ ์ ๊ฑฐํ๋๋ฐ ์๊ฐ์ด ์ ๊ฒ ๊ฑธ๋ฆฐ๋ค๋ ์ฅ์ ์ด ์๊ณ , ํฌ๊ธฐ๋ฅผ ๋์ ์ผ๋ก ์ฆ๊ฐ์ํฌ ์ ์๋ค.
*ArrayList์ LinkedList์ ๋ค๋ฅธ ์
ArrayList๋ ์์ฑํ ๋ ์ฉ๋์ ์ง์ ํ๊ณ ์ฉ๋๋ณด๋ค ๋ ๋ง์ ์์๊ฐ ์ถ๊ฐ๋ ๊ฒฝ์ฐ์ ์ฉ๋์ ๋๋ ค๊ฐ๋ฉฐ ์ํํ๋ค.
LinkedList๋ ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๋์ ์ผ๋ก ์์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฑํ๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ฒ๋ผ ์ฉ๋์ ๋๋ฆฌ๊ณ ์์ ๊ฐ์ ๋ณต์ฌํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์๋ค. ๋ํ, ์๋ฃ๋ฅผ ์ค๊ฐ์ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ๋ ์๋ฃ์ ์ด๋์ด ArrayList๋ณด๋ค ์ ๋ค.
ํ์ง๋ง ArrayList๋ ์๋ฃ์ ์์น๋ฅผ ์ฐพ์ ๋ ํธ๋ฆฌํ๊ณ LinkedList๋ณด๋ค ๊ตฌํํ๊ธฐ๋ ์ฝ๋ค.
๋ฐ๋ผ์ ์ฌ์ฉํ๋ ์๋ฃ์ ๋ณ๋(์ฝ์ ·์ญ์ )์ด ๋ง์ ๊ฒฝ์ฐ์๋ LinkedList๋ฅผ,
์๋ฃ ๋ณ๋์ด ๊ฑฐ์ ์๋ ๊ฒฝ์ฐ์๋ ArrayList๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋ค.
โ
-LinkedList ํด๋์ค ์ฌ์ฉํ๊ธฐ
โ
LinkedListTest.java
package collection;
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
LinkedList<String> myList = new LinkedList<String>();
myList.add("A");
myList.add("B");
myList.add("C");
System.out.println(myList); // ๋ฆฌ์คํธ ์ ์ฒด ์ถ๋ ฅ
myList.add(1, "D"); // LinkedList์ ์ฒซ ๋ฒ์งธ ์์น์ D ์ถ๊ฐ
System.out.println(myList);
myList.addFirst("0"); // ์ฐ๊ฒฐ๋ฆฌ์คํธ ๋งจ ์์ 0 ์ถ๊ฐ
System.out.println(myList);
System.out.println(myList.removeLast()); // ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋งจ ๋ค ์์ ์ญ์ ํ ํด๋น ์์๋ฅผ ์ถ๋ ฅ
System.out.println(myList);
}
}
<์คํ ๊ฒฐ๊ณผ>
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java-๊ธฐ์ด] Iterator๋ฅผ ์ฌ์ฉํ์ฌ ์์๋ฅผ ์ํํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋ (0) | 2021.02.22 |
---|---|
[Java-๊ธฐ์ด] ArrayList๋ก ์คํ๊ณผ ํ ๊ตฌํํ๊ธฐ (0) | 2021.02.21 |
[Java-๊ธฐ์ด] ์ปฌ๋ ์ ํ๋ ์์ํฌ (0) | 2021.02.21 |
[Java-๊ธฐ์ด] ๊ฐ๋ ์ก๊ธฐ 3 (๊ณต๋ถ ๊ธฐ๋ก) ๊ณ์ ์์ฑ์ค (0) | 2021.02.21 |
[Java-๊ธฐ์ด] ์๊ณ ๋ฆฌ์ฆ ์์ (ํ์ ์์ฐจ) (0) | 2021.02.21 |
๋๊ธ