Collection 클래스

LONG  

========================[LexicographicallyComparator.java]=====================

import java.util.Comparator;
public class LexicographicallyComparator implements Comparator{
 // 싱글톤 디자인 패턴을 이용하자.
 private static LexicographicallyComparator lc = new LexicographicallyComparator();
 private  LexicographicallyComparator(){}
 public static LexicographicallyComparator getInstance(){
  return lc;
 }
 // Comparator때문에 구현 할 메서드
 public int compare(Object o1, Object o2) {
     String sc1 = ((Student)o1).getName();
     String sc2 = ((Student)o2).getName();
     return sc1.compareTo(sc2);
 }
 // toString은 구현 안하면 Object toString사용
}
================================================================================

 

================================[Student.java]==================================

/*

    인터페이스 Comparable의 compareTo 메서드를 Collections에서 사용해 보자.

    학생을 성적순으로 정렬한다.

*/

public class Student implements Cloneable{
 private String name;
 private int id;
 private String addr;
 private Grade grade;
 public Student(String name, int id,String addr) {
  this.name=name;
  this.id=id;
  this.addr=addr;
 } // Student
 public String getAddr() {return addr;}
 public int getId() {return id;}
 public String getName() {return name;}
 public Grade getGrade(){
  return grade;
 } 
 public void setAddr(String string) {addr = string;}
 public void setId(int i) {id = i;}
 public void setName(String string) {name = string;}
 public void setGrade(Grade grade){
  this.grade=grade;
 } 
 public String toString(){
  return name+"  "+id+"  "+addr+"  "+grade.toString();
 } // toString
 public Object clone(){
  try{
   return super.clone();
  }catch(CloneNotSupportedException e){
   return this;
  }
 } // clone
 public boolean equals(Object obj){
  boolean isE=false;
  Student temp=(Student)obj;
  if(temp.getName().equals(name) && temp.getId()==id
   && temp.getAddr().equals(addr)){
   isE=true;
  }
  return isE;
 } // equals
 public int hashCode(){
  int temp=0;
  temp=name.hashCode()+addr.hashCode()+id+37;
  return temp;
 } // hashCode
}
===========================================================================================

 

================================[Grade.java]==================================

public class Grade implements Comparable{
 private double kor;
 private double eng;
 private double math;
 private double total;
 private double mean;
 public Grade(){  this(0,0,0);  }
 public Grade(double kor,double eng,double math){
  this.kor=kor;    
  this.eng=eng;       
  this.math=math;
  getMean();
 }
 public String toString (){
  return (kor+"/"+eng+"/"+math+"/"+total+"/"+mean);
 }
 public double getEng() {   return eng;   }
 public double getKor() {   return kor;   }
 public double getMath(){   return math;  }
 public double getMean() {
  mean=getTotal()/3.0;
  return mean;
 }
 public double getTotal() {
  total=(this.kor+this.eng+this.math);
  return total;
 }
 public void setEng(double d) {  eng = d;   getMean();}
 public void setKor(double d) {  kor = d;   getMean();}
 public void setMath(double d){  math = d;  getMean();}
 //Comparable의 구현해야 할 메서드
 public int compareTo(Object o1){
  Grade g2=(Grade)o1;
  double mean1=this.mean;
  double mean2=g2.getMean();
  if(mean1<mean2){ //increasing
   return -1; 
  }else if(mean1==mean2){
   return 0;
  }else {         //decreasing
   return 1; 
  }
 }
}

===========================================================================================

ARTICLE

: java.util.Collections를 이용하여 정렬 (Collections.sort 이용)

 

/* 학생 데이터를 성적순으로 정리하기 */

 

=========================[StudentCollectionsMain.java]=========================

import java.util.*;
public class StudentCollectionsMain {

