My Dev Blog

<비트 연산자>

// 비트 연산자
System.out.println(1 << 5); // 1 -> 100000 // 32
System.out.println(2 << 5); // 10 -> 1000000 // 64
System.out.println(10 >> 1); // 1010 -> 101 // 5
System.out.println(10 >> 2); // 1010 -> 10 // 2
System.out.println(1 << 5 & 1 << 3); // 100000 & 1000 // 모두 1인 경우만 1로 => 000000 // 0
System.out.println(13 & 9); // 1101 & 1001 // 모두 1인 경우만 1로 => 1001 // 9
System.out.println(1 << 5 | 1 << 3); // 100000 | 1000 // 하나라도 1이면 1로 => 101000 // 40
System.out.println(13 | 9); // 1101 | 1001 // 하나라도 1이면 1로 => 1101 // 13
System.out.println(13 ^ 9); // 1101 ^ 1001 // 모두 같으면 0, 다르면 1로 => 100 // 4
System.out.println(~13); // ~1101 // 8비트로 만든 후 0과 1 바꿈 => 00001101 => 11110010 // -14
// 2의 보수 = 1의 보수(0과 1 바꿈) + 1
// 10진수 -14를 2진수로 표현
// 14를 8비트로 만든다. 00001110
// -14는 음수이므로 첫 번째 부호 비트를 1로 바꾼다. 10001110
// 부호 비트만 그대로 유지하고 0과 1을 바꾼다.(1의 보수) 11110001
// 1을 더한다. 11110010

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class DequeSample {
	
	// Stack, Queue, Deque

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Deque<Integer> stack1 = new ArrayDeque<>(); // addFirst + removeFirst // 스택
		
		stack1.addFirst(1);
		stack1.addFirst(2);
		stack1.addFirst(3);
		
//		stack1.add(4); // add는 addLast와 같음 // addFirst로 쌓고 있었는데 그 방향과 반대 방향에 추가 4, 1, 2, 3이 됨
//		stack1.addFirst(5); // 1, 2, 3과 같은 방향으로 추가 // 4, 1, 2, 3, 5
//		stack1.addLast(6); // addFirst와 반대 방향으로 추가 // 6, 4, 1, 2, 3, 5
		
		System.out.println("stack1"); // stack1
		
		System.out.println(stack1.peekFirst()); // 3
		System.out.println(stack1.removeFirst()); // 3
		System.out.println(stack1.removeFirst()); // 2
		System.out.println(stack1.removeFirst()); // 1
		
		Deque<Integer> queue1 = new ArrayDeque<>(); // addFirst + removeLast // 큐
		
		queue1.addFirst(1);
		queue1.addFirst(2);
		queue1.addFirst(3);
		
		System.out.println("queue1"); // queue1
		
		System.out.println(queue1.peekLast()); // 1
		System.out.println(queue1.removeLast()); // 1
		System.out.println(queue1.removeLast()); // 2
		System.out.println(queue1.removeLast()); // 3
		
		Deque<Integer> queue2 = new ArrayDeque<>(); // addLast + removeFirst // 큐
		
		queue2.addLast(1);
		queue2.addLast(2);
		queue2.addLast(3);
		
		System.out.println("queue2"); // queue2
		
		System.out.println(queue2.peekFirst()); // 1
		System.out.println(queue2.removeFirst()); // 1
		System.out.println(queue2.removeFirst()); // 2
		System.out.println(queue2.removeFirst()); // 3
		
		Deque<Integer> stack2 = new ArrayDeque<>(); // addLast + removeLast // 스택
		
		stack2.addLast(1);
		stack2.addLast(2);
		stack2.addLast(3);
		
		System.out.println("stack2"); // stack2
		
		System.out.println(stack2.peekLast()); // 3
		System.out.println(stack2.removeLast()); // 3
		System.out.println(stack2.removeLast()); // 2
		System.out.println(stack2.removeLast()); // 1
		
		// Deque 자료구조에서 확인할 수 있는 사실
		// add(A) + peek(B) or remove(B)가 있을 때 // (A)와 (B)는 First 또는 Last
		// (A)와 (B)가 같다면 스택(Stack)처럼 동작
		// (A)와 (B)가 다르다면 큐(Queue)처럼 동작
		// First + First, Last + Last => 스택(Stack)
		// First + Last, Last + First => 큐(Queue)
		// addFirst로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addLast로 추가
		// addLast로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addFirst로 추가
		
		Stack<Integer> stack = new Stack<>();
		
		stack.push(1);
		stack.push(2);
		stack.push(3);
		
		System.out.println("Original Stack"); // Original Stack
		System.out.println(stack.peek()); // 3
		System.out.println(stack.pop()); // 3
		System.out.println(stack.pop()); // 2
		System.out.println(stack.pop()); // 1
		
		Queue<Integer> queue = new LinkedList<>();
		
		queue.offer(1);
		queue.offer(2);
		queue.offer(3);
		
		System.out.println("Original Queue"); // Original Queue
		System.out.println(queue.peek()); // 1
		System.out.println(queue.poll()); // 1
		System.out.println(queue.poll()); // 2
		System.out.println(queue.poll()); // 3
	}
}

