본문 바로가기
TechNical/JAVA

JAVA 문법들

by 강멍멍이 강멍멍이 2021. 3. 1.
반응형
ㅇ주요문법들
1. 정렬
    // int[] -> Integer[] -> int[]
    Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
    int[] z = Arrays.stream(i).mapToInt(Integer::intValue).toArray();
    
    Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]);		    // Int 배열    오름차순
    Arrays.sort(jobs, (o1, o2) -> o1[1].compareTo(o2[1]));  // String 배열 오름차순
    
    Collections.sort(arr, new Comparator<String>() {
    	public int compare(String o1, String o2) {				
    		return (o2+o1).compareTo(o1+o2) ;	// 3, 30인 경우 303/330 비교를 위해 문자를 붙여서 비교를 한다.
    	}
    });

	static class Node implements Comparable<Node> {
		public int compareTo(Node o) {
			return this.dist - o.dist;	// 오름차순 (내림차순은 o.dist - this.dist
		}		
	}
	
2. Map
    HashMap<Integer, Integer> xSet = new HashMap<>();
    xSet.put(1, 2);
    xSet.get(1);
    xSet.getOrDefault(key, defaultValue);   // 없으면 기본값을 리턴
    
    // Map 출력
    for(Map.Entry<Integer, Integer> entry : xSet.entrySet()) {
    	System.out.println(entry + " " + entry.getKey() + " " + entry.getValue());
    }	
    
    HashSet<Integer>[] dp = new HashSet[9];
    Iterator<Integer> listA = dp[a].iterator();
	while(listA.hasNext()) {
		int numA = listA.next();
	}
			
3. Stack, Queue
    Stack<Character> stack = new Stack<>();
    stack.push(1);    // 끝에 넣기
    stack.push(2);    // 끝에 넣기
    stack.add(0, 3);  // 앞에 넣기
    int a = stack.firstElement();	// 앞에조회
    int b = stack.peek();     // 끝에 조회
    int c = stack.remove(0);  // 앞에 꺼내기
    int d = stack.pop();      // 끝에 꺼내기
    System.out.println(stack.contains(2));  // 존재여부

    // Queue는 끝에꺼를 꺼낼 수 없다!!
    PriorityQueue<Node> pq = new PriorityQueue<>();
    pq.offer(value);    
    Node node = pq.poll();
    
    // PQ는 기본적으로 정수형은 오름차순으로 정렬해 준다.
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
    System.out.println(pq.poll());		// 앞에 꺼내기
    System.out.println(pq.contains(1));	// 존재여부
    System.out.println(pq.peek());		// 앞에 조회
    System.out.println(pq.remove(20));	// 제거 및 boolean 결과(값으로 처리)
        
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());
 
