히스토그램 = 문장들중에서 해당 알파벳이 얼마나 나왔는지를 보여주는 지표

텍스트를 키보드로 입력받아 알파벳이 아닌 문자는 제외하고 영문자 히스토그램을 만들어보자. 
대문자와 소문자는 모두 같은 것으로 간주하고,
세미콜론(;)만 있는 라인을 만나면 입력의 끝으로 해석한다.

--출력--
영문 텍스트를 입력하고 세미콜론을 입력하세요.
It's now or never, come hold me tight
Kiss me my darling, be mine tonight
Tomorrow will be too late
It's now or never, my love won't wait
When I first saw you, with your smile so tender
My heart was captured, my soul surrendered
I spent a lifetime, waiting for the right time
Now that your near, the time is here, at last
It's now or never, come hold me tight
Kiss me my darling, be mine tonight
Tomorrow will be too late
It's now or never, my love won't wait
;

히스토그램을 그립니다.
A----------------
B----
C---
D--------
E-------------------------------------------
F---
G--------
H--------------
I-------------------------------
J
K--
L----------------
M--------------------
N-----------------------
O-----------------------------------
P--
Q
R---------------------------
S------------------
T---------------------------------------
U------
V------
W------------------
X
Y---------
Z

package challenge.Histogram;

import java.util.Scanner;

public class HistoGram {
		
	String inputEng() {
		
		StringBuffer stringBuffer=new StringBuffer();
		Scanner sc = new Scanner(System.in);
		
        // while문 안에 넣어서 종료조건=;로 지정한 후 만족할 때 까지 무한입력 가능하게 하기
		while(true) {
			String sentence = sc.nextLine();      			
			if(sentence.length()==1 && sentence.contains(";")) {
				System.out.println("종료");
				break;
				
			}stringBuffer.append(sentence);     // 버퍼에 문자열 저장
			
		}
		// System.out.println(stringBuffer.toString());  문자열 들어온지 확인해봤음 오 잘들어옴 
		return stringBuffer.toString();  // 리턴값을 가져나와 다른메서드에 활용
	
	}
	
	void checkEng(String engsentence){
		int a=65; int b=97; // 아스키코드 A,a 번호
		char start=65;
		String line = "-";
		boolean bl=true;
		
		while(bl) {
			System.out.print(start);
			for(int i=0; i<engsentence.length(); i++) {
				char c = engsentence.charAt(i);
				if(c==a || c==b) {
					System.out.print(line);
				}				
			}
			
			System.out.println();
			a++; b++; start++;
			if(start>90) {       // Z가 넘어가도 계속 출력되는거 막기
				break;
			}	
			
		}	
		
	}
	
}

package challenge.Histogram;

import java.util.Scanner;

public class HistogramMain {

	public static void main(String[] args) {
		
		System.out.println("영문 텍스트를 입력하세요");
		System.out.println("종료를 원할경우 세미콜론(;)을 입력해 주세요");
		
		HistoGram histoGram1 = new HistoGram();
		String input = histoGram1.inputEng();
		histoGram1.checkEng(input);
		
	}
}

아직 메서드 세분화에 엄청 미숙한 것 같다

Map

Key와 Value값의 쌍(K, V)으로 저장 (Key값은 중복저장이 불가능하다)

  → 특정 Key로 value를 얻어낸다

동일한 Key로 다른 데이터를 저장 시 기존 데이터를 덮는다

요소의 저장 순서를 유지하지 않음

HashMap

Key와 Value를 묶어 하나의 Entry로 저장한다

많은 양의 데이터를 검색하는 데 속도가 빠르다

null이 가능하다

데이터의 크기가 예상 범위내에 있는 경우 ( 크기지정 ), 삽입 삭제가 빈번한 경우 사용

class ExamMain {

