대덕241025 자바:정렬 // HTML:이미지,테이블,iframe

<자바>

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
  정렬과 관련된 인터페이스는 Comparable, Comparator 이렇게 두 가지가 있다.
  
  Comparable은 Collection에 추가되는 데이터 자체에 정렬 기준을 넣고 싶을 때(내부 정렬 기준)을 
  넣고 싶을 때 구현하는 인터페이스이고,
  
  Comparator은 외부에 별도로 정렬 기준(외부 정렬 기준)을 구현하고 싶을 때
  구현하는 인터페이스이다.
  
  Comparable에서는 compareTo() 메서드를 재정의하고, 
  Comparator에서는 compare()메서드를 재정의해야 한다.
  
  String 클래스, Wrapper 클래스, Date 클래스, File클래스 등에는 내부 정렬 기준이
  이미 구현되어 있다. (이 때 내부 정렬 기준은 오름차순으로 처리되도록 구현되어 있따)
  
 */

public class LIstSortTest01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("일지매");
		list.add("홍길동");
		list.add("성춘향");
		list.add("변학도");
		list.add("이순신");
		
		System.out.println("정렬전 : " + list);
		
		// list의 정렬은 Collections.sort()메서드를 이용하여 정렬한다.
		// Collections.sort() 메서드는 기본적으로 내부 정렬 기준으로 정렬한다.
		Collections.sort(list);
		System.out.println("정렬후 : " + list);
		System.out.println();
		
		Collections.shuffle(list);   	// 데이터 섞기
		System.out.println("저료 섞기 후 : " + list);
		System.out.println();
		
		// 외부 정렬 기준을 적용해서 정렬하기
		// 형식) Collections.sort(List객체, 외부정렬기준객체);
		Collections.sort(list, new Desc());
		System.out.println("내림차순 정렬 후 : " + list);
		
		
	}
}

// 외부 정렬 기준을 정해주는 class 작성하기 (Comparator 인터페이스 구현하여 작성)
class Desc implements Comparator<String>{

	// compare() 메서드를 이용하여 정렬하고자 하는 기준을 정해준다.
	
	// compare() 메서드의 매개변수는 서로 인접한 2개의 데이터를 의미한다.
	
	// compare() 메서드의 반환값
	// 반환값이 '0'이면 두 값이 같다.
	// 반환값이 '양수'이면 앞, 뒤의 데이터 순서를 바꾼다.
	// 반환값이 '음수'이면 앞, 뒤의 데이터 순서를 바꾸지 않는다.
	
	// 예) 오름차순일 경우 ==> 앞의 값이 크면 '양수',
//								  같으면 '0',
//								  작으면 '음수'를 반환하도록 구현하면 된다.
	
	@Override
	public int compare(String str1, String str2) {
		/*
		if(str1.compareTo(str2) > 0 ) {
			return -1;			// 내림차순으로 할 것이기에 음수 아무거나 반환
		}else if(str1.compareTo(str2) < 0) {
			return 1;			// 0보다 작다 ==> 앞의 값이 크다 ==>내림차순이므로 양수 아무거나 반환하여 그대로 
		} else {
		return 0;
		}
		*/
		return str1.compareTo(str2) * -1;
	}
	
}

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ListSortTest02 {

	public static void main(String[] args) {
	ArrayList<Member> memList = new ArrayList<Member>();
	
			memList.add(new Member(1, "홍길동" , "010-1111-1111"));
			memList.add(new Member(5, "이순신" , "010-2222-1111"));
			memList.add(new Member(9, "성춘향" , "010-3333-1111"));
			memList.add(new Member(3, "강감찬" , "010-4444-1111"));
			memList.add(new Member(6, "일지매" , "010-5555-1111"));
			memList.add(new Member(2, "변학도" , "010-6666-1111"));
			
			System.out.println("정렬전...");
			for(Member mem : memList) {
				System.out.println(mem);
			}
			System.out.println("----------------------------");
			
			Collections.sort(memList);	// 이대로 하면 내부 정렬 기준이 없기에 오류가 나니까 내부정렬기준 추가해야함
			

			System.out.println("정렬후...");
			for(Member mem : memList) {
				System.out.println(mem);
			}
			System.out.println("----------------------------");
			System.out.println();
			
			//Member의 회원번호를 기준으로 내림차순 정렬하는 외부 정렬 기준
			// 클래스를 이용하여 정렬하시오.(클래스명: SortNumDesc)
			Collections.sort(memList, new SortNumDesc());
			
			System.out.println("회원번호의 내림차순 정렬후...");
			for(Member num : memList) {
				System.out.println(num);
			}
			System.out.println("----------------------------");
			System.out.println();
			
			
	}

}