<Deque 자료구조>
add(A) + peek(B) or remove(B)가 있을 때 // (A)와 (B)는 First 또는 Last
(A)와 (B)가 같다면 스택(Stack)처럼 동작
(A)와 (B)가 다르다면 큐(Queue)처럼 동작
First + First, Last + Last => 스택(Stack)
First + Last, Last + First => 큐(Queue)
addFirst로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addLast로 추가
addLast로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addFirst로 추가

<JAVA>
------------------------------------------------------------------------
문자 확인 및 변환

char ch1 = 'a';

Character.isUpperCase(ch1); // 대문자 확인 : false

Character.isLowerCase(ch1); // 소문자 확인 : true

Character.isDigit(ch1); // 숫자 확인 : false

Character.toUpperCase(ch1); // 대문자 변환 : 'A'

Character.toLowerCase(ch1); // 소문자 변환 : 'a'

Character.isAlphabetic(ch1); // 영문자 확인(한글 자음, 모음 포함) : true

Character.isLetter(ch1); // 영문자 확인(한글 자음, 모음 포함) : true
------------------------------------------------------------------------
문자열 관련

String str1 = "abcd...a";

str1.length(); // 문자열 길이 : 8

str1.charAt(1); // 문자열의 해당 인덱스 값 : 'b'

"abcd...a".equals(str1); // 문자열 같은지 비교 : true

str1.toUpperCase(); // 대문자 변환 : "ABCD...A"

str1.toLowerCase(); // 소문자 변환 : "abcd...a"

str1.indexOf("a"); // 문자열 포함 확인 & 포함한다면 첫 인덱스 반환 : 0
str1.indexOf("abc"); // : 0
str1.indexOf("bc"); // : 1
str1.indexOf("bca"); // : -1 (포함하지 않으면 -1)

str1.replace("ab", "z") // 문자열 변경  : "zcd...a"
str1.replace("..", ".") // : "abcd..a"

while (str1.indexOf("..") != -1) { // ".."이 남아있는지 체크
	str1 = str1.replace("..", ".");
} // : "abcd.a"

str1.isEmpty(); // 빈 문자열인지 체크 : false

str1.substring(1); // 인덱스로 문자열 자르기(이상) : "bcd...a"
str1.substring(1,3); // (이상~미만) : "bc"

String[] str1Arr = str1.split("bc"); // 문자열 쪼개서 배열 만들기 : "a", "d...a"

str1.startsWith("ab") // "ab"로 시작하는지 확인 : true

str1.endsWith("a") // "a"로 끝나는지 확인 : true

str1.contains("cd") // "cd"를 포함하는지 확인 : true

"A".charAt(0); // 'A'
(int)"A".charAt(0); // 65
(byte)"A".charAt(0); // 65
'A' // 'A'
(int)'A'; // 65
(byte)'A'; // 65