	public static void main(String[] args) {

		Map<String, Integer> map = new HashMap<String, Integer>();		
		
        // key-value 삽입
		map.put("a", 11);
		map.put("b", 22);
		map.put("c", 33);
		map.put("d", 44);
		map.put("e", 55);		
		// key값이 중복되면 마지막에 저장한 값으로 대체한다
		map.put("d", 77);
		map.put("e", 777);
		System.out.println(map.size());
		System.out.println(map);
// Console
// 5
// {a=11, b=22, c=33, d=77, e=777}        
		
		// value값 가져오기
   		System.out.println(map.get("d"));
		System.out.println(map.values());
// Console
// 77
// [11, 22, 33, 77, 777]
		
        // key값 가져오기
		Set<String> list1= map.keySet();
		System.out.println(list1);
// Console
// [a, b, c, d, e]
		
        // Iterator을 이용한 출력
		Iterator<String> iter = list1.iterator();
		while(iter.hasNext()) {
			String key= iter.next();
			int val= map.get(key);
			System.out.print(key+":"+val+" ");
		}
// Console
// a:11 b:22 c:33 d:77 e:777
        
}

public class Apartment {

	private int houseNum;
	private String name;
		
	public Apartment(int houseNum, String name) {
		super();
		this.houseNum = houseNum;
		this.name = name;
	}

	public int getHouseNum() {
		return houseNum;
	}

	public void setHouseNum(int houseNum) {
		this.houseNum = houseNum;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
		
	@Override
	public int hashCode() {
		return Objects.hash(this.houseNum, this.name);		
	}
	
	public static void main(String[] args) {
		
		Map<Apartment, Integer> goottMap = new HashMap<Apartment, Integer>();
		
		goottMap.put(new Apartment(001, "신짱구"), 30);
		
		System.out.println(goottMap);
		
		Set<Apartment> keySet2 = goottMap.keySet();
		Iterator<Apartment> iter2 = keySet2.iterator();
		while(iter2.hasNext()) {
			Apartment key= iter2.next();
			System.out.println(key.getHouseNum());
			System.out.println(key.getName());
			System.out.println(goottMap.get(key));
		}
		
	}		
	
}

// Console
// {CollectionList.Apartment@2f4b05b=30}
// 1
// 신짱구
// 30

TreeMap

노드로 연결되어 있는 구조

부모, 자식 노드로 구성되어 있으며 최상위 노드(root)가 항상 존재한다

정렬에 유리함(Key값 기준 오름차순, 내림차순)

null값 X

노드(node)
자료 구조의 일부분 하나 하나를 의미
노드는 데이터를 포함하며 다른 노드와 연결될 수 있다
대형 네트워크에서는 장치나 데이터 지점을 의미

※ 자식노드가 없는 경우 잎 노드(leaf node), 말단 노드(terminal)노드라고도 한다

class ExamMain {

	public static void main(String[] args) {
		
        // TreeMap 생성
		TreeMap<Integer,String> map1 = new TreeMap<Integer,String>();
        // new에서 타입 파라미터 생략가능
		TreeMap<Integer,String> map2 = new TreeMap<>();
		// map1의 모든 값을 가진 TreeMap생성
		TreeMap<Integer,String> map3 = new TreeMap<>(map1);
        // 초기값 설정
		TreeMap<Integer,String> map4 = new TreeMap<Integer,String>(){{
		    put(1,"a");
        }};
        
		
		// key-value값 추가
		map1.put(1, "리그오브레전드");
		map1.put(2, "발로란트");
		map1.put(3, "스타크래프트");

		// 출력
		System.out.println(map1);
		System.out.println(map1.get(1));
		System.out.println(map1.firstEntry());
		System.out.println(map1.firstKey());
		System.out.println(map1.lastEntry());
		System.out.println(map1.lastKey());
// Console
// {1=리그오브레전드, 2=발로란트, 3=스타크래프트}
// 리그오브레전드
// 1=리그오브레전드
// 1
// 3=스타크래프트
// 3
		
		// entrySet을 사용한 전체 값 출력
		for (Entry<Integer, String> entry : map1.entrySet()) {
		    System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());
		}
// Console
// Key:1 Value:리그오브레전드
// Key:2 Value:발로란트
// Key:3 Value:스타크래프트
		
		// keySet활용
		for(Integer i : map1.keySet()){ //저장된 key값 확인
		    System.out.println("Key:" + i + " Value:" + map1.get(i));
		}
// Console
// Key:1 Value:리그오브레전드
// Key:2 Value:발로란트
// Key:3 Value:스타크래프트
		
