종료하기 전 티스토리 네이버 로그아웃 할 것
1. 툴
동일
추가시:
2. 폴더
동일
추가시:
3. 사용할 사이트
동일
추가시:
4. 공부하는 것
오예 컬렉션! :>
컬렉션 쓰면 foreach 문 쓸 수 있음 :> 씬난당!
컬렉션은 클래스인데! - 배열의 단점을 개선한 것 (동적인 크기 변경이 가능해서 메모리 낭비 x)
Set 계열
List 계열
Map 계열이 있음.
java.util패키지의 자바 컬렉션(JCF)에서 자료구조 방법을 제공한다.
1. Set
1) 순서가 없고
2) 중복이 안됨
- HashSet, TreeSet
외우실 것
package day10;
import java.util.*; //자바 유틸 클래스의 모든 객체 임포트
public class SetTest {
// 얘는 왜 스태틱일까
public static void print(Set set) {
Iterator iter = set.iterator();
while (iter.hasNext()) {
String str = (String) iter.next();
System.out.println(str);
}
}
// 얘도 왜 스태틱일까
public static void print(Object[] obj) {
int count = obj.length;
for (int i = 0; i < count; i++) {
System.out.println(obj[i]);
}
}
/**
* @param args
*/
public static void main(String[] args) {
HashSet list = new HashSet();
// 이게 몰까! :>
// 컬렉션의 Set계열 사용해보기 위한
// Hashset 클래스
list.add("lee"); // 0
list.clear(); // 모두 제거
list.add("cho"); // 1
list.add("kim"); // 2
list.add("chung"); // 3
list.add("min"); // 4
list.add("chung"); // 3과 같다! - 중복된 내용 x - 안들어감 :<
System.out.println("set 사이즈: " + list.size());
// cho kim chung min 이라서 4
System.out.println(list.contains("chung"));
// 이건 true false 값 리턴 :>!
list.remove("kim");
// 삭제도 메소드 :>
System.out.println("kim 제거후 set 사이즈: " + list.size());
System.out.println("Iterator 객체 이용해서 set 출력");
// 이터레이터는 비엔나처럼 이어져있는 데이터
// 하나 하나를 접근할 수는 없음 -_-);;
// set은 순서가 없으니까 Iterator 객체를
// 이용해서 출력함 :>
print(list);
/*
*
* public static void print (Set set){
//Set하고 HashSet이 클래스 연관성이 있는것 - 형변환했음
Iterator iter = set.iterator();
//iterator는 hasNext랑 next가 중요함.
//hasNext = 데이터에서 다음에 가리키는게 있냐고 물어봄
= 그래서 true 아니면 false를 리턴함
//Next = 데이터를 뽑아내고(가져오고) 다음을 가리키는 것
//요기서는 hasNext가 true이면 Next로 가져오고 -> 다음을 가리키고
// false이면 next로 안가고 종료 :>
while(iter.hasNext()){
String str = (String)iter.next();
System.out.println(str);
}
}
*
* */
System.out.println("배열을 이용해서 set 출력");
print(list.toArray());
//Set.의 toArray() 메소드를 호출하면 object형 배열로 바뀜
//Object[] :>
/*
public static void print(Object[] obj) {
int count = obj.length;
for (int i = 0; i < count; i++) {
System.out.println(obj[i]);
}
}
*/
}
}
------------------------------------------
2. List
1) 순서가 있고
2) 중복이 가능
-ArrayList, LinkedList, Vector
java.lang.Object
|
+--java.util.AbstractCollection
|
+--java.util.AbstractList
|
+--java.util.ArrayList
모든 구현 인터페이스:
Cloneable , Collection , List , RandomAccess , Serializable
package day10;
import java.util.*;
public class ListTest1 {
//근데 왜 다 스태틱으로 만드는 걸까
public static void print(List list){
Iterator iter = list.iterator();
while(iter.hasNext()){
String str = (String)iter.next();
System.out.println(str);
}
}
public static void print(Object [] obj){
int count = obj.length;
for(int i = 0; i< count; i++){
System.out.println(obj[i]);
}
}
public static void printGet(List set){
int count = set.size();
for(int i = 0;i<count; i++){
System.out.println(set.get(i));
//String str = (String)set.get(i);
}
}
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("lee"); //0
list.clear(); // 모두 제거
list.add("cho"); //1
list.add("kim"); //2
list.add("chung"); //3
list.add("min"); //4
list.add("chung"); // 3과 동일하지만 리스트니까 5
System.out.println("ArrayList 사이즈: " + list.size());
System.out.println(list.contains("chung"));
list.remove("kim");
list.remove(3); //오 순서가 있어서 순서대로 지울 수 있음
System.out.println("ArrayList 사이즈: " + list.size());
System.out.println("min이 있는 위치값: " + list.indexOf("min"));
System.out.println("Iterator를 이용해서 출력");
print(list);
/*
* public static void print(List list){
*//리스트 클래스로 받을 수 있는 어레이리스트
Iterator iter = list.iterator();
while(iter.hasNext()){
String str = (String)iter.next();
System.out.println(str);
}
}
*/
System.out.println("배열을 이용해서 출력");
print(list.toArray());
/*
* public static void print(Object [] obj){
int count = obj.length;
for(int i = 0; i< count; i++){
System.out.println(obj[i]);
}
}
* */
//ArrayList에서 0에서 1까지의 데이터 추출
List sublist = list.subList(0, 2);
//이게 서브스트링 같은 건데 넘나 좋은거임
System.out.println("추출된 데이터만 출력");
print(sublist);
System.out.println("for문을 이용해서 출력");
printGet(list);
/*
* public static void printGet(List set){
int count = set.size();
for(int i = 0;i<count; i++){
System.out.println(set.get(i));
//String str = (String)set.get(i);
}
}
* */
}
}
compact1, compact2, compact3
java.util
Interface Iterator<E>
출처: http://docs.oracle.com/javase/8/docs/api/
이터레이터(Iterator) 인터페이스
- 모든 컬렉션(Collection)으로 부터 정보를 얻을 수 있는 인터페이스 입니다.
- 즉, 자신이 컬렉션(List, Set 등)이라면 이터레이터 인터페이스를 사용할 수 있습니다.
출처: http://bitnori.tistory.com/entry/JAVA-JAVA-ITERATOR-%EC%9E%90%EB%B0%94-%EC%9D%B4%ED%84%B0%EB%A0%88%EC%9D%B4%ED%84%B0
어 구래서 이터레이터는 그냥 인터페이스였습니다
----------------------------------------------------------------------------------------
>>>>> ArrayListTest.java 파워복붙
package day10;
import java.util.ArrayList;
class Jumsu {
// 멤버 변수
String name = "";
int kuk = 0;
int eng = 0;
int tot = 0;
int avg = 0;
public Jumsu() {
// 생성자
}
public Jumsu(String name, int kuk, int eng) {
this.name = name;
this.kuk = kuk;
this.eng = eng;
this.tot = kuk + eng;
this.avg = (kuk + eng) / 2;
}
}
public class ArrayListTest {
public static void main(String args[]) {
int i = 0;
// sungjuk 객체 생성
Jumsu s = null;
Jumsu s1 = new Jumsu("왕눈이", 100, 80);
Jumsu s2 = new Jumsu("아로미", 80, 90);
Jumsu s3 = new Jumsu("투투", 90, 80);
// Vector에 요소 저장
ArrayList v = new ArrayList();
//점수 클래스타입을 오브젝트 클래스타입으로 업캐스팅해서
//사용함
//v.add(오브젝트); <- 같이 생김
v.add(s1);
v.add(s2);
v.add(s3);
//요소는 해시코드를 뜻함
//리스트에 객체도 저장 가능! :>
// ArrayList에 저장된 sungjuk객체 추출하여 출력
for (i = 0; i < v.size(); i++) {
// Client ---> Object Interface <---> Sungjuk 객체
// Client ---> Sungjuk Interface <---> Sungjuk 객체
s = (Jumsu) v.get(i);
// 아까 위에서 업캐스팅했으니까
//다시 다운캐스팅 해서 사용함 (멤버 변수가 없으니까 :<)
System.out.print(s.name + "\t");
System.out.print(s.kuk + "\t");
System.out.print(s.eng + "\t");
System.out.print(s.tot + "\t");
System.out.print(s.avg + "\t\n");
}
}
}
----------------------------------------------------------------
Vector!
package day10;
import java.util.*;
import javax.xml.bind.ValidationEvent;
//벡터의 정의 및 요소 검색, 크기 조절
//직계의 기존의 서브 클래스: 스택
public class SearchDelete {
public static void main(String[] args) {
String name[] = { "기획자", "설계자", "개발자" };
// 3개
Vector v = new Vector();
// Vector에 배열 요소 저장
for (int i = 0; i < name.length; i++) {
v.addElement(name[i]);
// 벡터는 v.add와 v.addElement 둘 다 가능
}
// 으아아 잠시 졸았음.
// "개발자" 가 있는지 검사
if (v.contains("개발자")) {
int i = v.indexOf("개발자");
System.out.println("해당 객체의 인덱스 " + (i + 1) + "번째에 있습니다.");
} else {
System.out.println("해당 객체가 없습니다.");
}
// 첫번째 요소 삭제
v.removeElementAt(0);
// 2개 설계자 개발자
System.out.println("지우고 난 후에는");
String s = "";
for (int j = 0; j < v.size(); j++) {
s = (String) v.elementAt(j);
// 값 가져오는 것
System.out.println("Vector " + j + "번째 요소는 " + s);
}
// 설계자개발자
System.out.println("\n초기상태 크기");
System.out.println("엘리먼트의 수는 " + v.size());
// 실제 저장된 객체의 수 - 2개
System.out.println("벡터의 크기는 " + v.capacity());
// 객체를 저장할 수 있는 초기 사이즈 - 모름
System.out.println("\nv.trimToSize()후");
v.trimToSize(); // 값이 할당되지 않았으면 메모리 삭제.
// 첨에는 10개 정도 넣을 수 있는 메모리로 태어남
// 근데 효율적이지가 않아서 trimToSize해줘야합니다
// 또 졸았음 ㅠㅠㅠ
System.out.println("엘리먼트의 수는 " + v.size());
// 실제 저장된 객체의 수 - 2개
System.out.println("벡터의 크기는 " + v.capacity());
// 객체를 저장할 수 있는 초기 사이즈 - 아마 2개?
System.out.println("\n디자이너 요소 추가후");
v.addElement("디자이너");
System.out.println("엘리먼트의 수는 " + v.size());
// 3개
System.out.println("벡터의 크기는 " + v.capacity());
// 아마 3개
// capacity 늘어날 때는 부족할 경우 현재 capacity 보다 2배씩 늘어남
System.out.println("\nCoder 요소 추가후");
v.addElement("Coder");
System.out.println("엘리먼트의 수는 " + v.size());
// 4개
System.out.println("벡터의 크기는 " + v.capacity());
// 아마 4개
v.addElement("PM");
System.out.println("엘리먼트의 수는 " + v.size());
// 5개
System.out.println("벡터의 크기는 " + v.capacity());
// 아마 5개 -> 아니네
}
}
--------------------------------------
성적도 파워복붙
package day10;
import java.util.Vector;
class Sungjuk {
// 멤버 변수
String name = "";
int kuk = 0;
int eng = 0;
int tot = 0;
int avg = 0;
public Sungjuk() {
}
public Sungjuk(String name, int kuk, int eng) {
this.name = name;
this.kuk = kuk;
this.eng = eng;
this.tot = kuk + eng;
this.avg = (kuk + eng) / 2;
}
}
public class VectorTest2 {
public static void main(String args[]) {
int i = 0;
// sungjuk 객체 생성
Sungjuk s = null;
Sungjuk s1 = new Sungjuk("기획자", 100, 80);
Sungjuk s2 = new Sungjuk("설계자", 80, 90);
Sungjuk s3 = new Sungjuk("개발자", 90, 80);
// Vector에 요소 저장
Vector v = new Vector();
v.addElement(s1);
v.addElement(s2);
v.addElement(s3);
// vector에 저장된 sungjuk객체 추출하여 출력
for (i = 0; i < v.size(); i++) {
s = (Sungjuk) v.get(i);
System.out.print(s.name + "\t");
System.out.print(s.kuk + "\t");
System.out.print(s.eng + "\t");
System.out.print(s.tot + "\t");
System.out.print(s.avg + "\t\n");
}
}
}
------------------------------------------------------------
Map
-컬렉션에 포함되어져 있지 않은 그냥 맵구조인것
1) Key 와 Value 한쌍
-HaspMap, Hashtable
-put메소드로 입력한다.
- 중복된 키 값 허용 x - 만약에 쓰면 기존 값 삭제됨
- 검색 결과가 없으면 null 리턴
list = new Hapmap();
list.put("0", "lee"); <- 이런식으로 삽입함
얘도 iterator를 이용할 수 있다.
/*
*map
*key와 value의 한쌍
*중복된 키값 허용 x - 사용하면 기존 값 삭제
*/
package day10;
import java.util.*;
public class MapTest {
public static void main(String[] args) {
HashMap list = new HashMap();
list.put("0", "lee");
list.clear();
list.put("1", "cho");
list.put("2", "kim");
list.put("3", "chung");
list.put("4", "min");
list.put("3", "jung");
// ↑동일 에러 -> 동일한 키값을 사용해서 chung 지워지고 jung이 들어감
System.out.println(list.size());
System.out.println(list.containsKey("3"));
list.remove("2");
System.out.println(list.size());
print(list);
}
public static void print(Map sets) {
/*
* //static 안쓰면 오류남 Exception in thread "main" java.lang.Error:
* Unresolved compilation problem: Cannot make a static reference to the
* non-static method print(Map) from the type MapTest
*
* at day10.MapTest.main(MapTest.java:30)
*/
Set set = sets.keySet();
//키값들만 set으로 받음
Iterator iter = set.iterator();
while (iter.hasNext()) {
String key = (String) iter.next();
System.out.println(key + " " + sets.get(key));
//받아온 key값의 value를 출력하는 get()
}
}
}
---------------------------------------------------------------------------------------
package day10;
import java.util.Enumeration;
import java.util.Hashtable;
public class TestHashTable {
public static void main(String[] args) {
Hashtable ht = new Hashtable();
ht.put("AREA01", "대한민국");
ht.put("AREA02", "러시아");
ht.put("AREA03", "중국");
ht.put("AREA04", "일본");
String area = (String)ht.get("AREA01");
//String area = (String)ht.get("AREA05");
if(area != null){
System.out.println(area);
}
else{
System.out.println("검색 지역이 없습니다.");
}
Enumeration e = ht.keys();
//해시테이블은 keys()라는 메소드가 있는데
//이터레이터 같은 거임
//enumeration 타입으로 해시테이블의 키를 받음
while(e.hasMoreElements()){
//이게 hasnext 같은 건가봄
String key = (String)e.nextElement();
System.out.println(key + " = " + ht.get(key));
}
//그러니까 얘는 이터레이터가 무필요
//객체 자체가 keys()라는 메소드가 있어서
//Enumeration 타입으로 쓸 수 있음 :>
}
}
----------------------------------------------------------
-------------------------------------------------------------
Hashtable의 Properties라는 것도 있는데
얘는 파일 입출력 같은 거 써봄
package day10;
//해시테이블의 하위 테이블 (자식인것)
//얘는 키랑 밸류가 문자열로만 저장 가능 :>
//순수 확장자가 properties인 문자열을 읽어다가 저장할 수 있다(?)
//키랑 밸류값 구분법은 = 임
//import java.util.Properties;
public class ProTest {
public static void main(String[] args) {
// Properties p = new Properties();
java.util.Properties p = new java.util.Properties();
p.put("step1", "JAVA + SCJP");
p.put("step2", "JSP + Oracle + SCWCD");
p.put("step3", "EJB + SCBCD");
p.put("step4", "OJT + MVC2, Framework + 개발");
System.out.println("STEP1:" + p.getProperty("step1"));
System.out.println("STEP2:" + p.getProperty("step2"));
System.out.println("STEP3:" + p.getProperty("step3"));
System.out.println("STEP4:" + p.getProperty("step4"));
}
}
----------------------------------------
package day10;
import java.io.FileInputStream;
import java.util.Iterator;
import java.util.Properties;
public class ProTest2 {
public static void main(String[] args) {
String myinfoPath = "myinfo.properties";
//파일명을 문자열변수 안에 넣는다.
FileInputStream fis = null;
//Stream은 자바의 IO인것
//인풋스트림 / 아웃풋스트림 있음
Properties pro = new Properties();
//얘 객체 만든 이유는 키와 밸류의 값을 담기 위해
try{
fis = new FileInputStream(myinfoPath);
//이렇게 하면 연결이 된 것...
pro.load(fis);
//load 메소드를 통해서
//파일의 값을 pro로 읽어옴
}catch(Exception e){
e.printStackTrace();
}
Iterator iter = pro.keySet().iterator();
/*
while(iter.hasNext()){
String key = (String)iter.next();
String value = (String)pro.getProperty(key);
System.out.println(key + " = " + value);
}
//얘는 다 읽어오는거
*/
System.out.println("이름: " + pro.getProperty("name"));
System.out.println("전화: " + pro.getProperty("phone"));
System.out.println("주소: " + pro.getProperty("address"));
//얘는 출력하느라 하나하나 읽어오는것
}
}
이렇게 쓴 것입니다.
-------------------------------------A4에 정리해야함
----------------------------------------수업 안해서 다했음
Iterator 공부해야함
아니 이블로그 짱짱맨임 상줘야함ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ
얘는 이터레이터 공부했고
http://seeit.kr/36
얘는 리스트 공부했음 :>! 이힣힣
----------------------------------------------------밥먹음 :>!
1. 업캐스팅 - 프로그램에서 이루어지는 자동 타입 변환 입니다.
- 서브 클래스의 레퍼런스 값을 슈퍼클래스 타입의 변수에 대입 합니다.
- 슈퍼 클래스 레퍼런스가 서브 클래스 객체를 가리키게 되는 현상 입니다.
- 객체 내에 있는 모든 멤버를 접근할 수 없고 슈퍼 클래스의 멤버만 접근
가능합니다.
복습하려고 복붙하는 업캐스팅의 정의
그러니까 자식 클래스의 해시코드를 부모 클래스 타입의 변수에 대입하면
부모 클래스 해시코드가 자식 클래스 객체를 가리키게 되는 현상임
그러면 객체 내에 있는 모든 멤버는 접근 못 하고 슈퍼클래스 멤버만 접근 가능함.
--------------------------------
예제 복붙하면서 복습하고 있읍니다
package Test_day10;
class DObject {
public DObject next;
//지네 타입 변수를 싱글톤이라고 부르는데 몰라도됨
//어쨌든 멤버 변수를 지 타입으로 만듬 ㅇㅇ...
// class 타입 멤버변수인것
public DObject() {
next = null;
}
public void draw() {
System.out.println("DObject draw");
}
}
class Line extends DObject {
public void draw() { // 메소드 오버라이딩
System.out.println("Line");
}
}
class Rect extends DObject {
public void draw() { // 메소드 오버라이딩
System.out.println("Rect");
}
}
class Circle extends DObject {
public void draw() { // 메소드 오버라이딩
System.out.println("Circle");
}
}
public class MethodOverringEx {
public static void main(String[] args) {
DObject obj = new DObject();
Line line = new Line();
DObject p = new Line();
DObject r = line;
obj.draw(); // DObject.draw() 메소드 실행. "DObject draw" 출력
line.draw(); // Line.draw() 메소드 실행. "Line" 출력
p.draw(); // 오버라이딩된 메소드 Line.draw() 실행, "Line" 출력
r.draw(); // 오버라이딩된 메소드 Line.draw() 실행, "Line" 출력
DObject rect = new Rect();
DObject circle = new Circle();
rect.draw(); // 오버라이딩된 메소드 Rect.draw() 실행, "Rect" 출력
circle.draw(); // 오버라이딩된 메소드 Circle.draw() 실행, "Circle" 출력
}
}
---------------------------------------------------------
package Test_day10;
class Person {
String phone;
public void setPhone(String phone) {
this.phone = phone;
}
public String getPhone() {
return phone;
}
}
class Professor extends Person {
public String getPhone() { // Person의 getPhone()을 오버라이딩
return "Professor : " + super.getPhone(); // Person의 getPhone() 호출
}
}
public class Overriding {
public static void main(String[] args) {
Professor a = new Professor();
a.setPhone("011-123-1234"); // Professor의 getPhone() 호출
System.out.println(a.getPhone());
Person p = a; //업캐스팅
System.out.println(p.getPhone()); // 동적 바인딩에 의해
// Professor의 getPhone() 호출
}
}
---------------------------------------
package Test_day10;
class A {
public A() {
System.out.println("생성자A");
}
}
class B extends A {
public B() {
System.out.println("생성자B");
}
}
class C extends B {
public C() {
System.out.println("생성자C");
}
}
public class ConstructorEx {
public static void main(String[] args) {
C c;
c = new C();
}
}
-----------------------------------------------
오늘 목표는 구구단! - 어렵게! -_-ㅋㅋ
ㅇㅇ
------------------------------------
수업시간에 한 건 이거임
package Test_day10;
public class Test12 {
public static void main(String[] args) {
for (int i = 2; i < 9; i = i + 3) {
for (int j = 1; j <= 3; j++) {
System.out.print(i + " * " + j + " = " + (i * j) + "\t");
System.out.print((i + 1) + " * " + j + " = " + (i + 1) * j + "\t");
if ((i + 2) == 10) {
System.out.println("");
continue;
}
System.out.print((i + 2) + " * " + j + " = " + (i + 2) * j + "\n");
}
System.out.println("");
}
}
}
잼슴
------------------------------
package Test_day10;
public class WrapperClassEx {
public static void main(String[] args) {
Integer i = new Integer(10);
char c = '4';
Double d = new Double(3.1234566);
System.out.println(Character.toLowerCase('A')); // 대문자 A를 소문자로 변환
if (Character.isDigit(c)) // 문자 c가 숫자를 나타내면 true
System.out.println(Character.getNumericValue(c)); // 문자 c를 숫자로 변환하여
// 출력
System.out.println(Integer.parseInt("-123")); // 문자열 “-123”을 정수로 변환하여 출력
System.out.println(Integer.parseInt("10", 16)); // 16진수로 표현된 문자열 “10”을
// 정수로 변환하여 출력
System.out.println(Integer.toBinaryString(28)); // 28의 2진수 표현을 나타내는 문자열
// 출력
System.out.println(Integer.bitCount(28)); // 28의 2진수에서 1의 개수출력
System.out.println(Integer.toHexString(28)); // 28의 16진수 표현을 나타내는 문자열 출력
System.out.println(i.doubleValue()); // i값(=10)을 double로 변환하여 출력
System.out.println(d.toString()); // d값(=3.1234566)을 문자열로 변환하여 출력
System.out.println(Double.parseDouble("44.13e-6")); // 문자열 “44.13e-16"을
// double로 변환하여 출력
}
}
//Wrapper
---------------------------------------------------------------------------------------------
package Test_day10;
public class AutoBoxingUnBoxing {
public static void main(String[] args) {
int i = 10;
Integer intObject = i; // auto boxing
// 이거 주소값을 조서 10이 안나올 거 같지만 10이나옴ㅋㅋㅋㅋㅋㅋㅋ
// 자바 5.0 버전부터는 언박싱 오토박싱 기능이 있어서 넘나조은것
// 기본형 타입 -> 해시코드 x
// 이게 사실 Integer intObject = new Integer(10); 이랑 같은 말인것
//
System.out.println("intObject = " + intObject);
i = intObject + 10; // auto unboxing
// 이거는 intObject.Intvalue() 한거랑 같은 거임
// 이게 참조형 타입에 기본형 타입을 담을 수 있는
// 5.0 버전으것
System.out.println("i = " + i);
}
}
---------------잼슴---------------------------------
package Test_day10;
public class StringEx {
public static void main(String[] args) {
String a = new String(" abcd");
String b = new String(",efg");
// 문자열 연결
a = a.concat(b);
System.out.println(a);
// 공백 제거
a = a.trim();
System.out.println(a);
// 문자열 대치
a = a.replace("ab", "12");
System.out.println(a);
// 문자열 분리
String s[] = a.split(","); // a.split("요걸로 구분함")
for (int i = 0; i < s.length; i++)
System.out.println("분리된 " + i + "번 문자열: " + s[i]);
// 서브 스트링
a = a.substring(3);
System.out.println(a);
// 문자열의 문자
char c = a.charAt(2);
System.out.println(c);
}
}
abcd,efg
abcd,efg
12cd,efg
분리된 0번 문자열: 12cd
분리된 1번 문자열: efg
d,efg
e
------------------------------------------------
4시 51분!
1시간 39분 남았당:>
오 스트링버퍼임! :>
얘는 막 바꿔도 그대로 자기 해시코드임! :>
package Test_day10;
public class StringBufferEx {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("This");
System.out.println(sb.hashCode()); // 생성 후 스트링버퍼 해쉬값 출력
sb.append(" is pencil"); // 문자열 덧붙이기
System.out.println(sb);
sb.insert(7, " my"); // 문자열 삽입
System.out.println(sb);
sb.replace(8, 10, "your"); // 문자열 대치
System.out.println(sb);
sb.setLength(5); // 스트링 버퍼 내 문자열 길이 설정 0 1 2 3 4 까지 나옴
System.out.println(sb);
System.out.println(sb.hashCode()); // 문자열 조작 후 스트링 버퍼의 해쉬 코드
// 값이 같으면 같은 객체임을 나타낸다.
}
}
----------------------------------------------------
스트링 토크나이저임! :>
오 이거 좋은데 ㅋㅋㅋㅋㅋㅋ - 이거 Split이랑 같이 기억하면 좋음!
package Test_day10;
import java.util.StringTokenizer;
public class StringTokenizerEx {
public static void main(String[] args) {
StringTokenizer st = new StringTokenizer("홍길동/장화/홍련/콩쥐/팥쥐", "/");
// 구분자로 / 사용
//StringTokenizer st = new StringTokenizer("홍길동^장화^홍련^콩쥐^팥쥐", "^");
// 구분자를 이렇게 ^로 지정할 수도 있음
while (st.hasMoreTokens())
System.out.println(st.nextToken());
}
}
-------------------------------------------------
-------------------------------------------------------------------
이제 Exception이랑 interface 할거임!
package Test_day10;
import java.util.Scanner;
public class ExceptionExample2 {
public static void main(String[] args) {
Scanner rd = new Scanner(System.in);
int divisor = 0;
int dividend = 0;
System.out.print("나뉨수를 입력하시오:");
dividend = rd.nextInt();
System.out.print("나눗수를 입력하시오:");
divisor = rd.nextInt();
try {
System.out.println(dividend + "를 " + divisor + "로 나누면 몫은 " + dividend / divisor + "입니다.");
} catch (ArithmeticException e) { // ArithmeticException 예외 처리 블록
System.out.println("0으로 나눌 수 없습니다.");
}
}
}
----------------------------------------------------------
package Test_day10;
public class ArrayException {
public static void main(String[] args) {
int[] intArray = new int[5];
intArray[0] = 0;
try {
for (int i = 0; i < 5; i++) {
intArray[i + 1] = i + 1 + intArray[i]; // i=4인 경우 예외 발생
System.out.println("intArray[" + i + "]" + "=" + intArray[i]);
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("배열의 인덱스가 범위를 벗어났습니다.");
}
}
}
----------------------------------------잼슴-------------------
package Test_day10;
public class NumException {
public static void main(String[] args) {
String[] stringNumber = { "23", "12", "998", "3.141592" };
try {
for (int i = 0; i < stringNumber.length; i++) {
int j = Integer.parseInt(stringNumber[i]); // "3.141592"에서 예외 발생
System.out.println("숫자로 변환된 값은 " + j);
}
} catch (NumberFormatException e) {
System.out.println("정수로 변환할 수 없습니다.");
System.out.println(e); //오류 원인 알려줌
}
}
}
--------------------------------------------------------------------
package Test_day10;
interface MobilePhone {
public boolean sendCall();
public boolean receiveCall();
public boolean sendSMS();
public boolean receiveSMS();
}
interface MP3 {
public void play();
public void stop();
}
class PDA {
public int calculate(int x, int y) {
return x + y;
}
}
public class SmartPhone extends PDA implements MobilePhone, MP3 {
// 클래스 상속도 하고 (얜 한개만)
// 인터페이스 구현도 할 수 있는데(얜 여러개 가능)
// 순서가 바뀌면 안됨
// MobilePhone의 추상 메소드 구현
public boolean sendCall() {
System.out.println("전화 걸기");
return true;
}
public boolean receiveCall() {
System.out.println("전화 받기");
return true;
}
public boolean sendSMS() {
System.out.println("SMS 보내기");
return true;
}
public boolean receiveSMS() {
System.out.println("SMS 받기");
return true;
}
// MP3의 추상 메소드 구현
public void play() {
System.out.println("음악 재생");
}
public void stop() {
System.out.println("재생 중지");
}
// 메소드 추가 구현
public void scheduler() {
System.out.println("일정관리");
}
public void applicationManager() {
System.out.println("어플리케이션 설치/삭제");
}
public static void main(String[] args) {
SmartPhone p = new SmartPhone();
p.sendCall();
p.play();
p.calculate(3, 5);
p.scheduler();
}
}
-----------------------------------------------------------
package Test_day10;
interface ISungjuk {
public void setJumsu(int kuk, int eng);
public abstract void print();
}
class Sungjuk implements ISungjuk {
int kuk = 0; // 국어
int eng = 0; // 영어
@Override
public void setJumsu(int kuk, int eng) {
this.kuk = kuk;
this.eng = eng;
}
@Override
public void print() {
System.out.println("성적 증명서");
System.out.println("국어: " + this.kuk);
System.out.println("영어: " + this.eng);
}
}
public class SungjukTest {
public static void main(String[] args) {
// ERROR
// ISungjuk iis = new ISungjuk();
// 인터페이스 = 구현 클래스
ISungjuk is = new Sungjuk();
is.setJumsu(90, 85);
is.print();
}
}
----------------------------------------------------------ㅇㅅㅇ
이제 벡터~~~!!
package Test_day10;
import java.util.Vector;
public class VectorEx {
public static void main(String[] args) {
Vector v = new Vector(); // 디폴트 용량 10의 벡터 생성
v.add("Hello"); // String 객체 요소 삽입
v.add(new Integer(4)); // Integer 객체 요소 삽입
v.add(new Double(3.14)); // Double 객체 요소 삽입
System.out.println("벡터내의 요소 객체 수 :" + v.size()); // 크기는 3
System.out.println("벡터의 현재 용량 :" + v.capacity()); // 용량은 10
for (int i = 0; i < v.size(); i++) {
Object obj = v.get(i); // 해당 인덱스의 요소 얻어오기
if (obj instanceof String) { // String 객체의 경우
String str = (String) obj;
System.out.println(str);
} else if (obj instanceof Integer) { // Integer 객체의 경우
Integer x = (Integer) obj;
int n = x.intValue();
System.out.println(n);
} else if (obj instanceof Double) { // Double 객체의 경우
Double y = (Double) obj;
double d = y.doubleValue();
System.out.println(d);
}
}
}
}
--------------------------위에 코드 중에서 ------------------------------------
Object obj = v.get(i); // 해당 인덱스의 요소 얻어오기
if (obj instanceof String) { // String 객체의 경우
//instanceof = 객체 비교
//그 객체가 instanceof 스트링타입이면
//요거실행
String str = (String) obj;
System.out.println(str);
} else if (obj instanceof Integer) { // Integer 객체의 경우
//그 객체가 instanceof 인티저타입이면
//요거실행
Integer x = (Integer) obj;
int n = x.intValue();
System.out.println(n);
} else if (obj instanceof Double) { // Double 객체의 경우
//그 객체가 instanceof 더블타입이면
//요거실행
--------------------------------------------------------------------
package Test_day10;
import java.util.Vector;
public class VectorAddEx {
public static void main(String[] args) {
Vector v = new Vector(); // 디폴트 용량 10의 벡터 생성
v.add("Hello");
v.add(new Integer(4));
v.add(new Double(3.14));
v.add(new Integer(5));
int sum = 0;
for (int i = 0; i < v.size(); i++) {
Object obj = v.get(i);
if (obj instanceof Integer) { // Integer 객체의 경우에만 덧셈 수행 - true false 값 출력하는 instanceof
Integer x = (Integer) obj;
int n = x.intValue(); // int값으로 변환
sum += n;
}
}
System.out.println("모든 정수의 합은 : " + sum);
}
}
-------------------------------------------------------------
package Test_day10;
import java.util.*;
public class HashtableEx {
public static void main(String[] args) {
Hashtable h = new Hashtable(); // 디폴트 용량 11의 Hashtable 생성
h.put("21", "홍길동");
h.put("54", "황기태");
h.put("76", "이소룡");
h.put("123", "해리슨포드");
System.out.println("Hashtable의 키 개수 : " + h.size()); // 키의 개수
Enumeration e = h.keys(); // Hashtable의 모든 키들을 얻어옴
//에뉴머레이션 = 이터레이터 친구같은애인데 해시테이블은 얘가 다이렉트로 된당 :>
while (e.hasMoreElements()) {
String key = (String) e.nextElement(); // 키
String value = (String) h.get(key); // 키에 매핑된 값
System.out.println(key + ":" + value);
}
}
}
-------------------------------------------------------------------
package Test_day10;
import java.util.*;
public class HashTableExample {
public static void main(String[] args) {
Hashtable members = new Hashtable(); // 디폴트 용량 11의 Hashtable 생성
Scanner sin = new Scanner(System.in);
System.out.println("공백으로 분리된 이름과 전화번호 5개를 입력하십시오.");
for (int i = 0; i < 5; i++) {
System.out.print("이름, 전화번호 : ");
String name = sin.next(); // 이름 입력
String tel = sin.next(); // 전화번호 입력
members.put(name, tel); // 이름이 키, 전화번호를 값으로 Hashtable에 저장
}
System.out.println("전화번호를 검색할 이름을 입력하십시오.");
String key = sin.next(); // 키인 이름 입력
String val = (String) members.get(key); // 키로 매핑된 전화번호 검색
if (val != null)
System.out.println(key + "의 전화번호는 " + val + "입니다.");
else
System.out.println("입력하신 이름을 찾을 수 없습니다.");
}
}
// 스캐너가 한번에 입력받는 성질이 있어서
// a 1 b 2 c 3 d 4 e 5 입력하고 f 출력해도 나옴...
-----------------------------------------------------------------
package Test_day10;
import java.util.*;
public class IteratorExample {
public static void main(String[] args) {
ArrayList a = new ArrayList(); // 빈 리스트 생성
a.add("Hello");
a.add(3); // 자동 박싱, JDK 1.5 이후에서만 실행됨
// 그래서 요거는 new Integer(3) 이랑 같은거임
a.add(3.14); // 자동 박싱
a.add(2, 3.4); // 자동 박싱, 인덱스 2에 객체 삽입
// 2번째에 3.14말고 3.4를 대입해라 (0 1 2 의 인덱스 2)
Iterator i = a.iterator(); // Iterator 객체 반환
while (i.hasNext()) { // Iterator 객체에 요소가 있을 때 까지 반복
Object obj = i.next(); // 다음 요소 반환
if (obj instanceof String) { // String 객체의 경우
String str = (String) obj;
System.out.println(str);
} else if (obj instanceof Integer) { // Integer 객체의 경우
int n = (Integer) obj; // 자동 언박싱, JDK 1.5 이후에서만 실행됨
//그러니까 이거는 (Integer)obj.intValue(); 한게 생략임
System.out.println(n);
} else if (obj instanceof Double) { // Double 객체의 경우
double d = (Double) obj; // 자동 언박싱, JDK 1.5 이후에서만 실행됨
System.out.println(d);
}
}
}
}
//해시코드값이 참조타입으로 형변환 : 박싱
//참조타입이 기본형으로 형변환 : 언박싱
----------------------------------------------------------
package Test_day10;
import java.util.*;
public class VectorExample {
public static void main(String[] args) {
Vector<Integer> v = new Vector<Integer>(3);
// Integer를 요소로하는 용량 3의 벡터 생성
System.out.println("벡터의 초기 크기는 " + v.capacity());
v.add(new Integer(1));
//이게 벡터가 애초에 Integer를 요소로 하는 걸 생성해서 인티저만 넣어줘야함
v.add(new Integer(22));
v.add(new Integer(51));
v.add(new Integer(10));
//얘들도 다그래 :<
System.out.println("벡터의 크기는 " + v.capacity());
Collections.sort(v); // 요소 순서대로 정렬 - 오름차순
for (int i = 0; i < v.size(); i++) { // 벡터에 있는 모든 요소에 대해 반복
Integer n = v.elementAt(i); // 요소 객체 알아내기
System.out.println(n.toString());
}
}
}
---------------------------------------------------------
5. 수업
진도:
hw:
6. 할것
