플레이스토어 병아리게임 출시!!!~~ [많은 이용 부탁드립니다!]

public void hashTest() {
    HashMap<String, String> map = new HashMap<>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");

    /** 모든 키 가져오기 **/
    Set<String> keys = map.keySet();
    System.out.println("Keys: " + keys);
    // Keys: [key1, key2, key3]

    /** 모든 값 가져오기 **/
    Collection<String> values = map.values();
    System.out.println("Values: " + values);
    // Values: [value1, value2, value3]

    /** 모든 키, 값 가져오기 **/
    for (Map.Entry<String, String> entry : map.entrySet()) {
      System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
      // Key: key1, Value: value1
      // Key: key2, Value: value2
      // Key: key3, Value: value3
    }

}

HashMap의경우 키와 값을 저장합니다. 키로 접근해서 값을 찾습니다. 그래서 키는 중복 저장이 불가능합니다.

• map.put("키","값")
  • 키와 값을 추가합니다.
• map.get("키")
  
  • 키를 통해 값을 가져옵니다.
• map.remove("키")
  • 키와 값을 제거합니다.
    
• entrySet()
  • 모든 키-값 쌍을 포함하는 집합(Set)을 반환한다, Set<Map.Entry<K,V>>형태로 반환하기 때문에 Set에서 for문으로 하나씩 꺼내서 키와 값을 출력할 수 있다.

package collection_fram;

public class Board {
	String subject;
	String content;
	String writer;
	
	public Board(String subject , String content, String writer) {
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}
}

package collection_fram;

import java.util.*;

public class Set_example {

	public static void main(String[] args) {
		
		// 저장 순서가 유지되지 않으며 객체를 중복해서 저장할 수 없다.
		// 인덱스를 매개값을 갖는 메소드가 없다.
		
		Set<String> set = new HashSet<String>();
		
		set.add("Java");
		set.add("JDBC"); // 값 추가
		
		System.out.println(set.size()); // 객체 수
		
		Iterator<String> iterator = set.iterator(); // <String> 을 받는 반복자 생성
		while(iterator.hasNext()) { // hasNext() 가져올 객체값이 있으면 True (0번인 JAVA있으니 True)
			String element = iterator.next(); // 컬렉션에서 하나의 객체를 가져옴 (0번을 가르킨 것을 가져옴)
			System.out.println("\t" + element);
		}
		
		
		set.remove("JDBC");
		

		
		iterator = set.iterator(); // 위에서 반복자가 끝까지 돌았기 때문에 다시 쓸라면 초기화 시켜야함
		while(iterator.hasNext()) { // hasNext() 가져올 객체값이 있으면 True 
			String element = iterator.next(); // 컬렉션에서 하나의 객체를 가져옴 넣은 순서대로?
			System.out.println("\t" + element);
		}
		
		Set<Board> set2 = new HashSet<Board>();
		
		set2.add(new Board("제목1","내용1","글쓴이1"));
		set2.add(new Board("제목2","내용2","글쓴이2"));


		Scanner Scanf = new Scanner(System.in);
 		for (int i = 0 ; i < 3; i++) {
 			String title = Scanf.nextLine();
 			String inner = Scanf.nextLine();
 			String author =Scanf.nextLine();
 			Board temp = new Board(title,inner,author);
 			set2.add(temp);
 		}


		Iterator<Board> iterator2 = set2.iterator(); // <String> 을 받는 반복자 생성
		while(iterator2.hasNext()) { // hasNext() 가져올 객체값이 있으면 True 
			Board element = iterator2.next(); // 컬렉션에서 하나의 객체를 가져옴 넣은 순서대로?
			System.out.println("\t" + element); // collection_fram.Board@7637f22
			System.out.println(element.subject);
			System.out.println(element.content);
			System.out.println(element.writer);
		}
		
		
		iterator2 = set2.iterator(); // 위에서 반복자가 끝까지 돌았기 때문에 다시 쓸라면 초기화 시켜야함
		while(iterator2.hasNext()) { // hasNext() 가져올 객체값이 있으면 True 
			Board element = iterator2.next(); // 컬렉션에서 하나의 객체를 가져옴 넣은 순서대로?
			System.out.println("\t" + element);
			System.out.println(element.subject);
			System.out.println(element.content);
			System.out.println(element.writer);
		
	}


	}
}

