AOP(Aspect Oriented Programming)는 관점지향프로그래밍이라고 불린다. 관점지향은 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 각각 모듈화하겠다는 것이다. 여기서 모듈화란 어떤 공통된 로직이나 기능을 하나의 단위로 묶는 것을 말한다. 

핵심적인 관점은 핵심 비즈니스 로직을 의미하고 부가적인 관점은 핵심로직을 실행하기 위해 행해지는 DB연결, 로깅, 예외처리 등이 있다. 소스코드 상에서 다른 부분에 반복해서 쓰는 코드들이 있는데 이것을 흩어진 관심사라고 부른다. 여기서 이 흩어진 관심하를 모듈화하고 핵심적인 비즈니스 로직에서 분리하여 재사용하겠다는 것이 AOP의 취지이다.

 

AOP의 주요 개념

- Aspect : 흩어진 관심사를 모듈화 한 것 (부가기능을 모듈화 한 것)

- Target : Aspect를 적용하는 곳(클래스, 메서드...) [부가기능을 부여할 대상]

- Advice : 실질적으로 부가기능을 담은 구현체 / Advice는 Aspect가 무엇을 언제 할지를 정의한다.

- JoinPoint : Advice가 적용될 수 있는 위치

- PointCut : JoinPoint의 상세한 스펙을 정의하여 선별 / 구체적으로 Advice가 실행될 지점을 정함 (ex : A라는 메서드의 진입 시점에 호출할 것)

- Proxy : 타겟을 감싸서 타겟의 요청을 대신 받아주는 랩핑 오브젝트

- Introduction : 타겟 클래스에 코드 변경없이 신규 메소드나 멤버변수를 추가하는 기능

- Weaving : 지정된 객체에 애스팩트를 적용해서 새로운 프록시 객체를 생성하는 과정

반응형

▶Math.ceil() : 올림 (실수형 유지)

Math.floor() : 내림 (실수형 유지)

Math.rint() : 반올림 (실수형 유지)

Math.round() : 반올림 (int형으로 반환)

System.out.println(Math.ceil(3.14));
System.out.println(Math.floor(3.14));
System.out.println(Math.rint(3.14));
System.out.println(Math.rint(3.51));
System.out.println(Math.round(3.51));
4.0
3.0
3.0
4.0
4

 

반응형

이번 포스팅에서는 Map인터페이스를 구현하는 컬렉션 클래스들에 대해 설명하고자 한다. 이 클래스들의 데이터 저장방식을 가리켜 key-value 방식이라 한다.

즉, key를 저장하고 그 key에 대응하는 value값도 같이 저장한다는 것이다.

그래서 데이터 1개는 key와 이에 딸려있는 value값이 각각 한개씩 있다는 것이다.

이러한 데이터 저장방식을 갖는 Map인터페이스를 구현하는 클래스는 HashMap, TreeMap, LinkedHashMap 세 가지가 있다.

 

먼저 HashMap을 살펴보겠다.

 

HashMap

import java.util.HashMap;

public class MapClass {

	public static void main(String[] args) {
		HashMap<Integer, String> hMap = new HashMap<Integer, String>();
		
		hMap.put(1, "홍길동");
		hMap.put(2, "세종대왕");
		hMap.put(3, "이순신");
		hMap.put(1, "유관순");
		hMap.put(4, "세종대왕");
		
		System.out.println(hMap);
	}
}
{1=유관순, 2=세종대왕, 3=이순신, 4=세종대왕}

 

HashMap을 간단하게 사용해 보았다. hMap이라는 HashMap 객체를 만들어 데이터를 저장하고 있다. 데이터 입력값은 5개인데 출력값을 보니 4개뿐이다. 이는 key값의 중복은 허용하지 않기 때문이다. 예를들어 학창시절 다들 자신만의 학번을 가졌을 것이다. 같은학번을 둘이서 가지는게 가능한가? 그런일은 절대 일어나지 않는다. 여기서 학번은 key값이 되는 것이다. 하지만 이름이 똑같은 학생은 종종 있기 마련이다. 이름이 같다고 해서 둘이 같은사람인가? 아니다. 여기서 이름은 value값이 된다. 그 이름이 같은 학생을 구분하려면 key값인 학번을 확인하면 된다. 3학년1반에 번호가 1번인 학생은 단 한명이듯 자바에서도 하나의 객체에서 1번이라는 key는 단 하나여야 한다는 것이다.