대문자 A ~ Z : 65 ~ 90
소문자 a ~ z : 97 ~ 122
------------------------------------------------------------------------
문자열을 숫자로

String s = "123";

Integer.parseInt(s); // 123
Float.parseFloat(s); // 123.0
Double.parseDouble(s); // 123.0
------------------------------------------------------------------------
int n = 32;

String strNum3 = Integer.toString(n, 3); // 10진수를 3진수로

StringBuilder sb = new StringBuilder(strNum3); // strNum3 값을 초기값으로 가지는 sb 생성

String strNum3Reverse = sb.reverse().toString(); // 문자열 뒤집기

int answer = Integer.parseInt(strNum3Reverse, 3); // 3진수를 10진수로

sb.setLength(0); // 가장 빠른 초기화 방법

String binaryNum = Integer.toBinaryString(n); // 100000
char[] charArr = binaryNum.toCharArray(); // {'1','0','0','0','0','0'}
------------------------------------------------------------------------
String : 문자열 연산이 적고 멀티쓰레드 환경일 경우
StringBuffer : 문자열 연산이 많고 멀티쓰레드 환경일 경우
StringBuilder : 문자열 연산이 많고 단일쓰레드이거나 동기화를 고려하지 않아도 되는 경우
------------------------------------------------------------------------
절대값
int num = Math.abs(-10); // 10

제곱근값
double sqrtN = Math.sqrt(n); // 제곱근값으로 소수점이 존재하기 때문에 double
------------------------------------------------------------------------
해시맵 안에 해시셋

HashMap<String, HashSet<String>> setHashMap = new HashMap<>();

setHashMap.put("key1", new HashSet<>());
        
setHashMap.get("key1").add("value1");
setHashMap.get("key1").add("value1");
setHashMap.get("key1").add("value2");
setHashMap.get("key1").add("value3");
setHashMap.get("key1").remove("value3"); // [value2, value1]

setHashMap.containsKey("key1"); // true
------------------------------------------------------------------------
해시맵 키, 값 세팅 및 꺼내기

HashMap<String, String> strHashMap = new HashMap<>();

strHashMap.put("key1", "value1");
strHashMap.put("key1", "value2"); // value2

for (int i = 0; i < strHashMap.size(); i++) {
	String hmKey = strHashMap.keySet().toArray()[i].toString(); // put한 순서로 인덱스가 정해지진 않는다.
	String hmValue = strHashMap.values().toArray()[i].toString(); // hmKey와 순서는 일치
}
------------------------------------------------------------------------
HashMap<String, Integer> intHashMap = new HashMap<>();
        
for (int i = 0; i < genres.length; i++) {
	intHashMap.put(genres[i], intHashMap.getOrDefault(genres[i], 0) + plays[i]); // 해시맵.getOrDefault(가져올 값, 없을 경우 디폴트 값)
}
------------------------------------------------------------------------
해시셋 값 세팅 및 꺼내기

HashSet<String> hs = new HashSet<>();

hs.add("value10");
hs.add("value11");
hs.add("value12");

HashSet 출력 방법1
for (String hsValue : hs) { // 집합의 값 꺼내는 방법
	System.out.print(hsValue + ","); // value11,value10,value12,
}

HashSet 출력 방법2
Iterator it = hs.iterator();

while (it.hasNext()) {
	System.out.print(it.next() + ","); // value11,value10,value12,
}
------------------------------------------------------------------------
Hash의 특성 : 중복된 키를 허용하지 않는다.
Set의 특성 : 중복된 값을 허용하지 않는다.
------------------------------------------------------------------------
 String s = "example";
        
if (s.contains("ex")) {
	s = s.replace("ex", "xe"); // replace만 하면 안되고 담아줘야 해
}
------------------------------------------------------------------------
정렬 및 비교

String[] participant = {"leo", "kiki", "eden"};

Arrays.asList(participant); // 배열의 리스트화
Collections.frequency(리스트, 찾고자 하는 객체); // 문자열은 Object이므로 몇 개 존재하는지 찾을 수 있음

