package chap9;

// StringBuffer 클래스 예제
// 가변적인 문자열 객체임
// 기본적으로 16개의 버퍼를 내부에 가지고 있다.
// new StringBuffer(100) => 116개의 버퍼를 가진다.
// equals 메서드가 오버라이딩 되지 않았다.
// 내용비교는 toString() 메서드로 String 객체로 변경 후 equals 메서드를 사용 해야 한다.

public class StringBufferEx1 {
 public static void main(String[] args) {

  long startTime = 0;
  long endTime = 0;
  double dTime = 0;
  
  
  StringBuffer sb = new StringBuffer("abc");
  StringBuffer sb2 = new StringBuffer("abc");
  
  
  // 시작 시간
  startTime = System.nanoTime();
  
  
  if( sb == sb2 )
   System.out.println("sb == sb2");
  else
   System.out.println("sb != sb2");
  
  if( sb.equals(sb2) )
   System.out.println("sb.equals(sb2) : true");
  else
   System.out.println("sb.equals(sb2) : false");
  
  if( sb.toString().equals(sb2.toString()) )
   System.out.println("sb.toString().equals(sb2.toString()) : true");
  else
   System.out.println("sb.toString().equals(sb2.toString()) : false");
  
  System.out.println();
  
  //끝난 시간
  endTime = System.nanoTime();
  dTime = (double)(endTime - startTime) / 10000000;
  System.out.println(dTime);
 }
}

package chap10;

class Outer{
 int iv = 10;
 int iv2 = 30;
 class InstanceInner{ // 인스턴스 내부클래스
  int iv = 100;
  void method1(){ // 인스턴스 내부클래스의 멤버 메서드
   System.out.println("iv =" + iv);
   System.out.println("this.iv=" + this.iv); // 100
   // 외부클래스 멤버 접근 방법
   System.out.println("Outer.iv=" + Outer.this.iv); // 10
   System.out.println("iv2=" + iv2); // 30
  }
 }
 
 static class StaticInner{
  int iv = 200;
  static int cv = 300;
 }
 
 void myMethod(){
  class LocalInner{
   int iv = 400;
  }
  LocalInner linner = new LocalInner(); // 반드시 객체 생성을 해야 사용 할 수 있다.
  System.out.println(linner.iv);
 }
}

public class InnerEx4 {
 public static void main(String[] args) {
  Outer oc = new Outer();
  
  // 내부클래스의 타입 : 외부클래스. 내부클래스
  Outer.InstanceInner ii = oc.new InstanceInner();
  System.out.println("ii.iv = " + ii.iv);  // 100
  
  // Static 내부클래스 클래스멤버 접근방법
  System.out.println("Outer.StaticInner.cv :" + Outer.StaticInner.cv); // 300
  
  // Static 내부클래스 인스턴스 멤버 => 객체화 필요
  Outer.StaticInner os = new Outer.StaticInner();
  System.out.println("os.iv = " + os.iv);
  oc.myMethod();
  
  // 인스턴스내부클래스의 메서드 호출
  Outer.InstanceInner ot = oc.new InstanceInner();
  ot.method1(); // 100
  
 }
}

package chap10;

public class InnerEx3 {
 private int outeriv = 0;
 static int outercv = 0;
 class InstanceInner{
  int iiv = outeriv;
  int iiv2 = outercv;
 }
 
 static class StaticInner{
//  int siv = outeriv; // 에러!!
  // outeriv의 객체를 만들어서 사용 해야 한다.
  int siv = new InnerEx3().outeriv;
  static int scv = outercv;
 }
 
 void myMethod(){
  // 내부클래스에서 사용시에는 상수가 되어야 한다.
  int lv = 0;
  final int LV = 0;
  class LocalInner{
   int liv = outeriv;
   int liv2 = outercv;
   // 지역 내부 클래스에서 메서드의 지역변수를 호출하지 못했다.
   int liv3 = lv; // jdk 8.0 이후 가능.
       // lv 변경없으므로 내부적으로 상수로 처리됨.
   int liv4 = LV; // 상수는 접근 가능
  }
 }
 
 public static void main(String[] args) {

 }
}

