iridescent

• Java Development Environment
  • integrated Development Environment (IDE)
    • 통합 개발 환경
    • Eclipse, Netbeans, InteliJ IDEA

예약어와 식별자

• 식별자
  • 명명 규칙에 따라야함
    1. 문자, $, _로 시작해야함
    2. 숫자로 시작할 수 없음
    3. 대,소문자 구분됨
    4. 예약어는 사용할 수 없음

변수와 자료형

• 변수
  • 데이터를 다루는 상자 (공간)
• 자료형
  • 기본 자료형
    • 변수를 사용하는 도중 변경할 수 없음
    • 최소 단위의 자료형
    • 메소드 없이 값만 가짐
    • ex) 
    • int score = 50;​
  • 참조형
    • 여러 자료형들의 집합
    • 클래스의 객체를 참조
    • 데이터 있을 수도 있고 없을 수도 있음
    • 데이터와 메소드를 가짐 
    • 상자보다는 짝대기라고 생각.
    • ex)

      String mStr = new mStr();​

      

이렇게 보면

H1과 H3가 같고

H2는 다르게 가르키는 것을 알 수 있다. 

• 기본 자료형
  • 정수형
    • 가장 왼쪽 비트 : 부호
    • long > int > short

      public static void intLongEx() {
      		//byte(1) < short(2) < int(4:default) < long(8)
      		int intVar1;	//변수 선언
      		int intVar2;	//선언
      		
      		intVar1 = 2021;	//변수 초기화
      		//intVar2 = 1234567891234; 	//표현할 수 있는 범위 초과
      		
      		System.out.println(intVar1); 	//변수 값 조회
      		
      		long longVar1 = 2021;	// 선언 + 초기화
      		// long longVar2 = 1234567891234;	//오류
      		long longVar2 = 1234567891234L;		//	L (or l)추가
      		
      		
      		//	2진수, 8진수, 16진수
      		int bin, oct, hex;
      		bin = 0b1101;	//	2진수 0b
      		oct = 0721;		// 8진수 0
      		hex = 0xFF;		// 16진수 0x
      		
      //		결과 -> bin : 13, oct : 465, hex : 255
      		System.out.println("bin : " + bin + ", oct : " + oct + ", hex : "+ hex);
      		
      		
      	}

    • 문자형

      // 	문자형 타입 : 부호 없는 정수
      	private static void charEx() {
      		char ch1 = 'A';
      		char ch2 = '한';
      		
      		System.out.println(ch1);
      		System.out.println(ch2);
      		
      //		결과 -> ch1 4글자 뒤인 69가 나온다.
      		System.out.println(ch1+4);
      //		결과 -> ch1 4글자 뒤인 E가 나온다.
      		System.out.println((char)(ch1+4));
      	
      		
      	}​

  • 실수형 논리형
    • 실수형 
      • double :  정밀도 포기, 표현 범위만 넓어짐, 형 변환시 유실 일어남
      • 지수 표기법 (e) : 3E - 6F = 3 * 10^-6

        //	실수형 타입
        	private static void floatDoubleEx() {
        		//	float(4) < double(8)
        		// 	정밀도 포기, 표현 범위 넓힌 것 -> 금융권 안 씀
        		
        		// float floatVar = 3.14159;	//오류
        		float floatVar = 3.14159F;	// 	float사용 시 뒤에 F or f 추가
        		double doubleVar = 3.14159;
        		
        		floatVar = 0.123456890123456789F;
        		doubleVar = 0.123456890123456789;
        		
        //		결과 -> float : 0.12345689, Double : 0.12345689012345679
        		//	둘 다 오차가 있음, double은 수용범위 안에서 반올림 한다.
        		System.out.println("float : "+ floatVar + ", Double : " + doubleVar);
        		
        //		결과 -> 0.30000000000000004
        		System.out.println(0.1*3);
        		
        		
        		//지수 표기법(e)
        		floatVar = 3E-6F;	// 3 * 10 ^ -6
        		System.out.println(floatVar);
        		
        	}​

    • 논리형
      • C처럼 boolean 값을 값으로 하지 않는다. 
      • true/false 그 자체로 저장이 가능하다.

        //	논리형 : 참 or 거짓
        	private static void booleanEx() {
        		boolean b1 = true;
        		boolean b2 = false;
        		
        		System.out.println(b1);
        		System.out.println(b2);
        		
        		boolean result;
        		
        		int var1 = 3;
        		int var2 = 5;
        		
        		result = var1 < var2;	//비교 결과 넣기
        //		결과 -> 3 < 5 = true
        		System.out.println(var1 + " < " + var2 + " = " + result);
        	}​