		// 값 제거
		map1.remove(1);
		map1.clear();
        
	}
    
}

HashTable

HashMap의 구버전

병렬 처리를 하면서 자원의 동기화를 고려해야 하는 상황에 사용(멀티스레드)

Properties

Key, Value를 String타입으로 제한한 Map 컬렉션

변경이 잦은 문자열을 저장해서 유지보수를 편리하게 만들어 준다

만약 프로퍼티 파일이 없다면 소스코드를 변경 시 마다 수정해서 릴리즈(요청)을 해야함 ㅡ> 불편

Set

중복 저장 불가능

순서가 없다 (인덱스로 관리하지 않음)

  → 데이터 검색을 위해 iterator메서드로 iterator(반복자)를 생성하고 데이터를 가져와야 한다

HashSet

데이터 크기가 어느정도 예상되면서 삽입, 삭제가 빈번할 경우 사용하는 것이 좋다

객체를 넣으면 해당 객체의 hashcode 값을 사용하여 버킷을 찾고 해당 위치에 요소가 있는지 확인한다. 같은 객체라 판단되면 저장하지 않는다

서로 다른 객체여도 같은 hashcode값을 가질 수 있다. → 해당 버킷에 이미 값이 있다면 equals메서드를 통해 비교작업을 거친다. equals=false이면 LinkedList의 형태로 버킷에 값을 추가한다

class ExamMain {
	
	public static void main(String[] args) {
		
       Set<String> fruit = new HashSet<String>();
       
       // 데이터 삽입
       fruit.add("사과");
       fruit.add("오렌지");
       fruit.add("수박");
       fruit.add("포도");
       
       // 데이터 삭제
       fruit.remove("수박");
       
       // 데이터 출력
       Iterator<String> iter1 = fruit.iterator();
       while(iter1.hasNext()) {
    	   System.out.print(iter1.next()+" ");
       }
       
       System.out.println();       
       System.out.println(fruit.toString());
       
       // 데이터 포함 유무
       System.out.println(fruit.contains("수박"));
       System.out.println(fruit.contains("포도"));
       
       // 전체 데이터 삭제
       fruit.clear();
       System.out.println(fruit.toString());
       
       // 데이터의 존재 유무
       System.out.println(fruit.isEmpty());
       
       // 해당 Set의 크기
       System.out.println(fruit.size());
    		           
	}
    
}

// Console
포도 오렌지 사과 
[포도, 오렌지, 사과]
false
true
[]
true
0

public class Member {

	private String name;
	private int age;

	public Member(String name, int age) {
		this.age = age;
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}	
	
	public static void main(String[] args) {		
    
		Set<Member> set = new HashSet<Member>();        
        //클래스의 인스턴스주소값이 다르기 때문에 Key값이 같아도 각각 저장 가능하다
		set.add(new Member("홍길동", 30));
		set.add(new Member("홍길동", 100));
		
		Iterator<Member> iterator = set.iterator();		
		while(iterator.hasNext()) {
			Member elem = iterator.next();
			System.out.println(elem.getName() + elem.getAge());
		}
		
	}
    
}

// Console
홍길동30
홍길동100

TreeSet

트리구조로 저장하는 Set
오름차순으로 데이터를 저장한다

class ExamMain {	

	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<Integer>();

		set.add(4); // 데이터 추가
		set.add(2);
		set.add(1);
		set.add(3);
		set.add(6);
		set.add(5);

		Iterator<Integer> iter2 = set.iterator();
		while(iter2.hasNext()) {
			System.out.print(iter2.next()+" ");
		}

		System.out.println();

		Set<String> set2 = new TreeSet<String>();
		set2.add("d");
		set2.add("c");
		set2.add("a");
		set2.add("b");

		Iterator<String> iter3 = set2.iterator();
		while (iter3.hasNext()) {
			System.out.print(iter3.next()+" ");
		}
		
	}
	
}

// Console
1 2 3 4 5 6 
a b c d

대표적인 클래스 종류

• ArrayList<E>
• LinkedList<E>
• Vector<E>
• Stack<E>

ArrayList

가장 많이 사용되는 컬렉션 클래스 중 하나

가변배열이며 JDK 1.2부터 제공됨

배열 공간이 가득차면 새로운 배열을 만들어 기존의 내용을 복사

