23일차 java(11)

# ArrayList

// 동적배열(ArrayList구조) : 리스트 내부에 배열이 들어가 있는 구조 
public class ArrayListTest {

	public static void main(String[] args) {
		
		// ArrayList<String> list = new ArrayList<String>();
		LinkedList<String> list = new LinkedList<String>();
		
		list.add("포도"); // index = 0;
		list.add("딸기"); // index = 1;
		list.add("복숭아"); // index = 2; -> 3
		
		// 중간에 값이 들어갈 경우
		// add(1. 삽입할 위치, 2. 저장할 객체명)
		list.add(2, "키위"); // index = 2;

		// 중간검사
		System.out.println("list 의 size() : " + list.size());
		for (int i = 0; i < list.size(); i++) {
			System.out.println("list 의 순서 " + i + "번째 : " + list.get(i));
		}
		System.out.println("=====================================");
		
		// 중간에 값을 수정할 경우
		// set(1. 수정할 인덱스번호, 2. 수정할 값);
		list.set(0, "오렌지"); // 포도 -> 오렌지
		
		// 중간에 값을 삭제할 경우
		// 1. remove(삭제할 데이터명) = 만약 동명이인이 있을경우 해당 이름 전부 삭제됨
		// 2. remove(인덱스번호) = 중복된 데이터를 구분해서 삭제
		list.remove("키위"); // = list.remove(2);
		
		// 값을 조회 하는 경우
		// get(인덱스번호)
		System.out.println("list 의 size() : " + list.size());
		for (int i = 0; i < list.size(); i++) {
			System.out.println("list 의 순서 " + i + "번째 : " + list.get(i));
		}
	}
}

 

# ArrayList (2)

import java.util.*; // ArrayList...
import java.io.Serializable; // 직렬화 하기위해서 필요 (데이터전송)

// class Person implements Serializable {}
class Person { // DTO (Data Tranfer Object) 데이터를 전송할수 있는 객체

	private String name;
	private int age;

	public Person() {
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

// 회원가입 -> 회원로그인 -> 관리자만 회원리스트 목록을 볼 수 있도록 구성
public class ArrayListTest2 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("회원명 입력 : ");
		String name = sc.next();

		System.out.println("나이 입력 : ");
		int age = sc.nextInt();

		Person p = new Person(); // new Person(name, age)
		p.setName(name); // input box때문에
		p.setAge(age);

		Person p2 = new Person(); // new Person(name, age)
		p2.setName("임시"); // input box때문에
		p2.setAge(32);

		Person p3 = new Person(); // new Person(name, age)
		p3.setName("테스트김"); // input box때문에
		p3.setAge(25);

		// ArrayList을 이용해서 저장
		ArrayList<Person> list = new ArrayList<Person>();

		list.add(p);
		list.add(p2);
		list.add(p3);

		// 출력
		ArrayListTest2 alt = new ArrayListTest2(); // 메소드 호출(데이터 저장용)
		alt.setPersonList(list);
		
		sc.close();
	}

	// ArrayList<Person>매개변수로 전달 받아서 출력 -> html
	// html 이 지금은 없기 때문에 console에 출력
	public void setPersonList(ArrayList<Person> list) {
		/*
		for (int i = 0; i < list.size(); i++) {
			// <td><% = st.getName() %></td>
			Person st = list.get(i); 
			System.out.println("이름 : " + st.getName());
			System.out.println("나이 : " + st.getAge());
		}
		*/
		// for (꺼낸 객체의 자료형 객체명 : 배열 또는 컬렉션객체)
		for (Person st:list) {
			System.out.println("이름 : " + st.getName());
			System.out.println("나이 : " + st.getAge());
		}
	}

	// 웹에 출력시켜주는 메소드를 작성(DB에 저장된 데이터를 찾아서 담아서 출력)
	// <td> <% = p.getName() %> </td>
	// <td> <% = p.getAge() %> </td>
	public ArrayList<Person> getPersonList() {

		// DB에 접속해서 데이터를 가져온다는 경우(JDBC)
		ArrayList<Person> list2 = new ArrayList<Person>();

		list2.add(new Person("hong", 23)); // 익명객체형태로
		list2.add(new Person("kim", 25));
		list2.add(new Person("park", 28));

		return list2;
	}

}

 

