import java.util.ArrayList;
import java.util.List;
 
public class ArrayListExam {
 
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
 
        list.add("Java");
        list.add("JDBC");
        list.add("JTBC");
        list.add("Servlet/JSP");
        list.add(2, "Database");
        list.add("iBATIS");
 
        int size = list.size();
        System.out.println("총 객체 수: " + size);
        System.out.println();
 
        String skill = list.get(2);
        System.out.println("2: " + skill);
        System.out.println();
 
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            System.out.println(i + ": " + str);
        }
 
        System.out.println();
 
        list.remove(2);
        list.remove(2);
        list.remove("iBATIS");
 
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            System.out.println(i + ": " + str);
        }
     }
 }

		// "Lee"라는 이름을 가진 데이터 삭제
		for (int i = 0; i < cs.length; i++) {
			// 대소문자 상관없이 해줌.
			if (cs[i].getCname().equalsIgnoreCase("Lee")) {
				// 마지막데이터 대체
				cs[i] = cs[cs.length - 1];
				cs[cs.length - 1] = null;

				// 한 칸씩 이동
				for (int j = i; j < cs.length; j++) {
					cs[j] = cs[j + 1];
					break;
				}
				cs[cs.length - 1] = null;
				break;
			}
		}

import java.util.List;
import java.util.Vector;

public class VectorExample {
 public static void main(String[] args) {
  List<Board> list = new Vector<Board>();
  
  //Board 객체에 값을 넣어줍니다. 
  list.add(new Board("제목1", "내용1", "글쓴이1"));
  list.add(new Board("제목2", "내용2", "글쓴이2"));
  list.add(new Board("제목3", "내용3", "글쓴이3"));
  list.add(new Board("제목4", "내용4", "글쓴이4"));
  list.add(new Board("제목5", "내용5", "글쓴이5"));
  
  list.remove(2); // 2번 인덱스 객체를 삭제합니다. 앞으로 한 칸 당겨집니다.
  list.remove(3); 
  
  for(int i=0; i<list.size(); i++) {
   Board board = list.get(i);
   System.out.println(board.subject + "\t" + board.content + "\t" + board.writer);
  }
 }
}

public class Board {
 String subject;
 String content;
 String writer;
 
 public Board(String subject, String content, String writer) {
  this.subject = subject;
  this.content = content;
  this.writer = writer;
 }
}

Set<String> set = ...;
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()) {
	String str = iterator.next();
}

public class Member_1 {
	public String name;
	public int age;
	
	public Member_1(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Member_1) {
			Member_1 member = (Member_1) obj;
			return member.name.equals(name) && (member.age == age);
		}else {
			return false;
		}
	}
	@Override
	public int hashCode() {
		return name.hashCode() + age;	
	}
}

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {

	public static void main(String[] args) {
		Set<Member_1> set = new HashSet<Member_1>();
		
		
		set.add(new Member_1("hello", 30));
		set.add(new Member_1("hello", 30));
		
		System.out.println("total object : " + set.size());
	}
}

public class Student {
  public int sno;
  public String name;
  
  //생성자입니다. 바로 인스턴스 변수에 값을 넣습니다. 
  public Student(int sno, String name) {
    this.sno = sno;
    this.name = name;
  }

  //equals 함수를 override합니다. 
  public boolean equals(Object obj) {
    //그 매개변수로 받은 객체가 Student 클래스의 인스턴스인지 확인합니다.
    if (obj instanceof Student) {
      //Student클래스로 형변환을 해줍니다. 
      Student student = (Student) obj;
      //인스턴스 변수인 sno와 student 객체의 sno가 똑같은지 확인하면서 name 배열 또한 확인해줍니다. 
      return (sno == student.sno) && (name.equals(student.name));
    } else {
      return false;
    }
  }
  
  //hashCode() 메소드도 override 해줍니다. 
  public int hashCode() {
	//sno int값에 name의 hashCode()를 더해주고 리턴합니다. 
    return sno + name.hashCode();
  }
}