(복사하는 과정에서 지연이 발생하고, 데이터가 많아질수록 카피에 대한 지연시간 증가)

중간 데이터가 삭제되면 그 앞 인덱스에 있는 데이터들이 한 칸씩 당겨져온다

특정 데이터에 빠르게 접근할 수 있다

데이터의 양이 일관적이고 삽입 및 삭제가 거의 없는경우, 접근속도가 중요할 때 사용한다

(가변배열이지만 거의 변하게 하지 않을 때 사용하는 것이 좋다)

class ExamMain {
	
	public static void main(String[] args) {
		
        // 생성은 가능하나 제네릭타입이기 때문에 경고 발생
   		// ArrayList list1 = new ArrayList();
        
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		list1.add(3);
		list1.add(33);
		list1.add(333);
		list1.add(77);
		list1.add(777);	
		
        // for문과 get메서드를 이용한 출력
		for(int i=0; i<list1.size(); i++) {
			System.out.print(list1.get(i)+" ");
		}
		System.out.println();
        // size메서드를 이용한 배열의 크기
		System.out.println(list1.size()); 
        
        // remove메서드를 이용한 요소의 삭제
        list1.remove(3);
        
        // Collections.sort메서드를 이용한 정렬
		Collections.sort(list1);
                
        // set메서드를 이용한 요소의 변경
   		list1.set(2, 33333);
   		
        // iterator메서드와 get메서드를 이용한 출력
        Iterator<Integer> iter = list1.iterator();
		while (iter.hasNext()) {
		    System.out.print(iter.next() + " ");
		}
        
	}
    
}

// Console
3 33 333 77 777 
5
3 33 33333 777

LinkedList

ArrayList 클래스가 배열을 이용하여 요소를 저장함으로써 발생하는 단점을 극복하기 위해 고안됨

노드에 의해 데이터들이 연결되어있는 리스트

데이터의 삭제시 연결만 해지된다
데이터 삽입, 삭제가 빠르다
노드를 차례대로 검색하기 때문에 접근속도가 ArrayList에 비해 느리다
데이터의 삽입, 삭제가 자주 일어날 때 / 맨 앞, 맨 뒤 데이터의 삭제가 빈번할 때 사용

ArrayList클래스와 사용할 수 있는 메서드가 거의 같다

collection framework 

다수의 데이터를 쉽고 효과적으로 처리할 수 있는 표준화, 정형화된 방법을 제공하는 클래스의 집합

• 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 제공되는 라이브러리
• 데이터를 저장하는 자료구조와 데이터를 처리하는 알고리즘을 구조화하여 클래스로 구현 해 놓은것
• 인터페이스를 사용하여 구현된다
• 컬렉션 프레임워크를 구성하는 모든 클래스가 제네릭으로 표현되어 있다

※ 배열의 문제점 : 크기가 정적이면서 불변이다 (객체 삭제 시 해당 인덱스가 공백)

주요 인터페이스

컬렉션 클래스 collection class

컬렉션 프레임워크에 속하는 인터페이스를 구현한 클래스

List, Set, Map중 하나의 인터페이스를 구현

클래스의 이름에도 구현한 인터페이스의 이름이 포함되므로 바로 구분이 가능

class Collection1 {
	
	public static void main(String[] args) {
		
		ArrayList<Integer> arrInt = new ArrayList<Integer>();
		arrInt.add(1);
		arrInt.add(3);
		arrInt.add(5);
		arrInt.add(7);
		
		for(int i=0; i<arrInt.size(); i++) {
			System.out.print(arrInt.get(i));
		}
        
		System.out.println();
		System.out.println(arrInt.get(3));
        
	}
    
}

// Console
1357
7

기본 메서드

제네릭 Generic

타입을 파라미터화 하여 실행시에 구체적으로 해당하는 타입으로 결정

  → 특정(Specific)타입을 미리 지정해주는 것이 아닌 필요에 의해 지정할 수 있도록 하는 일반(Generic)타입

장점

• 잘못된 타입이 들어올 수 있는 것을 컴파일 단계에서 방지 가능
• 따로 타입을 체크하고 변환할 필요가 없다 (캐스팅 최소화로 인한 관리수월)
• 타입체크를 강력하게 하여 잘못된 데이터를 일반적인 원시, 참조 타입보다 안정성 확보에 좋음
• 코드의 재사용성이 높아짐