=======================================================================================================
ㅇArray, List 정렬

    // Integer[] -> int[]
	Integer[] i = {3,2,1};
	int[] z = Arrays.stream(i).mapToInt(Integer::intValue).toArray();

    // int[] -> Integer[]  (int 타입 배열을 Arrays.sort 리버스 하려면 변환해야 한다)
	int[] test = {1,5,2,3};
	Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
	
	System.out.println(Arrays.toString(i));
	System.out.println(Arrays.toString(z));
    
    Arrays.sort(arr);
    
    // 내림차순은 문자열 밖에 안 된다.
    Arrays.sort(arr, Collections.reverseOrder());

    // 숫자 int 배열을 내림차순 정렬해서 int 배열로 반환하기
	int[] test = {1,5,2,3};
	Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
	Arrays.sort(arr3, Collections.reverseOrder());
	test = Arrays.stream(arr3).mapToInt(Integer::intValue).toArray();
	System.out.println(Arrays.toString(arr3));
		    
    // 2차원 배열 정렬
    int[][] jobs = {{2,3}, {4,5}};
    Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]);
	for(int i  = 0 ; i < jobs.length ; i++) {
		for(int x  = 0 ; x < jobs.length ; x++) {
			System.out.println(jobs[i][x]);
		}
	}
	
		    
	int[] numbers = {0, 0, 0};	
	ArrayList<String> arr = new ArrayList<>();
	for(int i : numbers) {
		arr.add(String.valueOf(i));
	}
	
	Collections.sort(arr, new Comparator<String>() {
		@Override
		public int compare(String o1, String o2) {				
			return (o2+o1).compareTo(o1+o2) ;	// 3, 30인 경우 303/330 비교를 위해 문자를 붙여서 비교를 한다.
		}
	});
	
	---------------------------------------------------------------------------------------------------------
	
	// 이차원 배열은 comparator 로 처리가 안 된다. 람다식으로 가야 한다. 
	// 숫자 처리(타입에 따라서 다르게 써야 한다.)
	int[][] jobs = {{0,3}, {1,9}, {2,6}};
	Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]);		// 오름차순

    // 문자 처리(타입에 따라서 다르게 써야 한다. int 안 되고 Integer 만 된다)
	String[][] jobs = {{"0","3"}, {"1","9"}, {"2","6"}};
	Arrays.sort(jobs, (o1, o2) -> o1[1].compareTo(o2[1]));
		
	for(int[] i : jobs) {
		System.out.println(Arrays.toString(i));
	}

    String[] phone_book = {"119", "89798", "1195522"};
    Arrays.sort(phone_book);
    ---------------------------------------------------------------------------------------------------------
	ArrayList<Mnode> mList = new ArrayList<>();
	HashMap<String, Integer> genMap = new HashMap<>();
	
	Collections.sort(mList, new Comparator<Mnode>() {
		@Override
		public int compare(Mnode o1, Mnode o2) {
			if(o1.gen.equals(o2.gen)) {
				return o2.playCnt - o1.playCnt;	// 같은 장르는 플레이횟수로 내림차순
			} else {
				return genMap.get(o2.gen) - genMap.get(o1.gen);	// 다른 장르는 플레이 횟수로 내림차순
			}
		}			
	});
	---------------------------------------------------------------------------------------------------------
	문자열 정렬
	String[] list = {"1","100", "111", "2", "202"};  
	// Array 도 Comparator 를 쓸 수가 있다.
    Arrays.sort(list, new Comparator<String>() {
		public int compare(String s1, String s2) {
			if(s1.length() == s2.length()) {
				return (s1+s2).compareTo(s2+s1);
			} else {
				return s1.length() - s2.length();
			}
		}			
	});
	System.out.println(Arrays.toString(list));
		
	// Array to List
	ArrayList<String> listArr = new ArrayList<>(Arrays.asList(list));
	Collections.sort(listArr, new Comparator<String>() {
		public int compare(String s1, String s2) {
			if(s1.length() == s2.length()) {
				return (s1+s2).compareTo(s2+s1);
			} else {
				return s1.length() - s2.length();
			}
		}
	});
	System.out.println(listArr);
	
	// List to Array (Ineger 는 이렇게 처리가 안 된다. JAVA8은 되지만..
	list = listArr.toArray(new String[listArr.size()]);
	System.out.println(Arrays.toString(list));
		
ㅇ순열
	String numbers = "011";
	int answer = 0 ;
	
	HashSet<Integer> set = new HashSet<>();
		
    permutation("", numbers, set);

	private static void permutation(String prefix, String num, HashSet<Integer> set) {
		int n = num.length();
		if(prefix.equals("") == false) {
			set.add(Integer.valueOf(prefix));
		}
		
		for(int i = 0 ; i < n ; i++) {
			// 타겟숫자와 나머지 숫자를 넘겨서 중복되지 않는다.
			permutation(prefix + num.charAt(i), num.substring(0, i) + num.substring(i + 1, n), set);
		}
	}

ㅇMap
    HashMap<Integer, Integer> xSet = new HashMap<>();
    xSet.put(getX, 2);
    xSet.get(getX)
    xSet.getOrDefault(key, defaultValue);   // 없으면 기본값을 리턴한다.
    
    // Map 출력
	for(Map.Entry<Integer, Integer> entry : xSet.entrySet()) {
		System.out.println(entry);
	}
	
	// 입력하면 키값으로 정렬이 되는 맵
	TreeMap<Integer, Integer> trMap = new TreeMap<>();
	
	// 맵에 기존에 값이 없으면 기본값 넣기
	hs.getOrDefault(key, defaultValue)
		
