반응형
- C21콜렉션응용
- 콜렉션응용_개념
- 콜렉션종류_기본이론1_어레이리스트1
package 콜렉션응용_개념;
import java.util.ArrayList;
import java.util.Vector;
public class 콜렉션종류_기본이론1_어레이리스트1 {
public static void main(String[] args) {
// 1) Vector 보다 나중에 나온 자료구조.
// 2) Vector 보다 성능이 좋다.
// [결론] Vector 보다 ArrayList 를 사용하자.
// 문법은 똑같다.
ArrayList<Integer> list = new ArrayList<Integer>();
// add(value) : ArrayList의 맨 뒤에 value를 추가한다.
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println(list);
// remove(index) : ArrayList의 index번째 데이터를 제거한다.
list.remove(3);
System.out.println(list);
// size() : ArrayList에 저장된 데이터의 개수를 얻어온다.
int count = list.size();
System.out.println("count = " + count);
// get() : ArrayList의 index번째의 value를 얻어온다.
System.out.print("[");
for(int i=0; i<count; i++) {
System.out.print(list.get(i));
if(i != count - 1) {
System.out.print(", ");
}
}
System.out.println("]");
// add(index, value) : ArrayList의 index번째 위치에 value를 삽입한다.
list.add(0, 9);
System.out.println(list);
// set(index, value) : ArrayList의 index번째 위치에 value를 수정한다.
list.set(3, 5);
System.out.println(list);
// clear() : ArrayList의 모든 데이터를 제거한다.
list.clear();
System.out.println(list.size());
}
}- 콜렉션종류_기본이론2_어레이리스트2
package 콜렉션응용_개념;
import java.util.ArrayList;
import java.util.Scanner;
public class 콜렉션종류_기본이론2_어레이리스트2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<>();
while(true) {
System.out.println(list);
System.out.println("1.추가 2.삭제 3.삽입 4.종료");
int sel = scan.nextInt();
if(sel == 1) {
System.out.println("추가할 숫자를입력하세요 >> ");
int num = scan.nextInt();
list.add(num);
}else if(sel == 2) {
System.out.println(list);
System.out.println("삭제할 인덱스를 입력하세요 >> ");
int index = scan.nextInt();
if(list.size() <= 0) {
continue;
}
if(index < 0) {
continue;
}
if(index >= list.size()) {
continue;
}
list.remove(index);
}else if(sel == 3) {
System.out.println(list);
System.out.println("삽입할 위치를 입력하세요 >> ");
int pos = scan.nextInt();
System.out.println("삽입할 값을 입력하세요 >> ");
int value = scan.nextInt();
list.add(pos , value);
}
else if(sel == 4) {
System.out.println("종료");
break;
}
}
scan.close();
}
}- 콜렉션종류_기본이론3_맵
package 콜렉션응용_개념;
import java.util.HashMap;
import java.util.Map;
public class 콜렉션종류_기본이론3_맵 {
public static void main(String[] args) {
// === map === 은 인터페이스이다.
// 1) 기존의 배열은 index 가 자동으로 0,1,2...순서로 생성되었지만
// 2) map 은 index 부분을 직접 설정하는것을 말한다.
// 3) map 은 index 를 Key로 바꾸어부른다.
// HashMap은 K(Key)에 V(Value)를 할당하는 방식으로 저장된다.
// Key는 String으로 하고 Value는 HashMap에 저장할 데이터의 타입을 쓴다.
//맵의 객체생성은 앞에 변수는 Map 으로 사용하고 new 는 HashMap 으로 한다.
//HashMap 의 부모인 Map의 메서드를 이용하기때문이다.
Map<String, Integer> hmap = new HashMap<String, Integer>();
// (key, value) : HashMap의 key에 value를 할당한다.
hmap.put("apple", 1000);
hmap.put("orange", 1500);
hmap.put("melon", 5000);
hmap.put("water melon", 15000);
System.out.println(hmap.size() + " : " + hmap);
System.out.println("============================================================");
// get(key) : HashMap의 key에 할당된 value를 얻어온다.
System.out.println(hmap.get("melon"));
System.out.println("============================================================");
// put() 메소드는 존재하지 않는 key에 넣어주면 데이터가 입력되고 존재하는 key에 넣어주면 수정된다.
hmap.put("apple", 1234);
System.out.println(hmap.size() + " : " + hmap);
System.out.println("============================================================");
// keySet() : HashMap의 key만 얻어온다.
System.out.println(hmap.keySet());
System.out.println("============================================================");
// 향상된 for와 keySet() 메소드를 사용하면 HaskMap에 저장된 모든 데이터를 얻어올 수 있다.
int sum = 0;
for(String key : hmap.keySet()) {
// System.out.println(key); // HashMap의 모든 key를 얻어올 수 있다.
System.out.println(hmap.get(key)); // HashMap의 모든 key에 할당된 value를 얻어올 수 있다.
sum += hmap.get(key);
}
System.out.println("금액 합계 : " + sum);
System.out.println("============================================================");
// remove(key) : HashMap의 key에 해당되는 값을 제거한다.
hmap.remove("apple");
System.out.println(hmap.size() + " : " + hmap);
System.out.println("============================================================");
// clear() : HashMap의 모든 값을 제거한다.
hmap.clear();
System.out.println(hmap.size() + " : " + hmap);
System.out.println("============================================================");
}
}- arr[0] = 10;
- arr[1] = 20;
- int [ ] arr = new <int , int> ( ) ;
- arr [ 0 ] = 10;
- arr["국어"] = 10;
- Map map = new Map<String, Integer > ( );
- 콜렉션종류_기본이론4_정렬
package 콜렉션응용_개념;
import java.util.ArrayList;
import java.util.Collections;
/*
Collections 정렬
자바에서 제공하는 성능좋은 정렬 (직접만드는게 힘들때 사용)
[1] Comparable<Fruit> 을 인터페이스 상속을 받는다.
[2] public int compareTo(Fruit fruit){}
메서드를 강제 구현해야한다.
[3] 정렬하고 싶은 내용을 구체적으로 적는다.
int check = 0;
if(price - fruit.price > 0) {
check = -1;
}else if(price - fruit.price < 0) {
check = 1;
}
return check;
*/
//정렬하는 클래스
//원래 클래스에다가 Fruit . Comparable<Fruit>을 상속 받아야 한다. 인터페이스
class Fruit implements Comparable<Fruit>{
private String name;
private int price;
public Fruit() {}
public Fruit(String name, int price) {
this.name = name;
this.price = price;
}
@Override
public int compareTo(Fruit fruit) {
// # 정수 비교
int check = 0;
if(price > fruit.price ) {
check = -1;
}else if(price < fruit.price ) {
check = 1;
}
return check;
// #문자 비교
//return name.compareTo(fruit.name);
}
@Override
public String toString() {
return name + " : " + price;
}
}
public class 콜렉션종류_기본이론4_정렬 {
public static void main(String[] args) {
ArrayList<Fruit> list = new ArrayList<>();
//어레이리스트 정렬
//배열에 담아서 배열 정렬하는게 편하다.
list.add(new Fruit("사과", 3000));
list.add(new Fruit("귤", 1000));
list.add(new Fruit("오렌지", 2000));
Collections.sort(list); //정렬하고 싶으면 콜렉션을 쓰는것
System.out.println(list);
}
}- 콜렉션종류_기본이론5_다중정렬
package 콜렉션응용_개념;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Student {
int num;
String name;
int score1;
int score2;
Student(int num, String name, int score1 , int score2) {
this.num = num;
this.name = name;
this.score1 = score1;
this.score2 = score2;
}
public String toString() {
String print = String.format("%d %s %d %d", num, name, score1 , score2);
return print;
}
}
//--------------------------------------------------
//여러개면 클래스를 따로 만드는것 // 내림차순
class DownCompare implements Comparator<Student> {
int ret = 0;
@Override
public int compare(Student s1, Student s2) {
if (s1.score1 < s2.score1) {
ret = 1;
}
else if (s1.score1 == s2.score1) {
if(s1.score2 < s2.score2) {
ret = 1;
}
else if(s1.score2 == s2.score2) {
ret = 0;
}
else if(s1.score2 > s2.score2) {
ret = -1;
}
}
else if (s1.num > s2.num) {
ret = -1;
}
return ret;
}
}
//--------------------------------------------------
class UpCompare implements Comparator<Student> {
int ret = 0;
@Override
public int compare(Student s1, Student s2) {
if (s1.score1 < s2.score1) {
ret = -1;
}
else if (s1.score1 == s2.score1) {
if(s1.score2 < s2.score2) {
ret = -1;
}
else if(s1.score2 == s2.score2) {
ret = 0;
}
else if(s1.score2 > s2.score2) {
ret = 1;
}
}
else if (s1.num > s2.num) {
ret = 1;
}
return ret;
}
}
//--------------------------------------------------
public class 콜렉션종류_기본이론5_다중정렬 {
public static void main(String[] args) {
//리스트 집어넣기
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student(11001244, "아무개", 10,20);
Student s2 = new Student(25109435, "김김김", 50,90);
Student s3 = new Student(11005338, "사이다", 40,30);
Student s4 = new Student(11005338, "박박박", 40,20);
Student s5 = new Student(11005338, "오오오", 10,80);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
// 정렬을 종류별로 다양하게 만들수 있다.
Collections.sort(list, new DownCompare());
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------------------------");
Collections.sort(list, new UpCompare());
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}- 콜렉션종류_기본이론6_리스트
package 콜렉션응용_개념;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import java.util.Vector;
public class 콜렉션종류_기본이론6_리스트 {
public static void main(String[] args) {
//List는 인터페이스 클래스이며, java.util.Collection 인터페이스를 구현한것이다.
List<Integer> list1 = new ArrayList<Integer>();
//단점 : add가 느리다.
//장점 : 인덱스 검사가 가능하다.
// list.get(3); //찾을 수 있다.
List<Integer> list2 = new LinkedList<Integer>();
//장점 : add가 빠르다.
//단점 : list.get(2)안된다. //인덱스 찾기가 불가능
//무조건 처음부터 찾아야 된다.
List<Integer> list3 = new Vector<Integer>();
//ArrayList와 같다.
List<Integer> list4 = new Stack<Integer>();
//선입호출
//자동으로 늘어나는 배열이 크게 4가지가 있다.
//ArrayList LinkedList Vector Stack
//위의 4개는 전부다 부모가 있다. List
}
}- 자동으로 늘어나는 배열이 4가지가 있다.
- 동작하는것
- Arraylist
- arr : x
- x = 10
- temp에게 arr의 x를 맡긴다. / x = 10 이것을 가지고 있다.
- arr은 1칸에서 지우고. 2칸을 만든다.
- temp를 복사를 하고. 10 , 20이 된다.
- 30을 넣고 싶으면 또 같이. temp한테 y를 맡기고. arr은 3칸을 만들고 . temp에게 복사를 하는것
- 단점 : push 할때마다 . 배열을 삭제하고 만들고 한다. push가 느리다. add가 느리다.
- 장점 : 배열이 다 붙어있기 떄문에. 인덱스 검사가 가능하다.
- list.get(2) => 30
- LinkedList
- arr
- 10이 들어있다. 1칸이 아니라. 2칸이다.
- 0번째는 null . => null에 y의 주소를 넣는다.
- 1번째 10
- 추가 20을 하면
- 2칸을 만든다. 새로
- 0번째 : y주소 : null => y의 주소를 10이 들어있는 null에 주소를 넣는다.
- 1번째 : 20
- 장점 : add가 빠르다.
- 단점 : get을 사용할 수 없다.
- 무조건 처음부터 찾을 수 밖에 없다.
- list.get(2)
- 인덱스를 찾는게 불가능하다.
- Vector
- 어레이리스트와 같다.
- Stack
- 위에 쌓는것 / 뷔페의 접시와 같음 / 나중에 들어오는게 먼저 나감 / 선입호출
- 큐 => 선입선출 / 번호 순서대로
- 콜렉션종류_기본이론7_이차원벡터1
package 콜렉션응용_개념;
import java.util.ArrayList;
class Node1to50 {
public int num;
public void printNode() {
System.out.print(num + "\t");
}
}
class Manager1to50 {
public ArrayList<Node1to50[]> nodeList;
//Node1to50 => 여기에도 배열을 넣을 수 있다.
//ArrayList 안에 클래스의 배열도 들어올 수 있다.
public int data[][];
public final int SIZE = 5;
public void dataInit() {
data = new int[SIZE][SIZE];
int num = 1;
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
data[i][j] = num;
// System.out.println(num);
num += 1;
}
}
}
public void dataShuffle() {
}
public void nodeInit() {
nodeList = new ArrayList<>();
for (int i = 0; i < SIZE; i++) {
Node1to50[] temp = new Node1to50[SIZE];
for (int j = 0; j < SIZE; j++) {
Node1to50 node = new Node1to50();
node.num = data[i][j];
// System.out.println(node.num);
temp[j] = node;
}
nodeList.add(temp);
}
}
public void printNodeList() {
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
nodeList.get(i)[j].printNode();
}
System.out.println();
}
}
public void init() {
dataInit();
dataShuffle();
nodeInit();
printNodeList();
}
}
public class 콜렉션종류_기본이론7_이차원벡터1 {
public static void main(String[] args) {
// 1to50 을만들어보세요
Manager1to50 nm = new Manager1to50();
nm.init();
}
}- 콜렉션종류_기본이론8_이차원벡터2
package 콜렉션응용_개념;
import java.util.ArrayList;
class Manager1to50Ver2{
public ArrayList<ArrayList<Node1to50>> nodeList;
public int data[][];
public final int SIZE = 5;
public void dataInit() {
data = new int[SIZE][SIZE];
int num = 1;
for(int i = 0; i < SIZE; i++) {
for(int j = 0; j < SIZE; j++) {
data[i][j] = num;
//System.out.println(num);
num += 1;
}
}
}
public void dataShuffle() {}
public void nodeInit() {
nodeList = new ArrayList<>();
for(int i = 0; i < SIZE; i++) {
ArrayList<Node1to50> temp = new ArrayList<>();
for(int j = 0; j < SIZE; j++) {
Node1to50 node = new Node1to50();
node.num = data[i][j];
//System.out.println(node.num);
temp.add(node);
}
nodeList.add(temp);
}
}
public void printNodeList() {
for(int i = 0; i < SIZE; i++) {
for(int j = 0; j < SIZE; j++) {
nodeList.get(i).get(j).printNode();
}
System.out.println();
}
}
public void init() {
dataInit();
dataShuffle();
nodeInit();
printNodeList();
}
}
public class 콜렉션종류_기본이론8_이차원벡터2 {
public static void main(String[] args) {
// 1to50 을만들어보세요
Manager1to50Ver2 nm = new Manager1to50Ver2();
nm.init();
}
}- 콜렉션종류_기본이론9_맵정렬
package 콜렉션응용_개념;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class 콜렉션종류_기본이론9_맵정렬 {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "apple");
map.put(3, "mango");
map.put(4, "grape");
map.put(2, "orange");
map.put(5, "melon");
Object[] mapKey = map.keySet().toArray();
Arrays.sort(mapKey);
for(Integer key : map.keySet()) {
System.out.println(key + " : " + map.get(key));
}
}
}반응형