HashSet은 저장순서가 유지되지 않고 객체를 중복해서 저장할 수 없습니다.

Set<자료형> 객체 = new HashSet<자료형>();
Set<String> set = new HashSet<String>();

set.add(내용)으로 값을 추가할 수 있습니다.
set.size()으로 set의 갯수를 알 수 있습니다.
set.remove(내용)으로 값을 없앨 수 있습니다.

Iterator란 반복자로 배열같은 것이 있으면 순서대로 반복해서 0 ~ 마지막까지 가는 느낌입니다.

get(인덱스)로 접근할 수 없으니 이와같은 상황에 이용해야 합니다.

Iterator<자료형> 객체명 = 반복자에 이용할 컬렉션프레임.iterator();

Iterator<String> iteartor = set.iterator();

iteartor = set2.iterator(); 처럼 초기화 시켜서 다시 사용할 수 있다.

hasNext()의 경우 가져올 객체의 값이 있으면 True를 반환합니다.

인덱스란 개념이 없지만 첫번째 추가한java를 가르키는 것이 아닌 그 앞에 아무것도 없는 부분을 가르킵니다.

hasNext로 다음 값을 가르키며 가져올 객체의 값이 있는지 확인하는 것입니다.
get(인덱스)가 아닌 next()로 값을 가져올 수 있습니다.

package collection_fram;

public class Board {
	String subject;
	String content;
	String writer;
	
	public Board(String subject , String content, String writer) {
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}
}

package collection_fram;

import java.util.*;

public class LinkedList_example {

	public static void main(String[] args) {


		List<String> list = new LinkedList<String>();
		list.add(0,String.valueOf(1));
		list.add(String.valueOf(2)); // toString의 경우 null 문자열 처리 불가
		list.add(String.valueOf(3));
		System.out.println(list);// [1, 2, ,3]
		list.remove(1); // 2 제거 [1 , 3]
		list.add("2"); //  맨 끝에 2 추가 [1, 3 ,2]
		list.add("1"); // [1, 3, 2, 1]
		System.out.println(list); 
		list.remove("1"); // [3, 2, 1] 가장 적은 인덱스에 것 먼저 제거
		System.out.println(list);
		
		
		List<Board> list2 = new LinkedList<Board>(); 
		list2.add(new Board("제목1","내용1","글쓴이1"));
		list2.add(1,new Board("제목2","내용2","글쓴이2"));
		list2.add(new Board("제목3","내용3","글쓴이3"));
		list2.size(); // 1
		list2.remove(1);
		Board board = list2.get(1); // collection_fram.Board@26f0a63f
		System.out.println(board.subject); // 제목3
		System.out.println(board.content); // 내용3
		System.out.println(board.writer); // 글쓴이3
		


 		for (int i = 0 ; i < 3; i++) {
 			String title = Scanf.nextLine();
 			String inner = Scanf.nextLine();
 			String author =Scanf.nextLine();
 			Board temp = new Board(title,inner,author);
 			list2.add(temp);
 		}

	}

}

Linked List (연결리스트)의 특징은 배열과 다르게 인덱스 값이 아닙니다. 

여러 유형이 있지만 위에 사진 처럼 Data값과 다음 주소를 가르키고 있는 NEXT로 이루어져있는 걸로 생각 해봅시다.

Linked List의 특징은 인덱스로 값을 한번에 찾아갈 수 없습니다. 왜냐하면 인덱스를 이용 안 하거든요

찾아가려면 Head에 연결된 부분에서 Data값을 확인 후 아니면 Next 이런식으로 끝까지 가야합니다.

그럼 이런거에 장점이 뭐냐 싶은데 장점은 ArrayList나 Vector의 경우 값을 중간에 추가시키려면