# ArrayList (3) - 로또번호

// List -> ArrayList, Vector, Random....
import java.util.*;

public class ArrayListLotto extends Object {
	
	Integer bonus; // 숫자객체
				   // int(X)
	List<Integer> lotto = new ArrayList<Integer>();
	// 부모가 가져오지 못해서 자식클래스의 객체를 통해서 인터페이스객체를 얻어올 수 있다.
	
	// 6개의 번호를 랜덤으로 출력
	public void setUp() { // 난수 0 ~ 0.999....
		
		/* 
		 * 난수를 발생 시킬수 있는 방법
		 * 1. Math.random() : 난수를 만들어주는 메소드
		 *             단점 : 중복된 숫자가 나옴
		 *                    seed값(섞어주는값 고정) -> 중복 높음
		 */
		Random random = new Random(); // 내부값이 변경될 때 마다 seed값이 변경됨 -> 중복X
		while (bonus == null) { // 보너스 번호가 설정 안되어 있을때
			
			// nextInt(숫자범위) = 숫자범위내의 임의의수를 출력
			int num = random.nextInt(45)+1; // 1이 안나오기 때문에 +1을 해줘야됨
			// System.out.println("num : " + num);
			
			// 번호를 하나 뽑을때마다 lotto 배열의 내용을 비교 (중복비교)
			if (!lotto.contains(num)) { // 중복된 숫자가 아니라면
				if (lotto.size() < 6) { // 중복되지않음 + lotto 배열에 6개의 숫자가 다 안찼을 경우
					lotto.add(num); // 뽑은 숫자를 lotto에 저장
				} else { // lotto 배열이 꽉 찬 경우 lotto.size() >= 6
					bonus = num; // 6개의 수가 꽉 차고 중복되지 않으면 나머지 보너스
				} // else
			} // outer if
		} // while
		Collections.sort(lotto); // 랜덤으로 뽑은 숫자를 오름차순으로 정렬
		System.out.println(lotto.size());
	}
	
	@Override
	public String toString() {
		return "당첨번호 : " + lotto + ", 보너스 번호 : " + bonus;
	}
	
	public static void main(String[] args) {
		
		ArrayListLotto lotto = new ArrayListLotto();
		
		lotto.setUp(); // 6개의 번호를 구함
		System.out.println(lotto); // 주소값 출력 -> lotto.toString()
	}
}

 

# ArrayList (4) - Generic

* 자주 사용이 되는 클래스도 import형태로 등록
 * 형식) import static 자주 불러서 사용하는 클래스명(패키지명....클래스명)
 * 제너릭 클래스 : 특정 자료형의 값만 입력받아서 저장, 조회, 계산, 출력 등
 *            적용) 멤버변수, 메소드의 매개변수에도 제너릭을 부여가능
 */

import static java.lang.System.out; // 메모리에 로딩

// 기능은 동일한데 서로 다른 자료형을 하나의 Type로 설계O (=추상화)
public class GenericEX <T> { // GenericEx클래스에 객체를 생성하면서 값을 저장할 Type에 대한 자료형만 받아서 처리함
	
	/*
	String v[];
	Double v2[];
	Integer v3[];
	*/
	
	T v[];
	
	public void set(T n[]) {
		v = n;
	}
	
	public void getPrint() {
		for(T s:v) {
			System.out.println(s);
		}
	}
	
	/*
	// 1. 배열의 값을 저장시킬 경우(setter)
	public void set(String n[]) {
		v = n;
	}
	
	public void set(Double n[]) {
		v2 = n;
	}
	
	public void set(Integer n[]) {
		v3 = n;
	}
	
	// 2. 배열의 값을 꺼내와서 출력(getter)
	public void getPrint() {
		for (String s:v) {
			System.out.println(s);
		}
	}
	
	public void getPrint2() {
		for (Double s:v2) {
			System.out.println(s);
		}
	}
	
	public void getPrint3() {
		for (Integer s:v3) {
			System.out.println(s);
		}
	}
	*/
	