Arrays.sort(participant); // a ~ z 순서 정렬 // 숫자의 경우 1부터 정렬
Arrays.sort(participant, Collections.reverseOrder()); // z ~ a 순서 정렬 // 숫자의 경우 int[]가 아닌 Integer[]일 경우에만 가능

int[] arrA = {1, 1, 1, 6, 0};
int[] arrTempA = arrA;
Arrays.sort(arrTempA); // arrTempA 오름차순 정렬

Integer[] tempA = Arrays.stream(arrA).boxed().toArray(Integer[]::new); // int 배열인 arrA를 Integer 배열 tempA로
Arrays.sort(tempA, Collections.reverseOrder()); // tempA 내림차순 정렬
int[] arrTempA = Arrays.stream(tempA).mapToInt(Integer::intValue).toArray(); // Integer 배열인 tempA를 int 배열 arrTempA로

int[][] arr = {{5, 4}, {5, 2}, {1, 2}, {3, 1}, {1, 3}};

Arrays.sort(arr, new Comparator<int[]>() { // 2차원 배열 정렬
	@Override
	public int compare(int[] o1, int[] o2) {
		if(o1[0] == o2[0]) {
			return o1[1] - o2[1]; // 뒤 원소 오름차순 // o2[1] - o1[1] 뒤 원소 내림차순
		}else {
			return o1[0] - o2[0]; // 앞 원소 오름차순 // o2[0] - o1[0] 앞 원소 내림차순
		}
	}
});

Arrays.sort(strNumbers, new Comparator<String>() { // 숫자로 된 문자열 배열이 있을 때, 이어서 가장 큰 숫자를 만들고자 할 때 사용
	@Override
	public int compare(String o1, String o2) {
		// TODO Auto-generated method stub
		return (o2+o1).compareTo(o1+o2); // 내림차순 정렬 // 오름차순 정렬 (o1+o2).compareTo(o1+o2);
	}
});

String answer = "YES";

if ("YES".equals(answer)) // 문자열 비교는 equals로

ArrayList<String> strArrayList = new ArrayList<>();

Collections.sort(strArrayList); // 정렬

static class Music{
        String genre;
        int play;
        int idx;
        
        public Music(String genre, int play, int idx) {
            this.genre = genre;
            this.play = play;
            this.idx = idx;
        }
}

ArrayList<Music> list = new ArrayList<>();

Collections.sort(list, (o1, o2) -> o1.play - o2.play); // 오름차순 정렬
Collections.sort(list, (o1, o2) -> o2.play - o1.play); // 내림차순 정렬

int idx = Arrays.asList(strArr).indexOf("Kim");
boolean containCheck = Arrays.asList(strArr).contains("Kim");
------------------------------------------------------------------------
코딩테스트 볼 때
import java.util.*; 쓰고 시작하자
------------------------------------------------------------------------
continue; // 아래 구문으로 내려가지 않고 다시 반복문 조건으로
break; // 반복문 종료
return; // 함수 종료
------------------------------------------------------------------------
문자 치환

String match1 = "[^a-zA-Z]";

str1 = str1.replaceAll(match1, ""); // 문자열 str1에서 영문자를 제외한 모든 문자를 ""로 치환 // ^는 제외라는 의미

"[a-zA-Z]" : 영문자
"[^0-9a-zA-Z]" : 숫자, 영문자 제외
"[^\uAC00-\uD7A3]" : 특수문자 제외
"[^\uAC00-\uD7A30-9a-zA-Z]" : 특수문자, 숫자, 영문자 제외
------------------------------------------------------------------------
int[] numArr = {9, 3, 9, 3, 9, 7, 9};

Arrays.stream(numArr).sum(); // 합계 49
------------------------------------------------------------------------
System.out.println(2f); // 2.0

int i = 100;
long l1 = 100L;
long l2 = 100l;
double d1 = 1.23;
double d2 = 1.23D;
double d3 = 1.23d;
float f1 = 1.23F;
float f2 = 1.23f;
------------------------------------------------------------------------

