📌Today I Learned

Java 수업 (67~72)

Ex67_sort

배열 or 컬렉션

• 오름차순 정렬, 내림차순 정렬
  1. 직접 알고리즘 구현
  2. JDK 제공 기능
     
     

정렬 방법

Arrays 클래스의 sort() 메소드를 사용한다.
오름차순 정렬이다.
내림차순 정렬은 지원하지 않아서 직접 구현해야 한다.

Integer[] nums = { 1, 5, 2, 4, 3 };

// 오름차순 정렬
Arrays.toString(nums);

// 내림차순 정렬 > 지원 안함 > 직접 구현
//		Arrays.sort(배열, Comparator);
Arrays.sort(nums, new MyComparator());

Comparator 인터페이스를 사용할 수 있다.
o1 vs o2
1. 오름차순
a. o1이 더 크면 > 양수 반환 > 1
b. o2가 더 크면 > 음수 반환 > -1
c. 같으면 > 0 반환


2. 내림차순
a. o1이 더 크면 > 음수 반환 > -1
b. o2가 더 크면 > 양수 반환 > 1
c. 같으면 > 0 반환

Arrays.sort(nums2, new Comparator<Double>() {

	@Override
	public int compare(Double o1, Double o2) {
//		if (o1 < o2)
//			return 1;
//		else if (o1 > o2)
//			return -1;
//		else
//			return 0;

		return o2 - o1; // 정수

	}
});

System.out.println(Arrays.toString(nums2));

자료형별 정렬

1. 숫자형
2. 문자(열) > 문자코드값 > 숫자
3. 날짜시간 > 숫자
4. 객체 ***

위에 정리해 둔 것이 숫자형이다.

문자열은 참조값이므로 주소값은 연산의 대상이 되지 않기 때문에 한 문자(값)씩 비교한다.
만약 문자열 그대로 정렬하려면 compareTo() 메소드를 이용하면 된다. (-> 앞이 크면 양수, 작으면 음수, 같으면 0이다.)
compareToIgnoreCase() 메소드는 대소문자 구분 없이 비교한다.

String txt1 = "ABC";
String txt2 = "abc";