import java.util.HashMap;
import java.util.Map;

public class HashMapExample2 {

  public static void main(String[] args) {
    Map<Student, Integer> map = new HashMap<Student, Integer>();

    map.put(new Student(1, "hong"), 95);
    map.put(new Student(1, "hong"), 95);

    System.out.println("total entry : " + map.size());
  }
}

import java.io.FileReader;
import java.net.URLDecoder;
import java.util.Properties;

public class PropertiesExample {
  public static void main(String[] args) throws Exception {
    //Properties 파일을 읽기 위해서는 Properties 객체가 필요.
    Properties properties = new Properties();
    //Properties 파일은 보통 .class 파일과 함께 저장되는데 이 클래스 파일을 기준으로 상대경로를 이용해서 properties 파일의 경로를 얻으려면 Class의 getResource() 메소드를 이용합니다.
    //getResource()는 주어진 파일의 상대 경로를 URL 객체로 리턴.
    //URL 객체의 getPath()는 파일의 절대 경로를 리턴.
    String path = PropertiesExample.class.getResource("database.properties").getPath();
    //경로에 한글이 있을 경우, 한글을 복원합니다. 
    path = URLDecoder.decode(path, "utf-8");
    //load() 메소드를 사용하기 위해서 FileReader 패키지를 추가. 
    properties.load(new FileReader(path));
    
    //Properties 객체에서 해당 키의 값을 읽으려면 getProperty() 메소드. 
    //Map Collection이므로 get()을 쓸 수도 있으나 Object 타입이므로 String으로 강제변환 해야하니 귀찮. 
    String driver = properties.getProperty("driver");
    String url = properties.getProperty("url");
    String username = properties.getProperty("username");
    String password = properties.getProperty("password");
    
    System.out.println("driver : " + driver);
    System.out.println("url : " + url);
    System.out.println("username : " + username);
    System.out.println("password : " + password);
  }
}

import java.util.NavigableSet;
import java.util.TreeSet;

public class TreeSetExample {

  public static void main(String[] args) {
    TreeSet<String> treeset = new TreeSet<String>();
    treeset.add("apple");
    treeset.add("forever");
    treeset.add("description");
    treeset.add("ever");
    treeset.add("zoo");
    treeset.add("base");
    treeset.add("guess");
    treeset.add("cherry");
    
     //가장 위의 객체 리턴
    System.out.println(treeset.first());
    //가장 밑의 객체 리턴
    System.out.println(treeset.last());
    //주어진 객체보다 바로 아래 객체 리턴
    System.out.println(treeset.lower("ever"));
    //주어진 객체보다 바로 위 객체 리턴
    System.out.println(treeset.higher("ever"));    
    
    System.out.println("c~f사이의 단어 검색");    
    
    NavigableSet<String> rangeSet = treeset.subSet("c", true, "f", true);
    for(String word : rangeSet) {
      System.out.println(word);
    }
    
    System.out.println("내림차순");    
    NavigableSet<String> descendingSet = treeset.descendingSet();
    for(String word : descendingSet) {
      System.out.println(word);
    }

    System.out.println("오름차순");    
    NavigableSet<String> ascendingSet = treeset.descendingSet().descendingSet();
    for(String word : ascendingSet) {
      System.out.println(word);
    }

  }
}

import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.Set;
import java.util.TreeMap;

public class TreeMaptExample {

