728x90

 

문제 : 1330번: 두 수 비교하기 (acmicpc.net)

 

1330번: 두 수 비교하기

두 정수 A와 B가 주어졌을 때, A와 B를 비교하는 프로그램을 작성하시오.

www.acmicpc.net

 

brain Storming
if문 사용
한 줄에 두 수 받기 뭐가 있을까
한 줄에 공백으로 두개 받고 구분자로 나누기? StringTokenizer
방법1 : Scanner + split()
방법2 : BufferedReader + StringTokenizer

 

풀이

일단 스캐너로 숫자1 공백 숫자2 이런식으로 입력을 받고

공백을 기준으로 split을 이용하여 나눠서 배열에 넣는다(split이 배열로 반환하기에 배열로 받아줘야함)

이후 배열의 인덱스번호로 두 수를 지정하고 int로 형변환 해주면서 각각 변수에 넣어주고 if문으로 조건을 주어서 출력했다

 

정답

Scanner + String Class split() 방법

import java.util.*;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        String num = sc.nextLine();

        String[] nums = num.split(" "); // String Class인 split()은 배열로 반환하므로, 배열로 받아야함


        // 배열로 받은 것을 인덱스 번호로 수 2개로 나눔
        int num1 =  Integer.parseInt(nums[0]);
        int num2 =  Integer.parseInt(nums[1]);

        if(num1 < num2){
            System.out.println("<");
        }else if(num1 > num2){
            System.out.println(">");
        }else {
            System.out.println("==");
        }

    }
}

 

 

728x90
반응형
728x90

 

For each문

= 향상된 for문

= 개선된 for문

 

배열이나 컬렉션의 요소(element)에 대해 특정 작업을 반복적으로 가져오기 위해 사용

for(타입 변수명 : 배열or컬렉션){
		반복할 코드
}

 

특징

자바5.0(JDK 1.5)이상 사용가능

일반적인 for문과 달리 배열과 컬렉션에 저장된 요소들을 읽어오는 용도로만 사용 가능

for each 문은 따로 반복횟수를 명시적으로 주는 것이 불가능하며,

순차적으로 반복될 때만 사용가능

for each문 안에 선언된 변수는 for문 내에서만 사용가능(지역변수 취급)

 

 

장점

1.심플, 가독성Good

2.배열 인덱스 문제 해결

ex) ArrayIndexOutOfBoundsException 예외발생 해결

 

 

단점

1.인덱스를 사용불가x

2.배열 & ArrayList 값을 사용가능하나 수정불가x

 

 

로직

배열or컬렉션에 저장된 값이 매 반복마다 하나씩 순서대로 읽혀져 변수에 저장됨

변수명을 출력하면 해당 인덱스 배열 요소값이 출력

배열or컬렉션을 처음부터 하나씩 변수명에 대입하여 바디 부분을 실행함

즉, 배열or컬렉션[0]의 값을 변수명에 다시 담아 바디부분을 실행하고 총길이 만큼 for문이 도는 것

 

ex)

for(int num : arrList){
		System.out.println(num);
}

 

아래처럼 a를 al을 두가지 반복 시키면 헷갈리는 부분이 있어서 정리해봤다

  • a를 반복시킬 경우 : 변수 al 전체를 al의 길이만큼 반복
  • al을 반복시킬 경우 : 변수 al의 요소 하나씩 순서대로 al길이만큼 반복

 

 

ex)구체적 예시

 

728x90
반응형
728x90

 

▶ Iterator<E> 인터페이스

컬렉션에 저장된 요소(element)를 읽어오는 표준화된 방법

  • 자바의 collection framework는 컬렉션에 저장된 요소(element)를 읽어오는 방법을 Iterator 인터페이스로 표준화하고 있음

Collection 인터페이스에서는 Iterator 인터페이스를 구현한 클래스의 인스턴스를 반환하는 iterator() 메소드를 정의하여 각 요소에 접근함

즉, Collection 인터페이스를 상속받는 List와 Set 인터페이스에서도 iterator() 메소드를 사용

       → iterator() 사용 : List & Set

 