for (int i = 0; i < 3; i++) {
	char c1 = txt1.charAt(i);
	char c2 = txt2.charAt(i);

	if (c1 > c2) {
		n = 1;
		break;
	} else if (c1 < c2) {
		n = -1;
		break;
	}	

문자열 배열 정렬하기

String[] names = { "홍길동", "아무개", "유재석", "박명수", "이순신", "훈", "김철" };

// 가나다순으로 정렬
Arrays.sort(names);

// 사용자 정의형 정렬
Arrays.sort(names, new Comparator<String>() {

	@Override
	public int compare(String o1, String o2) {
//		return o1.compareTo(o2); // 오름차순
//		return o2.compareTo(o1); // 내림차순

//		return o1.length() - o2.length(); // 글자수 비교 > 오름차순
//		return o2.length() - o1.length(); // 글자수 비교 > 내림차순

		if (o1.length() > o2.length()) {
			return 1;
		} else if (o1.length() < o2.length()) {
			return -1;
		} else {
			// 2차 정렬 기준. 1차로 정렬한 뒤 2차로 정렬하고 싶을 때 여기에 적으면 된다.
			return o2.compareTo(o1); // 문자 코드값 비교
		}
	}
});

날짜 정렬

1. Arrays.sort(dates);

   • 기본적인 날짜순 정렬이다.

2. Arrays.sort() 메소드의 인자로 Comparator 인터페이스의 compare() 메소드

   • 내림차순이나 요일순 정렬 등 사용자 정의로 정렬을 사용할 때 쓴다.

Calendar[] dates = new Calendar[5];

for (int i = 0; i < dates.length; i++) {
	dates[i] = Calendar.getInstance();
}

dates[0].add(Calendar.DATE, 7);
dates[1].add(Calendar.DATE, -2);
dates[2].add(Calendar.DATE, 1);
dates[3].add(Calendar.DATE, 0);
dates[4].add(Calendar.DATE, 3);

//1. 
Arrays.sort(dates);

//2.
Arrays.sort(dates, new Comparator<Calendar>() {

	@Override
	public int compare(Calendar o1, Calendar o2) {
		// 날짜 순 정렬
//		return (int) (o2.getTimeInMillis() - o1.getTimeInMillis()); // 형변환 시 위험할 수 있음
//		return o2.compareTo(o1); // 반드시 compareTo() 사용

		// 요일 순 정렬 (일(1) ~ 토(7))
		return o1.get(Calendar.DAY_OF_WEEK) - o2.get(Calendar.DAY_OF_WEEK); // 오름차순
//		return o2.get(Calendar.DAY_OF_WEEK) - o1.get(Calendar.DAY_OF_WEEK); // 내림차순
	}
});

객체 정렬

Score[] list = new Score[5];

list[0] = new Score("홍길동", 100, 90, 80);
list[1] = new Score("아무개", 98, 78, 88);
list[2] = new Score("유재석", 78, 95, 79);
list[3] = new Score("박명수", 56, 78, 76);
list[4] = new Score("이순신", 99, 67, 79);

System.out.println(Arrays.toString(list));

// 이름순 정렬
Arrays.sort(list, new Comparator<Score>() {

	@Override
	public int compare(Score o1, Score o2) {
		// 이름 비교
//		return o1.getName().compareTo(o2.getName());

		// 국어점수 내림차순
//		return o2.getKor() - o1.getKor();

		// 총점 내림차순
		return (o2.getKor() + o2.getEng() + o2.getMath()) - (o1.getKor() + o1.getEng() + o1.getMath());
	}
});

class Score {
	private String name;
	private int kor;
	private int eng;
	private int math;
    
	public Score(String name, int kor, int eng, int math) {
		this.name = name;
		this.kor = kor;
		this.eng = eng;
		this.math = math;
	}
	public String getName() {
		return name;
	}
	public int getKor() {
		return kor;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	@Override
	public String toString() {
		return "Score [name=" + name + ", kor=" + kor + ", eng=" + eng + ", math=" + math + "]\n";
	}
}

Collections 정렬
1. ArrayList > 순서 존재 > 정렬 O
2. HashMap > 순서 미존재 > 정렬 X
3. Queue > 순서 존재 > 정렬 X (들어온 순서가 중요함)
4. Stack > 순서 존재 > 정렬 X (들어온 순서가 중요함)
5. HashSet > 순서 미존재 > 정렬 X

보통의 오름차순 정렬 시 Collections.sort()를 사용한다.
사용자 정의 정렬이 필요하다면 Comparator에서 구현한다.

ArrayList<Integer> list = new ArrayList<>();

for (int i = 0; i < 10; i++) {
	list.add((int) (Math.random() * 100)); // 0 ~ 99
}

//		Collections.sort(list); // = Arrays.sort() 오름차순
//		Collections.sort(list, new Comparator<Integer>() { // 내림차순
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				return o2 - o1;
//			}
//		});

// 오름차순 -> Collections.sort()사용, 그 외 정렬 -> list.sort()사용 추천
list.sort(new Comparator<Integer>() { // 무조건 Comparator 구현해야 함.
	@Override
	public int compare(Integer o1, Integer o2) {
		// TODO Auto-generated method stub
		return o1 - o2;
	}
});

Ex68

this vs super

• 객체 지정 연산자
• this: 자기 자신
• super: 부모

Ex69_LinkedList

물리 구조 + 인터페이스(사용법)

• Array + List
• Linked + List
• Hash + Map
• Tree + Map
• Hash + Set
• Tree + Set

ArrayList

• 모든 컬렉션 중에서 요소에 접근하는 속도가 가장 빠르다.
• 요소 삽입/삭제에 대한 비용이 많이 든다. > shift O
• 보통 초기 생성 이후에 삽입, 삭제가 없으면서 저장할 변수의 개수를 모를 때 사용한다.

LinkedList

• 요소에 접근 속도가 상대적으로 느리다.
• 요소 삽입/삭제에 대한 비용이 거의 없다. > shift X
• 초기 생성 이후 삽입, 삭제가 많을 때 사용한다.
• List 인터페이스로 구현하여 ArrayList와 사용법이 유사하다. 개발자 경험을 사용할 수 있다.
• ArrayList와 내부구조가 달라 사용 용도가 다르다.

Collection(I) > List(I) > ArrayList(C), LinkedList(C)

LinkedList 종류

1. LinkedList: 일방 통행
2. Double LinkedList: 양방향 통행
3. Double Circle LinkedList: 양방향 + 처음~끝 연결 > 자바의 LinkedList

=> 배열의 접근 -> 시간 복잡도 : O(1) -> 배열의 시작 주소값과 인덱스를 이용한 단순 계산으로 한번에 주소를 찾아간다.

Ex70_TreeSet

TreeSet

• Tree 구조 > 이진 트리 구조(이진 탐색 트리, Binary Search Tree)
• Set 사용법
  -> 값을 넣을 때 자동으로 정렬되어 들어간다. 역순 정렬은 안된다.

Set

• 순서가 없다.
• 중복값을 가지지 않는다.
  
  

TreeSet 고유 기능

set2.first(); //시작 값
set2.last(); // 끝 값
set2.headSet(30); // 파라미터보다 작은 값들
set2.tailSet(30); // 파라미터보다 큰 값들
set2.subSet(20, 40) // 해당 범위 내의 값들

set을 ArrayList로 만들 수 있다.

ArrayList<Integer> list = new ArrayList<>(set2);

Ex71_TreeMap

TreeMap

• Tree > 이진 탐색 트리 > 자동 정렬
• Map > 키 + 값 > 연관 배열

TreeMap 고유 기능

map.firstKey(); // 첫번째 키
map.lastKey(); // 마지막 키
map.headMap("m"); // 파라미터보다 작은 키+값들
map.tailMap("m"); // 파라미터보다 큰 키+값들
map.subMap("r", "y") // 파라미터들 중간의 키+값들

List

• ArrayList > 배열이 필요할 때 / 삽입, 삭제(X) *
• LinkedList > ArrayList 대체제 / 삽입, 삭제(O)
• Stack > 스택 구조 필요
• Queue > 큐 구조 필요
• Vector => ArrayList와 거의 비슷하나 잘 안씀. Thread 부분에서 조금 다르다.

Set (근데 정렬 거의 안씀)

• HashSet > 중복값 배제, 유일한 집합 *
• TreeSet > HashSet + 정렬

Map (근데 정렬 거의 안씀)

• HashMap > 키/값 연관 배열이 필요할 때 *

• TreeMap > HashMap + 정렬

• HashTable => HashMap과 거의 비슷하나 잘 안씀. Thread 부분에서 조금 다르다.

• Properties > JSON, XML => 잘 안씀.

Ex72_Lambda

람다식, Lambda Expression

• 함수형 프로그래밍 > 지원
• 자바 > 람다식 > 컬렉션 조작(= 스트림)
• 람다식을 사용하면 코드가 간결해진다.
  메소드 표기법)
• 람다식은 매개변수를 가지는 코드블럭이다. =메소드)
• 자바의 람다식은 인터페이스를 사용해서 만든다.(자바만의 특징)

람다식 형식

• 인터페이스 변수 = 람다식;

• ex) MyInterface m1 = () -> {};

• (매개변수) -> {실행코드}

• 자바의 메소드의 다른 표현

• a. (매개변수): 메소드의 매개변수 리스트와 동일

• b. ->: 화살표(Arrow), 코드블럭 호출 역할

• c. {실행코드}: 메소드의 구현부와 동일

프로젝트 진행 설명

어떻게 진행되어야 하는지 설명을 들었다. 첫 번째 프로젝트의 주제를 논의했다.