• 상수와 형변환
  • 상수
    • 변경할 수 없는 고정된 데이터
    • 코드의 이해와 변경이 쉬움
    • final 로 선언 ( 선언과 동시에 할당)
      1. final class : 상속 불가
      2. final 메소드 : 오버라이딩 불가 (재사용)
    • 대문자로 표현한다. 
    • ex)

      int SPEED = 110;​

      스피드의 값을 함수안에서 SPEED로만 가지고 사용하면
      1. 코드 가독성이 좋아짐
      2. 유지보수 종속성이 높아짐
      3. 안정성
  • 형 변환
    • byte(1) < short, char (2) < long (8) < float (4) < double (8) 
    • 암묵적 형변환

      //	형 변환(Promotion)
      	private static void promotionEx() {
      // 1. 암묵적 형 변환
      	//	표현 범위 좁은 자료 -> 표현 범위가 넓은 자료
      	//	자동으로 변환 promation
      		byte b = 25;	//1바이트 정수
      		System.out.println(b);
      		
      		short s = b;	//	2바이트 정수
      		
      		int i = s;	//	4바이트 정수
      		System.out.println(i);
      		
      		float f = i;	//	4바이트 실수
      		System.out.println(f);	
      	}​

      • 표현범위가 작은 곳에서 큰 곳으로 할당
    • 강제 형 변환
      • 큰 자료형에서 작은 자료형

        // 2. 강제 형 변환 (Casting)
        	private static void castingEx() {
        	//	표현 범위가 넓은 자료 -> 표현 범위 좁은 자료
        	//	명시적으로 변환 해줘야 함
        		float f = 123.456f;
        		System.out.println(f);
        		
        		//int i = f;	//오류
        		int i = (int)f;
        		System.out.println(i);	//123
        		
        		int i2 = 1234567890;
        		System.out.println(Integer.toBinaryString(i2));	//1001001100101100000001011010010
        
        		short s = (short)i2;
        		System.out.println(Integer.toBinaryString(s));	//1011010010
        		
        		//주의점 : 형 변환 시 자료 유실이 일어날 수 있으므로 주의
        		
        	}​

연산자와 문자열

