문법

문자열

• equals : 두개의 문자열이 동일한지를 비교하여 결과값을 리턴한다.

String a = "hello";
String b = "java";
String c = new String("hello"); // a와 equals하지만 자료형이 다르기에 a==b는 false
System.out.println(a,equals(b)); // false 
System.out.println(a,equals(c)); // true

• indexOf : 특정 문자열이 시작되는 위치(인덱스)를 리턴한다.

→ 선택한 문자열의 시작 위치를 알고 싶은 경우 사용한다. / 특정 문자의 개수를 뽑는다.

String str = "To be, or not to be, that is the question.";
		int count = 0;
		int pos = str.indexOf("be");
		while(pos > -1) {
			count++;
			pos = str.indexOf("be", pos + 1);
		}
		System.out.println(count); // 2

• contains : 문자열에서 특정 문자열이 포함되어 있는지의 여부를 리턴

String a = "Hello Java";
System.out.println(a.contains("Java"));  // true 출력

• charAt : 문자열에서 특정 위치의 문자(char)를 리턴한다.

String a = "Hello Java";
System.out.println(a.charAt(6));  // "J" 출력 . 띄어쓰기 공백은 제외 시킴

• toUpperCase : 문자열을 모두 대문자로 변경할 때 사용한다. (모두 소문자로 변경할때는 toLowerCase를 사용한다.)

String a = "Hello Java";
System.out.println(a.toUpperCase());  // HELLO JAVA 출력

• split : 문자열을 특정 구분자로 나누어 문자열 배열로 리턴하는 메서드이다.

String a = "a:b:c:d";
String[] result = a.split(":");  // result는 {"a", "b", "c", "d"}

 

StringBuffer

문자열을 추가하거나 변경 할 때 사용하는 자료형 / 문자열 추가나 변경 등의 작업이 많을 경우 사용

• append : StringBuffer 객체를 생성하고 문자열을 생성

StringBuffer sb = new StringBuffer();  // StringBuffer 객체 sb 생성
sb.append("hello");
sb.append(" ");
sb.append("jump to java");
String result = sb.toString(); // sb 객체를 문자열로 리턴
System.out.println(result);  // hello jump to java

• insert : 특정 위치에 원하는 문자열을 삽입

StringBuffer sb = new StringBuffer();
sb.append("jump to java");
sb.insert(0, "hello "); // 문자열 위치, 내용
System.out.println(sb.toString()); // hello jump to java

• substring : 문자열의 지정 위치의 문자열을 뽑아낸다**.**

StringBuffer sb = new StringBuffer();
sb.append("Hello jump to java");
System.out.println(sb.substring(0, 4)); // Hell. 시작위치, 끝위치

 

List

ArrayList

배열은 크기가 정해져 있지만 리스트는 크기가 정해져 있지 않고 동적으로 변한다.

• add

import java.util.ArrayList; // 필수

public class Sample {
    public static void main(String[] args) {
        ArrayList pitches = new ArrayList();  
        pitches.add("129");
				pitches.add(0, "138"); // 첫번째 위체에 삽입
        pitches.add("142");
    }
}

• get

import java.util.ArrayList;

public class Sample {
    public static void main(String[] args) {
        ArrayList pitches = new ArrayList();
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
        System.out.println(pitches.**get(1)**); // 2번째 값을 출력 129
    }
}

• size

System.out.println(pitches.size()); // ArrayList의 갯수를 리턴 3

• contains

System.out.println(pitches.contains("142")) // 리스트 안에 해당 항목이 있는지 판별 true

• remove

System.out.println(pitches.remove("129")); // 삭제 후 결과 출력 true
System.out.println(pitches.remove(0)); // 0번에 있는 138을 삭제. 삭제된 항목 리턴 138

 

 

제네릭스(Generics)

ArrayList<**String**> pitches = new ArrayList<>();// <>안에 String 생략
pitches.add("138");
pitches.add("129");

String one = pitches.get(0);  // 형 변환이 필요없다.
String two = pitches.get(1);  // 형 변환이 필요없다.