Iterator 인터페이스는 아래 메소드를 사용하여 컬렉션의 각 요소(element)에 접근

 

※ JDK 1.5에 추가된 for each문(Enhanced for문)을 사용하도록 권장

→ 같은 성능을 유지하면서도 코드의 명확성을 확보하고 발생할 수 있는 버그를 예방

For each문 링크 : https://rise-up.tistory.com/777

 

ListIterator<E> 인터페이스

JDK 1.2에 추가됨

Iterator 인터페이스를 상속받아 여러 기능을 추가한 인터페이스

 

사용 조건

List 인터페이스를 구현한 List 컬렉션 클래스에서만 listIterator() 메소드를 통해 사용

 

ListIterator & Iterator 차이

Iterator 인터페이스는 컬렉션의 요소에 접근할 때 한 방향으로만 이동 가능

ListIterator 인터페이스는 컬렉션 요소의 대체, 추가, 인덱스 검색 등을 위한 작업에서 양방향으로 이동하는 것을 지원

 

연결 리스트(LinkedList)를 반복자(iterator)를 사용하여 순회하는 예제

 

리스트 반복자(List Iterator)를 사용하여 리스트의 모든 요소를 양방향 즉, 각각 순방향과 역방향으로 출력하는 예제

*while문 대신 for each문(향상된 포문) 많이씀

 

 

메소드

ListIterator 인터페이스 메소드

 

 

 

Enumeration<E> 인터페이스

JDK 1.0부터 사용해 온 Iterator 인터페이스와 같은 동작을 하는 인터페이스

hasMoreElements()와 nextElement() 메소드를 사용하여 Iterator와 같은 작업을 수행

 

현재에는 기존 코드와의 호환성을 위해서만 남아있으므로, Iterator 인터페이스 사용 권장

 

 

출처 : http://www.tcpschool.com/java/java_collectionFramework_iterator

 

 

 

 

 

728x90
반응형
728x90

 

컬렉션 List,Set에서 내부 요소(엘리먼트)에 접근할 때

Iterator를 사용해서 while + hasNext()로 가져오고는 했는데

향상된 포문(for each문)을 권장한다고 해서 찾아보다가 해보게 되었다

 

LinkedHashSet<Dog> lhSet = new LinkedHashSet<>();
lhSet.add(new Dog("a",10));
lhSet.add(new Dog("b",10));
System.out.println(lhSet); // [a(10.0kg), b(10.0kg)]

ArrayList<Dog> al = new ArrayList<>(lhSet);
System.out.println(al); // [a(10.0kg), b(10.0kg)]

al.get(1);
System.out.println(al.get(0)); // a(10.0kg)
System.out.println(al.get(1)); // b(10.0kg)
al.add(new Dog("c",10));


// for문을 이용한 엘리먼트 추출
for(int i=0; i < al.size();i++){
    System.out.println(al.get(i)); // a(10.0kg) b(10.0kg)
}

for(Dog a : al){
    System.out.println("for each = "+al);
    // 결과화면
    // for each = [a(10.0kg), b(10.0kg), c(10.0kg)]
    // for each = [a(10.0kg), b(10.0kg), c(10.0kg)]
    // for each = [a(10.0kg), b(10.0kg), c(10.0kg)]
}
for(Dog a : al){
    System.out.println(a);
    // 결과화면
    // a(10.0kg) b(10.0kg) c(10.0kg)
}
for(Dog b : lhSet){
    System.out.println("for each = "+lhSet);
    // 결과화면
    // for each = [a(10.0kg), b(10.0kg)]
    // for each = [a(10.0kg), b(10.0kg)]
}
728x90
반응형
728x90

ListIterator<E>
Iterator인터페이스의 확장된 인터페이스

이터레이터와 달리 컬렉션 요소를 앞뒤 방향으로 탐색가능 및 컬렉션 요소 추가,제거,수정 가능

 

배열처럼 컬렉션도 뭉탱이로 있어서 주소값으로 출력됨