 public static void main(String[] args) {
  GradeComparator gc = GradeComparator.getInstance();
  // 싱글톤 페턴인 GradeComparator의 레퍼런스를 얻는다. getInstance()는 static 메서드이다.
  Vector v=new Vector(5,5);  //선언 
  //Student [] sg=new Student[7];
  //초기화
  Student stu1=new Student("김말뚝",101001,"서울");
  Student stu2=new Student("홍길동",101002,"경기");
  Student stu3=new Student("최순동",101003,"인천");
  Student stu4=new Student("이연림",101004,"부산");
  Student stu5=new Student("하하호",101005,"창원");
  Student stu6=new Student("김경민",101006,"목포");
  Student stu7=new Student("김소연",101007,"제주");

  v.add(stu1);
  v.add(stu2);
  v.add(stu3);
  v.add(stu4);
  v.add(stu5);
  v.add(stu6);
  v.add(stu7);

  stu1.setGrade(new Grade(60,60,70));
  stu2.setGrade(new Grade(89,65,67));
  stu3.setGrade(new Grade(60,80,100));
  stu4.setGrade(new Grade(70,99,80));
  stu5.setGrade(new Grade(60,70,80));
  stu6.setGrade(new Grade(60,80,80));
  stu7.setGrade(new Grade(73,70,80));

  // Grade의 레퍼런스가 없으므로 Student를 통해서만 학생의 Grade에 접근할 수 있다.
  System.out.println("입력순 출력==============");
  prints(v);
  System.out.println("입력 역순 출력==============");
  Collections.reverse(v); // 역순 만들기
  prints(v);
  System.out.println("임의로 섞은 후 출력==============");
  Collections.shuffle(v); // 임의로 섞는다.
  prints(v);
  System.out.println("성적순 출력==============");
  Collections.sort(v,gc); // v: List 계열, gc: Comparator
  prints(v);
 }
 public static void prints(Vector v){
  int num=v.size();
  for(int i=0;i<num;i++){
   Student stu=(Student)v.get(i);
      System.out.println(stu);

      // List 계열이므로 get(int index) 메서드를 이용하여 index의 데이터를 Object 타입으로 얻는다.

      // 여기서는 Vector에 Student를 입력했으므로 (Student)로 캐스팅된다.
    }//for     
    System.out.println();
 }//prints   
}
==============================================================================

 

============================[GradeComparator.java]===========================

import java.util.Comparator;
public class GradeComparator implements Comparator{
 private static GradeComparator gc = new GradeComparator();
 private  GradeComparator(){}
 public static GradeComparator getInstance(){
  return gc;
 }
 //Comparator 때문에 구현 할 메서드 (compare, equals)
 /*
 public int compare(Object o1, Object o2) {
  Student sg1=(Student)o1;
  Student sg2=(Student)o2;
  double mean1=sg1.getGrade().getMean();
  double mean2=sg2.getGrade().getMean();
  if(mean1<mean2){
   return -1;  //increasing
  }else if(mean1==mean2){
   return 0;
  }else {
   return 1;  //decreasing
  }
 }*/
 public int compare(Object o1, Object o2) { // Student끼리 비교하기 위해
  Student sg1=(Student)o1; // 학생 (Object → Student)
  Student sg2=(Student)o2;
  Grade g1=sg1.getGrade(); // 성적
  Grade g2=sg2.getGrade();
  return g1.compareTo(g2); // 성적비교
 }
}

-------------------------------------------------------------------------------------------

기본타입을 직접 비교하지 않으려면 Comparable 인터페이스의 compareTo 메서드를 이용한다.

성적순으로 정렬하려면 Comparator의 compare을 이용한다. compareTo 메서드에서 1은 증가순,

-1은 감소순, 0은 같음을 의미한다. compare 메서드 내부에서 if를 이용하여 직접 비교하거나 Comparable 인터페이스의 compareTo 메서드도 이용할 수 있다.

여기서는 compareTo 메서드를 사용한다.

 

Comparable의 compareTo 메서드는 대소 비교를 하고, Comparator의 compare는 대소비교를 이용한

정렬을 한다. 참조타입끼리 우선숭위를 비교하려면 compareTo 메서드 내에서 Comparator의 compare

메서드를 호출하여 사용한다.

==============================================================================

 

 

Student.java

0.0MB

Grade.java

0.0MB

StudentCollectionsMain.java

0.0MB

GradeComparator.java

0.0MB

LexicographicallyComparator.java

0.0MB