이제 이해가 되었는가? 그렇다면 위의 소스를 이해할 수 있을 것이다. 이해만 하면 그리 어려운 내용은 아니니 바로 다음으로 넘어가겠다.

 

TreeMap

package CollectioinPractice;

import java.util.TreeMap;

public class MapClass {

	public static void main(String[] args) {
		TreeMap<Integer, String> tMap = new TreeMap<Integer, String>();
		
		tMap.put(4, "세종대왕");
		tMap.put(1, "유관순");
		tMap.put(3, "이순신");
		tMap.put(1, "홍길동");
		tMap.put(2, "세종대왕");

		System.out.println(tMap);
	}
}
{1=홍길동, 2=세종대왕, 3=이순신, 4=세종대왕}

TreeMap의 특징은 key값을 기준으로 데이터를 정렬한 상태로 저장한다는 것이다.

소스를 보면 입력을 무작위로 넣은 것을 볼 수 있을 것이다. 하지만 출력값은 key값을 기준으로 정렬이 되어있다.

이것이 HashMap과 TreeMap의 차이이다.

 

LinkedHashMap

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;

public class MapClass {

	public static void main(String[] args) {
		LinkedHashMap<Integer, String> lMap = new LinkedHashMap<Integer, String>();

		lMap.put(4, "세종대왕");
		lMap.put(1, "유관순");
		lMap.put(3, "이순신");
		lMap.put(1, "홍길동");
		lMap.put(2, "세종대왕");
		
		
		System.out.println(lMap);
		
		Iterator<Integer> ir = lMap.keySet().iterator();
		while(ir.hasNext()) {
			System.out.println(ir.next());
		}
	}
}
{4=세종대왕, 1=홍길동, 3=이순신, 2=세종대왕}
4
1
3
2

이번에는 LinkedHashMap을 사용한 소스이다. TreeMap에서 입력한 순서 그대로 사용해보았다. 하지만 출력값 순서는 입력한 순서 그대로 나오는 것을 알 수 있다. 이와 같이 LinkedHashMap은 입력한 데이터 순서대로 저장되는 특성이 있다.

참고로 소스에 Iterator라는 순환자를 사용한 것을 볼 수 있을 것이다. 이것은 List와 Set을 구현하는 클래스이다. 주로 읽기 전용으로 사용하고 위 소스와 같이 값하나하나 읽어들이는 것으로 사용할 수 있다. Iterator는 Map을 구현하지 않기때문에 ketSet() 이라는 메소드를 통해 key값을 set(집합)으로 만들어주고 iterator메소드로 순회하는 방법으로 LinkedHashMap의 Key값들을 순회하며 하나씩 읽어들이고 있는 것이다.

 

마지막으로 정리하자면

Map인터페이스는 Collection인터페이스를 구현하며 Map 인터페이스를 구현하는 Map의 종류에는 HashMap, TreeMap, LinkedHashMap 클래스가 존재한다. Map은 기본적으로 key와 value값을 가진다.

 

HashMap은 입력한 순서에 상관없이 데이터가 저장된다.

TreeMap은 입력한 순서에 상관없이 key를 기준으로 정렬이 되어 저장된다.

LinkedTreeMap은 입력한 순서대로 데이터가 저장된다.

 

 

반응형

Set 인터페이스를 공부하기에 앞서 Collection 인터페이스에 대해 모른다면 아래 링크를 걸어 놓을테니 읽어보는 것을 추천한다.

 

ckprk.tistory.com/27

 

[자바] 컬렉션 프레임워크 [Collection 인터페이스]

컬렉션 프레임워크란 무엇인가? 흔히 프로그램 개발을 건물 짓는 일에 비유한다. 원하는 건물을 지으려면 구조를 잘 잡아야하듯이 프로그램을 개발할 때도 사용하는 자료를 어떤 구조로 관리할

ckprk.tistory.com

 

자, 이제 그럼 Collection 인터페이스에서 제공하는 set인터페이스에 대해 알아보겠다.

set은 한마디로 '집합'이다. 수학시간에 배운 그 '집합'을 생각하면 된다. 집합은 어떤 요소가 어디에 속해있고 없고가 중요한 것이지 집합 안에서의 순서는 중요하지 않다. 자바에서 제공하는 set인터페이스도 이와 같다고 생각하면 된다.

 