System.out.println(listIterator); // java.util.ArrayList$ListItr@1b6d3586 -> 주소값이 나오므로 Arrays.toString 한번 찍어보자

 

 

배열이 아니라 에러뜸
 iterator는 while문 써서 접근 해야한다

System.out.println(Arrays.toString(listIterator)); // 배열이 아니라 에러뜸
        // iterator는 while문 써서 접근했어야했다...

 

 

 

next()에 boolean타입이 들어와야하는데 Dog가 들어와서 에러발생

 

while(listIterator.next()){ // next()에 boolean타입이 들어와야하는데 Dog가 들어와서 에러발생
    System.out.println(listIterator);
}

 

 

 

전체코드

   public void method06(){

        LinkedHashSet<Dog> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(new Dog("ㄱ",10));
        linkedHashSet.add(new Dog("ㄴ",10));
        System.out.println(linkedHashSet); // [ㄱ(10.0kg), ㄴ(10.0kg)]


        // ListIterator<E>
        // Iterator인터페이스의 확장된 인터페이스로, 이터레이터와 달리 컬렉션 요소를 앞뒤 방향으로 탐색가능 및 컬렉션 요소 추가,제거,수정 가능
        ArrayList<Dog> al = new ArrayList<>();
        al.add(new Dog("aa",10));
        al.add(new Dog("bb",10));

        ListIterator<Dog> listIterator = al.listIterator();
        listIterator.add(new Dog("bb",10));
        System.out.println(listIterator); // java.util.ArrayList$ListItr@1b6d3586 -> 주소값이 나오므로 Arrays.toString 한번 찍어보자
//        System.out.println(Arrays.toString(listIterator)); // 배열이 아니라 에러뜸
        // iterator는 while문 써서 접근했어야했다...
        while(listIterator.hasNext()){
            System.out.println(listIterator.next()); // aa(10.0kg) bb(10.0kg)
        }
        while(listIterator.next()){ // next()에 boolean타입이 들어와야하는데 Dog가 들어와서 에러발생
            System.out.println(listIterator);
        }


        // Exception in thread "main" java.lang.ClassCastException:
        // java.util.LinkedHashMap$LinkedKeyIterator cannot be cast to java.util.ListIterator
        //      ArrayList의 값을 가져왔어야하는건데 LinkedHashSet의 값을 가져와버림

    }
728x90
반응형
728x90

 

ball 변수에 배열 선언 및 길이까지 할당

a = b

b = c

c = a

로직을 이용하여 Math.random()으로 생성한 난수를 j에 넣고 

temp에 ball[i]를 넣어서 임시 보관시키고, 

난수 생성한 j를 ball인덱스 번호에 넣은 ball[j]를 ball[i] 다시 넣고

ball[j]에는 tmp에 넣어두었던 ball[i]를 다시 넣으므로써 스위칭이 가능해진다

 

 

 // 로또번호 6개 만들기
        // 45개의 정수값을 저장하기 위한 배열 생성.
        int[] ball = new int[45];

        // 배열의 각 요소에 1~45의 값을 저장한다.
        for(int i=0; i < ball.length; i++)
            ball[i] = i+1;
        System.out.println(Arrays.toString(ball));

        int temp = 0; // 두 값을 바꾸는데 사용할 임시변수
        int j = 0;    // 임의의 값을 얻어서 저장할 변수

        // 배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
        // 0번째 부터 5번째 요소까지 모두 6개만 바꾼다.
        for(int i=0; i < 6; i++){
            j = (int)(Math.random()*45); // 0~44범위의 임의의 값을 얻는다.
            temp = ball[i];
            ball[i] = ball[j];
            ball[j] = temp;
            System.out.println(Arrays.toString(ball));
        }

        // 배열 ball의 앞에서 부터 6개의 요소를 출력한다.
        for(int i=0; i < 6; i++)
            System.out.printf("ball[%d]=%d%n", i, ball[i]);
728x90
반응형
728x90

 

Wrapper class(래퍼 클래스)

기본자료형을 클래스화 시킨 것

