[Java] String, StringBuilder, List, Collections, Set, Map, Stack, Queue 정리

import java.utils.*;

 

String

String str = “abcde”;

• length()
  • 길이 반환
• isEmpty()
  • 길이가 0이면 true, 아니면 false
• charAt(idx)
  • 해당 인덱스 위치의 문자 반환
• indexOf(”문자”)
  • 해당 문자의 첫번째 인덱스 위치 반환
• lastIndexOf(”문자”)
  • 해당 문자의 마지막 인덱스 위치 반환
• substring(n, m)
  • n~m-1위치의 문자열 반환
• subsring(n)
  • n부터 끝까지의 문자열 반환
• replace(”이전문자”, “바꿀문자”)
  • 이전문자를 해당 바꿀문자로 변경
• equals(”문자”)
  • 해당 문자랑 같으면 true, 다르면 false
• contains(”문자”)
  • 해당 문자가 포함되어 있으면 true, 아니면 false
• split(” “)
  • 띄어쓰기로 구분된 문자열을 분리해서 String[] 배열로 반환
• split()
  • 띄어쓰기 없는 문자열을 한 문자씩 분리해서 String[] 배열로 변환
• trim()
  • 앞뒤 공백 제거, 문자열 사이 공백은 제거 안함
• toLowerCase()
  • 모두 소문자로 변경
• toUpperCase()
  • 모두 대문자로 변경
• compareTo(”문자”)
  • 해당 문자랑 같으면 0, 사전순으로 앞이면 -1, 사전순으로 뒤면 1, 마지막 문자만 다르면 마지막 문자의 사전 순 차이 반환

 

StringBuilder

StringBuilder sb = new StringBuilder();

• append(”문자”)
  • 해당 문자 추가
• insert(idx, “문자”)
  • 해당 인덱스 위치의 문자 삽입
• delete(n, m)
  • n~m-1 인덱스 위치의 문자열 삭제
• deleteCharAt(idx)
  • 해당 인덱스 위치의 문자 삭제
• reverse()
  • 문자열 거꾸로 뒤집기
• setLength(n)
  • 문자열 길이를 n으로 줄인다
  • 문자열 길이를 n으로 늘린다 (뒤에 공백으로 채워서)

 

List

List<String> list = new ArrayList<>();

• add(”문자”)
  • 리스트 가장 뒤에 해당 문자 삽입
• add(idx, “문자”)
  • 해당 인덱스 위치에 문자 삽입
• addAll(list2)
  • 리스트 뒤에 list2의 모든 값 삽입
• get(idx)
  • 해당 인덱스 위치의 값 반환
• set(idx, “문자”)
  • 해당 인덱스 위치의 값을 해당 문자로 변경
• indexOf(”문자”)
  • 해당 문자의 첫번째 인덱스 값 반환
• lastIndexOf(”문자”)
  • 해당 문자의 마지막 인덱스 값 반환
• remove(idx)
  • 해당 인덱스 위치의 값 삭제
• remove(”문자”)
  • 해당 문자 값 삭제
• removeAll(list2)
  • 리스트에서 list2에 들어있는 모든 값 삭제
• retainAll(list2)
  • 리스트에서 list2에 들어있는 값 제외하고 삭제
• claer()
  • 전체 값 삭제
• isEmpty()
  • 길이가 0이면 true, 아니면 false
• size()
  • 길이 반환
• contains(”문자”)
  • 해당 문자가 리스트에 있으면 true, 아니면 false
• containsAll(list2)
  • 리스트에 list2의 모든 값이 포함되어있으면 true, 아니면 false
• removeIf(k → k % 2 ! = 0)
  • 홀수를 해당 리스트에서 모두 제거

 

배열↔리스트 형변환

• 문자열 배열 → 리스트
  • String[] arr = {“abc”, "def"};
  • List<String> list = new ArrayList<>(Arrays.asList(arr));
• 리스트→ 문자열 배열
  • List<String> list = new ArrayList<>();
  • String[] arr = list.toArray(new String[list.size()]);
