SORT 정리 / ArrayTesr

예제 - 1

      

        

          
          
          
        
         
      
import java.util.Arrays;
class Person  implements Comparable<Person> {
	String name;
	int age;
	String job;
	int score;
	
	public Person(String name, int age, String job, int score) {
		this.name = name;
		this.age = age;
		this.job = job;
		this.score = score;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age +
				", job=" + job + ", score=" + score + "]\n";
	}
	@Override
	public int compareTo(Person o) { //정렬의 기준을 정의~!!
		//this(Person)의 속성과 o(Person)의 속성을 비교
		//비교방법  this.속성 -  o.속성
		//결과: 음수, 0, 양수  ==> 음수의 경우 swap을 해줌  ==> 오름차순 정렬
		
//		return this.age - o.age; //오름차순정렬
		
		//만약 내림차순 정렬을 하고 싶다!!
		//1
		//return o.age - this.age;
		//2
		return -(this.age - o.age) ;
	}
	
}
public class ArraySortTest {
	public static void main(String[] args) {
	
		int[]su= {13, 8, 7, 10, 100, 5};	
		char[]ch= {'A','l','g','o','r','i','t','h','m'};
		String[]names= {"홍길동","길라임","김주원"};
		//API를 사용하여 배열에 대한 오름차순 정렬을 하자!!
	    Arrays.sort(su);
	    Arrays.sort(ch);
	    Arrays.sort(names);
		
		//배열 내용 출력
		System.out.println("정수배열>>"+Arrays.toString(su));
		System.out.println("문자배열>>"+Arrays.toString(ch));
		System.out.println("문자열배열>>"+Arrays.toString(names));
	
		//객체 배열 정렬
		Person p = new Person("갓길동",11,"학생",95);
//        ==>   이름    나이 직업   점수
		Person[] persons= {p ,
		    new Person("빛길동",19,"학생",80),
		 new Person("남길동",14,"학생",100),
		 new Person("여길동",17,"학생",99),
		 new Person("킹길동",15,"학생",56)};
		
		Arrays.sort(persons);
		System.out.println("사람배열>>"+Arrays.toString(persons));
//		class Person cannot be cast to class java.lang.Comparable 
//		(Person is in unnamed module of loader 'app'; 
//		java.lang.Comparable is in module java.base of loader 'bootstrap')
		
		
	}//main
}

 

예제 - 2

      

        

          
          
          
        
         
      
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class ArraySortTest2 {
	
	static class Person  implements Comparable<Person> {
//	static class Person  implements Comparator<Person> {
		String name;
		int age;
		String job;
		int score;
		
		public Person() {
			// TODO Auto-generated constructor stub
		}
		
		public Person(String name, int age, String job, int score) {
			this.name = name;
			this.age = age;
			this.job = job;
			this.score = score;
		}
		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age +
					", job=" + job + ", score=" + score + "]\n";
		}
		@Override
		public int compareTo(Person o) { //정렬의 기준을 정의~!!
			//this(Person)의 속성과 o(Person)의 속성을 비교
			//비교방법  this.속성 -  o.속성
			//결과: 음수, 0, 양수  ==> 음수의 경우 swap을 해줌  ==> 오름차순 정렬
			
			return this.age - o.age; //오름차순정렬
			
			//만약 내림차순 정렬을 하고 싶다!!
			//1
			//return o.age - this.age;
			//2
//			return -(this.age - o.age) ;
		}
//		@Override
//		public int compare(Person o1, Person o2) {
//			return -(o1.age - o2.age); //나이 오름차순 정렬
//		}
		
	}
	
	public static void main(String[] args) {
	
	
		//객체 배열 정렬
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("갓길동",11,"학생",95));
		list.add(new Person("빛길동",19,"학생",80));
		list.add(new Person("남길동",14,"학생",100));
		list.add(new Person("여길동",17,"학생",99));
		list.add(new Person("킹길동",15,"학생",56));
		
//		Arrays.sort(list);//에러발생: Arrays클래스의 sort메소드를 통해 Collection(List)의 정렬을 할 수 없음~!!
		
	      Collections.sort(list); //Comparable일 경우
//        Collections.sort(list,new Person());  //Comparator일 경우 Collections.sort(list, Comparator객체);		
		
	      System.out.println(list);
	      
	}//main
}

 

예제 - 3

      

        

          
          
          
        
         
      
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class ArraySortTest3 {
	
	static class Person {
		String name;
		int age;
		String job;
		int score;
		
		public Person() {
			// TODO Auto-generated constructor stub
		}
		
		public Person(String name, int age, String job, int score) {
			this.name = name;
			this.age = age;
			this.job = job;
			this.score = score;
		}
		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age +
					", job=" + job + ", score=" + score + "]\n";
		}
	}//Person
	
	public static void main(String[] args) {
	
	
		//객체 배열 정렬
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("갓길동",11,"학생",95));
		list.add(new Person("빛길동",19,"학생",80));
		list.add(new Person("남길동",19,"학생",100));
		list.add(new Person("여길동",19,"학생",99));
		list.add(new Person("킹길동",15,"학생",56));
		
		//나는 특정인터페이스를 상속받지 않는 Person을 사용하고 싶다!!
		
	   //추가 문제)  Person을 age오름차순으로 하되  같은 age의 경우 score내림차순으로 정렬하시오.
         Collections.sort(list, new Comparator<Person>() {//내부클래스 시작
        	             //implements Comparator의 의미        
			@Override
			public int compare(Person o1, Person o2) {
				if(o1.age == o2.age) return o2.score - o1.score;
				return o1.age - o2.age;
			}
        	                    
        	 
		  }//내부클래스 끝
         );
       
       
	      System.out.println(list);
	      
	}//main
}

정리

      

        

          
          
          
        
         
      
##### <sort정리>
1. 기본자료형, String 배열의 Sort
   ==> Arrays.sort( 기본자료형 배열 )사용
##### 2. 객체자료형(예:Person) 배열의 Sort
   ==> Arrays.sort( 객체자료형 배열 )  
   ==> ** 반드시 정렬객체에 implements Comparable 사용 **
            ==> compareTo메소드 오버라이딩 필요
                      return this.속성-o.속성;  //오름차순
                      return o.속성-this.속성; 또는 return -(this.속성-o.속성);  //내림차순
##### 3. List컬렉션을 사용하는 경우
   ==> ☆Collections.sort(컬렉션) 사용, ★Collections.sort(컬렉션, Comparator객체) 사용
   ==> ☆의 경우, 위의 2번처럼 ** 정렬객체에 implements Comparable **이면 동일하게 사용할 수 있음
            ==> compareTo메소드 오버라이딩 필요
                      return this.속성-o.속성;  //오름차순
                      return o.속성-this.속성; 또는 return -(this.속성-o.속성);  //내림차순
   ==> ★의 경우
          방법1)  ** 정렬 객체에 implements Comparator ** 사용
             ==> compare메소드 오버라이딩 필요
                      return o1.속성-o2.속성;  //오름차순
                      return o2.속성-o1.속성; 또는 return -(o1.속성-o2.속성);  //내림차순
          방법2)  정렬 객체에 implements Comparator 사용 하지 않고 익명의 내부클래스 사용
               ==> Collections.sort(컬렉션, new Comparator(){
                              compare메소드 오버라이딩
                        });