• 연산자
  • 순위
    1. 함수
    2. 산술연산 -> 비교연산-> 논리연산
    3.  .....
    4. 할당연산자
  • 산술 연산자

    //	산술 연산자
    	private static void arithOperEx() {
    		int a = 7;
    		int b = 3;
    		
    		//부호 연산자 (+,-)
    		System.out.println(-a);	// -1 * a
    		
    		//	산술 연산자 (+, -, *, /, %)
    		System.out.println(a / b);	//	int / int = int(몫)
    		System.out.println(a % b); //	정수 나눗셈의 나머지
    		
    //		System.out.println(a / 0);	//	에러 발생 (정수 나누기 0은 무한대라서)
    		System.out.println(7.0 / 0); //	Infinity(무한대)
    		System.out.println(7.0 / 0 + 100); // 	Infinity가 포함된 산술식 : 무한대
    		
    		//	어떤 값이 Infinity인지 체크
    		System.out.println(Double.isInfinite(7.0 / 0));	// 	true
    		
    		//	연산 결과값이 수치가 아닌 경우 (Not a Number) 체크
    		System.out.println(0.0 / 0.0);	//	NaN
    		System.out.println(Double.isNaN(7.0 / 0));	//	false -> 무한대라서 NaN아님
    		
    	}​

  • 전위 증감 연산

    //전위 증감
    	private static void prefixIncrEx() {
    		int a = 7;
    		int b = 0;
    		
    		b = ++a;
    		System.out.println("b : " + b);		// 8
    		System.out.println("a : " + a);		// 8
    	}​

  • 후위 증감 연산

    //	후위 증감 연산
    	private static void suffixIncrEx() {
    		int a = 7;
    		int b = 0;
    		
    		b = a++;
    		System.out.println("b : " + b);		// 7
    		System.out.println("a : " + a);		// 8
    	}​

  • 비교, 논리 연산

    //	비교, 논리 연산
    	private static void logicalOperEx() {
    		//	비교 연산자 : >, >=, <=, ==(equal), !=(not equal)
    		//	논리 연산자 : 논리곱 (AND, &&), 논리합(OR, ||), 논리 부정 (NOT, !)
    		int a = 5;
    		//	a가 0초과, 10미만의 값?
    		//	조건 1 : a > 0
    		//	조건 2 : a < 10
    		//	결과 : 조건1 AND 조건2
    		boolean b1 = a > 0;
    		boolean b2 = a < 10;
    		
    		boolean r = b1 && b2;
    		System.out.println("b1 && b2 = " + r);	//	true
    		
    		
    		//	10이상, 0이하
    		//	조건 1 : a <= 0
    		//	조건 2 : a >= 10
    		b1 = a <= 0;
    		b2 = a > 10;
    		r = b1 || b2;
    		System.out.println("b1 || b2 = " + r);	//false
    		
    		//	논리 부정 (NOT !)
    		System.out.println("!r == " + !r);	//true
    		
    	}​

  • 비트 연산자

    //비트 연산자
    	private static void bitOperEx() {
    		// int에서만
    		// 비트 단위의 미세한 제어에 이용
    		int b1 = 0b11011101;
    		int mask = 0b10101010;
    		
    		System.out.println(Integer.toBinaryString(b1));
    		System.out.println(Integer.toBinaryString(mask));
    		
    		System.out.println(Integer.toBinaryString(b1 & mask));	//비트 논리 곱
    		System.out.println(Integer.toBinaryString(b1 | mask));	//비트 논리 합
    		System.out.println(Integer.toBinaryString(~b1));	//비트 논리부정
    		
    	}​

  • 비트 시프트

    //비트 시프트
    	private static void bitshiftOperEx() {
    		int val = 1;
    		System.out.println(Integer.toBinaryString(val));
    		//왼쪽으로 3비트 시프트
    		System.out.println(Integer.toBinaryString(val<<3));
    		
    		int val1 = 0b1000;
    		System.out.println(Integer.toBinaryString(val1));
    		System.out.println(Integer.toBinaryString(val1>>2));
    	}​

  • 삼항 연산자

    //3항 연산자
    	private static void conditionalOperEx() {
    		int a = 10;
    		//	a가 짝수면 짝수, 홀수면 홀수 출력
    		System.out.println(a + "는 " + (a % 2 == 0? "짝수":"홀수"));
    		
    		int score = 49;
    		String message;
    		//	점수가 90점 이상이면 Good, 50점 미만이면 Fails, 아니면 Pass
    		System.out.println(score + "는 " + (score > 90? "Good":score < 50? "Fails":"Pass"));
    		
    	}​

• 콘솔 입출력
  • 콘솔 출력

    private static void consoleOutputEx() {
    		//	System.out.print : 개행 안 함
    		//	System.out.println : 개행함
    		//	System.out.printf : 형식 지정 문자열 출력 -> String.format
    		
    		System.out.print("print : 개행 안 함");
    		System.out.println(" println : 개행함");
    		
    		
    		//	이스케이프 문자
    		//	\n(개행), \t(탭문자), \"(따옴표), \\(역슬래시)
    		System.out.println("Hello\n Java");	//	개행
    		System.out.println("Hello\t Java");	//	탭 문자
    		System.out.println("Hello \"Java\"");	//	따옴표 
    		
    		String dir = "C:\\User\\Bit\\Desktop";
    		System.out.println(dir);
    	}​

  • 콘솔 입력

    //	콘솔 입력
    	private static void consoleInputEx() {
    		Scanner scanner = new Scanner(System.in);
    		System.out.print("이름 : ");
    		String name = scanner.next();
    		System.out.print("나이 : ");
    		int age = scanner.nextInt();
    		
    		System.out.println("당신의 이름은 "+ name+ ", 나이는 "+ age + "입니다.");
    		scanner.close();
    	}​

자바 공부하기 위해 한번 작성하면서 공부를 해보겠다.

https://www.acmicpc.net/problem/2750

정렬부터 시작했는데, 

먼저 첫 번째는 

Arrays함수를 사용해서 sort함수 이용해서 했다. ㅎㅎㅎㅋㅋㅋㅋ

import java.util.*;

public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++) {
			array[i]= scanner.nextInt();
		}
		Arrays.sort(array);
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

뭐 함수를 써보긴 해야 하니깐,, 

두 번째는 

버블 정렬을 사용했다. 