package chap10;

public class InnerEx2 {
 class InstanceInner{}
 static class StaticInner{}
 InstanceInner iv = new InstanceInner();
 static StaticInner cv = new StaticInner();
 static void staticMethod(){
  StaticInner obj = new StaticInner();
  // 클래스 멤버에서 인스턴스 내부 클래스의 객체화는 반드시 외부클래스의 객체화 후 가능 하다.
//  InstanceInner obj2 = new InstanceInner(); // 에러!!
  InnerEx2 outer = new InnerEx2();
  InstanceInner obj2 = outer.new InstanceInner();
 }
 
 void instanceMethod(){
  StaticInner obj = new StaticInner();
  InstanceInner obj2 = new InstanceInner();
  // myMethod()의 지역내부클래스는 다른메서드에서 사용 불가
  // LocalInner lv = new LocalInner();
 }
 
 void myMethod(){
  class LocalInner{} // 메서드 내부 클래스다. 밖에서 사용 불가.
  LocalInner iv = new LocalInner();
 }
 
 public static void main(String[] args) {
  
 }
}

package chap10;

// 열거형 예제

public class EnumEx1 {
 
 public enum Lesson{
  JAVA, XML, EJB, JSP, SPRING
 }
 
 public static void main(String[] args) {
  Lesson le = Lesson.JAVA;
  System.out.println("Lesson :" + le);
  System.out.println("XML :" + Lesson.XML);
  System.out.println("JSP :" + Lesson.JSP);
  System.out.println("SPRING :" + Lesson.SPRING);
  //le 객체다
  if( le instanceof Object ){
   System.out.println(le.toString());
   System.out.println(le.getClass().getName());
   System.out.println("저장된 정수값:" + le.ordinal());
  }
  Lesson[] lessons = Lesson.values();
  System.out.println("lesson.length =" + lessons.length);
  for( Lesson n : lessons ){
   System.out.println(n + ":" + n.ordinal() );
  }
 }
}

package chap11;
import java.util.*;
// 제품( Product ) 클래스 만들기
// 멤버 변수 : 제품명( name ), 제품가격( price ), 모델명( modelName )
// 멤버메서드 : toString 메서드만 오버라이딩
// 생성자 : 모든 멤버변수를 입력받도록 구현

// 제품클래스를 set에 저장할 떄 동일한 정보의 객체는 저장되지 않도록 Product 클래스 수정

class Product implements Comparable<Object>{
 String name;
 int price;
 String modelName;
 
 Product( String name, int price, String modelName ){
  this.name = name;
  this.price = price;
  this.modelName = modelName;
 }

 @Override
 public String toString() {
  return "Product [name=" + name + ", price=" + price + ", modelName="
    + modelName + "]";
 }

 @Override
 public int hashCode() {
  return name.hashCode() + price + modelName.hashCode();
 }

 @Override
 public boolean equals(Object obj) {
  if( obj instanceof Product ){
   Product p = (Product)obj;
   if( name.equals(p.name) && ( price == p.price ) && modelName.equals(p.modelName) )
    return true;
   else
    return false;
  }
  
  return false;
 }
 
 // 기본 compareTo 오름차순임. 내림차순은 스왚해야함.
 @Override
 public int compareTo(Object o){
  Product p = (Product)o;
  return name.compareTo(p.name);
 }
}

public class ProductEx {
 public static void main(String[] args) {
  MyTime t = new MyTime();
  
  t.start();
  Product[] items = {
    new Product("TV", 100, "S1000"),
    new Product("TV1", 100, "S2000"),
    new Product("TV2", 100, "S3000"),
    new Product("TV3", 100, "S4000"),
    new Product("컴퓨터", 150, "CS500"),
    new Product("컴퓨터", 150, "CS500"),
    new Product("컴퓨터1", 165, "CS550"),
    new Product("TV", 100, "S4000")
  };
  
  Set<Product> set = new HashSet<Product>();
  for( Product p : items )
   set.add(p);
  for( Product p : set )
   System.out.println(p);
  
  System.out.println();
  System.out.println();
  // set2 조회시 제품명으로 오름차순 정렬되도록
  // product 클래스 프로그램 수정
  TreeSet<Product> set2 = new TreeSet<Product>();
  for( Product p : items )
   set2.add(p);
  
  for( Product p : set2 )
   System.out.println(p);
  t.end();
 }
}