기본자료형을 객체화 해주는 클래스

 

기본형 데이터타입을 클래스화하면 Object 클래스의 자식 클래스가 되며,

데이터타입에 상관없이 Object클래스를 이용한 처리가 가능해진다

 

 

Wrapper class 출현 배경

기본 자료형들은 ‘자료형’으로만 사용, 메소드 사용불가. 그래서 래퍼클래스가 나오게됨

 

*기본자료형 8가지

boolean char byte int short long float double

 

Wrapper 래퍼클래스는 참조 자료형

클래스 자체가 자료형으로 사용가능하기에 래퍼클래스도 자료형으로도 사용 가능하고, 그 안에 메소드도 활용가능

 

기본 자료형(primitive)

    - 자료형 사용 o, 메소드 사용x

참조 자료형(non-primitive, reference type)

(Wrapper Class = 참조형)

    - 자료형 사용 o, 메소드 사용 o

 

기본 자료형 Wrapper Class
boolean Boolean
char Character
byte Byte
int Integer
short Short
long Long
float Float
double Double

 

 

boxing vs unBoxing

기본자료형 vs Wrapper클래스

  • boxing : 기본자료형 → wrapper클래스로 변환(객체화)
  • unBoxing : wrapper클래스 → 기본자료형으로 변환
    • 객체에 저장되어 있는 데이터를 기본형 데이터로 꺼내는 작업

 

Wrapper클래스가 박스

안에 메소드,필드 등 담아두기에 박스

반대로 박스(객체)에 저장되어 있는 데이터를 기본형 데이터로 꺼내는 작업이 언박싱

// boxing
int num1 = 10;
Integer integer1 = new Integer(**num1**); // num1 자체를 래퍼클래스로 전환 -> boxing

// unBoxing
int num2 = integer1.**intValue();**       // num2 : 래퍼클래스를 기본자료형 int로 변환 -> unBoxing
// boxing
int i = 10;
Integer iValue1 = new Integer(i); 
Integer iValue2 = new Integer(123);

double d = 1.123;
Double dValue1 = new Double(d); 
Double dValue2 = new Double(5.323);
// unBoxing
Integer iValue = new Integer(4578); 
int i = iValue.intValue();

Double dValue = new Double(44.241); 
double d = dValue.doubleValue();

 

 

autoBoxing, autoUnBoxing

JDK1.5버젼부터 지원

자동으로 박싱,언박싱

기본 타입과 Wrapper클래스 타입 간의 변환이 자동으로 이루어진다

(바로 대입적용이 가능케됨)

// 자동박싱,언박싱. 바로 대입적용이 가능케됨
Integer integer2 = num1; // autoBoxing
int num3 = integer2;     // autoUnBoxing
int i = 10; 
Integer iValue = i; // 바로 대입 가능

Double dValue = new Double(3.14); 
double d = dValue;  // 바로 대입 가능

 

 

 

 


 

 

 

1)String을 기본 자료형으로 바꾸기

parsing(파싱)

기본자료형에서 래퍼클래스로 변환하기 위해 많이 사용하는게 파싱(parsing)

parsing : 문자열을 기본 자료형으로 변환하는 것

변환가능한 같은 형태이여야한다

     ex) 숫자면 숫자끼리. 문자열 "1"을 int 1로 변환 가능

int i = Integer.parseInt("10");
double d = Double.parseDouble("홍길동");
// 에러메시지 : java.lang.NumberFormatException: For input string: "홍길동"
// 파싱할 자료형의 형태를 지니지 않아서 나는 에러

short s = Short.parseShort("10 ");		// 잦은 실수 요인 : 공백 조심
float f = Float.parseFloat(" 10");
boolean b = Boolean.parseBoolean("true");
byte by = Byte.parseByte("10");
Long l = Long.parseLong("10");
// 캐릭터 래퍼클래스에는 파싱기능 존재x -> chatAt()로 대체