ㅇStack, Queue
    Stack<Integer> stack = new Stack<>();
    if (stack.isEmpty()) System.out.println("empty");
    stack.push(1);    // 끝에 넣기
    stack.push(2);    // 끝에 넣기
    stack.add(0, 3);  // 앞에 넣기
    System.out.println(stack);
    int a = stack.firstElement();	// 앞에조회
    System.out.println(a);
    int b = stack.peek();     // 끝에 조회
    System.out.println(b);
    int c = stack.remove(0);  // 앞에 꺼내기
    System.out.println(c); 
    int d = stack.pop();      // 끝에 꺼내기
	System.out.println(d);
	System.out.println(stack.contains(2));  // 존재여부

    PriorityQueue<Node> canGo = new PriorityQueue<>();
    canGo.offer(tickets[i][1]);
    
    
    // PQ는 기본적으로 정수형은 오름차순으로 정렬해 준다.
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    pq.offer(3);pq.offer(1);pq.offer(2);pq.offer(5);pq.offer(20);
    System.out.println(pq);
    System.out.println(pq.poll());		// 앞에 꺼내기
    System.out.println(pq.contains(1));	// 존재여부
    System.out.println(pq.peek());		// 앞에 조회
    System.out.println(pq.remove(20));	// 제거 결과(값으로 처리)
    System.out.println(pq);
	    
    // PQ를 역순으로 정렬할 경우
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());

	static class Node implements Comparable<Node> {
		int idx;
		int dist;
		
		Node(int i, int d){
			this.idx = i;
			this.dist = d;
		}
		
		// comparator 의 compare 는 처음 넣을 때 큐가 비어 있을 대 오류가 발생한다.
		// comparable 의 compareTo는 상관 없더라.
		public int compareTo(Node o) {
			return this.dist - o.dist;	// 오름차순
		}		
	}
ㅇDFS, BFS

ㅇDP
    static HashSet<Integer>[] dp = new HashSet[9];
	
	public static int solution(int N, int number) {	      
       if(N==number) {
			return 1;
		}       
		String n_ = String.valueOf(N);		
		for(int i=0;i<=8;i++) {
			dp[i] = new HashSet<Integer>();
			if(i==1) dp[1].add(Integer.parseInt(n_));
			if(i<2 ) continue;
            //ex ) dp[3]에 NNN이 들어갈 수 있도록 지정
			n_+=String.valueOf(N);
			dp[i].add(Integer.parseInt(n_));
			for(int j=1;j<i;j++) {
				 calc(j,i);
                 //찾으려는 number가 만들어졌을 경우 바로 리턴
				 if(dp[i].contains(number)) {
					 return i;					 
				 }					
			}
		}
		return -1;
	}
	
	
    //각각 N의 개수마다 사칙연산을 해서 배열에 담아줌
	static void calc(int a,int b) {

		Iterator<Integer> listA = dp[a].iterator();
		Iterator<Integer> listB = dp[b-a].iterator();
		
		while(listA.hasNext()) {
			int numA = listA.next();

			while(listB.hasNext()) {
				int numB = listB.next();
				dp[b].add(numA+numB);
				dp[b].add(numA-numB);
				dp[b].add(numA*numB);
				if(numB!=0)
				dp[b].add(numA/numB);
			
			}
			listB = dp[b-a].iterator();
		}
	}

ㅇ최단경로 다익스트라

	static class Node implements Comparable<Node>{
		int index;
		int dist;
		
		Node(int i, int d) {
			this.index = i;
			this.dist = d;
		}
		
		public int compareTo(Node o) {
			return this.dist - o.dist;
		}
	}
	
	public static void main(String[] args) {
		int nodeCnt;
		int start = 1;
		
		int[][] paths = {{1, 2, 8}, {1, 3, 2}, {3, 2, 1}, {3, 5, 3}, {6, 7, 3}};
		
		ArrayList<ArrayList<Node>> ways = new ArrayList<ArrayList<Node>>();
		
		// 동적으로 경로배열 만들기. 복잡하다.. (양방향은 의미 없음)
		// 쉽게 가려면 그냥 노드 갯수만큼 미리 다 만들면 된다.
		// for(int i = 0 ; i <= nodeCnt ; i++) {
		//     ways.add(new ArrayList<Node>());
		// }
		for(int i = 0 ; i < paths.length ; i++) {
			int s = paths[i][0];
			int e = paths[i][1];
			int d = paths[i][2];
			
			if(ways.size() < e) {
				for(int x = 0 ; x <= e - ways.size() + 1; x++) {
					ways.add(new ArrayList<Node>());
				}
			}
			
			ways.get(s).add(new Node(e, d));
		}
		
		nodeCnt = ways.size();
		
		// 시작지점에서 각 노드까지의 최단거리를 저장하는 배열
		int[] distArr = new int[nodeCnt + 1];
		Arrays.fill(distArr, Integer.MAX_VALUE);
		
		// 최단거리 순서로 처리하는 큐
		PriorityQueue<Node> pq = new PriorityQueue<Node>();
		pq.offer(new Node(start, 0));
		distArr[start] = 0;
		HashSet<Integer> visitCity = new HashSet<Integer>();
		
		while(pq.isEmpty() == false) {
			Node curNode = pq.poll();
			int curIdx  = curNode.index;
			int curDist = curNode.dist;
			visitCity.add(curIdx);
			
			if(distArr[curIdx] < curDist) continue;
			
			for(int i = 0 ; i < ways.get(curIdx).size() ; i++) {
				Node nextNode = ways.get(curIdx).get(i);
				int nextIndex = nextNode.index;
				int cost      = distArr[curIdx] + nextNode.dist;
				
				if(cost < distArr[nextNode.index]) {
					pq.offer(new Node(nextIndex, cost));
					distArr[nextIndex] = cost;
				}
			}
			
			Iterator<Node> itr = pq.iterator();
			while(itr.hasNext()) {
				Node nd = itr.next();
				System.out.print(nd.index + "(" + nd.dist + "), ");
			}
			System.out.println();
		}
		
		int maxTime = 0;
		for(int i : distArr) {
			if(i != Integer.MAX_VALUE) {
				maxTime = Math.max(maxTime, i);
			}
		}
		
		System.out.println(Arrays.toString(distArr));
		System.out.println((visitCity.size() - 1) + " " + maxTime);		

	}

