** 우분투 리눅스 설치!!! 공부 스타트~~~

 

(1) eclipse

- Perspective : 전체화면 (window > open Perspective)

- view : perspective안의 창 하나하나를 의미

window > show view > 다시 view 띄우기

or

window : new window 초기 상태 (하나의 창만 띄우고 작업할 것!!)

 

Q. 순수 자바만 할 꺼면?? java developer 버전으로 다운

자바 + 웹 ? java ee 버전으로 다운

 

* 항상 eclipse에서 할일

1. Java Project 만들기

2. 만들고자 하는 곳에서 마우스 오른쪽 클릭 후 패키지 or 클래스 만들기

3. 패키지랑 클래스 한번에 가능(클래스 선택) - 일반적으로 이 방법으로 사용!!!!

 

Window > Preferences > General > Appeearance > Colors and Fonts

> Basic > Text Font > 더블클릭 후 크기 설정

 

Workspace > Text file encoding Other - UTF-8 (web에서 중요!! java에서는 괜찮지만 웹에서 설정 바꾸기)

 

delete > delete project contens on disk (해당 파일을 완전히 디스크 상에서 지울 것인가? ) --- 주의 할 것!!

Eclipse 단축키 (마우스 클릭 최소화 하기!!)

window > preferences > Java > Editor > Templates에서 내가 자동완성 만들 수 있다!!

ctrl + space

자동완성

ctrl + 숫자1

오류 해결

ctrl + alt + 아래화살표

한줄(블럭) 복사

ctrl + d

한줄씩 지우기

shift + alt + m

블록 지정한 중복코드 알아서 찾아서

메소드 만들어줌

ctrl + shift + o

자동으로 import

ctrl + shift + r

원하는 파일 찾기

ctrl + o

해당 클래스의 메소드, 변수명 확인

ctrl + /

한줄 주석

(블럭) ctrl + /

블럭 주석

alt + up(down)

위(아래) 줄 바꾸기

alt + left, alt + right

이전, 이후 작업 화면

ctrl + f

찾기

alt + shift + r

(ctrl + f의 replace all처럼 해당파일의 같은 이름을 모두 바꾸는 것이 아니기 때문에 이름이 같은 다른 변수를 바꿀 염려가 x )

이름을 바꿀 변수나 클래스 선택 후 rename

 

alt + s(source) + r(getter/setter) + a(all) + r(generate)

getter/setter 자동 완성

ctrl + shift + f

코드 정리

ctrl + shift + g

특정 메소드나 필드를 참조하고 있는 곳을 찾음

ctrl + t

계층구조

ctrl + n (java 입력)

java project or java class 생성

ctrl + s (반드시 저장 후 실행하기!!!)

저장

ctrl +F11

Console 실행

F11

클래스 실행

alt + shift + 방향키

블록선택

ctrl + k

해당 블럭 다음 단어 찾기

ctrl +shift + k

해당 블럭 이전 단어 찾기

ctrl + shift + F6

파일 간 이동

ctrl + f3/o/마우스커서

클래스, 메소드 상세 검색

ctrl + h

메소드 or 클래스의 호출위치 찾기

(프로젝트 규모가 클 때 유용)

 

(2) Import

- 외부파일 복사하기

1.패키지에 오른쪽 마우스 클릭 > import > general > file System(파일만 가져옴) - 폴더나 파일은 주의할 필요 x

2. general > exising project (프로젝트 자체를 가져옴)

 

** 프로젝트를 import할 때 주의 : 버전이 같아야 error가 나지 않는다. 드라이브도 같은 드라이브에 이클립스가 깔려 있어야 한다.

> 해결책 : 프로젝트 오른쪽 마우스 클릭 > Build Path > configure build path > Libraries > JRE System Library[JavaSE-1.8] 선택 후 Edit > 동일한 개발환경으로 맞추기

 

- import 하는 방법

1.파일하나하나 하는 방법 : General > File System >

2.프로젝트 : General > Existing Projects into Workspace >

3.프로젝트 생성 후 원하는 패키지를 import

 

(3) Export

1. 내보내기 할 프로젝트 선택

2. 마우스 오른쪽 마우스 클릭 후 Export 클릭

3. General > Archive File > Next

4. Browse로 경로 지정

5. To archive file 파일 이름 지정

 

cf) 알마인드 설치, Ovenapp.io 다운로드

oracle.com > downloads > Java (JDK) for Developers > JDK 8 Demos and Samples 다운받기

swing sample > cmd > d: > cd JDK Demo가 깔린 경로 java -jar SwingSet2.jar

 

(4)

- Component에 Event를 발생시키고자 한다면 기능(추상 method) 설정이 필요하다.

- Event Source ? Event를 발생시킬 수 있는 Component

- Source들은 Event Listner에 등록을 해야 하고, Event의 기능은 해당 Listner에 의해서만 호출이 가능하다.

 

** AWT 작업 순서

1. 그림그리기

2. Component 결정 및 객체명

3. Panel 작업

4. Class 생성 (extends Frame)

5. 선언부에 2번에 해당하는 객체생성

6. 생성자에서 배치 작업(~~~~~~~~~~~~~ setVisible(true);)

 

--java.awt.event

Button(누를 때),TextField, List - ActionListner

Choice, Checkbox - ItemListner

Scrollbar - AdjustmentListener(특화)

Button(tab키 등으로 이동) - FocusEvent

 

7. Event Source 결정

8. 7에서 발생하는 XXXListener 구현 (implements XXListener,...) >> 추상 method override(기능구현)

9. 생성자의 후미(setVisible(true);) 아래에 component(Event Source)를 Event Listener에 등록해줘야 함.

es.addXXXListener(Listener의 객체);

 

<19.11.12.java..awt.design에 이은 event 구현>

 

package javaStudy;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.Choice;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

public class ItemTest extends Frame implements ItemListener, ActionListener{

	Panel pN = new Panel();
	Panel pS = new Panel();
	
	CheckboxGroup cg = new CheckboxGroup();
	Checkbox mor = new Checkbox("아침", true, cg);
	Checkbox aft = new Checkbox("점심", false, cg);
	Checkbox eve = new Checkbox("저녁", false, cg);
	Checkbox app = new Checkbox("사과", true);
	Checkbox bana = new Checkbox("바나나");
	Checkbox gra = new Checkbox("포도");
	
	TextArea ta = new TextArea();
	
	Choice ch = new Choice();
	Button exit = new Button("종료");
	
	public ItemTest() {
		super("아이템 테스트!!");
		
		pN.setLayout(new GridLayout(2, 3, 10, 10));
		pN.add(mor);
		pN.add(aft);
		pN.add(eve);
		pN.add(app);
		pN.add(bana);
		pN.add(gra);
		
		pS.setLayout(new BorderLayout(10, 0));
		ch.add("아침");
		ch.add("점심");
		ch.add("저녁");
		pS.add(ch, "Center");
		pS.add(exit, "East");
		
		add(pN, "North");
		add(ta, "Center");
		add(pS, "South");
		
		setBounds(300, 200, 300, 400);
		setVisible(true);
		
		//이벤트감시자 붙이기
		exit.addActionListener(this);
		
		mor.addItemListener(this);
		aft.addItemListener(this);
		eve.addItemListener(this);
		app.addItemListener(this);
		bana.addItemListener(this);
		gra.addItemListener(this);
		ch.addItemListener(this);
	}
	
	public static void main(String[] args) {
		new ItemTest();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		System.exit(0);
		
	}

	@Override
	public void itemStateChanged(ItemEvent e) {
		Object ob = e.getSource();
		if (ob == ch) {
			String tmp = ch.getSelectedItem();
			if(tmp.equals("아침")) {
				mor.setState(true);
			} else if (tmp.equals("점심")) {
				aft.setState(true);
			} else {
				eve.setState(true);
			}
		}
		//내가 선택했던 checkbox 얻어옴
		Checkbox cb = cg.getSelectedCheckbox(); 
		String str = cb.getLabel();
//		System.out.println(str);
		ta.setText("===" + str + "===\n");
		ta.append("1. 사과 : " + eat(app.getState()) + "\n");
		ta.append("2. 바나나 : "+ eat(bana.getState()) +"\n");
		ta.append("3. 포도 : "+ eat(gra.getState()));
		ch.select(str);
	}
	
	private String eat(boolean flag) {
		return flag ? "먹었다." : "안 먹었다.";
	}

}

 


 

package javaStudy;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.List;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ListTest extends Frame implements ActionListener{

	Panel pW = new Panel();
	Panel pC = new Panel();
	Panel pE = new Panel();
	//다중선택 가능
	List listR = new List(0,true);
	List listL = new List(0,true);
	
	TextField tfR = new TextField();
	TextField tfL = new TextField();
	
	Button btnR = new Button("▷");
	Button btnRall = new Button("▶");
	Button btnL = new Button("◁");
	Button btnLall = new Button("◀");
	
	public ListTest() {
		super("리스트 테스트!!");
		//listL,tfL사이에 간격 10주기
		pW.setLayout(new BorderLayout(0, 10));
		pW.add(listL, "Center");
		pW.add(tfL, "South");
		
		pE.setLayout(new BorderLayout(0, 10));
		pE.add(listR, "Center");
		pE.add(tfR, "South");
		
		pC.setLayout(new GridLayout(6, 1, 0, 20));
		pC.add(new Label());
		pC.add(btnR);
		pC.add(btnRall);
		pC.add(btnL);
		pC.add(btnLall);
		
		setLayout(new GridLayout(1, 3, 10, 0));
		add(pW);
		add(pC);
		add(pE);
		
		setBounds(300, 200, 300, 400);
		setVisible(true);
		
		tfL.addActionListener(this);
		tfR.addActionListener(this);
		btnL.addActionListener(this);
		btnLall.addActionListener(this);
		btnR.addActionListener(this);
		btnRall.addActionListener(this);
	}
	
	public static void main(String[] args) {
		new ListTest();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		Object ob = e.getSource();
		if (ob == tfL) {
//			1. tfL의 문자열 얻기
//			2. tfL 지우기
//			3. 1의 값 검사
//			4. 1의 값을 listL 추가
			//trim으로 space등으로 앞,뒤 공백입력 되는 것 방지
			String tmp = tfL.getText().trim();
			tfL.setText("");
			if(tmp.isEmpty())
				return;
			listL.add(tmp);	
		}else if(ob == tfR) {
			String tmp = tfR.getText().trim();
			tfR.setText("");
			if(tmp.isEmpty())
				return;
			listR.add(tmp);	
		}else if(ob == btnL) {
			String[] tmp = listR.getSelectedItems();
			if(tmp == null)
				return;
			int len = tmp.length;
			for(int i=0;i<len;i++) {
				listL.add(tmp[i]);
			}			
			for(int i=len-1;i>=0;i--) {
				listR.remove(tmp[i]);
			}
					
		}else if(ob==btnLall) {
			String tmp[] = listR.getItems();
			int len = tmp.length;
			for(int i=0;i<len;i++) {
				listL.add(tmp[i]);
			}
			//removeAll()-이 method를 사용해도 되지만, util에는 x
			for(int i=len-1;i>=0;i--) {
				listR.remove(i);
			}
			
		}else if(ob==btnR) {
//			1. listL에서 선택한 문자열 얻기
//			2. 1의 값 검사 (항상 데이터 얻어오면 유효성 검사하기)
//			3. 1의 값을 listR에 추가
//			4. listL에서 삭제
			String[] tmp = listL.getSelectedItems();
			if(tmp == null)
				return;
			int len = tmp.length;
			for(int i=0;i<len;i++) {
				listR.add(tmp[i]);
			}			
			for(int i=len-1;i>=0;i--) {
				listL.remove(tmp[i]);
			}
		}else if(ob==btnRall) {
//			1. listL의 모든 문자열 얻기
//			2. 1의 값을 listR에 추가
//			3. listL에서 모든 문자열 삭제
			String tmp[] = listL.getItems();
			int len = tmp.length;
			for(int i=0;i<len;i++) {
				listR.add(tmp[i]);
			}
			for(int i=len-1;i>=0;i--) {
				listL.remove(i);
			}
		}
	}
}

 


 