	public static void main(String[] args) {
		out.println("자주 출력됨");
		
		// 제너릭 주의 : 객체명은 다르게 설정, 타입도 다르게 설정해서 생성 해야됨
		GenericEX<String> ge = new GenericEX<>();
		GenericEX<Double> ge2 = new GenericEX<>();
		GenericEX<Integer> ge3 = new GenericEX<>();
		
		
		String ss[] = {"제너릭", "제너릭의 종류", "제너릭 실습"};
		ge.set(ss);
		ge.getPrint();
		
		Double ss2[] = {3.4, 5.6, 7.8};
		ge2.set(ss2);
		ge2.getPrint();
		
		Integer ss3[] = {23, 43, 234};
		ge3.set(ss3);
		ge3.getPrint();
		
		/*
		String ss[] = {"제너릭", "제너릭의 종류", "제너릭 실습"};
		ge.set(ss);
		ge.getPrint();
		System.out.println("=======================");
		
		Double ss2[] = {3.4, 5.6, 7.8};
		ge.set(ss2);
		ge.getPrint2();
		System.out.println("=======================");
		
		Integer ss3[] = {23, 43, 234};
		ge.set(ss3);
		ge.getPrint3();
		*/
		
	}
}

 

# ArrayList (5) - WildCard

import java.util.*;

// 1. < ? > 와일드 카드를 이용한 제너릭 방법 -> 메소드 호출시 매개변수를 전달할 때

public class WildTest {

	public static void main(String[] args) {
		// 1. 문자열
		List<String> list = new ArrayList<>();
		
		list.add("test1");
		list.add("test2");
		list.add("test3");
		list.add("test4");
		
		printDate(list);
		System.out.println("===========================");
		
		// 2. 정수형
		List<Integer> list2 = new ArrayList<Integer>();
		list2.add(new Integer(1));
		list2.add(2);
		list2.add(3);
		list2.add(4);
		
		printDate(list2);
		System.out.println("===========================");
		
		// 3. 소수점
		List<Double> list3 = new ArrayList<Double>();
		list3.add(1.1);
		list3.add(2.2);
		list3.add(3.3);
		list3.add(4.4);
		
		printDate(list3);
		
	}
	
	// 오버로딩의 단점은 메소드의 개수를 줄이질 못한다.
	// 제너릭을 이용해 한개의 메소드로 통합
	// <?> : 매개변수를 전달 받을때 그때 그때 마다 자료형을 바꿔서 전달함
	public static void printDate(List<?> list) {
		
		for (Object obj:list) {
			System.out.println(obj);
		}
	}
	
	/*
	public static void printDate2(List<Integer> list) {

		for (Integer obj : list) {
			System.out.println(obj);
		}
	}
	
	public static void printDate3(List<Double> list) {

		for (Double obj : list) {
			System.out.println(obj);
		}
	}
	*/
}

 

# ArrayList (6) - WildCard (2)

import java.util.*;
/*
 * 2. < ? extends T > : 상속관계로 이루어진 클래스만 메소드의 매개변수로 받겠다는 뜻
 *                  ? : 자식클래스 (Man, Woman)
 *                  T : 부모클래스 (Person2, Test)
 *                  부모클래스뿐만 아니라 자식클래스만 임의의 자료형으로 매개변수를 전달받겠다는 표시
 */

class Test extends Object { // 부모클래스로 사용 할 예정
	
	String name;
	
}

class Person2 extends Object { // 부모클래스로 사용 할 예정
	
	String name;
	
}

// 자식클래스 Man
class Man extends Test {
	
	// String name
	Man(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return this.name;
	}
}


// 자식클래스 Woman
class Woman extends Test {
	
	// String name
	Woman(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return this.name;
	}
}

public class WildTest2 {

	public static void main(String[] args) {
		// 1. Man
		List<Man> list = new ArrayList<>();
		
		/*
		 * Man m = new Man("임시");
		 * list.add(m);
		 */
		
		list.add(new Man("테스트1"));
		list.add(new Man("test2"));
		
		printDate(list);
		System.out.println("===========================");
		
		// 2. Woman
		List<Woman> list2 = new ArrayList<Woman>();
		list2.add(new Woman("임시2"));
		list2.add(new Woman("임시3"));
		
		printDate(list2);
		System.out.println("===========================");
		
		/*
		// 3. Person
		List<Person2> list3 = new ArrayList<>();
		list3.add(new Person2());
		
		printDate(list3);
		System.out.println("===========================");
		*/
		
		// 4. Test
		List<Test> list4 = new ArrayList<>();
		list4.add(new Test());
		printDate(list4);
	}
	