package chap11;
//collection -> java.util
import java.util.*;

// Collection jdk 1.2에서 추가된 내용
// 컴파일에서 추가되는 객체의 자료형을 표시하기 위한 방법이 추가됨( jdk 5.0 )-> 제네릭 표현

// List : 순서가 유지 ( add 순서 )

// ArrayList, Vector
// ArrayList의 멤버메서드는 스레드에 동기화 되어있지 않다.
// Vector의 멤버메서드는 스레드에 동기화 되어있다.

// ArrayList 예제

public class ArrayListEx1 {
 public static void main(String[] args) {
  List<Integer> list1 = new ArrayList<Integer>();
  // 1 : 자동으로 Integer 객체로 형변환 5.0이후만 가능. Boxing
  list1.add(1); // list1.add( new Integer(1) );
  list1.add(2);
  list1.add(5);
  list1.add(4);
  list1.add(0);
  list1.add(3);
  
  ArrayList<Object> list2 = new ArrayList<Object>( list1.subList(1, 4) ); // index 1번부터 4번전까지.
  print( list1, list2 );
  // Collections 클래스
  // Collection  인터페이스
  Collections.sort(list1);
//  Collections.sort(list2); // Object일 경우 관련메서드 compareTo()
  print( list1, list2 );
  // list1 안에 list2 전부 포함되니 ?
  System.out.println(list1.containsAll(list2));
  
  list2.add("B");
  list2.add("C");
  print( list1, list2 );
  // index 3번째에 A를 넣는다, 아무것도 없다면 맨 앞에 들어간다.
  list2.add(3,"A");
  print( list1, list2 );
  // 기존내용을 변경
  list2.set( 3,  "AA");
  print( list1, list2 );
  
  //개선된 for문으로 사용 가능
  for( Object o : list1 ){
   System.out.println(o);
  }
  System.out.println();
 }

 private static void print(List list1, ArrayList list2) {
  // TODO Auto-generated method stub
  System.out.println("list1 :" + list1);
  System.out.println("list1 :" + list2);
  System.out.println();
 }
}

package chap11;
import java.util.*;

// Iterator 인터페이스
// Collection 객체는 모두 Iterator 객체로 변환이 가능하다.
// 변환 메서드 : Iterator()
// Iterator 인터페이스의 멤버 메서드
//  hasNext() : 조회할 객체(요소, Element) 존재 ?
//  next()   : 순서해당하는 객체를 리턴
//  remove()  : 반드시 next() 메서드 이후 사용가능함
//     객체를 삭제 가능
// Enumeration 인터페이스 : Iterator 구버전
//  Vector, Hashtable에서만 사용 가능.
//   멤버메서드
//    hasMoreElement() : 객체가 존재 여부 확인, hasNext()와 동일하다.
//    nextElement() : 순서에 해당하는 객체를 리턴, next()와 동일.
//    삭제는 불가.

public class InteratorEx1 {
 public static void main(String[] args) {
  List<String> list = new ArrayList<String>();
  Iterator<String> it;

  list.add("1");list.add("2");list.add("3");list.add("4");list.add("5");
  for( int i=0 ; i<list.size() ; i++ ){
   System.out.print( list.get(i) );
  }
  System.out.println();
  System.out.println("Iterator로 조회");
  it = list.iterator();
  while( it.hasNext() ){
   System.out.println("while문으로");
   System.out.println( it.next() );
  }
  
  for( it = list.iterator() ; it.hasNext() ; ){
   System.out.println("for문으로");
   System.out.println(it.next() );
  }
  
  List<String> list2 = new Vector<String>();
  list2.add("1");list2.add("2");list2.add("3");list2.add("4");list2.add("5");
  for( String v : list2 ){
   System.out.print( v );
  }
  System.out.println();
  System.out.println("Iterator list2 조회");
  it = list2.iterator();
  while( it.hasNext() ){
   System.out.println( "while");
   System.out.println( it.next() );
  }
  System.out.println("Enumeration 객체로 list2 조회");
  Enumeration e = ( (Vector)list2 ).elements();
  while( e.hasMoreElements() ){
   System.out.println(e.nextElement());
  }
  
  Set<String> set = new HashSet<String>();
  set.add("1");set.add("2");set.add("3");set.add("4");set.add("5");
  for( String z : set ){ //set은 get이 없어서 for 사용.
   System.out.print(z);
  }
  System.out.println();
  it = set.iterator();
  while( it.hasNext() ){
   System.out.println(it.next());
  }
 }
}