package javaStudy;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Color;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.Scrollbar;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;

public class ColorChooser extends Frame implements AdjustmentListener{
	
	Panel p1 = new Panel();
	Panel p11 = new Panel();
	Panel p12 = new Panel();
	Panel p13 = new Panel();
	Panel p2 = new Panel();
	Panel p21 = new Panel();
	//Label.CENTER - 글자 가운데 정렬
	Label lR = new Label("빨강",Label.CENTER);
	Label lG = new Label("초록", Label.CENTER);
	Label lB = new Label("파랑", Label.CENTER);
	
	Scrollbar sbR = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 265);
	Scrollbar sbG = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 265);
	Scrollbar sbB = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 265);
	
	Panel colorP = new Panel();
	Label colorL = new Label();
	Button change = new Button("변경");
	
	public ColorChooser() {
		super("색상표!!");
		
		p11.setLayout(new BorderLayout(10, 0));
		lR.setBackground(Color.RED);
		p11.add(lR, "West");
		p11.add(sbR, "Center");
		
		p12.setLayout(new BorderLayout(10, 0));
		lG.setBackground(Color.GREEN);
		p12.add(lG, "West");
		p12.add(sbG, "Center");
		
		p13.setLayout(new BorderLayout(10, 0));
		lB.setBackground(Color.BLUE);
		lB.setForeground(Color.WHITE);
		p13.add(lB, "West");
		p13.add(sbB, "Center");
		
		p1.setLayout(new GridLayout(5, 1, 0, 10));
		p1.add(new Label());
		p1.add(p11);
		p1.add(p12);
		p1.add(p13);
		
		p21.setLayout(new BorderLayout(10, 0));
		p21.add(colorL, "Center");
		p21.add(change, "East");
		
		p2.setLayout(new BorderLayout(0, 10));
		p2.add(p21, "South");
		p2.add(colorP, "Center");
		
		setLayout(new GridLayout(1, 2, 10, 0));
		add(p1);
		add(p2);
		
		setBounds(300, 200, 500, 300);
		setVisible(true);
		
		sbR.addAdjustmentListener(this);
		sbG.addAdjustmentListener(this);
		sbB.addAdjustmentListener(this);
		changeColor();
	}

	public static void main(String[] args) {
		new ColorChooser();
	}

	@Override
	public void adjustmentValueChanged(AdjustmentEvent e) {
		changeColor();
	}

	private void changeColor() {
		int r = sbR.getValue();
		int g = sbG.getValue();
		int b = sbB.getValue();
		
		colorP.setBackground(new Color(r,g,b));
		colorL.setText("r = "+ r + "  g = " + g + "  b = " + b);
	}

}

 


 

package javaStudy;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class BaseBall extends Frame implements ActionListener{
	
	//전역변수로 변수 선언하기!!
	int gameCnt;
	int count;
	
	int my[];
	int com[];
	
	Panel p1 = new Panel();
	Panel p2 = new Panel();
	Panel p3 = new Panel();
	
	TextArea ta = new TextArea();
	TextField tf = new TextField();
	Label l = new Label("숫자입력", Label.CENTER);
	
	Button newGame = new Button("새게임");
	Button answer = new Button("정답");
	Button clear = new Button("지우기");
	Button fontColor = new Button("글자색");
	Button exit = new Button("종료");

	public BaseBall() {
		super("숫자 야구게임!!!");
		
		gameCnt = 3;
		my = new int[gameCnt];
		com= new int[gameCnt];
		
		p1.setLayout(new BorderLayout(10, 0));
		p1.add(l, "West");
		tf.setEditable(false);
		p1.add(tf, "Center");
		
		p2.setLayout(new BorderLayout(0, 10));
		ta.setText("새게임 버튼을 눌러 게임을 시작하세요!!!\n ");
		//setEnabled(false) - 아예 클릭도 안되게끔 막아놓음
		ta.setEditable(false);
		ta.setFont(new Font(Font.SANS_SERIF,Font.ITALIC,15));
		p2.add(ta, "Center");
		p2.add(p1, "South");
		
		p3.setLayout(new GridLayout(5, 1, 0, 10));
		p3.add(newGame);
		p3.add(answer);
		p3.add(clear);
		p3.add(fontColor);
		p3.add(exit);
		
		setLayout(new BorderLayout(10, 0));
		add(p2, "Center");
		add(p3, "East");
		
		setBounds(300, 200, 400, 300);
		setVisible(true);
		
		newGame.addActionListener(this);
		answer.addActionListener(this);
		clear.addActionListener(this);
		fontColor.addActionListener(this);
		exit.addActionListener(this);
		tf.addActionListener(this);
	}
		
		private void comNansu() {
			com[0] = (int) (Math.random() * 9) + 1;//1 - 9
			do{
				com[1] = (int) (Math.random() * 10);//0 - 9
			}while(com[0] == com[1]);
			do{
				com[2] = (int) (Math.random() * 10);//0 - 9
			}while(com[0] == com[2] || com[1] == com[2]);
			System.out.println(com[0] + " " + com[1] + " " + com[2]);
		}
		
		@Override
		public void actionPerformed(ActionEvent e) {
			Object ob = e.getSource();
			if(ob == tf) {
				game();
			} else if(ob == newGame) {
				comNansu();
				ta.setText("새로운 게임을 시작합니다.\n");
				tf.setEditable(true);
				
			} else if(ob == answer) {
				String str = "";
				for(int i=0;i<gameCnt;i++)
					str += com[i];
				ta.append("정답은 " + str + "입니다.\n" );
				ta.append("새로운 게임을 시작하세요!!!\n");
				tf.setEditable(false);
				
			} else if(ob == clear) {
				ta.setText("");
			} else if(ob == fontColor) {
				
			} else if(ob == exit) {
				System.exit(0);
			} else if(ob == tf) {
				
			}
	}
	
	private void game() {
//		1. tf의 값을 얻기
//		2. 유효성검사(숫자, 3자리)
//		3. 1의 값을 배열로
//		4. my com 배열의 숫자, 자리수 비교
//		6. 결과 출력
		//trim으로 앞,뒤 공백 꼭 지우기
		String myNum = tf.getText().trim();
		//비워내기 위한 공백만들기
		tf.setText("");
		if(myNum.length() != gameCnt) {
			ta.append(gameCnt + "자리수의 숫자를 입력하세요.\n");
			return;
		}
		//myNum이 숫자인가요?
		if(!isNumber(myNum)) {
			ta.append("숫자만 입력하세요.\n");
			return;
		}
		for(int i=0;i<gameCnt;i++) {
			//String값을 int 배열에 담기 위한 charAt 사용 - index에 해당하는 문자열 출력
			//i = 0,1,2 (48,49,50) 그래서... -48 을 빼 준 것
			my[i] = myNum.charAt(i) - 48;
//			
		}
		
		int strike = 0;
		int ball = 0;
		for(int m=0;m<3;m++) {
			for(int c=0;c<3;c++) {
				if(my[m] == com[c]) {//숫자가 같다면..
					if(m == c)//자리수 같다면...
						strike++;
					else
						ball++;
				}
			}
		}// 숫자비교 for end
		
		if(strike != 3) {
			ta.append(++count + ". " + myNum + "은 " + strike + "스트라이크 " + ball + "볼입니다.\n");
		} else {
			ta.append(++count + ". " + myNum + "은 정답입니다.\n");
			ta.append(count + "번만에 정답!!!!\n");
			ta.append("새로운 게임을 시작하세요!!!\n");
			tf.setEditable(false);
			//정답을 맞추는 순간 초기화
			count = 0;
		}
			
		}

	private boolean isNumber(String myNum) {
			boolean flag = true;
			int len = myNum.length();
			for(int i=0;i<len;i++) {
				//문자열 얻어와서 ascii code값 나옴
				int num = myNum.charAt(i);
				if(num < 48 || num > 57) {
					flag  = false;
					break;
				}
			}
			return flag;
		}

	public static void main(String[] args) {
		new BaseBall();
		
	}
}

 

(1)

import java.awt.*;

public class ItemTest extends Frame{
	Panel pN = new Panel();
	Panel pS = new Panel();
	
	//CheckboxGroup : 단일선택 vs Checkbox : 다중선택
	CheckboxGroup cbg = new CheckboxGroup();
	Checkbox mor = new Checkbox("아침",cbg,true);
	Checkbox aft = new Checkbox("점심",cbg,false);
	Checkbox eve = new Checkbox("저녁",cbg,false);
	Checkbox app = new Checkbox("사과",null,true);
	Checkbox bana = new Checkbox("바나나");
	Checkbox gra = new Checkbox("포도");
	
	TextArea ta = new TextArea();
	
	Choice ch = new Choice();
	Button exit = new Button("종료");
	
	public ItemTest(){
		super("아이템 테스트!!");

		pN.setLayout(new GridLayout(2,3,2,2));
		pN.add(mor);
		pN.add(aft);
		pN.add(eve);
		pN.add(app);
		pN.add(bana);
		pN.add(gra);
		
		pS.setLayout(new BorderLayout(10,0));
		ch.add("아침");
		ch.add("점심");
		ch.add("저녁");
		pS.add(ch,"Center");
		pS.add(exit,"East");

		add(pN,"North");
		add(ta,"Center");
		add(pS,"South");

		setLocation(300,200);
		setSize(300,400);
		setVisible(true);
	}