그렇다면 자바에서 set의 종류는 어떤 것들이 있을까?

 

HashSet, TreeSet, LinkedHashSet 이렇게 총 세 가지이다.

 

각 set을 구현한 소스를 보기에 앞서 각각 간단하게 설명하고 넘어가겠다.

▶HashSet은 입력 순서와 상관없이 데이터를 저장한다.

▶TreeSet은 입력 순서와 상관은 없지만 정렬이 된 상태로 저장을 한다.

▶LinkedHashSet은 입력한 순서대로 데이터를 저장한다.

 

HashSet(입력 순서와 상관없이 데이터를 저장)

import java.util.HashSet;
import java.util.Iterator;

public class Main {

	public static void main(String[] args) {
		HashSet<String> hs1 = new HashSet<String>();
		
		hs1.add("pear");
		hs1.add("apple");
		hs1.add("tomato");
		hs1.add("pear");
		
		Iterator<String> itr = hs1.iterator();
		while(itr.hasNext()) {  //반복자를 이용해서 저장된 데이터를 전부 출력하고 있다.
			System.out.println(itr.next());
		}
	}
}
apple
pear
tomato

소스를 보면 apple, pear, tomato 순으로 입력이 되었고 다시 pear를 입력하였다. 출력결과를 보면 입력 순서와 상관이 없는 저장상태를 보여줄 뿐더러 중복입력한 pear는 하나만 저장이 되어있다. 앞서 설명한 부분이지만 set인터페이스는 집합이기에 중복값은 유효하지 않다.

 

우리는 집합을 공부할 때 합집합, 교집합, 차집합과 같은 집합 간의 연산을 배웠다. Set은 집합이다. 똑같이 사용할 수 있다. 합집합은 addAll(), 교집합은 retainAll(), 차집합은 removeAll() 이라는 함수를 각각 적용한다.

 

import java.util.HashSet;
import java.util.Iterator;

public class asgsdargafg {

	public static void main(String[] args) {
		HashSet<String> hs1 = new HashSet<String>();
		HashSet<String> hs2 = new HashSet<String>();
		HashSet<String> hs3 = new HashSet<String>();
		
		
		hs1.add("pear");
		hs1.add("apple");
		hs1.add("tomato");
		hs1.add("pear");
		
		hs2.add("apple");
		hs2.add("grapes");
		
		hs3.add("strawberry");
		hs3.add("grapes");
		hs3.add("pear");
		
		HashSet<String> union = new HashSet<String>(hs1);
		union.addAll(hs2);
		union.addAll(hs3); //hs1, hs2, hs3 모두 합한 합집합
		
		HashSet<String> intersection = new HashSet<String>(hs1);
		intersection.retainAll(hs2); //hs1와 hs2의 교집합
		
		HashSet<String> remove = new HashSet<String>(hs1);
		remove.removeAll(hs3); //hs1에서 hs3을 뺀 차집합
		
		System.out.println("합집합 " + union);
		System.out.println("교집합 " + intersection);
		System.out.println("차집합 " + remove);
	}
}
합집합 [apple, pear, strawberry, tomato, grapes]
교집합 [apple]
차집합 [apple, tomato]

 

 

- TreeSet(정렬이 된 상태로 저장)

import java.util.HashSet;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) {
		TreeSet<String> ts1 = new TreeSet<String>();
		TreeSet<String> ts2 = new TreeSet<String>();
		TreeSet<String> ts3 = new TreeSet<String>();
		
		ts1.add("pear");
		ts1.add("apple");
		ts1.add("tomato");
		ts1.add("pear");
		
		ts2.add("apple");
		ts2.add("grapes");
		
		ts3.add("strawberry");
		ts3.add("grapes");
		ts3.add("pear");
		
		System.out.println(ts1);
		System.out.println(ts2);
		System.out.println(ts3);
	}
}
[apple, pear, tomato]
[apple, grapes]
[grapes, pear, strawberry]

기존의 데이터를 TreeSet을 사용하여 출력해 보았다. 알파벳 순으로 정렬이 되어 데이터가 저장되어 있는 것을 확인할 수 있다.

 

 

- LinkedHashSet (입력된 순서대로 데이터 저장)

import java.util.LinkedHashSet;

public class Main {

