고정 헤더 영역
상세 컨텐츠
본문
Collections
데이터의 집합, 그룹이다.
Collections가 List와 Set을 가지고 있고, Map이 Hashtable, HashMap, SortedMap을 가지고 있다.
Set interface는 순서가 없으며, 데이터 집합으로 데이터 중복이 안된다.
List interface는 순서가 있으며, 데이터 집합으로 데이터 중복이 된다.
Map interface는 키와 값으로 이루어진 데이터 집합으로 순서가 없으며, 키 값이 중복이 안되며, 값은 중복이 된다.
Set
java.util 패키지에 존재하는 인터페이스로써, 특정 코드에서 중복된 값의 허용이 있어서는 안될 때 사용한다.
즉, Set을 사용하면 복잡한 코드구성 없이 중복된 요소들을 쉽게 제거 할 수 있는 장점이 있다.
가장 많이 사용되는 HashSet(정렬이 안됨)과 TreeSet(오름차순 정렬됨)을 알아본다.
구조
ArrayList와 같이 get() 메서드를 이용하여, 특정 인덱스(요소)로 접근할 수 없기 때문에 내용을 순차적으로 얻어 오기 위해,
Iterrator라고 하는 반복자를 이용해야 한다.
Iterator에서 next() 메소드는 하나의 객체를 가져오고,
hasNext()메서드는 가져올 객체가 있으면 true 리턴, 없으면 false 리턴한다.
Map
키(key)와 값(value)을 묶어서 하나의 데이터로 저장한다는 특징을 갖는다.
키를 통해 값을 검색하므로 많은 양의 데이터를 검색하는데 있어 뛰어나다.
키는 불변이고, 값은 중복 가능하다.
Map은 길이를 .size()를 사용한다.
구조
Key로 value를 찾기에, 배열처럼 메모리 공간에 순차적으로 자리를 잡고 있지 않아서 for 문들을 이용해 값을 얻을 수 없다.
순차적으로 얻어오기 위해, Iterator라는 반복자를 이용해야한다.
ArrayList
collection 프레임 워크의 일부로써, 표준 배열보다는 느리지만 배열을 여러번 수행할 때 편리하다.
List interface를 상속받아 사용한다.
객체가 추가 되어 배열의 용량을 초과하면 자동으로 부족한 크기만큼 용량을 늘려준다.
주로 <Integer>을 많이 사용하며, String Character 타입으로도 선언 가능하다.
| add(Object) | 마지막에 값 추가 |
| add(int index, Object) | 해당 index에 값 추가 |
| set(int index, Object) | 값 변경 |
| remove(int index) | 하나의 값을 제거 |
| clear() | 모든 값 제거 |
| get(int index) | 해당 인덱스 값 추출 <- for문과 함께 iterator 사용 가능 |
- 배열과의 차이
배열과 같지만 배열은 크기가 미리 int[] ar = new int[10]; 이런 식으로 정해져 있다.
하지만 List 구조는 size가 늘었다 줄었다 유동적이다.
- ArrayList ( Collections.sort(list); , Collections.sort(list, Collections.reverseOrder()); )
Collections.sort(list);
ArrayList를 오름차순으로 정렬합니다.
Collections.sort(list, Collections.reverseOrder());
Collections.sort()의 2번쨰 파라미터로 내림차순 정렬을 나타내는 Comparator를 전달해서,
ArrayList를 내림차순으로 정렬하였습니다.
Java 객체를 정렬할 수 있다.
Comparable interface를 쓰려면 compareTo 메서드를 구현해야하며, "자기 자신과 매개변수 객체를 비교" 하고,
Comparator interface를 쓰려면 compare 메서드를 구현해야 하며, "두 매개변수 객체를 비교" 한다.
HashSet / TreeSet
import java.util.HashSet;
import java.util.Random;
import java.util.TreeSet;
public class Test08 {
public static void main(String[] args) {
HashSet<Integer> hs = new HashSet<Integer>(); // Wrapper 구문
while(true) {
int v = (int)(Math.random()*45+1);
hs.add(v);
if(hs.size() >= 6)
break;
}
System.out.println(hs);
TreeSet<Integer> ts = new HashSet<Integer>();
while(true)
{
int v = (int)(Math.random()*45+1);
ts.add(v);
if(ts.size() >= 6)
break;
}
System.out.println(ts);
System.out.println(ts.subSet(10,30)); // 10 ~ 30 사이의 수
}
}
Iterator
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
public class Test08 {
public static void main(String[] args) {
HashSet<Integer> set = new HashSet<Integer>();
int[][] board = new int[5][5];
for(; set.size()<25;) {
set.add(new Random().nextInt(50)+1);
}
Iterator<Integer> it = set.iterator();
for(int i=0; i<board.length; i++) {
for(int j=0; j<board.length; j++) {
board[i][j] = (Integer)it.next(); // iterator()는 next로 데이터를 받는다.
System.out.printf("%02d ", board[i][j]);
}
System.out.println();
}
}
}02 03 04 05 06
09 17 18 22 24
26 27 30 32 35
36 37 40 41 43
44 45 46 48 49
Map
map 구조의 내용을 출력하기 위해 key 값을 모두 가져온다.
set<String> keys = map2.keySet(); // map2의 모든 key 값을 keys에 저장.
// map2의 key는 Stirng이기에, keys의 제네릭 타입 또한 String으로 한다.
import java.util.HashMap;
import java.util.Set;
import java.util.Iterator;
public class Test01 {
public static void main(String[] args) {
HashMap<String, Boolean> map = new HashMap<String, Boolean>();
map.put("k1", true);
map.put("k2", true);
map.put("k2", false); //k2는 추가가 아니라 값 변경
System.out.println("Map사이즈 :" + map.size());
boolean b1 = map.get("k1");
System.out.println("b1 :" + b1);
boolean b2 = map.get("k2");
System.out.println("b2 :" + b2);
System.out.println("----------");
HashMap<String, String> map2 = new HashMap<String, String>();
map2.put("s1", "My key is s1");
map2.put("s2", "My key is s2");
map2.put("s3", "My key is s3");
String str1 = map2.get("s1");
System.out.println("str1:" + str1);
String str2 = map2.get("s2");
System.out.println("str2:" + str2);
String str3 = map2.get("s3");
System.out.println("str3:" + str3);
System.out.println("----------");
Set<String> keys = map2.keySet();
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
String k = it.next();
String v = map2.get(k);
System.out.println(k + ":" + v);
}
}
}Map사이즈 :2
b1 :true
b2 :false
----------
str1:My key is s1
str2:My key is s2
str3:My key is s3
----------
s3:My key is s3
s1:My key is s1
s2:My key is s2
import java.util.HashMap;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("kim",1111);
map.put("lee",2222);
try (Scanner scan = new Scanner(System.in)) {
while (true) {
System.out.println("ID를 입력하세요:");
String id = scan.next();
System.out.println("PW를 입력하세요:");
int pwd = scan.nextInt();
if ( !map.containsKey(id)) {
System.out.println("ID가 없어요.....");
}else {
if(map.get(id)!=pwd) {
System.out.println("PW가 없어요.....");
}else {
System.out.println("로그인 성공!");
break;
}
}
}
}
}
}
ArrayList
import java.util.ArrayList;
import java.util.Iterator;
public class Test03 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>(); //고정 크기가 없다.
System.out.println("list.size():"+list.size());
list.add(100);
list.add(20);
list.add(1,300);
System.out.println("list.size():"+list.size());
for(int i =0; i<list.size(); i++){
System.out.println("for: "+list.get(i));
}
Iterator<Integer> itr = list.iterator();
while(itr.hasNext()){
System.out.println("iteator: " +itr.next());
}
}
}list.size():0
list.size():3
for: 100
for: 300
for: 20
iteator: 100
iteator: 300
iteator: 20
- list.add(1,300) 은 index 1인 곳에 300을 넣고, index 1 뒤로는 index 1은 2로, 2는 3으로... 뒤로 밀린다.
import java.util.ArrayList;
import java.util.Scanner;
public class Test06 {
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<String>();
outer: while (true) {
System.out.print("아이디 생성 : ");
Scanner sc = new Scanner(System.in);
String id = sc.next();
for (int i = 0; i < arr.size(); i++) {
/*
* if (id.contentEquals(arr.get(i))) {//문자열이 같은지 판단
* System.out.println("중복된 ID");
* continue outer;
* }
*/
if (arr.contains(id)) {//중복된 값이 있는지 체크
System.out.println("중복된 ID");
continue outer;
}
}
arr.add(id);
for (int j = 0; j < arr.size(); j++) {
System.out.println(arr.get(j));
}
}
}
}
ex연습문제1- UserInfo 클래스를 만들어 아이디와 비밀번호를 입력받아 ArrayList에 저장
// 코드1 //결과값이 전체가 다시 나옴
import java.util.ArrayList;
import java.util.Scanner;
class UserInfo{
String id;
int pw;
UserInfo(String id, int pw)
{
this.id = id;
this.pw = pw;
}
}
public class Test07 {
public static void main(String[] args) {
ArrayList<UserInfo> userlist = new ArrayList<>();
Scanner scan = new Scanner(System.in);
while(true)
{
userlist.add(new UserInfo(scan.next(), scan.nextInt()));
for(UserInfo user:userlist)
{
System.out.println("ID:"+user.id +"/PW:"+user.pw);
}
}
}
}one // 입력값
1233 // 입력값
ID:one/PW:1233
two // 입력값
443 // 입력값
ID:one/PW:1233
ID:two/PW:443
// 코드2 //하나씩 추가로 결과값이 나옴
import java.util.ArrayList;
import java.util.Scanner;
class UserInfo {
private String id;
private int pwd;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getPwd() {
return pwd;
}
public void setPwd(int pwd) {
this.pwd = pwd;
}
}
public class Test07 {
public static void main(String[] args) {
ArrayList<UserInfo> arr = new ArrayList<UserInfo>();
outer: while (true) {
System.out.println("아이디 생성 : ");
Scanner scan = new Scanner(System.in);
UserInfo ui = new UserInfo();
ui.setId(scan.next());
for (int i=0; i<arr.size(); i++) {
if(ui.getId().contentEquals(arr.get(i).getId())) {
System.out.println("아이디가 중복됩니다.");
continue outer;
}
}
System.out.println("패스워드 입력 : ");
Scanner scan2 = new Scanner(System.in);
ui.setPwd(scan2.nextInt());
arr.add(ui);
for (int i = 0; i < arr.size(); i++) {
System.out.println(arr.get(i).getId());
System.out.println(arr.get(i).getPwd());
System.out.println("-----------------");
}
}
}
}아이디 생성 :
Hwang
패스워드 입력 :
1234
Hwang
1234
-----------------
아이디 생성 :
Hwang
아이디가 중복됩니다.
아이디 생성 :
hwang
패스워드 입력 :
123
Hwang
1234
-----------------
hwang
123
-----------------
아이디 생성 :
ex연습문제2-Person클래스를 만들어 이름과 나이, 전화번호를 갖는 Person 클래스를 만든 후, ArrayList를 사용하여 아래 결과처럼 만들어보자
1. 정보추가
2. 정보삭제
3. 전체정보
4. 종료
항목선택 : 3 <- 전체정보 항목
----전체정보----
등록인원 1명
이름 : 1
나이 : 1
전화 : 1
// 코드1
import java.util.ArrayList;
import java.util.Scanner;
class Person{
String name;
int age;
int phone;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
public int getPhone() {
return this.phone;
}
public void setPhone(int phone) {
this.phone = phone;
}
}
public class Test08 {
public static void main(String[] args) {
boolean isname =true;
ArrayList<Person> userlist = new ArrayList<>();
Scanner scan = new Scanner(System.in);
outer:while(true){
System.out.println("원하는 항목 번호를 눌러주세요.");
System.out.print("1.정보추가 2.정보삭제 3.전체정보 4.종료 :");
int num = scan.nextInt();
Person per = new Person();
switch(num)
{
case 1:
System.out.print("이름:");
per.setName(scan.next());
System.out.print("나이:");
per.setAge(scan.nextInt());
System.out.print("번호:");
per.setPhone(scan.nextInt());
userlist.add(per);
System.out.println("정보가 저장되었습니다.");
continue outer;
case 2:
System.out.println("삭제할 이름을 써주세요.");
String delname = scan.next();
for (int i = 0; i < userlist.size(); i++) {
if(delname.contentEquals(userlist.get(i).getName())) {
userlist.remove(i);
System.out.println(delname+" 이 삭제되었습니다.");
isname = true;
break;
}
isname = userlist.contains(delname);
}
if(isname == false)
{
System.out.println("이름이 목록에 없습니다.");
break;
}
continue outer;
case 3:
System.out.println("-----전체정보-----");
System.out.println("등록인원 "+userlist.size()+"명");
for (int i = 0; i < userlist.size(); i++) {
System.out.println(userlist.get(i).getName());
System.out.println(userlist.get(i).getAge());
System.out.println(userlist.get(i).getPhone());
System.out.println();
}
continue outer;
case 4:
System.out.println("프로그램을 종료합니다.");
break outer;
default:
System.out.println("숫자를 잘못 입력하셨습니다. 다시 입력해주세요.");
continue outer;
}
}
}
}
// 코드2
import java.util.ArrayList;
import java.util.Scanner;
class Person1{
private String name;
private int age;
private int tel;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getTel() {
return tel;
}
public void setTel(int tel) {
this.tel = tel;
}
}
class PersonManage{
public void personMgr() {
int select;
Person1 p; //Person1 p = new Person1() ???
ArrayList<Person1> personArr = new ArrayList<>();
while (true) {
System.out.println("1. 정보추가");
System.out.println("2. 정보삭제");
System.out.println("3. 전체정보");
System.out.println("4. 종료");
System.out.println("항목선택");
Scanner sc = new Scanner(System.in);
select = sc.nextInt();
switch(select) {
case 1 :
p = new Person1();
System.out.println("정보추가");
System.out.println("이름 : ");
p.setName(sc.next());
System.out.println("나이 : ");
p.setAge(sc.nextInt());
System.out.println("핸드폰 번호 : ");
p.setTel(sc.nextInt());
personArr.add(p);
System.out.println("정보가 저장되었습니다.");
System.out.println("------------------");
break;
case 2 :
System.out.println("정보 삭제");
System.out.println("삭제 할 이름 : ");
String name = sc.next();
for(int i =0; i<personArr.size(); i++) {
if(personArr.get(i).getName().contentEquals(name)){
personArr.remove(i);
System.out.println(name +"님의 정보를 삭제");
break;
}else {
if(i+1 == personArr.size()) { //더이상 데이터 없음.
System.out.println(name+ "님이 없습니다.");
}
}
}
break;
case 3 :
System.out.println("전체정보");
System.out.println("등록인 수 : " +personArr.size()+" 명");
for(int j=0; j<personArr.size(); j++) { //오류나면 j로바꾸기
System.out.println("이름 " + personArr.get(j).getName());
System.out.println("나이 " + personArr.get(j).getAge());
System.out.println("핸드폰 번호 " + personArr.get(j).getTel());
System.out.println("----------------");
}
break;
default :
System.out.println("프로그램 종료");
}
}
}
}
public class Test07 {
public static void main(String[] args) {
PersonManage pMgr = new PersonManage();
pMgr.personMgr();
}
}
Collections.sort(list); 오름 차순
Collections.sort(list, Collections.reverseOrder()); 내림 차순
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class User {
private String name;
private int no;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
}
public class Test09 {
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<User>(); // arraylist의 정렬기능 보기
// Generic 타입으로 객체 생성
User user = new User(); // 일반적인 방법으로 객체 생성
user.setName("고철수");
user.setNo(1);
users.add(user);
user = new User();
user.setName("박영희");
user.setNo(2);
users.add(user);
user = new User();
user.setName("감수왕");
user.setNo(3);
users.add(user);
user = new User();
user.setName("이사람");
user.setNo(4);
users.add(user);
System.out.println("===== 정렬 하기 전 =====");
System.out.println("\n\n 문자 오름차순 정렬 ");
Collections.sort(users, new NameAscCompare());
for (User temp1 : users) {
System.out.print(temp1.getNo() + " : ");
System.out.println(temp1.getName());
}
System.out.printf("\n\n 문자 내림 차순 정렬 \n");
Collections.sort(users, new NameDescCompare());
for (User temp2 : users) {
System.out.print(temp2.getNo() + " : ");
System.out.println(temp2.getName());
}
Collections.sort(users, new NoAscCompare());
System.out.printf("\n\n 숫자 오름 차순 정렬 \n");
for (User temp3 : users) {
System.out.print(temp3.getNo() + " : ");
System.out.println(temp3.getName());
}
Collections.sort(users, new NoDescCompare());
System.out.printf("\n\n 숫자 내림 차순 정렬 \n");
for (User temp4 : users) {
System.out.print(temp4.getNo() + " : ");
System.out.println(temp4.getName());
}
}
static class NameAscCompare implements Comparator<User> {
@Override
public int compare(User x, User y) {
return x.getName().compareTo(y.getName());
}
}
static class NameDescCompare implements Comparator<User> {
@Override
public int compare(User x, User y) {
return y.getName().compareTo(x.getName());
}
}
static class NoAscCompare implements Comparator<User> {
// 숫자 오름차순(ASC)
@Override
public int compare(User o1, User o2) {
return o1.getNo() < o2.getNo() ? -1 : o1.getNo() > o2.getNo() ? 1 : 0;
}
}
static class NoDescCompare implements Comparator<User> {
// 숫자 내림차순(DESC)
@Override
public int compare(User o1, User o2) {
return o1.getNo() > o2.getNo() ? -1 : o1.getNo() < o2.getNo() ? 1 : 0;
}
}
}
Comparable interface를 쓰려면 compareTo 메서드를 구현해야하며,
Comparator interface를 쓰려면 compare 메서드를 구현해야 한다는 점.
Comparable은 "자기 자신과 매개변수 객체를 비교" 하며,
Comparator은 "두 매개변수 객체를 비교" 한다.
'BackEnd > JAVA_Collection' 카테고리의 다른 글
| JAVA Collection, Iterable, List, Set, Queue, Map (0) | 2022.07.21 |
|---|