	public static void main(String[] args) {
		new ItemTest();
	}
}

 

(2)

import java.awt.*;

public class ListTest extends Frame {
	Panel pW = new Panel();
	Panel pC = new Panel();
	Panel pE = new Panel();
	
	List listL = new List();
	TextField tfL = new TextField();
	
	Button btnR = new Button("▷");
	Button btnRall = new Button("▶");
	Button btnL = new Button("◁");
	Button btnLall = new Button("◀");

	List listR = new List();
	TextField tfR = new TextField();

	public ListTest(){
		super("리스트 테스트!!");
		pW.setLayout(new BorderLayout(0,10));
		pW.add(listL,"North");
		pW.add(tfL,"South");

		pC.setLayout(new GridLayout(6,1,0,20));
		pC.add(new Label());
		pC.add(btnR);
		pC.add(btnRall);
		pC.add(btnL);
		pC.add(btnLall);

		pE.setLayout(new BorderLayout(0,10));
		pE.add(listR,"North");
		pE.add(tfR,"South");
		
		setLayout(new GridLayout(1,3,10,0));
		add(pW); 
		add(pC);
		add(pE);

		setLocation(300,200);
		setSize(300,400);
		setVisible(true);
		
	}
	public static void main(String[] args) {
		new ListTest();
	}
}

 

(3)

import java.awt.*;

public class BaseBall extends Frame{
	Panel pWa = new Panel();
	Panel pW = new Panel();
	Panel pE = new Panel();

	TextArea ta = new TextArea();
	Label l = new Label("숫자입력", Label.CENTER);
	TextField tf = new TextField();

	Button newGame = new Button("새게임");
	Button answer = new Button("정답");
	Button clear = new Button("지우기");
	Button fontColor = new Button("글자색");
	Button exit = new Button("종료");

	public BaseBall(){
		super("숫자 야구게임!!!");
		
		pWa.setLayout(new BorderLayout(0,10));
		pWa.add(ta,"Center");
		pWa.add(pW,"South");

		pW.setLayout(new BorderLayout(0,10));
		pW.add(l,"West");
		pW.add(tf,"Center");
			
		pE.setLayout(new GridLayout(5,1,0,10));
		pE.add(newGame);
		pE.add(answer);
		pE.add(clear);
		pE.add(fontColor);
		pE.add(exit);
		
		setLayout(new BorderLayout(10, 0));
		add(pWa,"Center");
		add(pE,"East");
		
		setLocation(300,200);
		setSize(400,300);
		setVisible(true);
	}

	public static void main(String[] args) {
		new BaseBall();
	}
}

 

(4)

import java.awt.*;

public class ColorChooser extends Frame{
	Panel pW = new Panel();
	Panel plR = new Panel();
	Panel plG = new Panel();
	Panel plB = new Panel();
	Panel pS = new Panel();
	Panel pE = new Panel();
	
	Label lR = new Label("빨강", Label.CENTER);
	Label lG = new Label("초록", Label.CENTER);
	Label lB = new Label("파랑", Label.CENTER);
	
	Scrollbar sbR = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 255);
	Scrollbar sbG = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 255);
	Scrollbar sbB = new Scrollbar(Scrollbar.HORIZONTAL, 127, 10, 0, 255);

	Panel colorP = new Panel();
	Label colorL = new Label();
	Button change = new Button("변경");

	public ColorChooser(){
		super("색상표!!");

		plR.setLayout(new BorderLayout(10,0));
		lR.setBackground(Color.RED);
		plR.add(lR,"West");
		plR.add(sbR, "Center");
		
		plG.setLayout(new BorderLayout(10,0));
		lG.setBackground(Color.GREEN);
		plG.add(lG,"West");
		plG.add(sbG, "Center");

		plB.setLayout(new BorderLayout(10,0));
		lB.setBackground(Color.BLUE);
		plB.add(lB,"West");
		plB.add(sbB, "Center");

		pW.setLayout(new GridLayout(5,1,0,10));
		pW.add(new Label());
		pW.add(plR);
		pW.add(plG);
		pW.add(plB);

		pS.setLayout(new BorderLayout(10,0));
		pS.add(colorL,"Center");
		pS.add(change,"East");

		pE.setLayout(new BorderLayout(0,10));
		pE.add(pS,"South");
		pE.add(colorP,"Center");

		setLayout(new GridLayout(1,2,10,0));
		add(pW);
		add(pE);

		setLocation(300,200);
		setSize(500,300);
		setVisible(true);
	}

	public static void main(String[] args) {
		new ColorChooser();
	}
}

 

 

(5)

package com.kitri.awt.design;

import java.awt.*;

public class Calculator extends Frame{
	Panel pN = new Panel();
	Panel pB = new Panel();
	
	Label l = new Label();
	Label oper = new Label();
	String b[] = {"7","8","9","+","4","5","6","-","1","2","3","*","0","c","=","/"};
	Button[] bt = new Button[b.length];
	Button exit = new Button("종료");
	

	public Calculator (){
		super("Calculator");
		
		pN.setLayout(new BorderLayout(10,0));
		pN.add(l,"Center");
		pN.add(oper,"East");
		
		oper.setBackground(Color.BLACK);

		pB.setLayout(new GridLayout(4,4,2,2));
		for (int i=0;i<b.length;i++ ){
			//pB.add(new Button(bt[i]));
			bt[i] = new Button(b[i]);
			pB.add(bt[i]);
			//bt[i].setBackground(new Color(255,0,0));
			//그라데이션 효과
			bt[i].setBackground(new Color(255,100+(8*i),50+(8*i)));
		}
		
		add(pN,"North");
		add(pB,"Center");
		add(exit,"South");

		setLocation(300,200);
		setSize(300,400);
		setVisible(true);
	}

	public static void main(String[] args) {
		new Calculator();
		
	}
}

 

cf ) Calendar.HOUR_OF_DAY : 24시간

Calendar.HOUR : 12시간

 

(1)

따로따로 연,원,일을 구하고자 할 때 : Calendar

한꺼번에 연,원,일을 구하고자 할 때 :

 

import java.util.Date;
import java.text.Format;
import java.text.SimpleDateFormat;

public class DateFormatTest {
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println(date); //자동 toString()
		
		//SimpleDateFormat(String pattern)
		Format f = new SimpleDateFormat("yy.MM.dd HH:mm:ss");
		String today = f.format(date);
		System.out.println(today);

	}
}
---------- run ----------
Mon Nov 11 16:44:43 KST 2019
19.11.11 16:44:43

(2)

import java.text.*;

public class NumberFormatTest {
	public static void main(String[] args) {
		double d = 182635423.23789;
		
		//1.
		NumberFormat numberFormat = NumberFormat.getInstance();
		System.out.println(numberFormat.format(d));//182,635,423.23

		//2. 0 : 빈자리에 0 출력 vs # : 빈칸으로 처리 
		//Format f = new DecimalFormat("000,000,000,000.00");//Decimal : 소수점
		Format f = new DecimalFormat("###,###,###,###.##");
		String num = f.format(d);
		System.out.println(num);//182,635,423.23
	}
}
---------- run ----------
182,635,423.238
182,635,423.24

(3)

import java.util.Random;

public class RandomTest {
	public static void main(String[] args) {
		int num1 = (int) (Math.random()*45)+1;
		System.out.println("num1 : " + num1);

		//nextBoolean()
		Random ra = new Random();
		boolean flag = ra.nextBoolean();
		System.out.println("flag : " + flag);

		//nextDouble()
		double d = ra.nextDouble();
		System.out.println("d : " + d);

		//nextInt() - 음수도 나온다
		int num2 = ra.nextInt();
		System.out.println("num2 : " + num2);

		//nextInt(int bound) : 0부터 ~ - 로또 랜덤 변수
		int num3 = ra.nextInt(45) + 1;
		System.out.println("num3 : " + num3);	
	}
}

(4) StringTokenizer : 문자열을 의미가 가진 최소단위로 쪼개는 클래스

import java.util.StringTokenizer;

public class StringTokenizerTest {
	public static void main(String[] args) {
		String str = "hello java !!!";
		
		//StringTokenizer(String str) : 공백기준
		StringTokenizer st = new StringTokenizer(str);
		System.out.println("토큰수 : " + st.countTokens());

		//StringTokenizer(String str, String delim) : delim 기준,delim의 문자는 제외
		st = new StringTokenizer(str,"j");
		//countTokens() - for문
		System.out.println("토큰수 : " + st.countTokens());

		//	hasMoreTokens() - while문
		while (st.hasMoreTokens()){
			System.out.println(st.nextToken());
		}

		String msg = "TO||홍길동||안녕하세요.";
		StringTokenizer st2 = new StringTokenizer(msg,"||");
		String protocol = st2.nextToken();
		String to = st2.nextToken();
		String message = st2.nextToken();
		System.out.println("기능 : " + protocol);
		System.out.println("대상자 : " + to);
		System.out.println("메세지 : " + message);
	}
}
---------- run ----------
토큰수 : 3
토큰수 : 2
hello 
ava !!!
기능 : TO
대상자 : 홍길동
메세지 : 안녕하세요.

 

(5) AWT(Abstract Window Toolkit)

TUI(Text User Interface) ---------------------------> GUI(Graphical User Interface )

component란?

 

+ Container

- Window - Frame

- Dialog - FileDialog

- Panel - Applet (browser)

 

* window 단독으로 보여지는 x창 같은 것

* panel은 단독으로 보여지지 x,

window 안에 들어가야 한다.

 

Dialog : ~을 하시겠습니까?

Filedialog : ~을 저장 or 새이름으로 저장

Button

CheckBox

Choice

Label

List

Scrollbar

TextComponent - TextField : 한줄만 입력

- TextArea : 여러줄 입력

 

 

-java.awt.Component (Button,Label,List... 상속)

버튼 배경 색 : setBackground(Color c)

버튼 글자 색 : setForeground(Color c)

버튼 글꼴 : setFont(Font f)

 

프레임 안에 프레임 붙일 수 없다!!!!

패널 안에 패널을 붙일 수 있다.

프레임 안에 패널을 붙일 수 있다.

 

(6) setLayout(LayoutManager mgr) : component 배치 관리자 (3개만 알기)

- LayoutManager

1. FlowLayout

a.위->아, 왼->오.. (크기에 따라서 중앙을 기준으로 재정렬)

b.panel의 default layout (패널에 setLayout을 하지 않으면 default)

c. 붙이는 순서 상관 o

(*component의 크기는 default 크기)

사용)

container.setLayout(new FlowLayout());

 