	// 오버로딩의 단점은 메소드의 개수를 줄이질 못한다.
	// 제너릭을 이용해 한개의 메소드로 통합
	// <?> : 매개변수를 전달 받을때 그때 그때 마다 자료형을 바꿔서 전달함
	// 모든 클래스 OK
	/*
	 * public static void printDate(List<?> list) {
	 * 
	 * for (Object obj:list) { System.out.println(obj); } }
	 */
	// ?(자식) 대신에 자식클래스명 적으면 안됨
	public static void printDate(List<? extends Test> list) { // 부모상속을 물려받는 자식클래스인 Man, Woman만 가능

		for (Object obj : list) {
			System.out.println(obj);
		}
	}
}

 

# Collection - Wrapper

/*
 * 컬렉션(Collection) : 데이터(객체)를 저장할 수 있는 구조(List, Set, Map)
 *                     -> 객체만 저장
 * 기본자료형(8가지)은 컬렉션에 저장이 안됨 -> 객체가 아니기 때문에 저장이 안됨 
 * 											<-> 참조형(=객체형=클래스형)은 저장 가능
 * 기본자료형을 컬렉션에 저장하고 싶다. -> Wrapper
 */
public class BoxingTest {

	public static void main(String[] args) {
		System.out.println("자동 unboxing");
		// int obj = 10;
		
		// unboxing : 자바의 객체형(Wrapper) -> 기본자료형으로 변환됨
		Integer obj = new Integer(10);
		// int sum = obj.intValue() + 20;
		int sum = obj + 20; // Integer + int -> int + int = int(sum)
		System.out.println("sum : " + sum);
		
		// boxing : 기본자료형 -> 자바의 객체형(Wrapper)로 변환됨
		System.out.println("자동 boxing");
		/* Double d = new Double(123.45);
		printDouble(d);*/
		printDouble(new Double(123.45)); // 익명객체형태로 객체를 전달
		printDouble(143.67); // double -> new Double(143.67)
	}
	
	 
	
	static void printDouble(Double obj2) {
		System.out.println(obj2.toString()); // 소수점을 문자열로 변환해서 출력하는 메소드
	}
}

 

# Collection (2) - Vector

import java.util.*; // * = util에 관련된 전부
					// Scanner, Vector, ArrayList

public class VectorTest {

	public static void main(String[] args) {
		
		Vector v = new Vector(); // new Vector(1, 1) // (1, 1) = (생성개수, 증가분) = default값
		
		v.add("테스트"); // 자동으로 index 번호 0 부여
		v.addElement("임시테스트2"); // 구버전(옛날버전), index 번호 1 부여
		v.add("테스트2"); // index 번호 2 부여
		// v.add(100); // 숫자는 객체가 아니기 때문에 자동으로 변환됨 (v.add(new Integer(100));
		System.out.println("v 의 크기 : " + v.size());
		
		// 값 출력
		for(int i = 0; i < v.size(); i++) {
			// 저장할때 Object형으로 저장 했기 때문에 값을 꺼내올때 다시 변환 시켜줘야됨
			String temp = (String) v.elementAt(i);
			System.out.println("v에든 내용 " + i + "번째 : " + temp);
		}
		
		/* 
		 * 컬렉션의 장점이자 단점은 모든 '객체'가 저장이 가능하기 때문에 원치않는 타입의 객체를 넣을 수 있기 때문에
		 * 그 단점을 보안해주기 위한게 '제너릭'이다.
		 * 제너릭을 사용하면 원하는 타입만 들어가기 때문에 형변환 없이 바로 꺼내올 수 있다.
		 * 형식) Vector <원하는 타입>
		 */
		Vector<String> v3 = new Vector<String>(); // new Vector(1, 1) // (1, 1) = (생성개수, 증가분) = default값

		v3.add("테스트44"); 
		v3.addElement("임시테스트244"); 
		v3.add("테스트245");
		// v.add(100); // String으로 정했기 때문에 다른타입은 못들어옴
		System.out.println("v 의 크기 : " + v.size());

		// 값 출력
		for (int i = 0; i < v.size(); i++) {
			/*// 저장할때 Object형으로 저장 했기 때문에 값을 꺼내올때 다시 변환 시켜줘야됨
			String temp = (String) v.elementAt(i);*/
			System.out.println("v에든 내용 " + i + "번째 : " + v3.elementAt(i));
		}
		
		// 다양한 값 저장
		Vector v2 = new Vector();
		/*
		 * Character c = new Character('a');
		 * v2.add(c)
		 */
		v2.add('a'); // v2.add(new Character('a'));
		
		// 만약에 100자리에 3.14 넣고 싶을때 = 1번인덱스 값을 다른걸로 바꾸고 싶을때
		// 1. 기존에 100을 삭제하고 3.14 값을 집어넣는다
		// 2. 혹은 'a' 와 100 사이에 생성을 해야됨
		// insertElement(1. 저장할객체명, 2. 삽입할 인덱스번호)
		v2.add(100); // v2.add(new Integer(100));
		v2.insertElementAt(3.14, 1);
		System.out.println("v2 의 크기 : " + v2.size());
		
		// 수정
		// setElementAt(1. 수정할데이터명, 2. 수정할 인덱스번호)
		v2.setElementAt("사과", 2); // 2번의 인덱스 번호인 100의 값을 "사과"로 변경
		
		// 내부적인 값의 타입들이 다 다를때
		// 꺼내면서 내부적으로 자동형변환
		for (int i = 0; i < v2.size(); i++) {
			System.out.println("v2에든 내용 " + i + "번째 : " + v2.elementAt(i));
		}
	}
}

 