전부를 다 밀어야합니다. 예를 들어 100개 인덱스까지 저장되어있는 건데 인덱스 2에 추가시키려면

2에서 99번까지 하나씩 밀어야 합니다.

하지만 Linked List는 NEXT의 주소를 추가하려는 거에 위에 사진처럼 가르키게하면 됩니다.

List <자료형> 객체명 = new LinkedList<자료형>();
List <String> list = new LinkedList<String>();

List <Board> list = new LinkedList<Board>();

list.add("내용"); 으로 추가 시킬 수 있습니다. 또한

list.add(인덱스,"내용")으로 해당 인덱스에 추가시킬 수 있습니다.

list.get(인덱스)로 해당 인덱스의 값을 반환 받을 수 있습니다.

list.size()로 해당 ArrayList의 사이즈를 알 수 있습니다.

list.remove(인덱스)로 해당 인덱스 값을 삭제 할 수 있습니다.

또한 Board라는 클래스를 이용한 객체를 자료형에 선언도 가능합니다.

이럴경우 get으로 접근 할때 board.subject로 접근하던가 아니면 값을 return해주는 getter있으면 됩니다.

값을 입력받아 넣을 때는 각각에 해당되는 생성자의 매개변수를 미리 입력받아 넣고 그걸 생성자로 선언해

add를 통해 차곡차곡 쌓으면 됩니다.

package collection_fram;

public class Board {
	String subject;
	String content;
	String writer;
	
	public Board(String subject , String content, String writer) {
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}
}

package collection_fram;

import java.util.*;

public class Vector_example {

	public static void main(String[] args) {
		
		// ArrayList랑 비슷하지만 Vector는 동기화된 메소드로 구성되어
		// 멀티 스레드가 동시에 이 메소드를 실행할 수 없다		
		
		List<Board> list = new Vector<Board>();
		list.add(new Board("제목1","내용1","글쓴이1"));
		list.add(new Board("제목2","내용2","글쓴이2")); 
		list.add(0,new Board("제목3","내용3","글쓴이3"));
		list.remove(1); // 1번 인덱스 제거
		System.out.println(list.size());
		Board board = list.get(0);
		System.out.println(list.get(0)); // collection_fram.Board@4361bd48
		System.out.println(board.subject); // 제목1
		System.out.println(board.content); // 내용1
		System.out.println(board.writer); // 글쓴이1
		System.out.println(list.get(1).subject);
		
		Scanner Scanf = new Scanner(System.in);
		
 		for (int i = 0 ; i < 3; i++) {
 			String title = Scanf.nextLine();
 			String inner = Scanf.nextLine();
 			String author =Scanf.nextLine();
 			Board temp = new Board(title,inner,author);
 			list.add(temp);
 		}		
	}

}

Vector는 배열과 유사하고 ArrayList와도 유사합니다.

둘다 최적의 스토리지 사용을 유지하기 위해 동적으로 증가 및 축소 되지만 크기 조정 방식은 다릅니다. 

ArrayList는 요소 수가 용량을 초과하면 현재 배열 크기의 50 %를 증가시키는 반면 

벡터는 100 % 증가하여 본질적으로 현재 배열 크기를 두 배로 늘립니다.

또한 Vector는 동기화되어서 멀티스레드가 동시에 실행하지 않아 ArrayList에 비해 느립니다.

List<자료형> 객체명 = new Vector<자료형>();

List<Board> list = new Vector<Board>();

list. add("내용"); 으로 추가 시킬 수 있습니다. 또한

list.add(인덱스,"내용")으로 해당 인덱스에 추가시킬 수 있습니다.

list.get(인덱스)로 해당 인덱스의 값을 반환 받을 수 있습니다.

list.size()로 해당 ArrayList의 사이즈를 알 수 있습니다.

list.remove(인덱스)로 해당 인덱스 값을 삭제 할 수 있습니다.

또한 Board라는 클래스를 이용한 객체를 자료형에 선언도 가능합니다.