2. BorderLayout

a. add(동(EAST) or 서(WEST) or 남(SOUTH) or 북(NORTH) or 중앙(CENTER)) 5개 영역

ex) component.add(b1,"North");

b. Frame의 default layout (프레임에 setLayout을 하지 않으면 default)

c. 순서 상관 x

(*center가 가장 면적이 크다. - 하나의 component가 다른 component보다 크게 만들고 싶을 때 사용)

사용)

add(pN,"North");

3. GridLayout

a. 위->아, 왼->오

b.붙이는 순서 상관 o

(*모든 component의 크기를 같게 만들고 싶을 때 사용)

사용)

container.setLayout(new GridLayout(4,3,5,5)) : 4*3, 수평간격 5, 수직간격 5

 

1

2

3

4

5

빈칸

 

 

4. CardLayout -- event 수업할 때 ..

a. 점점 쌓아 놓고 event 처리를 할 때 해당 Component를 보여준다.

 

- AWT 작업순서

① 그림그리기

② 각 component의 객체명을 지정

③ panel 작업 (Layout 결정)

-------------------------------------초반을 넘어가면 머리속으로..

④ Frame 상속받음

⑤ 선언부(변수 선언 하는 곳)에 필요 객체 생성 or 생성자

⑥ 생성자에서 배치 (작은 것에서 큰 것 순으로)

 

ex) 해당 창 띄워보기

import java.awt.*;

public class AwtTest extends Frame {
	//객체 생성
	Panel pN = new Panel();
	Panel pS = new Panel();

	Label l = new Label("입력"); 
	TextField tf = new TextField();
	Button send = new Button("전송");

	TextArea ta = new TextArea();

	Button con = new Button("계속");
	Button exit = new Button("종료");

	//생성자 안에서 배치작업
	public AwtTest(){
		super("Awt Test!!!");
		//setTitle("Awt Test!!!");
		//LayoutManager lm = new BorderLaydout();
		pN.setLayout(new BorderLayout()); //레이아웃지정
		//l.setText("입력"); //라벨 - 생성자에서 처음부터 입력하기
		l.setBackground(Color.MAGENTA);
		l.setForeground(new Color(200,200,100));
		pN.add(l,"West");
		pN.add(tf,"Center");
		//send.setLabel("전송");//버튼 - 생성자에서 처음부터 입력하기
		pN.add(send, "East");
		
        //GridLayout(int rows, int cols, int hgap, int vgap)
		pS.setLayout(new GridLayout(1, 2, 10, 0));
		pS.add(con);
		pS.add(exit);
		
		add(pN,"North"); //frame의 default BorderLayout
		add(ta,"Center");
		add(pS,"South");

		setLocation(300,200);
		setSize(300,400);
		setVisible(true);
	}

	public static void main(String[] args){
		//익명 객체 생성 (위에 메소드만 호출 하려고 하니까)
		new AwtTest();
	}
}

 

(1) Regular Expression - 특정한 규칙을 가진 문자열의 집합을 표현하기 위해 쓰이는 것

(어떤 텍스트 내에서 특정한 형태나 규칙을 가진 문자열을 찾기 위해 그 형태나 규칙을 나타내는 패턴을 정의)

 

Q. 언제 사용?

> 텍스트 처리 작업에 유용

> 데이터 검증 (주민번호, 휴대폰 번호 등)에 사용

^

문자열 시작

$

문자열 종료

.