import java.util.*;
//버블 정렬
public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++)
			array[i]= scanner.nextInt();
		
		for(int i = 0; i<N-1; i++) {
			for(int row = 0, tem = 0; row <N-1-i; row++) {
				if(array[row] > array[row+1]) {
					tem = array[row];
					array[row] = array[row+1];
					array[row+1] = tem;
				}
			}
		}
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

선택정렬

package backjoon;

import java.util.*;
//버블 정렬
public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++)
			array[i]= scanner.nextInt();
		
		for(int i = 1,j; i<N;i++) {
			int compare_num = array[i];
			for(j = i-1; j>=0 && array[j]>compare_num; j--)
				array[j+1] = array[j];
			array[j+1] = compare_num;
			}
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

확실히 정렬을 오랜만에 만들어보는데

저학년일 때보다는 낫다,,

더 해보자,, 

https://jinseongsoft.tistory.com/251

해보았지만 계속 오류가 났다. 

https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/

여기서 보면 github는 '2021년 8월 13일부터 Git 작업을 인증할 때 계정 비밀번호를 더 이상 받지 않으며 GitHub.com에서 인증된 모든 Git 작업에 대해 개인 접속 토큰(개발자용)이나 OAuth 또는 GitHub App 설치 토큰(통합자용)과 같은 토큰 기반 인증을 사용하도록 요구할 예정이다.'이라고 파파고가 번역해줬다. 

https://hyeo-noo.tistory.com/184

여기 너무 상세히 적혀있다. 

여기 있는 것을 다 따라하고 , 체크해주면 된다. 

여기서 해시값을 따로 복사해서 저장해둬야한다. 

위에 말한 것처럼 비밀번호대신 hash값을 넣어야 하기 때문이다. 

이만 뿅 

프로젝트를 진행하면서 github를 쓸 수가 없어서 

막 힘들게 힘들게 만들어놓은 잔디밭이 비어져있었다,,

그래서 잔디밭을 매꾸러 날짜 수정을 해보겠다. 

① 먼저. 나는 git bash를 사용했다. 

물론 git을 사용하려면 git을 설치해야 한다. 

설치는 넘어가고

bash창을 열면 

② cd를 통해서 git이 저장될 장소에 간다. 

난 git파일을 D드라이버에 하고 싶어서 여기로 했다. 

복사하면 된다. 

여기서 물론, 파일 경로 적을 때 '\'로 적으면 안 되고, 

'/'로 사용해야한다.

난 이미 저장된 것의 날짜를 수정하기 위한 것이기 때문에, 

혹시 모르니

git init
git remote https://깃허브 주소

하고

③

git log

여기서 수정할 코드의 해시값을 복사를 해준다. 

백 트래킹 이 친구를 함 해보겠다. 

해시값을 복사해준다. 

④ 'q'를 눌러 나간다. 

⑤

git rebase -i 해시값

⑥ 젤 첫 줄에 'pick'값을 'edit'라고 바꾸고

'esc'누르고 ':w'엔터 친다

⑦ 자기가 원하는 달과 날짜, 시간을 지정한다. 

GIT_COMMITER_DATE="Sep 22 10:00:00 2018 +0000" git commit --amend --no-edit --date "Sep 22 10:00:00 2018 +0000"

⑧ git log로 확인한 뒤

⑨ git push 해준다. 

push에서 로그인하면 된다. 

cout << fixed << setprecision(1) << (min_pa + min_ju) + ((min_pa + min_ju) * 0.1);

fixed << setprecision(소수점 아래 수)

fixed가 있으면, 소수점 아래의 수만 생각하고

없으면 자연수까지 생각한다고 한다. 

setprecision(5)이면

123.45까지

 fixed << setprecision(5)이면

123.45678

이렇게 나온다. 

set과 map의 차이점 

set : key만 사용

map: key와 값이 한 쌍으로 저장함

set 의 장점

정렬 가능

key가 비어있는지 없는지 

검색 속도가 빨라야 할 때

set의 사용법

• #include <set>
• 선언 : set < key자료type, 비교함수 > 변수이름
  • 오름차순 : set<string>s;
  • 내림차순 : set<string, greater<string>> s;
• key 추가
  • s.insert ("hi")
  • 특정 위치에 추가 : s.insert ( s.begin(), "hh" ) : 첫 번째 위치에 "hh"저장
• 탐색
  • for_each 사용 
  • for -> iterator(반복자) 사용

참고 :

modoocode.com/260

hwan-shell.tistory.com/130