import java.util.ArrayList;
import java.util.Arrays; //asList 사용하기 위함

public class Sample {
    public static void main(String[] args) {
        String[] data = {"138", "129", "142"};  // 이미 투구수 데이터 배열이 있다.
        ArrayList<String> pitches = new ArrayList<>(Arrays.**asList(data)**);
        System.out.println(pitches);  // [138, 129, 142] 출력
    }
}

→ asList 메서드를 사용하면 이미 존재하는 문자열 배열로 ArrayList를 생성 = 일반 배열을 ArrayList로 변환한다.

 

▪️ Arrays의 메소드 : .asList .toString() .Sort(array) .Sort(array, Comparator) ..copyOf(array, int newlength)

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
    public static void main(String[] args) {
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        String result = "";
        for (int i = 0; i < pitches.size(); i++) {
            result += pitches.get(i);
            result += ",";  // 콤마를 추가한다.
        }
        result = result.**substring**(0, result.length() - 1);  // 마지막 콤마는 제거한다.
        System.out.println(result);  // 138,129,142 출력
    }
}

→ 콤마를 요소 중간마다 삽입

 

String.join 사용하여 위 코드 처리

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
    public static void main(String[] args) {
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        String result = **String.join**(",", pitches); // 구분자, 리스트객체
        System.out.println(result);  // 138,129,142 출력
    }
}

ArrayList를 순서대로 정렬

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Sample {
    public static void main(String[] args) {
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        pitches.sort(Comparator.naturalOrder());  // 오름차순으로 정렬
        System.out.println(pitches);  // [129, 138, 142] 출력
    }
}

→ sort메서드 사용. 내림차순(역방향) 정렬 - Comparator.reverseOrder()

 

for each

String[] numbers = {"one", "two", "three"};
for(String number: numbers){
    System.out.println(number);
}

 

Vector

 

set() 값을 변경

remove() 값을 삭제

size() 크기 및 용량

get() 값을 출력

Vector는 한번에 하나의 스레드만 엑세스(접근) 가능하며, ArrayList는 동시에 여러 스레드가

작업할 수 있습니다.

ArrayList에서 여러 스레드가 동시에 엑세스하는 경우 개발자가 명시적으로 동기화하는 코드를 추가해야합니다.

→ 멀티스레드 환경이 아닌 경우 ArrayList를 사용하는것이 바람직하다.

 

LinkedList

import java.util.LinkedList;

public class LinkedListDemo {
	public static void main(String[] args)  {
		LinkedList<String> ll = new LinkedList<String>();
		
		ll.add("Hello");
		ll.add("Hello");
		ll.add(1, "World"); // 위치 지정
		ll.set(1, "Hello"); //값 변경
		
		System.out.print(ll);
	
		ll.removeFirst(); // 첫 번째 데이터 삭제
		ll.removeLast(); // 마지막 데이터 삭제
		ll.remove(2); // Index순번의 데이터를 삭제
		ll.clear(); // List의 모든 데이터를 삭제
		System.out.print(ll.size());

		/* get(i) 메서드를 사용하여 값 출력 */
		for(int i = 0; i < ll.size(); i++)
			System.out.print(ll.get(i) + " ");
		
		System.out.println();

		/* 향상된 for문을 사용하여 값 출력 */
		for(String str : ll)
			System.out.print(str + " ");
		
		System.out.println();

		/* Iterator를 사용하여 값 출력 */
		Iterator iter = ll.iterator();
		while(iter.hasNext())
			System.out.print(iter.next() + " ");
	}
}

값을 찾는 방법에는 contains()와 indexOf()가 있습니다.

indexOf(Object) : LinkedList에서 값의 Index를 찾아줍니다.

contains(Object) : LinkedList에서 값이 있는지 없는지 여부만 판단합니다.

 

HashMap

초기에 저장할 데이터 개수를 알고 있다면 Map의 초기 용량을 지정

특정 저장 위치를 결정

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
		
System.out.println(map); //전체 출력 : {1=사과, 2=바나나, 3=포도}
System.out.println(map.get(1));//key값 1의 value얻기 : 사과
		