사용방법

• 반드시 한 글자일 필요도 없고 위의 표와 일치할 필요도 없다.
• Just 암묵적 규칙

선언

파라미터로 명시할 수 있는 것은 참조타입이다

• 사용자가 정의한 클래스도 타입으로 올 수 있다는 뜻과 같다
• int, double등 기본타입은 Integer, Double과 같은 Wrapper Type으로 사용한다
• static에는 제네릭 타입 선언 불가능하지만 정적 메서드에는 선언 가능 (밑에서 설명)

public class ExamMain<T> {
}

public Interface ExamMain2<T>{	
}

// 멀티 제네릭
// 두 개 이상의 타입을 파라미터로 사용 가능
public class ExamMain<T, E> {
}

public Interface ExamMain2<K, V>{	
}

제네릭 클래스

class ExamMain<E> {
	
	private E element;	     
	
	void set(E element) {	   
		this.element = element;
	}
	
	E get() {	             
		return element;
	}
    
}

class genericExamMain {
	
	public static void main(String[] args) {
		
		ExamMain<String> a = new ExamMain<String>();
		ExamMain<Integer> b = new ExamMain<Integer>();
		
		a.set("안녕");
		b.set(10);
	
		System.out.println("a data : " + a.get());
		System.out.println("a E Type : " + a.get().getClass().getName());      // 타입 출력
		
		System.out.println("b data : " + b.get());
		System.out.println("b E Type : " + b.get().getClass().getName());      // 타입 출력
		
	}
}

// Console
a data : 안녕
a E Type : java.lang.String
b data : 10
b E Type : java.lang.Integer

// 멀티 제네릭

public class Tv<E, T> {
	
	private E e;
	private T t;	
    
	public Tv() {
		
	}
	
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public E getE() {
		return e;
	}
	
	public void setE(E e) {
		this.e=e;
	}
    
}

public class TvMain {

	public static void main(String[] args) {
		
		Tv<Integer, String> tv1 = new Tv<Integer, String>();
		Tv<String, Float> tv3= new Tv<String, Float>();
		tv1.setE(123456);
		tv1.setT("가나다라마바");
		tv3.setE("어쩔티비");
		tv3.setT(12.345f);
		int tv2=tv1.getE();
		String tv4=tv3.getE();
		System.out.println(tv2);
		System.out.println(tv4);		
	}
	
}

// Console
123456
어쩔티비

제네릭 메서드

클래스에서 지정한 제네릭 유형과 별개로 독립적으로 제네릭 유형을 선언하여 사용 가능

public <T> T genericMethod(T t) {
	return t;
		
}

// 접근제어자 <제네릭타입> 반환타입 메소드명(제네릭타입 파라미터)

// 위의 TV예제에 제네릭 메서드인 genericMethod메서드를 추가
public class Tv<E, T> {
	
	private E e;
	private T t;
	
	public Tv() {
		
	}
	
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public E getE() {
		return e;
	}
	
	public void setE(E e) {
		this.e=e;
	}
	
	<N> N genericMethod(N n) {	// 제네릭 메소드
		return n;
	}
    
}

public class TvMain {
	
	public <T> T genericMethod(T t) {
		return t;
		
	}

	public static void main(String[] args) {
		
		Tv<Integer, String> tv1 = new Tv<Integer, String>();
		Tv<String, Float> tv3= new Tv<String, Float>();
		tv1.setE(123456);
		tv1.setT("가나다라마바");
		tv3.setE("어쩔티비");
		tv3.setT(12.345f);
		int tv2=tv1.getE();
		String tv4=tv3.getE();
		System.out.println(tv2);
		System.out.println(tv4);
		
		System.out.println("<N> returnType : " + tv1.genericMethod(3).getClass().getName());		
		System.out.println("<N> returnType : " + tv1.genericMethod("ABCD").getClass().getName());		
		System.out.println("<N> returnType : " + tv1.genericMethod(tv3).getClass().getName());		
	}
	
}

// Console
123456
어쩔티비
<N> returnType : java.lang.Integer
<N> returnType : java.lang.String
<N> returnType : generic1201.Tv