ㅇ연결된것들 그룹으로 분류하기(최상위 부모 찾기)

    // 부모-자식 관계 배열
    int[] astr = new int[n];
    Arrays.fill(astr, -1);
    
    // 부모-자식관계 만들기(연결된건 그룹으로 묶는다)
    for(int i = 0 ; i < astronaut.length ; i++) {
        int pa = astronaut[i][0];
        int ch = astronaut[i][1];
        
        if (astr[pa] == -1) {
            astr[pa] = pa;  // 최초면 자기자신을 부모로 선정
        } 
        if (astr[ch] == -1) {
            astr[ch] = ch;  // 최초면 자기자신을 부모로 선정
        }
        
        int updP = astr[ch];  // 이전 자식의 부모값(자기가 부모인 경우 갱신위해 보관)
        astr[ch] = astr[pa];  // 현재 자식의 부모값 갱신
        
        for(int x = 0 ; x < n ; x++) {
            if(astr[x] == updP) {
                astr[x] = astr[pa]; // 이전 자식의 부모값을 현재 자식의 부모값으로 갱신
            }
        }                        
    }
    
    System.out.println(Arrays.toString(astr));
    
    HashMap<Integer, Integer> gm = new HashMap<>();
    for(int i  = 0 ; i < astr.length ; i++)        
        if(astr[i] == -1) { // 연결 안 되고 독립된 것들
            gm.put(i, 1);   
        } else {    // 하나의 부모로 연결된 것들
            int cnt = gm.getOrDefault(astr[i], 0);
            cnt++;
            gm.put(astr[i], cnt);
        }
    }

ㅇ대용량 자리수
	BigInteger bi = BigInteger.ONE;
	BigInteger bi = BigInteger.ZERO;
	
	for(int i = 0 ; i < 25 ; i++) {
		bi = bi.multiply(BigInteger.valueOf(i + 1));
	}
	
	bi.add(BigInteger.valueOf(3));
	bi.subtract(BigInteger.valueOf(4));
	bi.multiply(BigInteger.valueOf(5));
	
	System.out.println(bi);	    	

ㅇ피보나치	
	public static void main(String[] args) {		
		// 1 1 2 3 5 8 13 21 34

		int target = 8;		
		int[] piboArr = new int[2];		
		for(int i = 1 ;  i <= target ; i++) {
			if(i < 2) {
				piboArr[piboArr.length - i] = i;
				System.out.print(piboArr[piboArr.length - i] + " ");
				continue;
			}
			int sum = piboArr[0] + piboArr[1];
			piboArr[0] = piboArr[1];
			piboArr[1] = sum;
			System.out.print(piboArr[1] + " ");
		}
		
		System.out.println();
		
		for(int i = 1 ; i <= target ; i++) {
			System.out.print(fibo(i) + " ");
		}
	}
	
	static int fibo(int get) {
		if(get < 2) return get;
		return fibo(get - 2) + fibo(get - 1);
	}
package com.kei;

public class StringFormats {

	public static void main(String[] args) {
		double a = 0.1234567;
		System.out.printf("%.4f\n", a);	// 소수점 4자리까지 출력
		
		String b = "#";
		System.out.printf("%5s\n", b);	// 앞에 공백 5개 추가
		System.out.printf("%-5s\n", b);	// 뒤에 공백 5개 추가
		
		System.out.printf("%10d\n", 3);	// 총 10자리, 숫자외에는 공백으로 좌측 채우기
		System.out.printf("%05d\n", 3);	// 총 5자리, 숫자외에는 0으로 좌측 채우기

	}

}
반응형

댓글0