byte b = Byte.parseByte("1");
short s = Short.parseShort("2");
int i = Integer.parseInt("3");
long l = Long.parseLong("4");
float f = Float.parseFloat("0.1");
double d = Double.parseDouble("0.2"); 
boolean bool = Boolean.parseBoolean("true");

char c = "abc".charAt(0);

 

 

2)primitive type(기본 자료형)을 String으로 바꾸기

String str1 = i + ""; 					   // 방법1. 가장 쉬운 변환.대중적 사용
String str2 = String.valueOf(s); 		   // 방법2
String str3 = Byte.valueOf(by).toString(); // 방법3
String b = Byte.valueOf((byte)1).toString();
String s = Short.valueOf((short)2).toString();
String i = Integer.valueOf(3).toString();
String l = Long.valueOf(4L).toString();
String f = Float.valueOf(0.1f).toString();
String d = Double.valueOf(0.2).toString();
String bool = Boolean.valueOf(true).toString();
String ch = Character.valueOf('a').toString();

 

728x90
반응형
728x90

 

A. StringBuffer 안에 쓸 수 있는 많이 쓰는 메소드

1) append()

받아온 값을 뒤에 추가로 이어주는 메소드

// append()
// 받아온 값을 뒤에 추가로 이어주는 메소드
buffer3.append("abc"); // 결과값 abcabc
System.out.println(buffer3);
System.out.println("buffer3의 실주소값 : " +System.identityHashCode(buffer3)); // append 추가후에도 주소값 같음
																		// ->수정 후에도 buffer가변클래스인걸 알 수 있음

 

*이중 append()

// 2) append() 반환값 : Stringbuffer
buffer3.append("abc").append("def"); // 메소드 체이닝
System.out.println(buffer3); // 결과값 abcabcdef
System.out.println("abc, def 추가 후의 buffer3의 수용량 : " +buffer3.capacity()); 		// 수용량 단위는 character 한문자이므로 기본용량16에 abc 세글자를 +3해서 19
System.out.println("abc, def 추가 후의 buffer3에 들어있는 실제 값의 길이 : " +buffer3.length()+"\\n"); // StringBuffer 생성자에 들어간 문자열 abc 길이3

 

 

2) insert()

원하는 자리에 값 추가 시킬 수 있는 메소드

// 원하는 자리에 값 추가 시킬 수 있는 메소드
buffer3.insert(2,"zzz");
System.out.println("인덱스2에 추가 후의 buffer3 : "+buffer3+"\\n"); // abzzzcabcdef

 

 

3) delete()

데이터 삭제하는 메소드

delete(int start, int end) : StringBuffer deleteCharAt(int index) : StringBuffer

// 데이터 삭제하는 메소드
// delete(int start, int end) : StringBuffer	
// deleteCharAt(int index) : StringBuffer	

buffer3.delete(2, 5);							 // zzz 삭제. 마지막 인덱스 미포함. 
System.out.println("삭제 후의 buffer3 : "+buffer3); // delete(2, 5-1) // (start, end-1)
buffer3.deleteCharAt(2);
System.out.println("삭제 후의 buffer3 : "+buffer3+"\\n"); //

 

 

4)reverse()

앞뒤 거꾸로 값을 바꿔놓는 메소드

buffer3.reverse();							 // zzz 삭제. 마지막 인덱스 미포함. 
System.out.println("reverse의 buffer3 : "+buffer3); // 

StringBuilder sb = new StringBuilder("abc"); 
sb.append("zzz").insert(2,"yy").reverse().delete(1,3);
// abc + zzz -> abyyczzz -> zzzcyyba -> zcyyba

 

 


 

 

B. String 안에 쓸 수 있는 많이 쓰는 메소드

 

1)charAt ()

charAt (int index):char 해당 문자열의 index번째 문자를 char로 변환

 

2)concat()

concat(String str):String String concatStr = str.concat("!!!"); System.out.println("concatStr : "+concatStr)

concat(String str):String 원래 문자열 끝에 매개변수로 들어온 값을 이어붙인 문자열 반환

String concatStr = str.concat("!!!");
System.out.println("concatStr : "+concatStr);
str += "!!!"; // concat과 같은 역할 : +
System.out.println(str);

 