	public static void main(String[] args) {
		LinkedHashSet<String> lhs1 = new LinkedHashSet<String>();
		LinkedHashSet<String> lhs2 = new LinkedHashSet<String>();
		LinkedHashSet<String> lhs3 = new LinkedHashSet<String>();
		
		lhs1.add("pear");
		lhs1.add("apple");
		lhs1.add("tomato");
		lhs1.add("pear");
		
		lhs2.add("apple");
		lhs2.add("grapes");
		
		lhs3.add("strawberry");
		lhs3.add("grapes");
		lhs3.add("pear");
		
		System.out.println(lhs1);
		System.out.println(lhs2);
		System.out.println(lhs3);
	}
}
[pear, apple, tomato]
[apple, grapes]
[strawberry, grapes, pear]

입력된 순서로 데이터가 저장된 것을 확인할 수 있다.

 

다음 글에서는 Set과 같이 Collection 인터페이스를 구현하는 Map인터페이스에 대해 포스팅할 예정이다.

그럼 이만.

반응형

ArrayList와 LinkedList는 모두 List 인터페이스를 구현하는 클래스들이다. (List 인터페이스는 자바의 컬렉션 프레임워크에서 Collection 인터페이스를 구현하는 인터페이스이다. 프레임워크와 Collection 인터페이스에 대해 궁금하다면 아래에 링크를 걸어 놓을테니 참고하길 바란다.)

ckprk.tistory.com/27

 

[자바] 컬렉션 프레임워크 [Collection 인터페이스]

컬렉션 프레임워크란 무엇인가? 흔히 프로그램 개발을 건물 짓는 일에 비유한다. 원하는 건물을 지으려면 구조를 잘 잡아야하듯이 프로그램을 개발할 때도 사용하는 자료를 어떤 구조로 관리할

ckprk.tistory.com

 

List 인터페이스를 구현하는 대표적인 제네릭 클래스인 ArrayList와 LinkedList는 다음 두가지 특성을 공통으로 지닌다.

 

▶동일한 인스턴스의 중복 저장을 허용한다.

▶인스턴스의 저장 순서가 유지된다.

 

이 둘의 사용방법은 거의 동일하다. 다만 데이터를 저장하는 방식에서 큰 차이를 보인다. 이와 관련해서는 ArrayList와 LinkedList 사용방법을 각각 살펴보고 설명하겠다.

 

import java.util.ArrayList;

public class IntroArrayList {

	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		
		System.out.println("1차 참조");
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
		
		System.out.println("2차 참조");
		list.remove(0);
		System.out.println(list);
	}
}
1차 참조
[1, 2, 3]
2차 참조
[2, 3]

Integer를 기반으로 ArrayList의 인스턴스를 생성하고 있다. 따라서 생성한 list라는 인스턴스는 Integer형의 인스턴스를 받는 저장소로 사용된다.

또한 add 메서드를 통해 세개의 인스턴스를 저장하고 있는 것을 볼 수 있다. 1차 참조 출력값을 보면 알 수 있듯이 순차적으로 저장된다는 것이다. 즉, 저장 순서가 ArrayList<Integer> 인스턴스 내에서 유지된다고 할 수 있다.

 

기본적으로 알고 있어야 하는 데이터의 저장, 참조 및 삭제 방법을 간단히 보였다. 이와 같이 ArrayList 클래스는 배열과 상당히 유사하다 하지만 데이터의 저장을 위해서 인덱스 정보를 별도로 관리할 필요가 없고, 데이터의 삭제를 위한 추가적인 코드의 작성이 전혀 필요 없다. 또한 저장되는 인스턴스의 수에 따라서 그 크기도 자동으로 늘어나고 줄어들기 때문에 이러한 면에서는 배열보다 편이하다고 할 수 있다.

 

이번에는 LinkedList 클래스의 사용방법을 살펴보겠다.

import java.util.LinkedList;

public class IntroArrayList {

	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<Integer>();
		
		System.out.println("1차 데이터");
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
		
		System.out.println("2차 데이터");
		list.remove(0);
		System.out.println(list);
	}
}
1차 데이터
[1, 2, 3]
2차 데이터
[2, 3]

 

ArrayList와 유일한 차이점은 import선언 부분과 LinkedList<Integer> list = new LinkedList<Integer>(); 이부분임을 알 수 있다. 이렇듯 ArrayList와 LinkedList 클래스 사이에서의 선택 기준은 사용방법 차이가 아닌, 내부적으로 인스턴스를 저장하는 방식의 차이에 있다.

 