임의의 문자 [단 ‘'는 넣을 수 없습니다.]

*

앞 문자가 0개 이상의 개수가 존재할 수 있습니다.

+

앞 문자가 1개 이상의 개수가 존재할 수 있습니다.

?

앞 문자가 없거나 하나 있을 수 있습니다.

[]

문자의 집합이나 범위를 표현합니다. -기호를 통해 범위를 나타낼 수 있습니다. ^가 존재하면 not을 나타냅니다.

{}

횟수 또는 범위를 나타냅니다.

()

괄호안의 문자를 하나의 문자로 인식합니다.

|

패턴을 OR 연산을 수행할 때 사용합니다.

\s

공백 문자

\S

공백 문자가 아닌 나머지 문자

\w

알파벳이나 문자

\W

알파벳이나 숫자를 제외한 문자

\d

[0-9] 숫자

\D

숫자를 제외한 모든 문자

(?i)

대소문자를 구분하지 않습니다.

 

(2) String, StringBuffer, StringBuilder

<String의 문제점>

메모리를 과소비한다. 처음 데이터에 변화가 생기면 기존 메모리 공간을 그대로 두고, 새로운 데이터를 새로운 메모리에 할당한다. 속도가 느려짐....

<String의 대안으로 StringBuffer, StringBuilder가 등장>

 

Q. 공통점?

모두 다 String 문자열을 저장하고 관리하는 클래스

Q. 차이점?

ⓐ String은 불변

ⓑ StringBuffer,StringBuilder은 가변 - 자기 자신을 리턴하여 계속해서 자신의 메소드를 호출

ⓒ StringBuffer, StringBuilder는 new 연산자로 객체 생성을 해야 한다.

 

StringBuilder : 동기화x, ,문자열 조작 속도가 빠르다.

VS

StringBuffer : string을 임시로 저장하는 공간, 동기화o, 쓰레드(다중작업)에서 안전, 속도가 느리다.

------------------------------------------------------------------------------

String 클래스 : 문자열 연산이 적고 조회가 많을 때 멀티쓰레드 환경에서 사용

VS

StringBuffer : 문자열 연산이 많을 때 or 멀티쓰레드환경에서 사용

VS

StringBuilder : 싱글쓰레드 or 쓰레드를 신경쓰지 않아도 되는 환경에서 사용

 

* 문자열과 문자열을 더하게 되면 내부적으로는 스트링버퍼가 매번 실행된다.

(java에서 많은 new를 만드는 것은 속도를 느리게 하는 원인 !!! )

또한, 문자열을 반복문에서 더하는 것은 비효율적인 코드이기 때문에 다음과 같이 하는 것이 효율적!!

public class StringBufferExam {
	public static void main(String[] args) {
		String str1 = "hello world";
        String str2 = str1.substring(5);
		String str3 = str1 + str2; // + 연산 비효율적
		System.out.println(str3);

       // str3 내부적으로 실행되는 코드, 매번 문자열을 append할 때마다 new StringBuffer가 실행 (비효율적)
        String str3 = new StringBuffer().append(str1).append(str2).toString(); 
		
        String str="";
        for(int i=0;i<100;i++){
            str=str+"*";
        }

        //String 변수 생성해서 StringBuffer의 toString()호출해서 String으로 리턴받게끔 (효율)
		//StringBuffer가 한 번만 실행 되니까!!!
		StringBuffer sb = new StringBuffer();
		for (int i = 0;i<100 ;i++ ){
			sb.append("*");
		}
		System.out.println(sb);
        
		String str = sb.toString();
		System.out.print(str);
	}
}

 

---------- run ----------
hello world world
****************************************************************************************************
****************************************************************************************************

 


 

- indexOf(String str) - 스페이스바도 계산

- indexOf(String str, int fromIndex) - ~번째 이후에 있는 문자열 출력

- isEmpty() - 문자열이 비어있는지 (is는 boolean값을 리턴)

 

public class StringTest5 {
	public static void main(String[] args) {
		//indexOf(String str) - 스페이스바도 계산
		String str = "hallo java !!!"; 
		System.out.println("1.str에서 o는 " + str.indexOf("o") + "번째 있습니다.");
		System.out.println("2.str에서 o는 " + str.indexOf('o') + "번째 있습니다."); //문자는 ascii code값이 있기 때문에 ok 
		System.out.println("3.str에서 java는 " + str.indexOf("java") + "번째 있습니다."); 
		System.out.println("4.str에서 a는 " + str.indexOf("a") + "번째 있습니다."); 
		System.out.println("5.str에서 a는 " + str.lastIndexOf("a") + "번째 있습니다."); //마지막 a 위치 출력
		
		//indexOf(String str, int fromIndex) - ~번째 이후에 있는 문자열 출력
		System.out.println("6.str에서 4번째 이후에 있는 a는 " + str.indexOf("a",4) + "번째 있습니다."); 

		//isEmpty() - 문자열이 비어있는지 (is는 boolean값을 리턴)
		if(str.isEmpty())
			System.out.println("7.str은 빈문자열입니다."); //x

		str = new String(); //or str = "";

		if(str.isEmpty())
			System.out.println("8.변경후 str은 빈문자열입니다.");

		//String numStr = "123";
		//String numStr = "1a3";
		//String numStr = "";
		String numStr = null;

		boolean flag = false;
		if (numStr != null && !numStr.isEmpty()){
			flag = true;
			int len = numStr.length(); //이렇게 len으로 변수 잡아주는 것이 시간을 줄일 수 있다!!
			for(int i=0;i<len;i++) {
				int ascii = numStr.charAt(i);
				if(ascii < 48 || ascii > 57) { //48은 0, 57은 9 - 음수거나 9보다 크다면 ?
					flag = false;
					break;
			}
		}
	}
	if (flag){
		System.out.println("9." + numStr + "은 숫자입니다.");
	} else {
			System.out.println("10." + numStr + "은 숫자가 아닙니다.");
		}
		//123은 숫자입니다.
		//1a3은 숫자가 아닙니다.
	}
}
---------- run ----------
1.str에서 o는 4번째 있습니다.
2.str에서 o는 4번째 있습니다.
3.str에서 java는 6번째 있습니다.
4.str에서 a는 1번째 있습니다.
5.str에서 a는 9번째 있습니다.
6.str에서 4번째 이후에 있는 a는 7번째 있습니다.
8.변경후 str은 빈문자열입니다.
10.null은 숫자가 아닙니다.

 

- replace(char oldChar, char newChar) - oldChar를 newChar로 문자를 바꿔라

- replaceAll(String regex, String replacement) - regax:정규표현식, 특정문자를 지정해서 모두(oldChar까지) 바꿔라

- split(String regex) = StringTokenizer : split과 비슷하지만, 더 많이 쓴다!!!

 

public class StringTest6 {
	public static void main(String[] args) {
		//replace(char oldChar, char newChar) - oldChar를 newChar로 문자를 바꿔라
		String str = "hallo jaba!!!";
		String str2 = str.replace('b','v');
		System.out.println("1.str2 : " + str2);
		String str3 = str2.replace("hallo","hello");
		System.out.println("2.str3 : " + str3);
		
		//replaceAll(String regex, String replacement) - regax:정규표현식, 특정문자를 지정해서 모두(oldChar까지) 바꿔라
		String str4 = str2.replaceAll("hallo","hello");
		System.out.println("3.str4 : " + str4);

		System.out.println("-----------------------------");

		//split(String regex) = StringTokenizer : split과 비슷하지만, 더 많이 쓴다!!!
		String s[] = str4.split(" "); //스페이스바를 기준으로 잘라라
		for (String msg : s){ //배열의 길이만큼 for문
			System.out.println("4."+msg);
		}
	}
}
---------- run ----------
1.str2 : hallo java!!!
2.str3 : hello java!!!
3.str4 : hello java!!!
-----------------------------
4.hello
4.java!!!

 

- subSequence(int start, int end) : 해당 문자열을 자르고 싶다면,endIndex 전까지

- substring(int beginIndex, int endIndex) -- ~번째 까지[index] 문자열 자르기, 문자열로 바꿀 필요가 없다.

자체가 문자열 vs CharSequence -> string 문자열이라고 생각하기

- substring(int beginIndex) - 시작지점부터 끝까지 모두 출력

- trim() - 공백제거 : 문자와 문자사이는 x, 앞 뒤의 공백만 제거 (로그인시 주로 사용)

 

public class StringTest7 {
	public static void main(String[] args) {
		String str = "hello java!!!";
		
		//subSequence(int start, int end)
		CharSequence cs = str.subSequence(6,10); //해당 문자열을 자르고 싶다면,endIndex 전까지
		String msg = cs.toString(); //toString 자동 호출
		System.out.println("1."+msg); //인터페이스는 화면에 출력x, 그래서 toString()이라는 메소드 호출해야 함
		
		//뽑아낸 문자열에서 a는 몇 번째?
		int idx = msg.indexOf('a'); 
		System.out.println("2.뽑아낸 문자열에서 a는 " + idx + "번째 입니다.");

		//substring(int beginIndex, int endIndex) -- ~번째 까지[index] 문자열 자르기, 문자열로 바꿀 필요가 없다. 자체가 문자열 vs CharSequence 
		String substr1 = str.substring(6,10); //endIndex 앞까지 반영!!
		System.out.println("3."+substr1); 
		idx = substr1.indexOf('a');
		System.out.println("4.뽑아낸 문자열에서 a는 " + idx + "번째 입니다.");

		//substring(int beginIndex) - 시작지점부터 끝까지 모두 출력
		substr1 = str.substring(6);
		System.out.println("5."+substr1); 

		//trim() - 공백제거 : 문자와 문자사이는 x, 앞 뒤의 공백만 제거
		String s = "j   ava";
		System.out.println("6.s의 길이 : " + s.length());
		System.out.println("7.s의 공백을 제거한 후 길이 : " + s.trim().length());
	}
}
---------- run ----------
1.java
2.뽑아낸 문자열에서 a는 1번째 입니다.
3.java
4.뽑아낸 문자열에서 a는 1번째 입니다.
5.java!!!
6.s의 길이 : 7
7.s의 공백을 제거한 후 길이 : 7

 

- StringBuffer - 문자열 조작 class(가변 - 원본이 바뀜) VS String - 문자열 불변

- StringBuffer(), capacity() - 만들 때부터 16의 용량이 고정

- StringBuffer(int capacity)- 만들 때부터 용량 조절 가능

- StringBuffer(String str) - 주로 사용(만들 때부터 문자를 입력하고 추가 용량)

- append(String str) - 문자열 추가

- delete(int start, int end) - 범위를 지운다

- deleteCharAt(int index) - 문자 하나만 지우기

- insert(int offset, boolean b) - 중간에 끼워넣기

- replace(int start, int end, String str)

- reverse() - 한번에 문자열 뒤집기

- setCharAt(int index, char ch) - 인덱스에 있는 문자 한개만 바꾸기

- setLength(int newLength) - 글자수를 줄이기

 

public class StringBufferTest1 {
	public static void main(String[] args) {
		//StringBuffer - 문자열 조작 class(가변 - 원본이 바뀜) VS String - 문자열 불변
		
		//StringBuffer(),capacity() - 만들 때부터 16의 용량이 고정
		StringBuffer sb1 = new StringBuffer(); 
		System.out.println("1.sb1의 초기 크기 : " + sb1.capacity());

		//StringBuffer(int capacity) - 만들 때부터 용량 조절 가능
		StringBuffer sb2 = new StringBuffer(20);
		System.out.println("2.sb2의 초기 크기 : " + sb2.capacity());

		//StringBuffer(String str) - 주로 사용 (만들 때부터 문자를 입력하고 추가 용량)
		StringBuffer sb3 = new StringBuffer("hello ");  
		System.out.println("3.sb3의 초기 크기 : " + sb3.capacity()); //용량, 6+16 = 22
		System.out.println("4.sb3의 문자 수 : " + sb3.length()); // 문자의 길이
		
		//append(String str) - 뒤에 16칸이 생성되지 않고, 남은 16칸에서 줄어든다.
		sb3.append("java");
		System.out.println("5.sb3 : " + sb3); // or System.out.println("sb3 : " + sb3.append("java"));
		System.out.println("6. 문자열 추가 후 크기 : " + sb3.capacity()); //크기는 같지만, 남은 용량은 12
		System.out.println("7. 문자열 추가 후 문자수 : " + sb3.length());
		
		sb3.append("!!!!!!!!!!!!");
		System.out.println("8.문자열 추가 후 크기 : " + sb3.capacity()); //크기 = 문자수, 남은 용량 0
		System.out.println("9.문자열 추가 후 문자수 : " + sb3.length());
		
		//Buffer는 문자열이 작업 공간을 초과하면 자동으로 공간 2배로 늘려준다.
		sb3.append("!!!!!!!!!!!!@");
		System.out.println("10.문자열 추가 후 크기 : " + sb3.capacity());
		System.out.println("11.문자열 추가 후 문자수 : " + sb3.length());

        //메소드체이닝 - 자신의 메소드를 호출하여 자기 자신의 값을 바꿔나감
        StringBuffer str2 = new StringBuffer().append("hello").append(" ").append("world");
        //위에랑 같은코드 toString()의 return 변수를 잡아준 것
        String str = new StringBuffer().append("hello").append(" ").append("world").toString(); 
		
        //delete(int start, int end) - 범위를 지운다
		sb3.append("!!@@@!!!!!@");
		System.out.println("12.문자열 추가 후 크기 : " + sb3.capacity());
		System.out.println("13.문자열 추가 후 문자수 : " + sb3.length());
		System.out.println("14.sb3 : " + sb3);
		System.out.println("15.sb3 : " + sb3.delete(12,15));
		System.out.println("16.sb3 : " + sb3); //원본이 바뀐다!!!

		//deleteCharAt(int index) - 문자 하나만 지우기
		System.out.println("17.sb3 : " + sb3.deleteCharAt(17));

		//insert(int offset, boolean b) - 중간에 끼워넣기
		System.out.println("18.sb3 : " + sb3.insert(6,"good "));

		//replace(int start, int end, String str) 
		System.out.println("19.sb3 : " + sb3.replace(6,10,"좋은"));

		//reverse() - 한번에 문자열 뒤집기

		//setCharAt(int index, char ch) - 인덱스에 있는 문자 한개만 바꾸기

		//setLength(int newLength) - 글자수를 줄이기
	}
}
---------- run ----------
1.sb1의 초기 크기 : 16
2.sb2의 초기 크기 : 20
3.sb3의 초기 크기 : 22
4.sb3의 문자 수 : 6
5.sb3 : hello java
6. 문자열 추가 후 크기 : 22
7. 문자열 추가 후 문자수 : 10
8.문자열 추가 후 크기 : 22
9.문자열 추가 후 문자수 : 22
10.문자열 추가 후 크기 : 46 (2배로 늘어남)
11.문자열 추가 후 문자수 : 35
12.문자열 추가 후 크기 : 46
13.문자열 추가 후 문자수 : 46
14.sb3 : hello java!!!!!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
15.sb3 : hello java!!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
16.sb3 : hello java!!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
17.sb3 : hello java!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
18.sb3 : hello good java!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
19.sb3 : hello 좋은 java!!!!!!!!!!!!!!!!!!!!@!!@@@!!!!!@
//문자열을 더할때(다중작업)는 builder 쓰는 것이 가장 효율적

public class StringVSBuffer {
	public static void main(String[] args) {
		long st = System.nanoTime();
		String str = "number : ";
		for (int i=1;i<1001 ;i++ ){
			str += i + "";
		}
		System.out.println("String : " + (System.nanoTime() - st)); //for문이 도는 시간
		//System.out.println(str);

		st = System.nanoTime();
		StringBuffer buffer = new StringBuffer("number : ");
		for (int i=1;i<1001 ;i++ ){
			buffer.append(i);
		}
		System.out.println("StringBuffer : " + (System.nanoTime() - st));
		//System.out.println(buffer);

		st = System.nanoTime();
		StringBuilder builder = new StringBuilder("number : ");
		for (int i=1;i<1001 ;i++ ){
			builder.append(i);
		}
		System.out.println("StringBuilder : " + (System.nanoTime() - st));
		//System.out.println(builder);
	}

}
---------- run ----------
String : 9364700
StringBuffer : 254400
StringBuilder : 120500

(3) StringTokenizer : 문자열을 나눌 때 사용

package test07;

import java.util.*;

public class StringEx {

	public static void main(String[] args) {
		String str1 = "오늘 날씨는 춥고, 눈이 많이 옵니다.";
		String str2 = "2019/11/08";
		
		System.out.println(str1);
		System.out.println(str2);
		
		StringTokenizer tokenizer1 = new StringTokenizer(str1);	//default는 띄어쓰기 기준
		StringTokenizer tokenizer2 = new StringTokenizer(str2, "/");
		
		System.out.println("tokenizer1 문자열 수" + tokenizer1.countTokens()); //7
		System.out.println("tokenizer2 문자열 수" + tokenizer2.countTokens()); //3
		
		while(tokenizer1.hasMoreTokens()) {
			System.out.println(tokenizer1.nextToken());
		}
		
		while(tokenizer2.hasMoreTokens()) {
			System.out.println(tokenizer2.nextToken());
		}
	}	
}
오늘 날씨는 춥고, 눈이 많이 옵니다.
2019/11/08
tokenizer1 문자열 수 : 6
tokenizer2 문자열 수 : 3
오늘
날씨는
춥고,
눈이
많이
옵니다.
2019
11
08

 

* java.lang의 Class라는 class는 추후에 데이터베이스에서 중요!!

Math

Process,Runtime 계산기 등을 띄울 때

 

*utf8(조합형 한글) 검색해보기, euc-kr(완성형 한글) 검색해보기, kac5601 ---------------- 웹에서 사용

 

(1) String VS new String()

 

String str1 = "java"; (리터럴 방식)

String str3 = new String("java"); (참조형 데이터 타입 사용 방식)

 

Q. 문자열 리터럴은 메모리에서 어떻게 존재하는가??

> 리터럴 방식은 문자열 저장소(String Pool)인 별도의 공간이 따로 있다!!

> 문자열 리터럴은 변하지 않는다. (상수의 한 종류)

 

* ~At : 항상 인덱스 사용 (0부터 시작)

* ~Of : 문자가 몇 번째 있는지, 리턴타입이 보통 int

 

ⓐ 같은 값인지 비교 (equals / equalsIgnoreCase)

 

object 타입을 비교할 때는 equals 쓰기!!!!

주소값을 비교할 경우가 있을 때는 비교연산자(==) 사용하기!!!!

 

ⓑ 인덱스 위치로 출력

1. indexOf(int ch) : 찾을 문자의 첫번째 위치를 숫자로 반환

2. lastIndexOf(int ch) : 뒤에서부터의 위치를 반환

 

ⓒ boolean값으로 반환

1. contains(CharSequence s) - 문자열 안에 해당 문자열이 포함되어 있는지

2. startsWith(String prefix) - 이걸로 시작하는지

3. endsWith(String suffix) - 이걸로 끝나는지

 

ⓓ 대소문자 변경

1. toUpperCase(), toLowerCase() - 대소문자 구분

2. equalsIgnoreCase(String anotherString) - 대소문자 구분 x

 

public class StringTest1 {
	public static void main(String[] args) {
		
		//String(String original)
		String s1 = null;
		String s2 = new String(); //비어있는 문자열, new를 하는 순간 null은 없어진다. null이 아님!!!!
		//String s2 = new String(""); 위에랑 같은 비어있는 문자열이지만, 위에와 같은 것을 만들 필요가 없기 때문에 이렇게 사용하지 x
		
		if (s1 == null){
			System.out.println("s1은 null입니다.");
		}
		if (s2 == null){
			System.out.println("s2은 null입니다.");
		}

		//System.out.println("s1의 길이 :" + s1.length()); //error - NullPointerException 문자열의 길이는 메소드()!!!!!
		System.out.println("s2의 길이 :" + s2.length()); // 0
		
		//String s3 = new String(""); //String의 객체를 생성하는 방식에는 2가지가 있다. new 또는 ""(리터럴방식)
		String str1 = "java";
		String str2 = "java";
		String str3 = new String("java");
		String str4 = new String("java");

		//str2에 문자열을 저장할 때? 같은 문자열이 있는지 str1을 검사하고 문자열이 같다면 str1의 주소값 자체를 str2로 가져와서 같은 문자열이 저장되는 것!!
		if (str1==str2) //기본DT처럼 인식함
			System.out.println("str1와 str2는 주소값이 같다.");//str1와 str2은 주소값이 같다.
		
		if (str1==str3)
			System.out.println("str1와 str3는 주소값이 같다.");//x

		if (str1==str4)
			System.out.println("str1와 str4는 주소값이 같다.");//x

		if (str2==str3)
			System.out.println("str2와 str3는 주소값이 같다.");//x

		if (str2==str4)
			System.out.println("str2와 str4는 주소값이 같다.");//x

		if (str3==str4)
			System.out.println("str3와 str4는 주소값이 같다.");//x

		System.out.println("--------------------------------");

		//eauals는 문자열 자체를 비교한다. 
		if (str1.equals(str2))
			System.out.println("str1와 str2는 문자열이 같다.");//o
		
		if (str1.equals(str3))
			System.out.println("str1와 str3는 문자열이 같다.");//o 

		if (str1.equals(str4))
			System.out.println("str1와 str4는 문자열이 같다.");//o

		if (str2.equals(str3))
			System.out.println("str2와 str3는 문자열이 같다.");//o

		if (str2.equals(str4))
			System.out.println("str2와 str4는 문자열이 같다.");//o

		if (str3.equals(str4))
			System.out.println("str3와 str4는 문자열이 같다.");//o
	}
}
---------- run ----------
s1은 null입니다.
s2의 길이 :0
str1와 str2는 주소값이 같다.
--------------------------------
str1와 str2는 문자열이 같다.
str1와 str3는 문자열이 같다.
str1와 str4는 문자열이 같다.
str2와 str3는 문자열이 같다.
str2와 str4는 문자열이 같다.
str3와 str4는 문자열이 같다.

 

- String(byte[] bytes) - byte형 배열 값들을 문자열로 리턴

- String(byte[] bytes, int offset(index 시작점), int length)

- String(char[] value) - char형 배열의 값들을 문자열로 리턴

- String(char[] value, int offset, int count) -- count는 한글일때는 2byte, 영어일 때는 1byte (주의!!!!)

 

public class StringTest2 {
	public static void main(String[] args) {
		
		//String(byte[] bytes) - byte형 배열 값들을 문자열로 리턴
		byte b[] = {97,98,99,100,101,102,103};
		//byte b[] = {-56,-66,-57,-68,-77,-54}; //한글, 2바이트니까 2개의 숫자가 합해져야 1자
		String s1 = new String(b);
		System.out.println("s1 : " + s1); //s1 : abcdefg

		//String(byte[] bytes, int offset(index 시작점), int length)
		String s2 = new String(b,3,2);
		System.out.println("s2 : " + s2); //de

		//String(char[] value) - char형 배열의 값들을 문자열로 리턴
		char[] c = {'h','e','l','l','o'};
		String s3 = new String(c);
		System.out.println("s3 : " + s3); //hello

		//String(char[] value, int offset, int count) -- count는 한글일때는 2byte, 영어일 때는 1byte (주의!!!!)
		String s4 = new String(c,1,3);
		System.out.println("s4 : " + s4); //ell
	}
}
---------- run ----------
s1 : abcdefg
s2 : de
s3 : hello
s4 : ell

 

- charAt(int index) - 해당 인덱스에 있는 문자열 리턴

- indexOf(int ch) - 첫번째 문자열의 인덱스 위치를 반환

- lastIndexOf(int ch) - 문자열의 끝에서부터 특정 문자 찾기

- concat(String str) - 문자열 합치기

- contains(CharSequence s) - 문자열 안에 해당 문자열이 있는지 없는지

- endsWith(String suffix) - 이걸로 끝나는지

- startsWith(String prefix) - 이걸로 시작하는지

- toUpperCase(), toLowerCase() - 대소문자 구분

- equalsIgnoreCase(String anotherString) - 대소문자 구분 x

 

public class StringTest3 {
	public static void main(String[] args) {
		//charAt(int index) - 해당 인덱스에 있는 문자열 리턴
		String str = "hello java!!!";
		char c = str.charAt(4);
		System.out.println("c : " + c);
		
		//indexOf(int ch) - 첫번째 문자열의 인덱스 위치를 반환
		int i = str.indexOf(c);
		System.out.println("i : " + i);

		//lastIndexOf(int ch) - 문자열의 끝에서부터 특정 문자 찾기
		int i2 = str.lastIndexOf(c);
		System.out.println("i2 : " + i2);

		//concat(String str) - 문자열 합치기
		String s1 = "hello ";
		String s2 = s1.concat("java"); //불변인 String변수를 바꾸고 싶다면 이렇게 대입해주기
		System.out.println(s1.concat("java"));
		System.out.println(s2); 
		System.out.println(s1); //string은 불변이다!!

		//contains(CharSequence s) - 문자열 안에 해당 문자열이 있는지 없는지
		System.out.println(s1.contains("java"));
		System.out.println(s2.contains("java"));

		//endsWith(String suffix) - 이걸로 끝나는지
		System.out.println(str.endsWith("java"));

		//startsWith(String prefix) - 이걸로 시작하는지
		System.out.println(str.startsWith("he"));

		//toUpperCase(), toLowerCase() - 대소문자 구분
		String t1 = "jaVa";
		String t2 = "JAva";
		if (t1.equals(t2))
			System.out.println("같은 문자열이다.");
		System.out.println("t1을 대문자로 " + t1.toUpperCase());
		System.out.println("t2을 소문로 " + t2.toLowerCase());
		if (t1.toUpperCase().equals(t2.toUpperCase()))
			System.out.println("t1과 t2는 대소문자 무시하는 같은 문자열이다.");

		//equalsIgnoreCase(String anotherString) - 대소문자 구분 x
		if (t1.equalsIgnoreCase(t2))
			System.out.println("t1과 t2는 대소문자 무시하는 같은 문자열이다.");
		
		//getBytes(Charset charset) - getBytes(utf-8)
	}
}
---------- run ----------
c : o
i : 4
i2 : 4
hello java
hello java
hello 
false
true
false
true
t1을 대문자로 JAVA
t2을 소문로 java
t1과 t2는 대소문자 무시하는 같은 문자열이다.
t1과 t2는 대소문자 무시하는 같은 문자열이다.

 

- getBytes() - 문자열을 byte 배열로 쪼갤 수 있다.

- toCharArray() - 문자열을 char 배열로 변환 (한글이든 영문이든 상관x)

 

public class StringTest4 {
	public static void main(String[] args) {
		//getBytes() - 문자열을 byte 배열로 쪼갤 수 있다.
		String str = "hello java";
		//String str = "안녕하세요";
		byte b[] = str.getBytes();
		
		for (int i=0;i<b.length ;i++ )
			System.out.print(b[i] + "  ");

		System.out.println();

		//byte를 char로 형변환 해버리면 영문은 상관없지만, 한글 같은 경우는 2byte이기 때문에 인식을 못하는 문제가 발생
		for (int i=0;i<b.length ;i++ )
			System.out.print((char)b[i] + "  ");
		
		System.out.println();

		//향상된 for문 - 단순히 값을 출력하고 싶다면 사용 vs for문 - i값으로 계산 등을 하고자 한다면 향상된 for문이 아니라 이거 사용
		for(byte x : b)
			System.out.print(x + "  ");
		 
		System.out.println();

		//toCharArray() - 문자열을 char 배열로 변환 (한글이든 영문이든 상관x)
		char c[] = str.toCharArray();
		for (int i=0;i<c.length ;i++ )
			System.out.print(c[i] + " ");
	}
}
---------- run ----------
104  101  108  108  111  32  106  97  118  97  
h  e  l  l  o     j  a  v  a  
104  101  108  108  111  32  106  97  118  97  
h e l l o   j a v a 
public class StringReverseTest {
	public static void main(String[] args) {
		String str = "!!! avaJ olleH";
		//String str = "!!! 바자 녕안";  

		//Hello Java !!! (3~4개 방법)
		//reverse한 문자열의 6번째 인덱스 값 : 'J'입니다. (3~4개 중 사용)
		
		//1.
		for (int i = str.length() -1;i>=0 ; i--) //문자열의 길이는 인덱스-1이니까
			System.out.print(str.charAt(i)); //해당 인덱스에 있는 문자열 리턴
		
		System.out.println();
		
		//2.
		String msg = ""; //literal방식의 객체 생성
		for (int i = str.length() -1;i>=0 ; i--)
			msg += str.charAt(i);
		System.out.println(msg);
		System.out.println("reverse한 문자열의 6번째 인덱스 값 : '" + msg.charAt(6) +"' 입니다.");
		
		//3.
		char a[] = str.toCharArray();
		char tmpc[] = new char[a.length];
		int idx = 0;
		
		for (int i = a.length -1;i>=0 ; i--)
			tmpc[idx++] = a[i];
		msg = new String(tmpc);
		System.out.println(msg);
		System.out.println("reverse한 문자열의 6번째 인덱스 값 : '" + msg.charAt(6) +"' 입니다.");

		//4.
		byte b[] = str.getBytes();
		byte tmp[] = new byte[b.length];
		idx = 0;
		for (int i = str.length() -1;i>=0 ; i--)
			tmp[idx++] = b[i];
		msg = new String(tmp);
		System.out.println(msg);
		System.out.println("reverse한 문자열의 6번째 인덱스 값 : '" + msg.charAt(6) +"' 입니다.");
		System.out.println("\n-------------------");
	}
}
---------- run ----------
Hello Java !!!
Hello Java !!!
reverse한 문자열의 6번째 인덱스 값 : 'J' 입니다.
Hello Java !!!
reverse한 문자열의 6번째 인덱스 값 : 'J' 입니다.
Hello Java !!!
reverse한 문자열의 6번째 인덱스 값 : 'J' 입니다.

 

(2) Primitive VS Object DataType

Primitive : 간단한 데이터들 (int, double, boolean, char 등등)

ex) int i = 10;