import java.util.Arrays;

public class PrimeNumber {
	
	// 소수(Prime Number)
	
	// x가 소수인지 체크
	public static boolean isPrimeNumber1(int x) { // 시간 복잡도 O(N)
		
		for (int i = 2; i < x; i++) { // 2부터 자기 자신 숫자전까지 체크
			
			if (x % i == 0) {
				return false;
			}
		}
		return true;
	}
	
	// 약수의 성질 : 모든 약수가 가운데 약수를 기준으로 곱셈 연산에 대해 대칭을 이룬다는 것을 이용하면 시간 복잡도를 줄일 수 있다.
	// 제곱근까지만 확인하면 된다는 것이다.
	
	// x가 소수인지 체크(더 효율적)
	public static boolean isPrimeNumber2(int x) { // 시간 복잡도 O(제곱근N)
		
		for (int i = 2; i <= Math.sqrt(x); i++) { // 2부터 제곱근 수 이하까지 체크
			
			if (x % i == 0) {
				return false;
			}
		}
		return true;
	}
	
	// 다수의 소수 판별
	// 에라토스테네스의 체 알고리즘 사용
	// 2부터 N까지의 모든 자연르르르 나열
	// 남은 수 중에서 아직 처리하지 않은 가장 작은 수 i를 찾는다.
	// 남은 수 중에서 i의 배수를 모두 제거한다. (i는 제거하지 않은다.)
	// 더 이상 반복할 수 없을 때까지 2번과 3번의 과정을 반복한다.
	
	// 26까지의 숫자 중 소수의 개수는?
	// 2를 제외한 2의 배수를 제거
	// 3을 제외한 3의 배수를 제거
	// 5를 제외한 5의 배수를 제거
	// 제곱근 26은 5와 6 사이이므로 5.xxxx (이 이하까지만 체크하면 된다.)
	// 제외되지 않은 수들은 모두 소수
	
	// x까지의 양의 정수 중 소수 나열하기
	public static void primeNumbers(int x) { // 26
		boolean[] arr = new boolean[x + 1]; // 26까지 체크해야 하므로 배열의 크기 +1
		
		Arrays.fill(arr, true); // 일단 모든 수를 소수라고 체크
		
		arr[0] = false; // 0은 소수가 아님
		arr[1] = false; // 1은 소수가 아님
		
		for (int i = 2; i <= Math.sqrt(x); i++) {
			
			// x까지의 2의 배수부터 지우자
			if (arr[i] == true) {
				
				int j = 2;
				
				while (i * j <= x) {
					arr[i * j] = false;
					j++;
				}
			}
		}
		
		for (int i = 2; i <= x; i++) {
			
			if (arr[i] == true) {
				System.out.print(i + " ");
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(isPrimeNumber1(6));
		System.out.println(isPrimeNumber2(7));
		primeNumbers(26);
	}
}

소수인지 체크, 특정 숫자까지 소수 나열

public class Person {
	
	// 필드
	String name = "";
	int age = 0;
	
	// 생성자(생략 가능)
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	// 메소드(함수)
	public void methodOne() { // return 없음(void)
		System.out.println("안녕하세요");
	}
	
	public int methodTwo() { // return 있음(int)
		return 1;
	}
	
	public String methodThree() { // return 있음(String)
		return "Hi";
	}
	
	public static void main(String[] args) { // 메인 메소드 // 실행되는 부분
		// TODO Auto-generated method stub
		Person p = new Person("홍길동", 20); // name이 홍길동이고, age가 20인 Person 클래스 객체 p 생성
		
		System.out.println(p.name);
		System.out.println(p.age);
		
//		methodOne(); // 위에 구현된 함수가 static을 포함한 public static void methodOne()였다면 호출 가능
		
		p.methodOne(); // p 객체의 methodOne함수 호출
	}
}

Java Class 안에는

필드, 생성자, 메소드 존재