메서드는 해당 클래스의 객체가 인스턴스화 됐을 때 <> 괄호 사이에 파라미터로 넘겨준 타입으로 지정이 된다
※ Static은 객체가 생성되기 이전, 즉 클래스가 생성될 때 같이 선언이 되기 때문에 제네릭 타입을 사용 불가능
    (제네릭 타입을 얻어올 방법이 없다)
정적메서드를 두고 싶은 경우 제네릭 클래스와 별도로 독립적인 제네릭이 사용되어야 한다

제한된 Generic과 와일드카드

<E>를 외부클래스에서 String파라미터로 보내면 E는 String이되고, Integer을 보내면 E는 Integer이 된다

Tv<E>클래스를 만들고 파라미터를 TV로 보내면 E는 TV 클래스가 된다. → 참조타입이 될 수 있다

extends, super, ? 을 통해특정 범위로 좁혀서 제한할 수 있다 (여기서 ?는 와일드카드. 즉 알 수 없는 타입이라는 의미)

• extends T : 상한경계
• ? super T : 하한경계
• <?> : 와일드카드

<E extends T>	       // T와 T의 자손 타입만 가능 (E는 들어오는 타입으로 지정 됨)
<E super T>	         // T와 T의 부모(조상) 타입만 가능 (E는 들어오는 타입으로 지정 됨)
<? extends T>	       // T와 T의 자손 타입만 가능
<? super T>      	// T와 T의 부모(조상) 타입만 가능
<?>		        // 모든 타입 가능. <? extends Object>

위 그림과 같은 경우

<T extends B>	// T = B~C
<T extends E>	// T = E
<T extends A>	// T = A~E

<? extends B>	// ? = B~C
<? extends E>	// ? = E
<? extends A>	// ? = A~E

<T super B>	// T = A~B
<T super E>	// T = A,D,E
<T super A>	// T = A
 
<? super B>	// ? = A~B
<? super E>	// ? = A,D,E
<? super A>	// ? = A

<?>		        // 모든 타입 가능. <? extends Object>

public class Exam extends Object{
	System.out.println("<?>(wild Card)와 같은 의미");
}

// 어떤 클래스를 만들던 extends Object를 암시적으로 상속받는다

지역변수

특정 구역 내에서 생성되어 그 구역에서만 사용

public class ExamMain {
	
	static String str = "전역변수";
	

    public static void main(String[] args) {
		System.out.println(str);		
		String local = "지역변수";				
		System.out.println(local);		
		method1();
	}
    
	public static void method1() {
		System.out.println(str);
        //System.out.println(local);
		//지역변수이기에 출력 불가. 에러발생
	}
	
}

// Console
전역변수
지역변수
전역변수

전역변수

멤버(인스턴스) 변수 : 클래스 영역에 선언되어, 객체가 생성될 때 마다 만들어지고 생성되었을 때만 호출하여 사용가능

정적(클래스) 변수 : 객체를 따로 생성하지 않아도 사용가능. 남발 시 프로그램 속도에 악영향을 끼침

public class ExamMain {
	
	static String str = "전역변수";
	String str2 = "멤버변수";

	
	public static void main(String[] args) {
		System.out.println(str);
		
		ExamMain examMain=new ExamMain();
		System.out.println(examMain.str2);        // 인스턴스 생성해야 호출 가능
	}

}

값에 의한 전달 / 주소값에 의한 전달

Call by Value

// count의 값을 add에 넘겨 변경시키더라도 출력값엔 변화가 없다
// ( 값을 전달받았기 때문에 )
class Add {
    void add(int count) {
        count++;
    }
}

class Counter {
    int count = 0;   
}

public class ExamMain {
    public static void main(String[] args) {
        Counter counter = new Counter();
        System.out.println("더하기 전 : "+counter.count);
        Add add1 = new Add();
        add1.add(counter.count);
        System.out.println("더한 후 : "+counter.count);
    }
}

// Consonle
더하기 전 : 0
더한 후 : 0

Call by Reference

// int count → Counter counter
// 객체를 전달받도록 바꿈
// 객체 주소를 전달받았기 때문에 count값이 올랐다
class Add {
    void add(Counter counter) {
        counter.count++;
    }
}