이럴경우 get으로 접근 할때 board.subject로 접근하던가 아니면 값을 return해주는 getter있으면 됩니다.

값을 입력받아 넣을 때는 각각에 해당되는 생성자의 매개변수를 미리 입력받아 넣고 그걸 생성자로 선언해

add를 통해 차곡차곡 쌓으면 됩니다.

package collection_fram;

public class Board {
	String subject;
	String content;
	String writer;
	
	public Board(String subject , String content, String writer) {
		this.subject = subject;
		this.content = content;
		this.writer = writer;
	}
}

package collection_fram;

import java.util.*;

public class ArrayList_example {

	public static void main(String[] args) {
		// List 인터페이스의 클래스
		// 객체 삽입하거나 제거되었을 때 하나씩 밀려나는 특징 LinkedList에 비해 안 좋음
		// 채우는 순서는 정해져있음 0 부터 ~ 차근차근
		// 제거하거나 추가하는 경우 인덱스가 하나씩 밀린다
		// 그냥 배열하고 다른 점은 크기가 동적으로


		
		List<String> list = new ArrayList<String>(); // (40) 숫자 지정가능
		// List list = new ArrayList(); 일 경우 객체를 다 받지만 형변환 속도문제가 생김
		list.add("홍길동"); //맨 끝에 객체 추가
		list.add(1,"신용권2"); // 지정 인덱스에 삽입
		list.add(1,"신용권"); // 지정 인덱스에 삽입
		String str = list.get(1); // 인덱스 1값 반환
		System.out.println(str); // 신용권
		list.size(); // 객체 수
		list.remove(0); // 인덱스로 삭제
		list.remove("신용권"); // 객체명으로 삭제
		
		

		
		List<Board> list2 = new ArrayList<Board>(); 
		list2.add(new Board("제목1","내용1","글쓴이1"));
		list2.add(1,new Board("제목2","내용2","글쓴이2"));
		list2.add(new Board("제목3","내용3","글쓴이3"));
		list2.size(); // 1
		list2.remove(1);
		Board board = list2.get(1); // collection_fram.Board@26f0a63f
		System.out.println(board.subject); // 제목3
		System.out.println(board.content); // 내용3
		System.out.println(board.writer); // 글쓴이3
		
		Scanner Scanf = new Scanner (System.in);

 		for (int i = 0 ; i < 3; i++) {
 			String title = Scanf.nextLine();
 			String inner = Scanf.nextLine();
 			String author =Scanf.nextLine();
 			Board temp = new Board(title,inner,author);
 			list2.add(temp);
 		}

	}

}

컬렉션 프레임워크란 다수의 데이터를 쉽고 효과적으로 처리할 수 있는 표준화된 방법을 제공하는 클래스 집합입니다.

즉, 데이터를 저장하는 자료구조와 데이터 처리하는 알고리즘을 구현해 놓은 것입니다.

오늘은 그중 ArrayList에 대해서 알아보려고 합니다.

List 인터페이스에서 상속 받는 걸로 삽입되거나 삭제 될 때 하나씩 밀려나가는 특징이 있습니다.

채우는 순서가 정해져있습니다. (0번 인덱스 ~ ...)

배열과 아주 유사한데 다른 점은 크기를 동적으로 지정할 수 있습니다.

삽입과 삭제가 빈번한 데이터인 경우에는 부적합 합니다.

List<배열 자료형> list객체명 = new ArrayList<배열 자료형> (크기);

List<String> list = new ArrayList<String>(); 로 처음에 선언이 가능합니다. (동적으로 크기 변화)

List<String> list = new ArrayList<String>(40);처럼 크기를 정해줄 수 있습니다.

list. add("내용"); 으로 추가 시킬 수 있습니다. 또한

list.add(인덱스,"내용")으로 해당 인덱스에 추가시킬 수 있습니다.

list.get(인덱스)로 해당 인덱스의 값을 반환 받을 수 있습니다.

list.size()로 해당 ArrayList의 사이즈를 알 수 있습니다.