LinkedList는 배열을 사용하는 대신에 서로서로 연결하는 방식으로 데이터를 저장한다. 이는 이해하기 위해 다음 코드를 제시한다. 이 코드는 LinkedList를 사용하는 것이 아닌 LinkedList의 데이터 저장방식을 이해하기 위한 코드이다.

class Box<T>{ //인스턴스를 담을 '상자' 클래스 (배열을 대신함)
	public Box<T> nextBox; //상자들을 연결하기 위한 참조변수. 이 변수를 이용해서 Box<T>의 인스턴스는 동일한 자료형의 인스턴스를 참조하게 된다.
	T item;
	
	public void store(T item) {this.item=item;} //인스턴스를 저장하기 위한 메서드
	public T pullOut() {return item;} //받은 인스턴스를 반환하는 메서드
}

public class LinkedListEx {

	public static void main(String[] args) {
		Box<String> box = new Box<String>(); //box를 생성
		box.store("First thing"); //만든 box에 문자열을 담음
		
		box.nextBox = new Box<String>(); // 두번째 box 생성
		box.nextBox.store("Second thing"); // 두번째 box에 문자열 담음
		
		box.nextBox.nextBox = new Box<String>(); //세번째 box 생성
		box.nextBox.nextBox.store("Third thing"); // 세번째 box에 문자열 담음
		
		System.out.println(box.pullOut());  //첫번째 박스에 담긴 인스턴스 출력
		System.out.println(box.nextBox.pullOut()); //두번째 박스에 담긴 인스턴스 출력
		System.out.println(box.nextBox.nextBox.pullOut()); //세번째 박스에 담긴 인스턴스 출력
	}
}
First thing
Second thing
Third thing

 

이렇게 연결 되어있는 상자들에 데이터가 저장되는 모습을 볼 수 있다. 이를 통해 LinkedList의 특성을 파악할 수 있다.

저장소를 늘리는 것은 마치 블록을 하나 연결하는 것과 마찬가지로 그 과정이 간단하고 데이터의 삭제 역시 매우 간단하다. 위의 코드에서는 보이진 않았지만 중간에 위치한 상자하나를 삭제하는 것은 어려운 일이 아니다. 하지만 데이터의 참조는 불편하다. 참조를 위해서는 위와 같이 연결되어있는 상자들을 통해 이동을 해야하기 때문이다.

 

따라서 총 정리해 보면, ArrayList는 배열을 기반으로 하지만 LinkedList는 배열이 아닌 연결방식이다.

 

ArrayList

장점 : 데이터의 참조가 용이해서 빠른 참조가 가능하다.

▶단점 : 저장소의 용량을 늘리는 과정에서 많은 시간이 소요된다.

                  데이터의 삭제에 필요한 연산과정이 매우 길다.

 

LinkedList

▶장점 : 저장소의 용량을 늘리는 과정이 간단하다.

                  데이터의 삭제가 매우 간단하다.

▶단점 : 데이터의 참조가 다소 불편하다.

 

 

그러면 마지막으로 다음의 상황에서 둘중 어떤 클래스를 사용해야하는지 판단해보자

 

상황1 : 저장하게 되는 데이터의 수가 대략적으로 예측 가능하며, 빈번한 데이터의 참조가 일어나는 상황에서 유용하게 사용할 수 있는 컬렉션 클래스는 무엇인가?

 

상황2 : 저장하게 되는 데이터의 수가 예측 불가능하며, 빈번한 데이터의 저장 및 삭제가 일어나는 상황에서 유용하게 사용할 수 있는 컬렉션 클래스는 무엇인가?

 

 

상황1 : ArrayList 클래스

상황2 : LinkedList 클래스

반응형

컬렉션 프레임워크란 무엇인가?

흔히 프로그램 개발을 건물 짓는 일에 비유한다. 원하는 건물을 지으려면 구조를 잘 잡아야하듯이 프로그램을 개발할 때도 사용하는 자료를 어떤 구조로 관리할 것인지가 중요하다. 그래야 프로그램의 기능을 효과적으로 구현할 수 있기 때문이다. 이 때 사용하는 것이 자료구조(data structure)이다. 자료 구조는 프로그램 실행 중 메모리에 자료를 유지 및 관리하기 위해 사용한다. 자바에서는 필요한 자료 구조를 미리 구현하여 java.util 패키지에서 제공하고 있는데 이를 컬렉션 프레임워크(collection framework)라고 한다. 자료 구조는 개발자가 필요할 때 직접 만들어 사용할 수도 있다. 하지만 자바 컬렉션 프레임워크를 사용하면 직접 개발하는 수고를 덜 수 있을 뿐만 아니라 잘 만들어진 자료구조 클래스를 활용할 수 있다.

 