# Collection (3) - Hash (Set, Map)

import java.util.*;

// Set, Map -> 공통으로 사용하는 검색
public class EnumTest {

	public static void main(String[] args) {
		
		System.out.println("Set(중복을 허용X, 데이터의 저장순서X)");
		HashSet<String> hs = new HashSet();
		hs.add("abc");
		hs.add("abc2");
		hs.add("abc3");
		
		System.out.println("hs : " + hs);
		
		hs.remove("abc"); // abc 객체 삭제
		System.out.println("hs : " + hs);
		
		hs.clear(); // 삭제할 데이터가 1개 이상 일때 clear를 통해서 전체삭제
		System.out.println("hs : " + hs);
		System.out.println("hs의 개수 : " + hs.size());
		System.out.println("저장 유무 확인 : " + hs.isEmpty()); // true = 비어있음
	
		System.out.println("========================================");
		// 검색 때문에
		Vector<String> v = new Vector();
		v.add("test1");
		v.add("test2");
		v.add("test3");
		
		//Map <E>, <K, V> -> 표 형태로 저장 -> 세션처리(회원로그인 할 때 사용)
		Hashtable<Integer, String> h = new Hashtable();
		// Hashtable은 add 대신 put을 사용함
		h.put(1, "홍길동");
		h.put(2, "테스트");
		h.put(3, "010-1234-1234");
		h.put(4, "23");
		h.put(5, "서울시 강남구");
		
		// 값을 꺼낼때
		// get(키명) -> 키를 알고 있으면 검색속도 제일 빠름
		String tel = h.get(3); // = h.put(3, "010-1234-1234");
		System.out.println("tel : " + tel);
		System.out.println("============================================");
		
		// 검색에 대한 인터페이스 -> Enumeration, Iterator
		// 1. Enumeration : 저장된 순서 그대로 가져오길 원할때
		Enumeration<String> eu = v.elements(); // 메소드 반환형
		
		// 데이터구조가 다르다 할지라도 공통된 검색방법을 쓰고 싶다.
		while(eu.hasMoreElements() == true) { // 검색할 데이터가 존재한다면
			System.out.println(eu.nextElement());
		}
		
		// 2. Iterator : 도서관의 책꽂이에 들어가 있는 여러권의 책을 꺼내올 때
		//             -> 출력할 때 저장된 순서대로 출력X
		Collection<String> c = h.values();
		Iterator<String> ih = c.iterator();
		
		while (ih.hasNext() == true) { // 검색할 데이터가 있다면
			System.out.println(ih.next()); // 있으면 꺼내와라(= nextElement())
		}
	}

}