3)equals()

equals(Object anObject):boolean

문자열이 같은지 확인

System.out.println("concatStr.equals(str) : "+concatStr.equals(str));
// 결과값 : concatStr.equals(str) : true

 

4)substring()

substring(int beginIndex):String

해당 인덱스 넘버부터 문자열 시작

substring(int beginIndex, int endIndex):String

A to B 사이의 문자열 일부 반환

System.out.println("str.substring(6) : "+str.substring(6));
// 결과값 : str.substring(6) : world!!!

str.substring(0,4) : Hell
// 결과값 : str.substring(0,4) : Hell

 

5)replace()

replace(char oldChar, char newChar):String

기존 문자를 새로운 문자로 대체하여 반환

System.out.println("str.replace('l','e') : "+str.replace('l', 'e'));
// 결과값 : str.replace('l','e') : Heeeo wored!!!

 

6)toUpperCase() & toLowerCase()

toUpperCase():String toLowerCase():String

문자열을 대/소문자로 변형 후 반환

System.out.println("str.toUpperCase() : "+str.toUpperCase());
System.out.println("str.toLowerCase() : "+str.toLowerCase());
// 결과값 : str.toUpperCase() : HELLO WORLD!!!
// 결과값 : str.toLowerCase() : hello world!!!

 

7)equalsIgnoreCase()

equalsIgnoreCase(String anotherString):boolean 대문자는 무시하고 비교

String str2 = "Wonderful";
String str3 = "wonderful";
System.out.println(str2.equals(str3));			    // 결과값 : false
System.out.println(str2.equalsIgnoreCase(str3));// 결과값 : true

 

8)trim()

trim():String

앞 뒤에 있는 빈 공간을 제거한 문자열 반환

String str4 = "    Java";
String str5 = "  Java  ";
String str6 = "Java    ";	
System.out.println(str4+" : "+str4.trim());
System.out.println(str5+" : "+str5.trim());
System.out.println(str6+" : "+str6.trim());
// 결과값
/*
Java : Java
Java   : Java
Java     : Java
*./

 

9)split()

split(String str):String[]

전달받은 구분자를 통해 문자열을 잘라 String[]반환

String splitStr = "Java, Oracle, JDBC, Front, Server, Framework";
String[] strArr = splitStr.split(", "); // 공백도 나누는 기준인걸 잊지마
for(int i=0; i < strArr.length; i++) {
	System.out.println(strArr[i]); //
/* 결과값
Java
Oracle
JDBC
Front
Server
Framework
*/

 

 

 

728x90
반응형
728x90

 

자바 기본 API(Application Programming Interface)

목차

1.String

2.Wrapper

3.Date

  1. Calendar
  2. Gregorian Calendar

4.Math

 


 

String Class

String : 문자열 클래스

문자열의 값 수정 불가(불변 클래스) 수정 시 수정된 문자열이 새로 할당 되어 새 주소를 넘김

String name = "abc";
name = "def"; // <-수정된 거 아닌가? 수정된거 아님
immutable(불변) 의미
배열 크기 변경 불가능처럼
눈으로 보이기는 수정되는 것처럼 보이나 컴퓨터 안에 로직은 삭제 새로생성되었고 주소값도 변경됨

 

 

API에 구현이 되어있는 메소드들

hashCode(), identityHashCode()

 

hashCode()

hashCode() : int ← 매개변수x 주소값 반환

Returns a hash code for this string.

주소값을 보기 위해 사용하는 코드

객체의 주소값을 해시코드로 구현한 결과값

object클래스에 있음.

실제 주소값을 직접 볼 수 있는건 아님.

자바는 애초에 주소값을 다이렉트로 볼 수 없게 만듬

equals비교했는데 둘이 같다면 해쉬코드 결과도 둘이 같게해줘야한다

System.out.println("str1의 hashcode : "+str1.hashCode());
System.out.println("str2의 hashcode : "+str2.hashCode());
System.out.println("str3의 hashcode : "+str3.hashCode());

 