// 회원번호(int), 회원이름, 전화번호 정보를 관리하는 Member클래스 작성하기
// 회원이름을 기준으로 오름차순 정렬이 되도록 내부 정렬 기준을 추가해 보자.
// (Comparable 인터페이스를 구현하여 작성한다.)



class Member implements Comparable<Member> {
	private int num;
	private String name;
	private String tel;
	
	//생성자
	public Member(int num, String name, String tel) {
		super();
		this.num = num;
		this.name = name;
		this.tel = tel;
	}
	
	//게터 세터 메서드
	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public String getName() {
		return name;
	}

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

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}
	@Override
	public String toString() {
		return "Member [num=" + num + ", name=" + name + ", tel=" + tel + "]";
	}
	
	// 회원이름을 기준으로 오름차순 정렬이 되도록 재정
	@Override
	public int compareTo(Member mem) {		// 비교할 대상 : 나(this)와 상대방(mem) 
		/*
		if(this.name.compareTo(mem.getName())>0) {
			return 1;
		}else if(this.name.compareTo(mem.getName())<0) {
			return -1;
		}
		return 0;
	*/
		return this.name.compareTo(mem.getName());  // 양수면 양수 반환, 음수면 음수 반환
	}
}
//--------------------------------------------------------------
//Member의 회원번호(nim)을 기준으로 내림차순 정렬하는 외부 정렬 기준 class작성

class SortNumDesc implements Comparator<Member> {
	
	@Override
	public int compare(Member mem1, Member mem2) {
		/*
		if(mem1.getNum()>mem2.getNum()) {
			return -1;			// 0보다 크다==>뒷 숫자가 큼(오름차)==> 냅둠(음수)
		}else if(mem1.getNum()<mem2.getNum()) {
			return 1;			// 0보다 작다==>뒷 숫자가 작음(내림차)==>바꿈(양수)
		}else
			return 0;
			*/
		
		// Wrapper 클래스를 이용하는 방법 1
		//return new Integer(mem1.getNum()).compareTo(mem2.getNum())* -1;	//내림차순 정렬
		// 래퍼 클래스로 객체화하기 위해 new Integer 사용하는데 이거보다는
		//return Integer.valueOf(mem1.getNum()).compareTo(mem2.getNum())* -1;
		// 요즘 버전에서 권장되는 ValueOf 방식으로 하자
		
		// Wrapper 클래스를 이용하는 방법 2
		return Integer.compare(mem1.getNum(), mem2.getNum()) * -1;
		// Integer 객체에 만들어져 있는 compere를 이용 
	}

	
	
}

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

//3.학번(int),이름,국어/영어/수학 점수, 총점, 등수를 멤버로 갖는
//Student 클래스를 만들고 해당 클래스의 생성자에서는 
//학번,이름,국어,영어,수학점수만 매개변수로 받아 초기화 처리를 한다.
//이때 총점은 세 과목의 점수를 이용해서 초기화한다.

//이 Student 객체는 List에 저장하여 관리한다
//(등수는 List에 데이터가 모두 추가된 후에 구한다).

//List에 저장된 데이터들을 학번의 오름차순으로 정렬할 수 있는 내부 정렬
//기준을 구현하고, 총점의 역순(내림차순)으로 정렬하는데 총점이 같으면 이름의 오름차순으로 
//정렬되는 외부 정렬 기준 클래스를 작성하여 정렬된 결과를 출력하시오.

public class StudentTest {
	private List<Student> stdList = new ArrayList<Student>();
	private Scanner scan = new Scanner(System.in);

	public static void main(String[] args) {
		new StudentTest().stdStart();
	}

	// 등수 구히는 메서드
	private void createRank() {
		for (Student std1 : stdList) { // 기준(등수 구할 자료)

			int rank = 1; // 등수는 처음엔 1로 초기화

			for (Student std2 : stdList) {// 비교할 자료
				if (std1.getTot() < std2.getTot()) {
					rank++;
				}
			}

			std1.setRank(rank); // 구해진 등수를 Student 객체에 저

		}

	}