package chap11;
import java.util.*;

// Set객체의 중복여부를 확인에 필요한 메서드
// equals() : 결과가 참이면 중복대상
// hashCode() : 결과가 동일하면 중복대상
//
// 두 가지 메서드의 결과가 참이고, 동일하면 해쉬값이 같은경우를
// 중복객체로 본다.

class Person{
 String name;
 int age;
 Person( String name, int age ){
  this.name = name;
  this.age = age;
 }
 
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
 }

 @Override
 public int hashCode() {
  /*final int prime = 31;
  int result = 1;
  result = prime * result + age;
  result = prime * result + ((name == null) ? 0 : name.hashCode());
  return result;*/

  return name.hashCode() + age;
 }

 @Override
 public boolean equals(Object obj) {
  /*if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  Person other = (Person) obj;
  if (age != other.age)
   return false;
  if (name == null) {
   if (other.name != null)
    return false;
  } else if (!name.equals(other.name))
   return false;
  return true;*/
  if( obj instanceof Person ){
   Person p = (Person)obj;
   if( name.equals(p.name) && age == p.age )
    return true;
   else return false;
  }
  else return false;
 }
 
}

public class HashSetEx2 {
 public static void main(String[] args) {
  HashSet set = new HashSet();
  set.add( new String("abc") );
  set.add( new String("abc") );
  set.add( new Person("David", 10) );
  set.add( new Person("David", 10) );
  System.out.println(set);
 }
}

중복 되지 않고

기본으로 오름차순으로 되어 있다.

내림 차순일 경우 구현 해야 하며

package chap11;
import java.util.*;

// Comparable을 implements 했을 경우.
// 오버라이딩 해서 기본 sort를 사용 하고,
// implements 하지 않았을 경우.
// comparable을 implement한 새로운 class를 만들어서 구현해서 쓴다.
class Phone implements Comparable{
 String name;
 int number;
 Phone(String name, int number){
  this.name = name;
  this.number = number;
 }
 
 // 이름순으로 정렬하도록 구현
 public int compareTo(Object o){
  Phone p = (Phone)o;
  return name.compareTo( p.name );
 }
 
 // 전화번호순으로 정렬
/* public int compareTo(Object o){
  Phone p = (Phone)o;
  return number - p.number;
 }*/
 
 @Override
 public String toString() {
  return name + ":" + number;
 }
}

public class ComparatorToEx2 {
 public static void main(String[] args) {
  TreeSet list = new TreeSet();
  // 내가 만들 클래스일 경우 정렬을 구현 해야 한다. compareTo 에러 발생.!!
  list.add( new Phone("김삿갓", 1235)); 
  list.add( new Phone("이몽룡", 3245));
  list.add( new Phone("홍길동", 1241));
  list.add( new Phone("임꺽정", 5142));
  System.out.println(list);
  
  // 오버라이딩이 겹치는 경우 새로운 클래스를 만들어서 쓴다.
  TreeSet list2 = new TreeSet(new NumberSort()); 
  list2.add( new Phone("김삿갓", 1235)); 
  list2.add( new Phone("이몽룡", 3245));
  list2.add( new Phone("홍길동", 1241));
  list2.add( new Phone("임꺽정", 5142));
  System.out.println(list2);
 }
}

class NumberSort implements Comparator{
 @Override
 public int compare( Object o1, Object o2 ){
  Phone p1 = (Phone)o1;
  Phone p2 = (Phone)o2;
  return p1.number - p2.number;
 }
}