컬렉션 프레임워크의 전체 구조는 Collection 인터페이스와 Map인터페이스 기반으로 이루어져있다.

Collection 인터페이스는 하나의 자료를 모아서 관리하는데 필요한 기능을 제공하고, Map인터페이스는 쌍(pair)으로 된 자료들을 관리하는데 유용한 기능을 제공한다.

 

이번시간에는 Collection 인터페이스 먼저 살펴보도록 하겠다.

 

 

 

Collection 인터페이스 하위에 List 인터페이스와 Set 인터페이스가 있다.

List를 구현한 클래스는 순차적인 자료를 관리하는데 사용할 수 있고, Set 계열의 클래스는 아이디처럼 중복되지 않는 객체를 다루는데 사용한다.

 

 

아래는 Collection 인터페이스에 선언된 메서드 중 자주사용하는 메서드이다.

 

▶(boolean) add(E e) : Collection에 객체를 추가한다.

▶(void) clear() : Collection의 모든 객체를 제거한다.

▶Iterator<E> iterator : Collection을 순환할 반복자(Iterator)를 반환한다.

▶(boolean) remove(Object o) : Collection에 매개변수에 해당하는 인스턴스가 존재하면 제거한다.

▶(int) size() : Collection에 있는 요소의 개수를 반환한다.

 

→add()나 remove() 메서드가 boolean형으로 결과 값을 반환하는 것은 객체가 잘 추가되었는지, 컬렉션에서 객체가 잘 제거되었는지 여부를 반환하는 것이다.

 

반응형

자바에서 String 하면 문자열이 떠오를 것이다.

String str1 = "Hello";

String str2 = " World";

라고 한다면 두개의 객체가 생성되어 각각 하나의 문자열을 가진다.

그리고 이 문자열을 더하는 행위를 했을 때, 또 다른 객체를 생성하여 받아야한다.

String str = str1+str2; //"Hello World" 이렇게 되는 것이다.

이러한 행위는 메모리 할당과 메모리 해제를 발생시키기 때문에 성능이 저하된다.

 

그래서 대안으로 StringBuilder 가 있는 것이다.

StringBuilder는 새로운 객체를 만들어 줄 필요 없이 하나의 객체에 기존의 문자열을 덧붙이는 방식을 사용하기 때문에 부하가 적으며 상대적으로 속도도 빠르다.

따라서 긴 문자열을 더하는 상황이 발생한다면 StringBuilder를 사용하면 효과적이다.

 

그러면 StringBuilder의 메소드를 살펴보면서 사용 방법을 소개하겠다.

 

append - 문자열 추가

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
Hello World

 

delete - 문자열 제거

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.delete(2, 4); //2번자리에서 4번자리 전까지 (2,3번 자리 문자 제거)
System.out.println(sb);
Hello World
Heo World

 

 

deleteCharAt - 특정 문자만 제거

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.deleteCharAt(5);
System.out.println(sb);
Hello World
HelloWorld

 

setCharAt - 특정 위치 문자 변경

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.setCharAt(0, 't');
System.out.println(sb);
Hello World
tello World

 

insert - 문자열 삽입

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.insert(5, "!"); //매개변수로 받은 인덱스 위치부터 문자열 삽입
System.out.println(sb);
Hello World
Hello! World

 

reverse - 문자열 반전

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.reverse();
System.out.println(sb);
Hello World
dlroW olleH

 

setLength - 문자열 길이 조절

현재 문자열 길이보다 짧게 설정하면 그 길이 이외의 문자열은 제거됨

현재 문자열 길이보다 길게 설정하면 공백으로 채워짐

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
System.out.println(sb);
		
sb.setLength(7);
System.out.println(sb);
Hello World
Hello W
반응형
import java.util.*;
public class Main
{
	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int n = sc.nextInt();
	    int result=1;
	    for(int i=1; i<=n; i++){ //1부터 n까지
	        result*=i;           //하나씩 곱해서 result에 저장
	    }
	    System.out.println(result);
	}
}

 

반응형

+ Recent posts