์ฒซ๋ฒ์งธ ์ค์๋ ์ ์ n์ด ์ฃผ์ด์ง๋ค.(์ ์ฒด ๋ผ์ธ์ ์)
๋ค์ ๊ฐ๊ฐ n ๋ผ์ธ๋ค์์ ๊ทธ ๋ผ์ธ์ ์ํ ์ ์๊ฐ ๋ช์ธ์ง ๋ํ๋ด๋ ์ ์ d์, ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ์ ์๋ค์ด ๋์ด๋๋ค.
๋ค์ ๋ผ์ธ์๋ ์ฟผ๋ฆฌ์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ q๊ฐ ๋์จ๋ค.
๊ฐ ์ฟผ๋ฆฌ๋ ๋๊ฐ์ ์ ์ x,y๊ฐ ๊ตฌ์ฑ๋๋ค.
์์ํ์ ๊ฐ ๋ผ์ธ์๋ x๋ฒ์งธ ๋ผ์ธ์ y๋ฒ์งธ ์ ์๊ฐ ์ถ๋ ฅ๋๋ค.
๋ง์ฝ ํด๋น ์์น๊ฐ ์์ผ๋ฉด ERROR์ ์ถ๋ ฅํด์ผ ํ๋ค.
์๋ฐ List ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ ์ฌ๋ฌ ํด๋์ค ์ค ํ๋๋ค.
์ผ๋ฐ ๋ฐฐ์ด๊ณผ ๋์ผํ๊ฒ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฌ์ฉํ๊ณ , ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํ๋ค.
ํฌ๊ธฐ๊ฐ ๊ณ ์ ์ธ Array์ ๋ค๋ฅด๊ฒ, ArrayList๋ ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ผ๋ก ๋ณํ๋ค.
๋ด๋ถ์ ์ผ๋ก ์ ์ฅ์ด ๊ฐ๋ฅํ ๋ฉ๋ชจ๋ฆฌ ์ฉ๋(Capacity)๊ณผ ์ฌ์ฉ์ค์ธ ๊ณต๊ฐ์ ํฌ๊ธฐ(Size)๊ฐ ์๋ค.
import java.util.ArrayList;
ArrayList<Integer> integers1 = new ArrayList<Integer>(); // ํ์
์ง์
ArrayList<Integer> integers2 = new ArrayList<>(); // ํ์
์๋ต ๊ฐ๋ฅ
ArrayList<Integer> integers3 = new ArrayList<>(10); // ์ด๊ธฐ ์ฉ๋(Capacity) ์ค์
ArrayList<Integer> integers4 = new ArrayList<>(integers1); // ๋ค๋ฅธ Collection๊ฐ์ผ๋ก ์ด๊ธฐํ
ArrayList<Integer> integers5 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); // Arrays.asList()
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> colors = new ArrayList<>();
// add() method
colors.add("Black"); //๋ฐฐ์ด ๋งจ ๋ง์ง๋ง ๋ถ๋ถ์ ๊ฐ์ด ์ถ๊ฐ๋๋ค.
colors.add("White"); // ์๋ก ์ถ๊ฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊ณต๊ฐ์ด ์์ผ๋ฉด(๋ด๋ถ ๋ฐฐ์ด์ด ๊ฝ ์ฐจ์์ผ๋ฉด) ๋ ํฐ ์ฌ์ด์ฆ์ ์ ๋ฐฐ์ด์ ์์ฑํ๊ณ , ๊ธฐ์กด ๊ฐ๋ค์ ์ ๋ฐฐ์ด๋ก ๋ณต์ฌํ๋ค.
colors.add(0, "Green"); //0๋ฒ ์์น์ ๊ฐ ์ถ๊ฐ
colors.add("Red");
// set() method
colors.set(0, "Blue");
System.out.println(colors);
}
}
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> colors = new ArrayList<>(Arrays.asList("Black", "White", "Green", "Red"));
String removedColor = colors.remove(0); //0๋ฒ ๊ฐ์ ์ ๊ฑฐ, ๋ค์ชฝ์ ์๋ ํญ๋ชฉ์ ํ์นธ์ฉ ์์ผ๋ก ๋ก๊ฒจ์ง๊ฒ ๋๋ค.
System.out.println("Removed color is " + removedColor);
colors.remove("White");
System.out.println(colors);
colors.clear(); // ArrayList ๋น์ฐ๊ธฐ
System.out.println(colors);
}
}
aList๋ผ๋ ArrayListํ ์์ ์์, a1์ด๋ผ๋ ArrayListํ ์์,
a2๋ผ๋ ArrayListํ ์์๊ฐ ์๋ค.
๊ทธ๋ฆฌ๊ณ a1์๋ 1,2๊ฐ ์ ์ฅ๋์ด ์๊ณ a2์๋ 3์ด ์ ์ฅ๋์ด ์๋ค.
1,2๋ฅผ ๊บผ๋ด๋ ค๋ฉด ๋ฐ๊นฅ์์๋ถํฐ ์์ฐจ์ ์ผ๋ก aList.get()ํ ๋ค, ๋ get()๋ฉ์๋๋ฅผ ์ด์ฉํด์ ์ถ๋ ฅํ๋ค.
import java.util.*:
public class Main {
public static void main(String[] args){
ArrayList<ArrayList<Integer>โบ aList = new ArrayList<ArrayList<Integer>>
ArrayList<Integer> a1 = new ArrayList<Integer>();
a1.add(1);
a1.add(2);
aList.add(a1);
ArrayList<Integer> a2 = new ArrayList<Integer>();
a2.add(3);
aList.add(a2);
for (int i = 0; i < aList.size(); i++) {
for (int j = 0; j < aList.get(i).size(); j++) {
System.out.print(aList.get(i).get(j) +" ");
}
System.out.println();
}
}
}
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class JavaArraylist {
public static void main(String[] args) {
/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
ArrayList<ArrayList<Integer>> lines = new ArrayList<>();
//ArrayList ์ ๋ค๋ฆญ์์ ArrayList๋ฅผ ๋ฃ์ด 2์ฐจ์ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ค.
for(int i=0; i<n; i++) { //๋ด๋ถ arraylist์ ๊ฐ์ ๋ด์ ๋ฐ๋ณต๋ฌธ
int d = sc.nextInt();// d๋ ๊ทธ line์ integer๊ฐ ๋ช๊ฐ ์๋์ง ๋ํ๋ด๋ ์
๋ ฅ๊ฐ
ArrayList<Integer> line = new ArrayList<>();// ๊ฐ line์ ArrayList๋ก ๋ด๊ธธ integer๊ฐ ์
๋ ฅ๋๋ค.
for(int j=0; j<d; j++) line.add(sc.nextInt());
lines.add(line);
}
int q = sc.nextInt(); //์ฟผ๋ฆฌ ๊ฐฏ์๋ฅผ ๋ปํจ
for(int i=0; i<q; i++) { //๋ฐฐ์ด์ด๋ฏ๋ก 0๋ถํฐ ๋ฐ๋ณต๋ฌธ์ ๋๋ฉฐ x,y๊ฐ์ ๋ฐ์์จ๋ค.
int x = sc.nextInt();
int y = sc.nextInt();
try { //๋ฐ์์จ x,y๊ฐ์ผ๋ก lines์ ๋ฐฐ์ด์์ ๊ฐ์ ์ฐพ์ ์ถ๋ ฅํ๋ค.
System.out.println( lines.get(x-1).get(y-1) );
} // ํด๋น ๋ฐฐ์ด์ ๊ฐ์ด ์์ผ๋ฉด, ERROR!๋ฅผ ์ถ๋ ฅํด์ค๋ค.
catch(IndexOutOfBoundsException e) {
System.out.println("ERROR!");
}
}
}
}