> 메모리에 값이 바로 들어간다.

Object : 여러 데이터들이 모여 있는 복잡한 데이터들 (String, System, ArrayList 등등)

ex) String s = "ABC";

> 메모리에 값이 바로 들어가지 않고, 따로 "ABC"가 메모리 어딘가에 또 저장이 된다. 메모리에는 "ABC"가 저장된 주소값이 들어간다.

 

 

* java.lang 패키지의 클래스들은 import 하지 않고 사용 가능하다.

 

(1) Java.lang.object에서 가장 많이 사용되는 3가지 (사용할 때 반드시 override해서 사용!!)

 

- toString() : 객체가 가진 값을 문자열로 반환

- hashCode() : 객체의 주소값 호출 --> 자료구조에서 자주 사용

- equals(Object) : 객체의 값이 같은지 비교

 

cf) finalize() : 객체에 대한 참조가 없음을 확인할 때 객체의 가비지 수집기에 의해 호출되어

해당 객체를 메모리에서 꺼냅니다.(C에서의 소멸자와 비슷)

 

 

(2) 비교연산자 : ==

 

기DT == 기DT : 값 비교

참DT == 참DT : 주소값 비교

Object : equals() >> 주소값 비교 (각 클래스에 맞게끔 override해서 사용)

 

public class Car {
	String carName;