• int[] 배열→ Integer 리스트
  • int[] arr = {11, 22};
  • for(int i: arr) { list.add(i); }
• 리스트→ 정수 배열
  • List<Integer> list = new ArrayList<>();
  • int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

 

배열, 리스트 길이 접근, 값 추가

• 배열
  • 값 접근
    • array[idx]
  • 값 할당
    • array[idx] = 값
  • 길이
    • length
• 리스트
  • 값 접근
    • list.get(idx)
  • 값 추가
    • list.add(값)
  • 길이
    • size()
• 문자열
  • 길이
    • length()

 

Collections

int[] arr = {11, 22};

List<Integer> list = new ArrayList<>(Arrays.toList(arr));

• Collections.max(list)
  • list 중 가장 큰 값 반환
• Collections.min(list)
  • list 중 가장 작은 값 반환
• Collections.sort(list)
  • list 오름차순 정렬
• Collections.sort(list, Collections.reverseOrder())
  • list 내림차순 정렬
• Collections.reverse()
  • 역순 정렬
• Collections.frequency(list, 11)
  • list 내의 11의 갯수 반환

 

HashSet

• HashSet
  • 중복을 허용하지 않는 set
  • 순서와 정렬이 없다
• LinkedHashSet
  • 중복을 허용하지 않는 set
  • 삽입된 순서대로 정렬
• TreeSet
  • 중복을 허용하지 않는 set
  • 이진 탐색 트리 형태로 저장하여 정렬

HashSet<Integer> set = new HashSet<>();

• add(값)
  • 해당 값 추가
• remove(값)
  • 해당 값 데이터 삭제
• removeAll(set2)
  • set 데이터 중 set2에 들어있는 데이터 모두 삭제
• retainAll(set2)
  • set 데이터 중 set2에 들어있지 않은 데이터 모두 삭제
• clear()
  • 모든 데이터 삭제
• size()
  • set 크기 반환
• contains(값)
  • 해당 값이 있으면 true, 없으면 false
• set에 들어있는 데이터 출력
  • for (String str: set) { sout(str); }

 

HashMap

• HashMap
  • <key, value> 쌍
  • 특정 규칙 없이 출력된다
• LinkedHashMap
  • <key, value> 쌍
  • 키 값이 입력순으로 정렬
• TreeMap
  • <key, value> 쌍
  • 키 값이 알파벳 오름차순으로 정렬

HashMap<Integer, String> map = new HashMap<>();

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

• put(키값, value값)
  • 해당 키와 value 쌍 set에 넣기
  • 해당 키가 이미 존재하면 해당 키의 value는 최신 value로 대체된다
• remove(키값)
  • 해당 키값 데이터 삭제
  • 키값으로만 요소 삭제 가능하다
• clear()
  • 전체 데이터 삭제
• containsKey(키값)
  • 해당 키값이 있으면 true, 없으면 false
• containsValue(value값)
  • 해당 value값이 있으면 true, 없으면 false
• 키와 value 값 출력
  • value 값만 출력시
    • for(Integer i: map.keySet()) { sout(map.get(i)); }
  • 키와 value 값 모두 출력시
    • for(Entry<Intger, String> entry: map.entrySet()) { sout(entry.getKey() + entry.getValue()); }

 

Stack

Stack<Integer> stack = new Stack<>();

• push(값)
  • 값 추가
• pop()
  • 제일 마지막에 들어온 값 반환 후 삭제
• clear()
  • 전체 값 삭제
• size()
  • 크기 반환
• empty()
  • 비어있으면 true, 아니면 false
• contains(값)
  • 해당 값 포함하면 true, 아니면 false
• peek()
  • 가장 나중에 들어온 값 출력, 비어있으면 null 반환

 

Queue

Queue<Integer> queue = new LinkedList<>();

• add(값)
  • 해당 값 추가
• offer(값)
  • 해당 값 추가
• poll()
  • 가장 오래된 값 반환 후 제거
  • 비어있으면 null 반환
• peek()
  • 가장 오래된 값 반환, 제거는 안됨
• remove()
  • 가장 오래된 값 제거
• clear()
  • 값 모두 삭제