//entrySet() 활용
for (Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도

//KeySet() 활용
for(Integer i : map.keySet()){ //저장된 key값 확인
    System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도

• put(key, value)
• get(key, value)
• containsKey(key) 데이터 일치 확인
• remove(key)
• size ()
• Set<k> keySet() 모든 키 값을 가진 Set 데이터 반환

상수집합 (Enum)

코드가 단순해지며 열거형인 것을 드러냄

 

콘솔/파일 입출력

• BufferedReader : 속도가 향상되고 시간부하가 적다는 장점 / readLine()으로 읽기 .close()로 닫기
• 파일 입출력 에제

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Sample {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("c:/out.txt"));
        while(true) {
            String line = br.readLine();
            if (line==null) break;  // 더 이상 읽을 라인이 없을 경우 while 문을 빠져나간다.
            System.out.println(line);
        }
        br.close();
    }
}

 

예외처리 (Exception)

 

throws는 예외 발생 시, throw는 강제로 예외를 발생 시킴

try {
            c = 4 / 0;
						sample.shouldBeRun(); // 위에서 오류 발생으로 실행 X
        } catch (ArithmeticException e) {
            c = -1; // try문 오류 발생 시 출력
        } finally {
            sample.shouldBeRun();  // 예외에 상관없이 무조건 수행된다.
        }

 

 

람다(Lambda)

람다 함수로 사용할 인터페이스는 다음처럼 @FunctionalInterface어노테이션을 사용하는 것이 좋다. → 2개 이상의 메서드를 가진 인터페이스를 작성하는 것이 불가능해 진다. → 2개 이상이면 람다 함수를 사용하지 못함

interface Calculator {
    int sum(int a, int b);
}

public class Sample {
    public static void main(String[] args) {
        **Calculator mc = (a, b) -> a +b;**
        int result = mc.sum(3, 4);
        System.out.println(result);
    }
}

 

스트림

import java.util.Arrays;
import java.util.Comparator;

public class Sample {
    public static void main(String[] args) {
        int[] data = {5, 6, 4, 2, 3, 1, 1, 2, 2, 4, 8};
        int[] result = Arrays.stream(data)  // IntStream을 생성한다.
                .boxed()  // IntStream을 Stream<Integer>로 변경한다.
                .filter((a) -> a % 2 == 0)  //  짝수만 뽑아낸다.
                .distinct()  // 중복을 제거한다.
                .sorted(Comparator.reverseOrder())  // 역순으로 정렬한다.
                .mapToInt(Integer::intValue)  // Stream<Integer>를 IntStream으로 변경한다.
                .toArray()  // int[] 배열로 반환한다.
                ;
    }
}

• 종류

filter() map() 은 연산을 한다. 예를 들면 .map(x -> x.concat("s")) 는 각 문자열 뒤에 “s” 를 붙였다.

peek() 연산

sorted() 요소를 정렬

limit(3) 개수를 제한

distinct() 중복을 제거

skip() 처음부터 요소를 제외하고 나머지를 새로운 스트림으로 만든다. count(), min(), max(), sum(), average() 연산

forEach 연산 set.forEach(x-> System.out.println(x));

mapToInt, mapToLong, mapToDouble 해당 스트림으로 바꿔준다.

 

LocalDateTime

LocalDateTime now = LocalDateTime.now(); // 현재 날짜와 시간을 반환
LocalDateTime of(2023, 8, 8, int hour, int minute) // 생성 - test 
// 조회 
System.out.println("getYear() = " + now.getYear());
System.out.println("getMonth() = " + now.getMonth());
System.out.println("getDayOfMonth() = " + now.getDayOfMonth());
System.out.println("getDayOfWeek() = " + now.getDayOfWeek());
System.out.println("getDayOfYear() = " + now.getDayOfYear());
System.out.println("getHour() = " + now.getHour());
System.out.println("getMinute() = " + now.getMinute());
System.out.println("getSecond() = " + now.getSecond());
// 비교
localDateTime3.isAfter(localDateTime1)
localDateTime1.isEqual(localDateTime2) 

.now()

.get—

.isEqual

.isAfter