	public Car(String carName){
		this.carName = carName;
	}	

	@Override
	public boolean equals(Object obj){
		Car car = (Car) obj; //형변환
		if(carName == car.carName)
			return true;
		else
			return false;			
	}

	@Override
	public String toString() {
		return "차이름 : " + carName;	
	}
}
 package com.mycompany;
 
 public class Car { 
	private String carName;
	private int speed;

	public Car(String carName){
		this.carName = carName;
	}

	public void speedUp(){
		this.speed += 10;
	}

	public String getCarName(){
		return carName;
	}

	public int getSpeed(){
		return speed;
	}
}
import com.mycompany.Car;

public class CarUser {
	public static void main(String[] args) {
		Car car = new Car("K5"); //Car클래스 사용하고자..
		System.out.println("자동차의 이름 : " + car.getCarName());
		car.speedUp();
		System.out.println("자동차의 속도 : " + car.getSpeed());
	}
}
public class ObjectTest {
	public static void main(String[] args) {
		Object ob1 = new Object();
		Object ob2 = new Object();
		System.out.println("ob1 : " + ob1.toString());
		System.out.println("ob2 : " + ob2.toString());
		System.out.println("ob1 hashcode : " + ob1.hashCode());
		System.out.println("ob2 hashcode : " + ob2.hashCode());

		if (ob1==ob2)
		System.out.println("ob1과 ob2는 주소값이 같다.");
		else
			System.out.println("ob1과 ob2는 주소값이 다르다.");

		if (ob1.equals(ob2))
		System.out.println("ob1과 ob2는 같다.");
		else
			System.out.println("ob1과 ob2는 다르다.");

		Car car1 = new Car("쏘나타");
		Car car2 = new Car("쏘나타");

		if (car1.equals(car2))
		System.out.println("car1과 car2는 차이름이 같다.");
		else
			System.out.println("car1과 car2는 차이름이 다르다.");

		System.out.println("car1 " + car1);
		System.out.println("car2 " + car2);
	}
}
---------- run ----------
ob1 : java.lang.Object@15db9742
ob2 : java.lang.Object@6d06d69c
ob1 hashcode : 366712642
ob2 hashcode : 1829164700
ob1과 ob2는 주소값이 다르다.
ob1과 ob2는 다르다.
car1과 car2는 차이름이 같다.
car1 차이름 : 쏘나타
car2 차이름 : 쏘나타

(3) Wrapper Class : 8개의 기본DT를 객체로 변환시킬 때 사용하는 클래스

더보기

Wrapper Class : 기본DT을 object(참조형)화 시킨 class

기본DT 참조DT

boolean Boolean

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

 

기DT >> String으로 변환

int x = 10;

1. String s = x + ""; (int를 문자열로 변환)

2. String s = Integer.toString(x);

3. String s = String.valueOf(x);

 

String >> 기본DT으로 변환 --- 기DT = Wrapper.parseXXX(String); -- 생성자 생성 안하고 클래스

이름으로 바로 사용 가능한 메소드

String s = "10";

int x = Integer.parseInt(s);

 

 

* java 5부터 생김... 점점 자바 버전이 높아질수록 사용자가 편리해진다.

autoboxing : Wrapper 클래스에서만 각 클래스에 대응되는 기본형DT으로 자동 형변환이 가능

unboxing : Wrapper 참조형 DT을 대응되는 기본형DT에 넣을 때 사용

boxing : 기본형 DT를 대응되는 Wrapper 참조형 DT에 넣을 때 사용

 

public class WrapperTest {
	public static void main(String[] args) {
		String s = "true";
		Boolean b = new Boolean(s); 
		System.out.println(b); //true

		//boolean bl = (boolean) s; //error
		boolean bl1 = b.booleanValue(); //String "true"가 boolean으로 바꿈
		if (bl1)
			System.out.println("bl1 boolean으로 바꼈다.");

		boolean bl2 = Boolean.parseBoolean(s); //기본DT을 참조DT으로 바꾸기
		if (bl2)
			System.out.println("bl2 boolean으로 바꼈다.");

		String s2 = "123";
		Integer i = new Integer(s2);
		int x1 = i.intValue();
		System.out.println(x1+100);//223

		int x2 = Integer.parseInt(s2); //String 참조타입인 123을 int 기본 타입으로 변환
		System.out.println(x2+200);//323

		//autoboxing(int와 Integer끼리만 boolean Boolean끼리만 가능)
		int z = 100;
		Integer it = new Integer(100); //Wrapper class
        Integer it1 = 100; //위에 new Integer(100)이랑 같은 코드, 자동으로 new를 생성해준다고 기억

		//unboxing(참조를 기본에다 집어넣을 때는)
		int y = it;
		System.out.println("y == " + y);
		
        //boxing (기본을 참조에다 집어넣을 때는)
		Integer it2 = y;
		System.out.println("it2 == " + it2);


	}
}
---------- run ----------
true
bl1 boolean으로 바꼈다.
bl2 boolean으로 바꼈다.
223
323
y == 100
it2 == 100

 

cf) Edit Plus에서 사용자 도구 > 기본설정 > 사용자도구> run의 동작을 없음 or 캡처로 바꾸기

 

(1) 참조DT을 저장하는 배열의 사용.

a. 선언

형식) 접근제어자 참DT[ ] 배열명; or 접근제어자 참DT 배열명[ ];

ex)

public String name[ ];

public Car car[ ];

private TV tv[ ];

 

b. 생성

형식) 배열명 = new 참DT[크기];

ex)

name = new String[3];

car = new Car[5];

tv = new TV[3];

 

>>>>>> a, b를 동시에..

접근제어자 참DT 배열명[] = new 참DT[크기];

ex)

public String name[ ] = new String[3];

public Car car[ ] = new Car[5];

private TV tv[ ] = new TV[3];

 

**c. 사용 : 주소값이 할당 (객체가 저장되는 것이 X) //

기본데이터 타입 배열은 생성자를 만들 필요가 없었다(바로 사용),

but, 참조형 데이터 타입 배열은 객체를 생성해줘야 함!!!

형식)

배열명[index] = new ClassName();

 

ex)

name[0] = new String();

or

name[0] = "홍길동"; -----> String만 이렇게 가능!!

car[0] = new Car("쏘나타");

tv[0] = new TV();

 

 

>>>>>> a, b, c를 동시에.. (값이 정해져 있을 때 - 주로 String 클래스에서 사용)

ex)

public String name[] = {"a","b","c"};

 

public class Car {
	String carName;
	private int speed;

	public Car(String carName) {
		this.carName = carName;
	}