class Counter {
    int count = 0;  //
}

public class ExamMain {
    public static void main(String[] args) {
        Counter counter = new Counter();
        System.out.println("더하기 전 : "+counter.count);
        Add add1 = new Add();
        add1.add(counter);
        System.out.println("더한 후 : "+counter.count);
    }
}

// Consonle
더하기 전 : 0
더한 후 : 1

StringBuffer

문자열을 추가하거나 변경할 때 주로 사용하는 자료형

• String 자료형이나 인스턴스의 경우 생성되면 변경이 불가능 → 문자열을 추가, 변경하는 과정 필요
• 버퍼(buffer)라는 독립적 공간을 통해 값을 변경, 추가
• 버퍼는 기본적으로 16개의 문자를 저장할 수 있지만 생성자를 통해 크기를 설정 가능

버퍼(Buffer) : 임시저장공간
데이터를 한 곳에서 다른 한 곳으로 전송하는 동안 일시적으로 그 데이터를 보관하는 메모리의 영역

※버퍼링을 큐(Queue)라고도 표현한다

append

문자열 추가

StringBuffer stringBuffer = new StringBuffer(); 
stringBuffer.append("오늘의");
stringBuffer.append(" 점심은 ");
stringBuffer.append("몰?루");
String result = stringBuffer.toString();
System.out.println(result);

String result2 ="";
result2 += "오늘의";
result2 += " 점심은 ";
result2 += "몰?루";
System.out.println(result2);

// 두 결과는 동일하지만 내부적으로 객체가 생성되고 메모리가 사용되는 과정이 다름
// StringBuffer객체는 한 번만 생성되지만
// String은 +연산이 있을 때마다 생성되고 있다

// StringBuffer가 String대비 메모리 사용량도 많고 속도도 느리다

// 종합 해 보았을 때 문자열 추가 및 변경 작업이 많을 경우 StringBuffer가 유리하지만
// 문자열 변경작업이 거의 없는 경우는 String을 사용하는 것이 유리하다

// StringBuilder
// StringBuffer와 비슷한 자료형이다
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("오늘의");
stringBuilder.append(" 저녁도 ");
stringBuilder.append("몰?루");
String result3 = stringBuilder.toString();
System.out.println(result3);

// StringBuffer : 멀티 스레드 환경에서 안전하다 → 동기화를 필요로 할 때
// StringBuilder : 버퍼보다 성능이 우수하다 → 필요 없을 때

insert

지정 위치에 문자 삽입

StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("오늘의 몰?루");
stringBuffer.insert(3, " 점심은 ");
System.out.println(stringBuffer.toString());

stringBuffer.insert(11, "라?");
System.out.println(stringBuffer.toString());

// Console
// 오늘의 점심은 몰?루
// 오늘의 점심은  몰?라?루

substring

String 자료형의 substring 메서드와 동일하게 문자열을 자름

StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("오늘의 점심은 몰?루");
System.out.println(stringBuffer.substring(4));
System.out.println(stringBuffer.substring(4, 9));

// Console
// 점심은 몰?루
// 점심은 몰

그 외 메서드들

StringBuffer stringBuffer = new StringBuffer("오늘의 점심은 몰?루");
System.out.println(stringBuffer);

// replace : 문자열 치환(교체)
System.out.println(stringBuffer.replace(4, 7, "바보야")); // 오늘의 바보야 몰?루

// delete : 문자열 삭제
System.out.println(stringBuffer.delete(2, 7));            // 오늘 몰?루

// deleteCharAt
System.out.println(stringBuffer.deleteCharAt(2));         // 오늘 점심은 몰?루

// toString : String으로 변환

// reverse : 문자 전체를 뒤집는다
System.out.println(stringBuffer.reverse());                // 루?몰 은심점 의늘오

// setCharAt
stringBuffer.setCharAt(2, '도');                          // 오늘도 점심은 몰?루
System.out.println(stringBuffer);

// setLength : 문자열 길이 조정(현재보다 길면 공백으로 채워짐)
stringBuffer.setLength(7);
System.out.println(stringBuffer);                       // 오늘의 점심은

// trimToSize : 배열 뒷 부분의 빈 공간 제거