identityHashCode()

System.identityHashCode(변수명)

실주소값을 연산해놓은 결과값을 도출하는 메소드

스트링은 불변 클래스

수정되는게 아닌 새로 생성하고 기존것 삭제하고 대체되는 개념

 


 

StringBuffer & StringBuilder

문자열 클래스

주소값은 그대로하고 문자열을 수정 가능케 하는 메소드

가변클래스 : 문자열 수정 가능. mutable(가변)

    - String클래스 : 변경이 적고 읽기만 많은 경우에 유리

    - StringBuffer / StringBuilder : 문자열에 대한 수정이 많이 일어나는 경우 유리

https://rise-up.tistory.com/303

 

[Java] 주소값은 그대로하고 문자열을 수정 가능케 하는 메소드 : StringBuffer & StringBuilder

StringBuffer & StringBuilder 클래스는 불변 클래스인 String 클래스랑 다르게 문자열 수정이 가능한 가변 클래스다 String이 수정이 불가능하다니 무슨 말일까? String 타입의 변수에 값을 넣어보면 언제든

rise-up.tistory.com

 

 

StringBuffer vs StringBuilder 비교

불변 클래스인 String 클래스랑 다르게 문자열 수정이 가능한 가변(mutable)클래스

문자열 값 수정 가능, mutable(가변) 수정, 삭제 등이 기존 문자열에 수정되어 적용 기본 16문자 크기로 지정된 버퍼를 이용하며 크기 증가 가능

모두 같은 기능이나 동기화처리 가능 / 불가능으로 구별된다

동기화가 들어가면 안전 : 데이터에 대해 락을 걸어놓고 진행. 처리속도가 느림. 동기화가 안들어가면 속도가 빠름

  • StringBuffer   동기화 o / 느림 / 안전 / thread safe기능o
  • StringBuilder 동기화 x / 빠름 / 안전 x / thread safe기능x

 

메모리 관리를 위해 String대신 쓰기도 하나 String을 대개 많이씀

컴퓨터도 많이 좋아지고 버퍼나빌더를 쓴다고 눈에띄게 빨라지는건 아님

StringBuffer/StringBuilder는 자동으로 수용량 증가

 

 

쓰레드 세이프 기능(thread safe)

멀티 쓰레드 프로그래밍에서 여러 쓰레드로부터 동시에 접근이 이루어져도 프로그램의 실행에 문제가 없는 것을 의미

이를 위해 한 쓰레드가 특정 작업을 끝마치기 전까지 다른 쓰레드에 의해 방해받지 않도록 "임계 영역(critical section)"과 "잠금(lock)"의 개념이 도입됨

 

  • 임계영역(critical section)

둘 이상의 스레드가 동시에 접근해서는 안 되는 공유 리소스(자료 구조 또는 장치)를 접근하는 코드의 일부를 뜻함

  • 락(lock)

모든 객체에는 락(lock)이 하나씩 있고 이 락(lock)을 가지고 있는 스레드만 해당 객체의 임계 영역 코드와 관련된 작업이 가능

  1. 공유 데이터를 사용하는 코드 영역을 임계 영역으로 지정하고, 공유 데이터가 가지고 있는 lock을 획득한 단 하나의 쓰레드만 영역 내의 코드를 수행할 수 있게함
  2. 해당 쓰레드가 임계 영역 내의 모든 코드를 수행하고 벗어나 lock을 반납해야만 다른 쓰레드가 반납된 lock을 획득하여 임계 영역 내의 코드를 수행할 수 있도록함

 

 

쓰레드(thread)의 동기화(Synchronization)

여러 스레드가 한 리소스를 사용하려 할 때

사용하려는 스레드 하나를 제외한 나머지 스레드들은 리소스를 사용하지 못하도록 막는 것

 

쓰레드 동기화는 크게 Synchronized, Volatile, Atomic 3가지가 있고 추후 깊게 공부해보자

 

728x90
반응형
728x90

 

list 안에 각각의 빈도 높은 메소드들을 다 써보고