list.remove(인덱스)로 해당 인덱스 값을 삭제 할 수 있습니다.

또한 Board라는 클래스를 이용한 객체를 자료형에 선언도 가능합니다.

이럴경우 get으로 접근 할때 board.subject로 접근하던가 아니면 값을 return해주는 getter있으면 됩니다.

값을 입력받아 넣을 때는 각각에 해당되는 생성자의 매개변수를 미리 입력받아 넣고 그걸 생성자로 선언해

add를 통해 차곡차곡 쌓으면 됩니다.

package date_method;

import java.text.SimpleDateFormat;
import java.util.*;

public class DateMethod {

	public static void main(String[] args) {
		Date now = new Date();
		String strNow1 = now.toString();
		System.out.println(strNow1);

		SimpleDateFormat sdf = new SimpleDateFormat
               ("yyyy년 MM월 dd일 HH시 mm분 ss초");
		String strNow2 = sdf.format(now);
		System.out.println(strNow2);

	}

}

Date클래스는 요일 / 월 / 일 / 시각 / KST(Korean Standard Time) / 년도 을 출력합니다.

SimpleDateForamt을 이용해 어떤 형식으로 보여지게 할지 형식을 변경할 수도 있습니다.

저는 새벽에 알바하면서 작업중입니다... 흑흑

https://github.com/SungJLee/My_Java_World.git

package math_methods;

public class MathMethods {

	public static void main(String[] args) {
		System.out.println("절댓값");
		int v1 = Math.abs(-5);
		double v2 = Math.abs(-3.14);
		System.out.println("v1 = " + v1);
		System.out.println("v2 = " + v2);
		System.out.println();
		
		System.out.println("올림");
		double v3 = Math.ceil(5.3);
		double v4 = Math.ceil(-5.3);
		System.out.println("v3 = " + v3);
		System.out.println("v4 = " + v4);
		System.out.println();
		
		System.out.println("버림");
		double v5 = Math.floor(5.3);
		double v6 = Math.floor(-5.3);
		System.out.println("v5 = " + v5);
		System.out.println("v6 = " + v6);
		System.out.println();
		
		System.out.println("최댓값");
		int v7 = Math.max(5,  9);
		double v8 = Math.max(5.3, 2.5);
		System.out.println("v7 = " + v7);
		System.out.println("v8 = " + v8);
		System.out.println();
		
		System.out.println("최솟값");
		int v9 = Math.min(5, 9);
		double v10 = Math.min(5.3, 2.5);
		System.out.println("v9 = " + v9);
		System.out.println("v10 = " + v10);
		System.out.println();
		
		System.out.println("랜덤");
		// double v11 = Math.random(); // 0 ~ 1까지 랜덤
		int v11 = (int)(Math.random()*6) + 1;
		System.out.println("v11 = " + v11);
		System.out.println();
		
		System.out.println("가까운 정수");
		double v12 = Math.rint(5.3);
		double v13 = Math.rint(5.7);
		System.out.println("v12 = " + v12);
		System.out.println("v13 = " + v13);
		System.out.println();
		
		System.out.println("반올림");
		long v14 = Math.round(5.3);
		long v15 = Math.round(5.7);
		System.out.println("v14 = " + v14);
		System.out.println("v15 = " + v15);
		System.out.println();
		
		System.out.println("반올림 가공(소수점 두번째자리 반올림)");
		double value = 12.3456;
		double temp1 = value * 100; // 1번째 자리면 * 10
		System.out.println("temp1 = " + temp1);
		long temp2 = Math.round(temp1);
		System.out.println("temp2 = " + temp2);
		double v16 = temp2 / 100.0;
		System.out.println("v16 = " + v16);

	}

}

Maht.abs()

     절대값처리를 해줍니다.

Maht.ceil()

     소수점 올림처리를 해줍니다.

Maht.floor()

     소수점 버림처리를 해줍니다.

Maht.math()

     두 수중 최대값을 구해줍니다.

Maht.min()

     두 수중 최솟값을 구해줍니다.