	public int changeSpeed(int speed){
		this.speed = speed;
		return this.speed; //이게 리턴하는 값만 가지고 사용할 수 있도록 private으로 잡기
	}
}
public class CarArray {
	public static void main(String[] args) {
		Car c1 = new Car("쏘나타"); //자동차를 만든 것
		System.out.println("c1의 이름 : " + c1.carName);

		Car car[] = new Car[3];//배열 생성 - 자동차를 만든 것이 아니라 3칸짜리 공간만 만든 것
		//car[0] = c1; //c1이 주소값이니까 쏘나타 출력
		car[0] = new Car("쏘나타");
		car[1] = new Car("코란도");
		car[2] = new Car("제네시스");
		System.out.println("car[0]의 이름 : " + car[0].carName); //NullPointerException error > 무조건 . 앞에가 null일 때 발생
		System.out.println("car[1]의 이름 : " + car[1].carName);
		System.out.println("car[2]의 이름 : " + car[2].carName);

		System.out.println("---------------------------------");
		//쏘나타, K5, 제네시스, 테슬라, 마이바흐, 롤스로이스...
		String name[] = {"쏘나타", "K5", "제네시스", "테슬라",  "롤스로이스"}; //추가되거나 삭제되더라도 가능한 프로그램 만들기
		
		Car mycar[] = new Car[name.length]; //새로운 빈 공간을 만든다.
		for (int i=0;i<mycar.length ;i++ ){
			mycar[i] = new Car(name[i]); // 차를 하나씩 집어넣기
            System.out.println(mycar[i].carName);
		}
	}
}
---------- run ----------
c1의 이름 : 쏘나타
car[0]의 이름 : 쏘나타
car[1]의 이름 : 코란도
car[2]의 이름 : 제네시스
---------------------------------
쏘나타
K5
제네시스
테슬라
롤스로이스
public class ArrayTest5 {
	public static void main(String[] args) {
		int[] x = new int[5];
		x[0] = 1;
		x[1] = 2;
		x[2] = 4;
		x[3] = 5;
		for (int i=0;i<5 ;i++ ){
			System.out.println(x[i]);
		}
		//실수로 빼먹은 3을 x[2]에 삽입.
		int idx = 2;
		for (int i=x.length-1;i>idx ;i-- ){ //for문 역순, 먼저, x[2], x[3]에 있는 것을 뒤로 미룬 후 대입
			x[i] = x[i-1];

		}
		x[idx] = 3;
		System.out.println("삽입후-------------");
		for (int i=0;i<5 ;i++ ){
			System.out.println(x[i]);
		}
	}
}
---------- run ----------
1
2
4
5
0
삽입후-------------
1
2
3
4
5
import java.io.*;

public class ArrayTest6 {

	private  BufferedReader in;

	public ArrayTest6() { //프로그램이 시작하자마자 실행
		in = new BufferedReader(new InputStreamReader(System.in));
	}

	private  String read() {
		String msg = "";
		try{
			msg = in.readLine();
		}catch (Exception e){
			e.printStackTrace();
		}
		return msg;
	}

	public static void main(String[] args) {
		ArrayTest6 a = new ArrayTest6();
		int c = 2; //입력횟수
		int n = 20;
		int cnt = 0;
		
		int[] x = new int[c];
	
		for (int i=0;i<c;i++ ){
			x[i] = Integer.parseInt(a.read()); //read로 적은 것은 int로 변환 (4,6입력하기)

		}		
			boolean b[] = new boolean[n+1]; //
			for (int i=0;i<c;i++){
				for (int k=x[i];k<n+1 ;k+=x[i] ){//4의배수, 6의배수 자체를 true로 만듦
					b[k] = true;
				}  		
			}
			
			for (int i=0;i<n+1 ;i++ ){
				if (b[i]){
					cnt++;
				}
				
			}
				System.out.println(cnt);//7 (겹치는 12는 한 번만 카운팅)
		}
}
//백준 알고리즘 (배열 - 오르막길)

import java.io.*;
import java.util.*;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(in.readLine());
		String str = in.readLine();
		int x[] = new int[N];
		StringTokenizer st = new StringTokenizer(str);
		for(int i=0;i<N;i++) {
			x[i] = Integer.parseInt(st.nextToken());
		}

		int max = 0;
		int start = x[0];
		int tmp = start;
		int s = 0;
		for(int i=1;i<N;i++) {
			int end = x[i];
			if(tmp < end) {
				tmp = end;
				if(i == N - 1) {
					s = tmp - start;
					if(max < s)
						max = s;
				}
			} else {
				s = tmp - start;
				if(max < s)
					max = s;

				start = tmp = x[i];
			}
		}
		System.out.println(max);
	}
}

// 숫자 야구 게임 (미완성.. 버그 발생)

/*
1. 123은 x스트라이크 x볼입니다.
2. 456은 x스트라이크 x볼입니다.
.
.
.
.
10. 749는 정답입니다.
-- a. 컴이 3자리 난수 발생 -- 로또
-- b. 내가 3자리 숫자 입력 -- 자판기
-- c. a와 b의 숫자를 비교
	c-1. 숫자가 같다면 ? 
		c-1-1. 자리수가 같다면? 스트라이크 // 자리수 비교는 '배열'
		c-1-2. 자리수가 다르다면 ? 볼
	c-2. 숫자가 다르다면 ? 아무런 일도 발생하지 x
-- d. 스트라이크가 3이면 '749는 정답입니다.' >> 게임 종료
				아니라면 456은 x스트라이크 x볼입니다. >> 다음으로 진행
*/

import java.io.*;

public class NumberBaseBall {

	private static BufferedReader in;

	int[] my = new int[3];
	int[] com = new int[3];
    int strikeCount = 0;
	int ballCount = 0;
	int count = 0;

	public NumberBaseBall(){
		in = new BufferedReader(new InputStreamReader(System.in));
	}
	
	private static String read(){
		String msg = "";
		try{
			msg = in.readLine();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return msg;
	}
	
	void comNansu(){
		//난수발생, 배열에 집어넣기
		
		do{	
			com[0] = (int)(Math.random()*9+1);
		}
		while (com[0] == 0); //처음에 0이 나올 수 없으므로, 0이 나오면 반복문으로 올라감
		
		do{
			com[1] = (int) (Math.random()*9+1);
		}
		while (com[0] == com[1]);

		do{
			com[2] = (int) (Math.random()*9+1);
		}
		while (com[0] == com[2] || com[1] == com[2]);
	}
	
	void game(){
		while (true){ //무한루프
		strikeCount = 0; //누적이 아니기 때문에 초기화 필요
		ballCount = 0;
		count ++;
		System.out.print("숫자입력 : ");
		String msg = read(); //숫자를 얻어옴
		System.out.println("받은 값 : " + msg);
		my[0] = Integer.parseInt(msg)/100; // int이기 때문에 백의자리, 십의자리, 일의자리로 구해주지 않으면 123123123으로 출력됨...
		my[1] = Integer.parseInt(msg)%100/10;
		my[2] = Integer.parseInt(msg)%10;
		System.out.println(my[0] +""+ my[1]+""+my[2]);

		/*for (int i=0;i<my.length ;i++ ){
			for (int j=0;j<com.length ;j++ ){

				if (my[i] == com[i] ){ //숫자가 같다면..
					strikeCount++;
					System.out.println("스트라이크");
					continue;
					
				} else if (my[i] == com[j]){
					ballCount++;
					System.out.println("볼");
					break;
				}	
			}	
		}*/
		
		for (int i=0;i<my.length ;i++ ){
			if (my[i] == com[i] ){
					strikeCount++;
					System.out.println("스트라이크");
					continue;
			} else {
				for (int j=0;j<com.length ;j++ ){
					if(my[i] == com[j]){
					ballCount++;
					System.out.println("볼");
					break;
					}
				}
			}
		}
		
		if (strikeCount == 3){
			System.out.println(count+"." +com[0] +""+ com[1]+""+com[2] +"" +"는 정답입니다.");
			break;
		} else {
			System.out.println(count+"." + my[0]+""+my[1]+""+my[2]+"는 " + strikeCount + "스트라이크 " + ballCount +"볼 입니다.");
		} 
		} 
	}

	public static void main(String args[]){
		NumberBaseBall nbb = new NumberBaseBall();
		
		nbb.comNansu();
		System.out.println(nbb.com[0] +""+ nbb.com[1]+""+nbb.com[2]); //int변수이기 때문에 중간에 ""을 주지 않으면, 더하기를 해버림...
		nbb.game();

		/*
		System.out.print("숫자입력 : ");
		String msg = read();
		System.out.println("받은 값 : " + msg);
		nbb.my[0] = Integer.parseInt(msg)/100;
		nbb.my[1] = Integer.parseInt(msg)%100/10;
		nbb.my[2] = Integer.parseInt(msg)%10;
		System.out.println(nbb.my[0] +""+ nbb.my[1]+""+nbb.my[2]);
		*/
		
		//int num = Integer.parseInt(msg); //String문자열을 int 숫자형으로 바꿔주는 메소드
	}
}

// 숫자 야구 게임 (정상 실행)

import java.io.*;

public class NumberBaseBall1 { 

	private static BufferedReader in;

	int my[] = new int[3];
	int com[] = new int[3];

	public NumberBaseBall1() { //프로그램이 시작하자마자 실행
		in = new BufferedReader(new InputStreamReader(System.in));

		comNansu();
	}

	private static String read() {
		String msg = "";
		try{
			msg = in.readLine();
		}catch (Exception e){
			e.printStackTrace();
		}
		return msg;
	}

	private void comNansu() {
		com[0] = (int) (Math.random() * 9) + 1;//1 - 9
		do{
			com[1] = (int) (Math.random() * 10);//0 - 9
		}while(com[0] == com[1]);
		do{
			com[2] = (int) (Math.random() * 10);//0 - 9
		}while(com[0] == com[2] || com[1] == com[2]);
		System.out.println(com[0] + " " + com[1] + " " + com[2]);
	}

	private void game() {
		int count = 0;
		while(true) {
			System.out.print("숫자입력 : ");
			int myNum = Integer.parseInt(read());//573
			my[0] = myNum / 100;//5
			my[1] = myNum % 100 / 10;//7
			my[2] = myNum % 10;//3
			System.out.println(my[0] + " " + my[1] + " " + my[2]);

			int strike = 0;
			int ball = 0;
			for(int m=0;m<3;m++) {
				for(int c=0;c<3;c++) {
					if(my[m] == com[c]) {//숫자가 같다면..
						if(m == c)//자리수 같다면...
							strike++;
						else
							ball++;
					}
				}
			}// 숫자비교 for end

			if(strike != 3) {
				System.out.println(++count + ". " + myNum + "은 " + strike + "스트라이크 " + ball + "볼입니다.");
			} else {
				System.out.println(++count + ". " + myNum + "은 정답입니다.\n" + count + "번만에 정답!!!!");
				System.out.print("0 : 종료, 1 : 새게임 >> ");
				int num = Integer.parseInt(read());
				if(num == 0) {
					break;
				} else {
					System.out.println("새로운 게임을 시작합니다.");
					count = 0; //누적되는 것이 아니라 새롭게 시작해야 하니까 초기화해주기
					comNansu(); //다시 난수 발생
				}
			}
		}
	}


	public static void main(String[] args) {
		NumberBaseBall1 nbb = new NumberBaseBall1();
		nbb.game();
		/*
		System.out.print("숫자입력 : ");
		String msg = read();
		System.out.println("받은 값 : " + (msg + 100));
		int num = Integer.parseInt(msg);
		System.out.println("받은 값 : " + (num + 100));
		*/
	}
}

+ Recent posts