어떤 방식으로 작동하는지와 반환값도 어떻게 반환되는지 파악하고

리스트의 코드 형태도 익숙해지는 중!

 

get 같은 경우 어디에 써먹을지 고민하게보게 됨. 해당 값을 가져와서 여기저기 유용할 것 같은데 당장 생각이 잘안난다

 

/******************************** collection 2nd practice ***************************************/	
public void method02() {

    ArrayList<Student> list = new ArrayList<Student>(3);


    // add(E e):boolean
    list.add(new Student("김",99));
    list.add(new Student("이",98));
    list.add(new Student("최",100));
    list.add(new Student("박",95)); // 길이 자동 추가 : 길이4

    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점)] 길이 4
    // Object의 toString()를 오버라이딩 때문에 주소값이 아닌 객체값이 바로나옴
    System.out.println(list.add(new Student("황",94))); // true // boolean값 반환


    // 장점1. 크기 제약 x
    // .size() : 인덱스 길이 반환
    System.out.println(list.size()); // 5


    // 장점2. 추가/삭제/정렬 기능처리 간단
    // add(int index, E elemnet) 
    list.add(5,new Student("차",88)); // 5번 인덱스에 '차' 추가
    list.add(5,new Student("사",87)); // 5번 인덱스 '차'자리에 '사'가 들어가면서 '차'가 뒤로 밀림

    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점), 사(87점), 차(88점)]


    // 삭제
    // remove(int index):E
//		// remove()의 return은 삭제한 값을 돌려준다
//		list.remove(7);
    System.out.println("remove(int index):E = "+list.remove(6)); // remove(int index):E = 차(88점)
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점), 사(87점)]


    // 삭제
    // remove(Object o):boolean
    list.remove(new Student("사",87));
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점)]

    System.out.println(list.remove(new Student("황",94))); // true - 반환값 불리안 겟
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점)]


    // 지네릭 추가 : <String> 
    ArrayList<String> listStr = new ArrayList<String>(2);
    listStr.add("임");
    listStr.add("강");
    listStr.add("심");
    System.out.println(listStr); // [임, 강, 심]
    System.out.println(listStr.remove(2)); // 심
    System.out.println(listStr); // [임, 강] -> print에 써도 잘지워진다
    listStr.remove(new String("강"));
    System.out.println(listStr); // [임]
    // equals랑 hashCode가 잘 오버라이딩이 되어있기 때문에 삭제 가능


    // set(int index, E e)
    // 해당 인덱스 번호에 값  교체
    list.set(3, new Student("박박",99));
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박박(99점)]
    System.out.println(list.set(2, new Student("최최",1000))); // 최(100점)
    System.out.println(list); // [김(99점), 이(98점), 최최(1000점), 박박(99점)]


    //get(int index):E
    // 인덱스번호의 엘리먼트 값을 가져온다
    Student stu = list.get(1);
    System.out.println(stu); 		 // 이(98점)
    System.out.println(list.get(0)); // 김(99점)



    // contains(Object) : boolean
    // indexObject : int 

    System.out.println(list.contains(new Student("김",99))); // true
    System.out.println(list.indexOf(new Student("김",99)));	// 0

    // 지네릭<String>과 일반 참조객체<Student>의 오버라이딩 비교
    System.out.println(listStr.contains(new String("임")));   // true
    System.out.println(listStr.indexOf(new String("임")));	 // 0
    System.out.println(listStr.indexOf(new String("임없음"))); // -1 : 없는 값이라 -1반환
    //  equals메소드와 해쉬코드가 오버라이딩 되지 않으면 주소값이 달라 없는걸로 나옴. 현재는 오버라이딩된 상태


    // clear():void
    list.clear();
    System.out.println(list); 			 // []
//		System.out.println(listStr.clear()); // clear는 반환타입이 없는 void라 print시켜서 java.lang.Error 
    listStr.clear();

    // isEmpty():boolean
    System.out.println(list.isEmpty());		// true
    System.out.println(listStr.isEmpty());	// true


}
728x90
반응형

+ Recent posts