	// 시작 메서드
	public void stdStart() {
		/*
		System.out.println("학생 성적 정보를 입력하세요...");
		while (true) {
			System.out.println("학번 >>");
			int num = scan.nextInt();

			System.out.println("이름 >>");
			String name = scan.next();

			System.out.println("국어점수 >>");
			int kor = scan.nextInt();
			System.out.println("영어점수 >>");
			int eng = scan.nextInt();
			System.out.println("수학점수 >>");
			int mat = scan.nextInt();

			stdList.add(new Student(num, name, kor, eng, mat));

			System.out.println("입력을 계속하시겠습니까? (y/n) >> ");
			String again = scan.next();

			if (!again.equalsIgnoreCase("y")) {
				break;
			}

		} // while syntax end
		*/

		stdList.add(new Student(1, "홍길동", 90, 95, 80));
		stdList.add(new Student(3, "성춘향", 90, 75, 70));
		stdList.add(new Student(7, "강감찬", 95, 95, 80));
		stdList.add(new Student(5, "변학도", 80, 95, 90));
		stdList.add(new Student(2, "일지매", 100, 85, 80));
		stdList.add(new Student(4, "이순신", 70, 75, 70));
		stdList.add(new Student(6, "이몽룡", 90, 100, 90));
		
		createRank(); // 등수 구하는 메서드 호출

		System.out.println("== 학생 성적 결과 ==");
		System.out.println("정렬전...");
		for (Student std : stdList) {
			System.out.println(std.toString()); // toString() 생략 가
		}
		System.out.println("-----------------------------");
		System.out.println();
		
		// 학번의 오름차순으로 정렬(내부 정렬 기준 이용)
		Collections.sort(stdList);
		System.out.println("학번의 오름차순 정렬후...");
		for (Student std : stdList) {
			System.out.println(std.toString()); // toString() 생략 가
		}
		System.out.println("-----------------------------");
		System.out.println();
		
		// 총점의 역순(내림차순)으로 정렬 (외부 정렬 기준 이용)
		Collections.sort(stdList, new sortByTotal());
		
		System.out.println("총점의 역순으로 정렬 후...");
		for (Student std : stdList) {
			System.out.println(std.toString()); // toString() 생략 가
		}
		System.out.println("-----------------------------");
		System.out.println();
	}

}

// Student 클래스 작성
class Student implements Comparable<Student> {
	private int sdtNum;
	private String sdtName;
	private int kor;
	private int eng;
	private int mat;
	private int tot;
	private int rank;

	public Student(int sdtNum, String sdtName, int kor, int eng, int mat) {
		super();
		this.sdtNum = sdtNum;
		this.sdtName = sdtName;
		this.kor = kor;
		this.eng = eng;
		this.mat = mat;
		tot = kor + eng + mat;
	}

	public int getSdtNum() {
		return sdtNum;
	}

	public void setSdtNum(int sdtNum) {
		this.sdtNum = sdtNum;
	}

	public String getSdtName() {
		return sdtName;
	}

	public void setSdtName(String sdtName) {
		this.sdtName = sdtName;
	}

	public int getKor() {
		return kor;
	}

	public void setKor(int kor) {
		this.kor = kor;
	}

	public int getEng() {
		return eng;
	}

	public void setEng(int eng) {
		this.eng = eng;
	}

	public int getMat() {
		return mat;
	}

	public void setMat(int mat) {
		this.mat = mat;
	}

	public int getTot() {
		return tot;
	}

	public void setTot(int tot) {
		this.tot = tot;
	}

	public int getRank() {
		return rank;
	}

	public void setRank(int rank) {
		this.rank = rank;
	}

	@Override
	public String toString() {
		return "Student [sdtNum=" + sdtNum + ", sdtName=" + sdtName + ", kor=" + kor + ", eng=" + eng + ", mat=" + mat
				+ ", tot=" + tot + ", rank=" + rank + "]";
	}
	
	//학번의 오름차순으로 정렬되는 기준 만들기
	@Override
	public int compareTo(Student std) {
		
		return Integer.compare(this.sdtNum, std.sdtNum);
	}
}
//총점의 역순(내림차순)으로 정렬하는데 총점이 같으면 이름의 오름차순으로 
//정렬되는 외부 정렬 기준 클래스
class sortByTotal implements Comparator<Student> {

	@Override
	public int compare(Student std1, Student std2) {
		if(std1.getTot() == std2.getTot()) {
			return std1.getSdtName().compareTo(std2.getSdtName());
		}else {
			return Integer.compare(std1.getTot(), std2.getTot()) * -1;
		}
	}
	
}

<HTML>

 

 

권장하지 않는 방식인 인라인 스타일로 border속성을 정의한 이유는 >> 내부스타일 정의보다 효율적

 

 

+ iframe