  public static void main(String[] args) {
    //Map이니까 각각 key와 value가 된다. 
    TreeMap<String,Integer> treemap = new TreeMap<String, Integer>();
     
     //데이터 넣기.
    treemap.put("apple", new Integer(10));
    treemap.put("forever", new Integer(60));
    treemap.put("description", new Integer(40));
    treemap.put("ever", new Integer(50));
    treemap.put("zoo", new Integer(10));
    treemap.put("base", new Integer(70));
    treemap.put("guess", new Integer(30));
    treemap.put("cherry", new Integer(20));
    
     //가장 위의 객체(Map.Entry) 리턴
    System.out.println(treemap.firstEntry());
    //가장 밑의 객체 리턴
    System.out.println(treemap.lastEntry());
    //주어진 객체보다 바로 아래 객체 리턴
    System.out.println(treemap.lowerEntry("ever"));
    //주어진 객체보다 바로 위 객체 리턴
    System.out.println(treemap.higherEntry("ever"));    
    
    System.out.println("c~f사이의 단어 검색");    
    
    NavigableMap<String, Integer> rangeMap = treemap.subMap("c", true, "f", true);
    for(Map.Entry<String, Integer> entry : rangeMap.entrySet()) {
      System.out.println(entry.getKey() + "-" + entry.getValue());
    }
    
    System.out.println("내림차순");    
    NavigableMap<String, Integer> descendingMap = treemap.descendingMap();
    Set<Entry<String, Integer>> descendingEntrySet = descendingMap.entrySet();
    for(Map.Entry<String, Integer> entry : descendingEntrySet) {
      System.out.println(entry.getKey() + "-" + entry.getValue());
    }

    System.out.println("오름차순");    
    NavigableMap<String, Integer> ascendingMap = descendingMap.descendingMap();
    Set<Entry<String, Integer>> ascendingEntrySet = ascendingMap.entrySet();
    for(Map.Entry<String, Integer> entry : ascendingEntrySet) {
      System.out.println(entry.getKey() + "-" + entry.getValue());
    }
  }
}

public class Person implements Comparable<Person>{
  public String name;
  public int age;
  
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  
  @Override
  public int compareTo(Person o) {
    if(age<o.age) return -1; 	//나이가 적을 경우
    else if(age == o.age) return 0; 	//나이가 같을 경우
    else return 1; 	//나이가 많을 경우
  }

}

import java.util.Comparator

public class DescendingComparator implements Comparator<Fruit> {
	@Override
	public int compare(Fruit o1, Fruit o2) {
		if(o1.price < o2.price) return 1;
		else if(o1.price == o2.price) return 0;
		else return -1;
	}
}

package com.ssafy.comparator;

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorTest {

	public static void main(String[] args) {
		int[] arr = { 3, 5, 2, 5, 10 };

		System.out.println(Arrays.toString(arr));
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));

		Integer[] arr2 = { 3, 5, 2, 5, 10 };

		//Integer 배열로 줘야됨. 
		
		System.out.println(Arrays.toString(arr2));
		Arrays.sort(arr2, new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// 객체 빼기 객체는 원래 안 된다. 오토박싱까지 되니까 되는 거지 원래는 아래의 코드와 같아져야 한다.
//				return -1*(o1.intValue() - o2.intValue()); 
				
				return -1*(o1 - o2); // 부호를 반대로 주면 내림차순으로 된다. 
			}
		});

		System.out.println(Arrays.toString(arr2));
		
		String arr3[] = {"hello", "hi", "bye"};
		System.out.println(Arrays.toString(arr3));
		Arrays.sort(arr3); // 그냥 sort해도 정렬이 된다. 이 뜻은  String이 Comparable하게 되어있다는 소리. 
		// String은 final이라서 못 바꾼다. 그럴 때 별도의 Comparator를 준다.
		System.out.println(Arrays.toString(arr3));

		
		String arr4[] = {"hello", "hi", "bye"};
		System.out.println(Arrays.toString(arr4));
		// 익명 클래스는 한 번만 쓰면서 바로 new할 수 있기때문에 편하다. 
		Arrays.sort(arr4, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// 객체 빼기 객체는 원래 안 된다. 오토박싱까지 되니까 되는 거지 원래는 아래의 코드와 같아져야 한다.
//				return -1*(o1.intValue() - o2.intValue()); 
				
				return -1*o1.compareTo(o2); // 부호를 반대로 주면 내림차순으로 된다. 
			}
		});

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

		
	}

}