Math.random()

     0 ~ 1까지 랜덤으로 나옵니다.

     *6은 6 나올 숫자가 6가지인거고 +1은 1부터 시작한다는 의미로 1 ~ 6까지 숫자가 랜덤으로 나옵니다.

Maht.rint()

     소수점까지 있을 때 가까운 정수를 구해줍니다.

Maht.round()

     반올림 처리를 해줍니다.

https://github.com/SungJLee/My_Java_World.git

package token;

import java.util.StringTokenizer;

public class ToeknExam {

	public static void main(String[] args) {
	
		String text = "홍길동/이수홍/박연수";
		
		StringTokenizer st = new StringTokenizer(text,"/");
		// "/" 기준으로 분리함
		int countTokens = st.countTokens();
		for (int i = 0 ; i < countTokens; i++) {
			String token = st.nextToken(); // 토큰 한개 pop
			System.out.println(token);
		}
		
		System.out.println();

			st = new StringTokenizer(text,"/");
			while(st.hasMoreTokens()) { // 토큰이 남아있는가
				String token = st.nextToken();
				System.out.println(token);
			}
	}
}

토큰이란 계주를 하는 것과 비슷합니다. 바톤을 들고 자기 역할을 다 하면 다른 사람한테 전달해주는 거 처럼

자기가 토큰이란 걸 가지고 있다가 자기가 할 일을 다 하면 전달해주는 거라고 생각하시면 됩니다.

이걸로 어떤 일을 할 수 있냐면 위에 코드와 같이 StringTokenizer로 /로 구분되어 있는 String형을 받아서

"/"로 나눠서 배열에 저장하는 거마냥 구분합니다.

그리고 countTokens로 몇개로 구분되어 있는지 갯수를 셉니다.

그리고 처음 토큰은 0번째 인덱스라고 해야할까요 홍길동한테 있지 않고 아예 다른 곳에 보존되어 있습니다.

그걸 nextToken()을 통해서 넘겨줍니다. 이런식으로 for문을 countTokens만큼 돌 수도 있지만

hasMoreTokens()라는 메소드를 통해서 토큰이 아예 다른 곳에 보존된 곳 홍길동 이수홍 박연수가 가지고 있는지 

확인시키고 가지고 있을시 True를 반환해줍니다.

결국 박연수가 자기 다음으로 토큰반환소에 주면 false를 반환해서 while문을 탈출합니다.

https://github.com/SungJLee/My_Java_World.git

package casting_methods;

public class CastingMethods {

	public static void main(String[] args) {

		System.out.println("*********** 문자열 -> 기본타입(정수, 실수) 변환Test ******");
		
		int value1 = Integer.parseInt("10");
		
		double value2 = Double.parseDouble("3.14");
		
		System.out.println("Value1 : " + value1);
		System.out.println("Value2 : " + value2);
		
		System.out.println("*********** 기본타입(정수, 실수) -> 문자열 변환Test ******");
		
		String str1 = String.valueOf(10); 
		String str2 = String.valueOf(10.5);
		
		System.out.println(str1);
		System.out.println(str2);
		
		System.out.println("*********** 객체 -> 문자열 변환Test ******");
		
		Integer obj1 = 300;
		Double obj2 = 111.11;
		
		String str3 = Integer.toString(obj1);
		String str4 = Double.toString(obj2);
		
		System.out.println(str3);
		System.out.println(str4);

	}

}

형변환하는 메소드에 대해서 알아보도록 하겠습니다.

Integer.parseInt는 문자열을 int형으로 변환시킵니다.

Double.parseDouble은 문자열을 double형으로 변환시킵니다.

여기서 공통점이 있죠? 바꿀 기본자료형.parse바꿀 기본자료형으로 하시면 됩니다(첫 글자는 대문자!!)

다시 String형으로 바꾸려면 String.valueOf를 사용할 수도 있고

Integer.toString() 즉 자료형.toString으로 쓸수도 있습니다.

https://github.com/SungJLee/My_Java_World.git