Yoon's Dev

[JavaScript] 자바스크립트 정규표현식 Regexp ② - 날짜 입력 조건 | Yoon's Dev

Yooniron — Tue, 19 Oct 2021 08:00:32 +0900

자바스크립트 정규표현식 Regexp ②

- 날짜 입력 조건

TO Do.

목표: 정규식을 활용하여 날짜 입력 조건으로 입사연월일이

올바른 형식이면 입사 축하 메세지를 띄우는 기능을 만들자

[날짜 입력 조건]

1. 연도4자리, 월이나 일은 1자리이거나 2자리로 한다.

ex) 2018-05-24

1. html 작성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>정규표현식</title>
  <script defer src="./regexp_hw_02.js"></script>
</head>
<body>
  <div class="wrap">
    <label for="date">입사연월일</label>
    <input type="text" name="date" id="date">
    <input type="button" id="commit" value="commit">
  </div>
</body>
</html>
Colored by Color Scripter

cs

2. JavaScript작성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

const date = document.querySelector("#date")
const btn = document.querySelector("#commit")
 
console.log(date)
 
// (^\d{4}) - 숫자 4개 : 연도
//  (0[1-9]|1[0-2]) - '0 다음 1부터 9 사이 값' 또는 '1 다음 0부터 2 사이 값 : 01~12월
//  (0[1-9]|[12][0-9]|3[01])$ - '0 다음 1부터 9 사이' 또는 '1 또는 2 다음 0부터 9 사이' 또는 '3 다음 0 또는 1' : 01~31일
const pattern = /(^\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/
console.log(date.value)
btn.addEventListener('click', function() {
  if (pattern.test(date.value)) {
    alert('입사축하')
  } else {
    alert('다시입력')
    date.value = ''
    date.focus()
  }
})
Colored by Color Scripter

cs

다음과 같이 정규식을 작성하였다

/d{4} ---> 4글자 : 연도

(0[1-9]|1[0-2]) ---> '0 다음 1부터 9 사이 값' | '1 다음 0부터 2 사이 값: 01월~12월

(0[1-9]|[12][0-9]|3[01] ---> '0 다음 1부터 9 사이' | '1 또는 2 다음 0부터 9 사이' | '3 다음 0 또는 1'

---> 01일~31일

3. 실행결과

정규식에 해당될 때

정규식에 해당되지 않을 때

[JavaScript] 자바스크립트 정규표현식 Regexp ① - 아이디 입력 조건 | Yoon's Dev

Yooniron — Mon, 18 Oct 2021 20:16:35 +0900

자바스크립트 정규표현식 Regexp ①

- 아이디 입력 조건

TO Do.

목표: 정규식을 활용하여 아이디 입력 조건을 만들자

[아이디 입력 조건]

1. 입력되는 전체 길이는 5~8자이어야 한다.

2. 아이디는 숫자와 영문자로만 사용 가능하다.

1. html 작성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>정규표현식</title>
  <script defer src="./regexp_hw_01.js"></script>
</head>
<body>
  <div class="wrap">
    <label for="id">아이디</label>
    <input type="text" name="id" id="id">
    <input type="button" id="commit" value="commit">
  </div>
</body>
</html>
Colored by Color Scripter

cs

2. JavaScript작성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

const id = document.querySelector("#id")
const btn = document.querySelector("#commit")
 
console.log(id)
 
const pattern = new RegExp("^[a-zA-Z][0-9a-zA-Z]{4,7}$")
// const pattern = / /
console.log(id.value)
btn.addEventListener('click', function() {
  if (pattern.test(id.value)) {
    alert('성공')
  } else {
    alert('다시입력')
    id.value = ''
    id.focus()
  }
})
Colored by Color Scripter

cs

다음과 같이 정규식을 작성하였다

[a-zA-Z][0-9a-zA-Z] --> 영문 + 숫자의 조합으로

{4,7} ---> 5~8글자

const pattern = new RegExp("^[a-zA-Z][0-9a-zA-Z]{4,7}$")

위 정규식은 "const pattern = / / "으로 / / 안에 정규식을 작성해도 된다.

3. 실행결과

정규식에 해당될 때

정규식에 해당되지 않을 때-1

정규식에 해당되지 않을 때-2

[JavaScript] 자바스크립트 이벤트 처리와 DOM의 개념 | Yoon's Dev

Yooniron — Sun, 17 Oct 2021 21:01:26 +0900

자바스크립트 이벤트 처리와 DOM의 개념

이벤트 처리와 DOM의 개념

■ 이벤트 발생과 처리

✓ HTML 문서에서 발생하는 특정 상황으로 이벤트 발생은 보통 자바스크립트 코드와 연계됨

ex) 버튼 클릭, 마우스 이동, 마우스 클릭, 키보드 입력, 문서 로드, 창 크기 변경 등

✓ 자바스크립트에서 이벤트를 처리하는 방법

- HTML 태그에 이벤트 처리 속성을 이용

- 문서 객체 모델 DOM 요소에 속성을 추가

- DOM 요소에 addEventListener()로 콜백 함수를 등록

□ 문서 객체 모델 DOM

✓ 자바스크립트에서는 DOM을 통해 HTML 요소에 접근할 수 있음

✓ DOM은 텍스트로 된 HTML 문서를 프로그램적으로 처리할 수 있도록 문서 구조 전체를 객체화한 것을 의미함

□ DOM의 체계

✓ 태그: 요소 노드(Element node)로 정의됨

✓ 태그의 속성: 속성 노드(Attribute node)가 됨

✓ 태그 보디의 텍스트는 다시 텍스트 노드(Text node)가 될 수 있음

✓ 경우에 따라서는 innerHTML 속성으로 표현하는 것도 가능함

✓ 이러한 DOM 체계에 따라 모든 HTML은 브라우저에 의해 로딩될 때 각각의 요소가 하나하나 '부모-자식' 관계를 객체 트리 구조로 재구성됨

□ 자바스크립트에서 DOM에 접근하는 방법

✓ 특정 태그, 아이디를 비롯해 CSS 셀렉터를 통한 요소 선택이 가능함

✓ querySelector(): 선택자와 일치하는 첫 번째 노드만 가지고 옴

✓ querySelectorAll(): 선택자와 일치하는 모든 노드를 가지고 옴

✓ getAttribute(), setAttribute(): 가져온 요소의 속성에 접근

□ DOM을 활용한 동적 디자인 변경

✓ 스타일 속성 변경

- 특정 태그 요소의 스타일 속성을 직접 변경하는 방식

ex) document.getElementById("box1").setAttribute("style", "background-color: yellow");

✓ 스타일 객체 변경

- 스타일 속성 변경과 동일한 방식이지만 코드 구현에서 차이가 있음

- 태그의 속성을 문자열 형태로 지정하는 것이 아닌 객체 참조 방식으로 스타일 속성을 지정

ex) document.getElementById("box1").style.backgroundColor = "yellow";

✓ 클래스 변경

- 태그 노드의 스타일 속성이 아니라 클래스 변경을 통해 디자인을 변경하는 방식

ex) document.getElementById("box1").className = "bgyellow";

[Android] 안드로이드 컨텍스트(Context) 메뉴 | Yoon's Dev

Yooniron — Fri, 18 Jun 2021 08:00:13 +0900

안드로이드 컨텍스트(Context) 메뉴

TO Do.

- 메뉴를 생성하는 방법 중에서 XML을 이용하여 컨텍스트 메뉴 구성

컨텍스트(Context) 메뉴

■ 컨텍스트 메뉴

✓ 특정 뷰 또는 항목에 필요한 명령어들만 모아 놓은 메뉴

✓ 옵션 메뉴 생성 과정과 상당 부분이 일치

. 메뉴 구성하는 순서를 기억하자

1. 레이아웃 구성

activity_main.xml)

activity_main

Component Tree

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <TextView
        android:id="@+id/textView01"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:background="#B5B2FE"
        android:text="TextView(Choice 1)"
        android:textSize="16sp"
        app:layout_constraintBottom_toTopOf="@+id/textView02"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_chainStyle="packed"
        app:layout_constraintVertical_weight="1" />
 
    <TextView
        android:id="@+id/textView02"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginTop="8dp"
        android:background="#BCE5EC"
        android:text="TextView(Choice 2)"
        android:textSize="16sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/textView01"
        app:layout_constraintBottom_toTopOf="@+id/textView03"
        app:layout_constraintVertical_weight="1" />
 
    <TextView
        android:id="@+id/textView03"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginTop="8dp"
        android:background="#BDBDBD"
        android:text="TextView(Choice 3)"
        android:textSize="16sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/textView02"
        app:layout_constraintBottom_toTopOf="@+id/btn_close"
        app:layout_constraintVertical_weight="1" />
 
    <Button
        android:id="@+id/btn_close"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:layout_marginBottom="8dp"
        android:text="Button"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
Colored by Color Scripter

cs

textView01

chainStyle에 대한 정보는 textView01에 표기한다.

weight가 필요한 경우 각 요소에 기록!

textView02

textView03

chainStyle은 서로 양방향으로 연결되는 과정을 진행해야 한다.

연결점 정보 확인!!

2. 메뉴 구성

리소스 생성에서 Resource type을 Menu로 두고 xml파일을 생성합니다.

다음과 같이 메뉴 아이템을 추가해줍니다.

context_menu1.xml

마찬가지로 context_menu2.xml에 Menu4와 Menu5를 추가해줍니다.

3. MainActivity.java

컨텍스트 메뉴를 호출할 수 있는 뷰를 설정

(컨텍스트 메뉴를 호출할 수 있게 등록)

Ctrl + O를 눌러 onCreateContextMenu 메서드를 @Override 해줍니다.

옵션 메뉴와 달리 설정된 뷰에서 각각 필요한 컨텍스트 메뉴를 호출함으로 그에 따른 구분이 필요합니다.

Ctrl + O를 눌러 onContextItemSelected 메서드를 @Override 해줍니다.

메뉴 아이템이 선택되었을 때 처리하는 부분은 컨텍스트 메뉴를 호출하는 구간에 관계없이

한 곳에서 모두 구분하여 필요한 내용을 처리하게 됩니다.

컨텍스트 메뉴에서 아이템이 선택되었을 때 호출합니다.

MainActivity.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

package com.exam.contextmenu;
 
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
 
import android.os.Bundle;
import android.view.ContextMenu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
 
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 
    TextView text01, text02;
    Button btn;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        text01 = (TextView)findViewById(R.id.textView01);
        registerForContextMenu(text01);
 
        text02 = (TextView)findViewById(R.id.textView02);
        registerForContextMenu(text02);
       
btn = (Button)findViewById(R.id.btn_close);
        btn.setOnClickListener(this);
    }
 
    @Override
    public boolean onContextItemSelected(@NonNull MenuItem item) {
        
        switch (item.getItemId()) {
            case R.id.item1:
                Toast.makeText(this,"Menu1", Toast.LENGTH_LONG).show();
            case R.id.item2:
                Toast.makeText(this,"Menu2", Toast.LENGTH_LONG).show();
            case R.id.item3:
                Toast.makeText(this,"Menu3", Toast.LENGTH_LONG).show();
            case R.id.item4:
                Toast.makeText(this,"Menu4", Toast.LENGTH_LONG).show();
            case R.id.item5:
                Toast.makeText(this,"Menu5", Toast.LENGTH_LONG).show();
                
        }
        return super.onContextItemSelected(item);
    }
 
    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
 
        if (v.getId() == R.id.textView01)
            getMenuInflater().inflate(R.menu.context_menu1, menu);
        if (v.getId() == R.id.textView02)
            getMenuInflater().inflate(R.menu.context_menu2, menu);
    }
 
    @Override
    public void onClick(View v) {
        finish();
    }
}
Colored by Color Scripter

cs

4. 실행 결과

[Android] 안드로이드 메뉴 표현 속성 showAsAction | Yoon's Dev

Yooniron — Thu, 17 Jun 2021 08:00:47 +0900

안드로이드 메뉴 표현 속성

■ 옵션 속성

✓ android:showAsAction

- 코드

. setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)

- 종류

. never: 항상 액션 아이템으로 표시하지 않음 (기본값)

. ifRoom: 액션 아이템을 표시할 수 있는 공간이 있다면 액션 아이템을 표시함

. withText: 메뉴 항목의 텍스트를 함께 액션 아이템으로 표시

. always: 항상 액션 아이템으로 표시

always

never

[Android] 안드로이드 ListView 구성 | Yoon's Dev

Yooniron — Wed, 16 Jun 2021 08:00:42 +0900

안드로이드 ListView 구성

TO Do.

- 레이아웃에서 ListView 추가

- ListView 객체를 얻어 오기

- ListView 객체로 setAdapter() 메서드의 매개변수로 화면에 출력하고자 하는 데이터 지정하여 호출

- 리스너와 연결

. setOnItemClickListener() 메서드로 리스너와 연결

. 선택한 항목을 확인

ListView

■ ListView

✓ 안드로이드에서 리스트 박스를 구현하기 위해 제공해주는 클래스

■ 선택 위젯

✓ 어댑터(Adapter)를 이용하여 데이터 ㅇ녀결

✓ 특징

. 배열 리스트, 데이터베이스 내의 데이터 등 여러 개의 데이터 항목들을 나타내 줌

1. 레이아웃 구성

리스트 뷰의 경우 아이디를 부여하고 기준선을 연결해야 한다.

activity_main.xml

activity_main)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <Button
        android:id="@+id/close_btn"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        android:text="Close"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />
 
    <ListView
        android:id="@+id/listView01"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        app:layout_constraintBottom_toTopOf="@+id/close_btn"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
Colored by Color Scripter

cs

3. MainActivity.java

MainActivity.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package com.exam.listview;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.os.Bundle;
import android.view.View;
import android.widget.Adapter;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;
 
public class MainActivity extends AppCompatActivity implements View.OnClickListener,
                                                                AdapterView.OnItemClickListener {
 
    private String[] list_items = {"item 01", "item 02","item 03","item 04","item 05",
            "item 06","item 07", "item 08","item 09","item 10","item 11","item 12"};
    
    Button btn01;
    ListView lv;
    
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        btn01 = (Button)findViewById(R.id.close_btn);
        btn01.setOnClickListener(this);
 
        ArrayAdapter<String> adapter = new ArrayAdapter<String>
                (this, android.R.layout.simple_list_item_1, list_items);
        
        lv = (ListView)findViewById(R.id.listView01);
        lv.setAdapter(adapter);
        
        lv.setOnItemClickListener(this);
    }
 
    @Override
    public void onClick(View v) {
        finish();
    }
 
    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        Toast.makeText(this,"Click id = " + list_items[position], Toast.LENGTH_LONG).show();
    }
}
Colored by Color Scripter

cs

화면에 표시할 데이터를 배열로 정의

list_items

어댑터 설정

어댑터 설정

리스트 뷰 화면에 출력하고자 하는 대상 지정

리스트에서 선택된 항목을 알아내기 위해 아이템 처리 리스너와 연결

선택된 아이템 처리

-->> 클릭된 항목의 부모 뷰인 어댑터 뷰

-->> 사용자가 클릭한 항목에 해당되는 뷰

-->> 선택된 항목의 위치

-->> Position과 동일

int position, long id: 위치를 나타냄

4. 실행 결과

[Android] 안드로이드 옵션 메뉴 구성/속성 (XML 사용) | Yoon's Dev

Yooniron — Tue, 15 Jun 2021 08:00:20 +0900

안드로이드 옵션 메뉴 구성/속성 (XML 사용)

TO Do.

- 메뉴를 생성하는 방법 중에서 XML을 이용하는 방법

. Option Menu 생성 과정

. 일반적인 형태의 메뉴 생성 방법

- 메뉴의 재사용성

- 옵션 메뉴를 XML을 이용하여 생성

- 콘텍스트 메뉴도 같은 방법으로 생성

1. 레이아웃 구성

* 이 글은 옵션 메뉴만을 구성하는 과정이기에 별도의 레이아웃 구성이 필요가 없습니다. *

대신에 옵션 메뉴에 대한 구성을 위한 XML 작업이 필요로 합니다.!

-> 옵션 메뉴의 선택 여부는 토스트 기능으로 확인해보도록 합시다.

메뉴 구성

res/menu 하단에 구성 (Resource type을 Menu로 설정)

2. main_option.xml

다음과 같이 메뉴를 추가해 줍시다.

main_option.xml

3. MainActivity.java

Ctrl + O를 눌러서 onCreateOptionsMenu를 @override 해줍니다.

MainActivity.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.exam.myapplication;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.os.Bundle;
import android.view.Menu;
 
public class MainActivity extends AppCompatActivity {
 
 
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
 
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main_option, menu);
        return super.onCreateOptionsMenu(menu);
    }
}
Colored by Color Scripter

cs

 

- XML 메뉴를 생성할 때 MenuInflater 객체의 inflate() 메서드를 사용

- MenuInflater 객체는 Activity.getMenuInflater() 메서드로 얻어올 수 있음

- 메뉴의 리소스 ID만 전달하면 XML 엘리먼트를 읽어 항목을 추가할 수 있음

추가로 선택된 메뉴를 구분처리하기 위해 onOptionsItemSelected 메서드를 @override 해줍니다.

onOptionsItemSelected() 추가

4. 실행 결과

[Android] Adapter(어댑터) | Yoon's Dev

Yooniron — Mon, 14 Jun 2021 08:00:34 +0900

Adapter(어댑터)

Adapter

■ Adapter(어댑터)

✓ 외부 데이터 소스와 어댑터 뷰(AdapterView) 사이의 연결 수단을 의미

✓ Adapter는 여러 계층으로 구성(리스트 어댑터, 스피너 어댑터, 베이스 어댑터 등....)

□ 데이터 소스

✓ DB, XML, 배열 등....

□ 어댑터 뷰

✓ ViewGroup의 서브클래스

✓ GridView, ListView, Gallery, Spinner .....

✓ 어댑터를 이용하여 데이터로 레이아웃을 구성

✓ 사용자에 의한 항목 선택 이벤트 처리

ArrayAdapter

● 선택 위젯에서 사용할 값들의 목록을 설정하기 위한 공통 인터페이스로 어댑터를 제공

● 어댑터는 어댑터 뷰와 데이터 소스 사이를 연결하고 데이터 항목을 관리

● 어댑터는 여러 계층으로 구성 (리스트 어댑터, 스피너 어댑터, 베이스 어댑터...)

● 데이터 소스가 배열인 경우 ArrayAdapter

● 데이터베이스인 경우 CursorAdapter

● XML을 포함한 정적 데이터인 경우 SimpleAdapter

■ ArrayAdapter

✓ ArrayAdapter는 자바의 배열이나 java.util.List의 인스턴스를 주는 것으로 어댑터를 사용하기 위한 준비가 끝남

1
2
3
4
5

String[] items = {"item 1", "item 2", "item 3"};
ArrayAdapter<String> adapter = new ArrayAdapter<String>(
this,
 android.R.layout.simple_list_item_1,
 items);
Colored by Color Scripter

cs

✓ 어댑터가 포함될 인스턴스 지정, 항목을 표시하기 위해 사용할 뷰의 리소스 ID(내장된 리소스 ID), 화면에 표시할 실제 내용이 들어 있는 배열 지정

레이아웃 리소스 ID

리소스 ID	설명
simple_list_item_1	하나의 텍스트 뷰로 구성된 레이아웃
simple_list_item_checked	체크가 표시되는 레이아웃
simle_list_item_single_choice	라이도 버튼이 표시되는 레이아웃
simple_list_item_multiple_choice	체크 버튼이 표시되는 레이아웃

[Android] 안드로이드 기본 이벤트 처리 | Yoon's Dev

Yooniron — Sun, 13 Jun 2021 21:18:52 +0900

안드로이드 기본 이벤트 처리

(클릭, 포커스, 롱 클릭, 키, 터치)

사용자 간의 상호작용을 위한 간단한 이벤트 처리 과정

( 한 화면에 여러 이벤트가 존재하는 다중 이벤트 처리)

기본 이벤트 종류

■ 클릭

✓ OnClickListener

. void onCLick(View v)

■ 포커스 변경

✓ OnFocusChangeListener

. void onFocusChange(View v, boolean hasFocus)

■ 롱클릭

✓ OnLongClickListener

. Boolean onCLick(View v)

■ 키 (특정 위치를 사용하는 경우)

✓ OnKeyListener

. Boolean onKey(View v, int KeyCode, KeyEvent event)

. onKeyDown(int keyCode, KeyEvent event) // 특정 위치를 사용하지 않는 경우

■ 터치

✓ OnTouchListener

. Boolean onTouch(View v, MotionEvent event)

KEY CODE

*키 코드 가운데 숫자, 알파벳 등의 입력은 안드로이드 버전에 따라 인식이 제한됨*

 KEYCODE_DPAD_LEFT 왼쪽 화살표

 KEYCODE_DPAD_RIGHT 오른쪽 화살표

 KEYCODE_DPAD_UP 위쪽 화살표

 KEYCODE_DPAD_DOWN 아래쪽 화살표

 KEYCODE_DPAD_CENTER 중앙 버튼

 KEYCODE_CALL 통화 버튼

 KEYCODE_ENDCALL 통화 종료 버튼

 KEYCODE_HOME 홈 버튼

 KEYCODE_BACK 뒤로 가기 버튼

 KEYCODE_BOLUME_UP 볼륨 업 버튼

 KEYCODE_BOLUME_DOWN 볼륨 다운 버튼

 KEYCODE_0 ~ KEYCODE_9 숫자 0 ~ 9

 KEYCODE_A ~ KEYCODE_Z 알파벳 A ~ Z

1. EventTest 레이아웃 구성

다음과 같은 화면을 작성해봅시다.

activity_main.xml

Component Tree

activity_main.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
 
    <androidx.constraintlayout.widget.Guideline
 
        android:id="@+id/v_gline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.50" />
 
 
    <Button
 
        android:id="@+id/button01"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:text="Click / LongClick"
        android:textAllCaps="false"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
 
 
    <EditText
 
        android:id="@+id/editText01"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:ems="10"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/button01" />
 
 
    <EditText
 
        android:id="@+id/editText02"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:ems="10"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/editText01">
 
        <requestFocus />
 
 
    </EditText>
 
 
    <TextView
 
        android:id="@+id/textView01"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        android:background="#BDBDBD"
        android:text="TouchEvent Test"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/editText02" />
 
 
</androidx.constraintlayout.widget.ConstraintLayout>
Colored by Color Scripter

cs

2. Java Class 파일(기능 구현)

MainActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

package com.examples.eventtest;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.os.Bundle;
import android.view.GestureDetector;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
 
public class MainActivity extends AppCompatActivity implements View.OnClickListener,
                                                                View.OnLongClickListener,
                                                                View.OnFocusChangeListener,
//                                                                View.OnKeyListener,
                                                                View.OnTouchListener {
 
    Button btn01, btn02;
    EditText edit01, edit02;
    TextView text01;
 
    /* Gesture Detector 추가 */
 
    GestureDetector gDetector;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        btn01 = (Button) findViewById(R.id.button01);
        btn01.setOnClickListener(this);
        btn01.setOnLongClickListener(this);
 
//        btn02 = (Button) findViewById(R.id.button02);
//        btn02.setOnLongClickListener(this);
 
        edit01 = (EditText) findViewById(R.id.editText01);
        edit01.setOnFocusChangeListener(this);
 
        edit02 = (EditText) findViewById(R.id.editText02);
//        edit02.setOnKeyListener(this);
 
        text01 = (TextView) findViewById(R.id.textView01);
        text01.setOnTouchListener(this);
 
        //GestureDetector 추가 부분
 
        gDetector = new GestureDetector(this, new GestureDetector.OnGestureListener() {
            @Override
            public boolean onDown(MotionEvent e) {
                //터치하려고 손을 대는 순간
                return false;
            }
 
            @Override
            public void onShowPress(MotionEvent e) {
                //터치하면 호출, 일정시간 누르는 경우
            }
 
            @Override
            public boolean onSingleTapUp(MotionEvent e) {
                //한번 터치가 확실한 경우 호출
                return false;
            }
 
            @Override
            public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
                // 드래그 하면...
                return false;
            }
 
            @Override
            public void onLongPress(MotionEvent e) {
                // 길게 누르면
            }
 
            @Override
            public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                // 드래그하다가 떼면...
                return false;
            }
        });
 
    }
 
    @Override
    public void onClick(View v) {
        Toast.makeText(this, "onClick!", Toast.LENGTH_LONG).show();
    }
 
    @Override
    public boolean onLongClick(View v) {
        Toast.makeText(this, "onLongClick!", Toast.LENGTH_LONG).show();
        return false;
    }
 
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        String s = "";
        if (hasFocus) {
            ((EditText) v).setText("");
        } else {
            s = edit01.getText().toString();
            edit01.setText(s + "+ focus change");
        }
    }
 
//    @Override
//    public boolean onKey(View v, int keyCode, KeyEvent event) {
//        if (keyCode == KeyEvent.KEYCODE_BACK) {
//            Toast.makeText(this, "KEYCODE_BACK", Toast.LENGTH_LONG).show();
//        }
//        if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
//            text01.setText("Volume Up");
//        }
//        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
//            text01.setText("Volume Down");
//        }
//        return false;
//    }
 
 
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
            text01.setText("Volume Up");
        }
        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
            text01.setText("Volume Down");
        }
        return super.onKeyDown(keyCode, event);
    }
 
    // back 키
    @Override
    public void onBackPressed() {
        super.onBackPressed(); // 주석처리하면 Back키 안먹음
        Toast.makeText(this, "BACK", Toast.LENGTH_SHORT).show();
    }
    
    // Home 키
    @Override
    protected void onUserLeaveHint() {
        super.onUserLeaveHint();
        Toast.makeText(this, "홈키", Toast.LENGTH_SHORT).show();
    }
 
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
//            text01.setText("ACTION_DOWN");
            return true;
        }
        if (event.getAction() == MotionEvent.ACTION_MOVE) {
//            text01.setText("ACTION_MOVE");
 
            //상대좌표
            float x = event.getX();
            float y = event.getY();
 
            //절대좌표
            float rawX = event.getRawX();
            float rawY = event.getRawY();
 
            text01.setText("X: " + x + "\nY: " + y
                    + "\n\nrawX: " + rawX + "\nrawY: " + rawY);
 
            return false;
        }
        if (event.getAction() == MotionEvent.ACTION_UP) {
//            text01.setText("ACTION_UP");
            return false;
        }
 
        gDetector.onTouchEvent(event);
        return false;
    }
}
Colored by Color Scripter

cs

3. 실행결과

■ 실행 화면

처음 실행 화면

■ onClick

클릭 시

■ onLongClick

롱 클릭

■ onFocusChnage

Focus Change

■ onTouch

onTouch

■ onKeyDown

KeyDown

[JAVA] UDP 기반 통신 (JAVA 네트워크) | Yoon's Dev

Yooniron — Sat, 12 Jun 2021 17:33:14 +0900

UDP 기반 통신 (JAVA 네트워크)

1. InetAddress 클래스

■ InetAddress 클래스

✓ 인터넷 주소와 관련된 기능을 제공하는 클래스

✓ IP 주소를 액세스 하기 위한 추상층을 제공

✓ IPv6용 프로그램으로 포팅 할 때 투명성 유지 가능

□ InetAdress 클래스의 메서드

메서드 이름	설명
boolean equals(InetAddress other)	현 객체가 other 객체와 같은 주소를 가지면 true, 아니면 false
byte[] getAddress()	주소를 나타내는 4개의 요소를 가진 바이트 배열을 반환
String getHostAddress()	주소 정보를 나타내는 문자열 반환
String getHostName()	컴퓨터 이름을 나타내는 문자열을 반환
InetAddress getLocalHost() throws UnknownHostException	현재 컴퓨터를 나타내는 InetAddress 객체를 반환
InetAddress getByName(String hostName) throws UnknownHostException	hostName으로 지정된 컴퓨털르 나타내는 InetAddress 객체를 반환
InetAddress[] getAllByName(String hostName throws UnknownHostException)	hostName으로 지정된 모든 컴퓨터 (하나의 도메인 이름으로 여러 대의 컴퓨터를 사용하는 경우)를 나타내는 InetAddress 객체들의 배열을 반환

2. UDP

■ UDP(User Datagram Protocol)

✓ 비연결성 통신 방식

✓ 높은 신뢰성이 요구되지 않는 분야에 이용

✓ TCP에 비해 네트웍 부담을 주지 않음

✓ 자바는 UDP를 지원하기위해

. DatagramPacket

. DatagramSocket 클래스 제공

3. DatagramPacket 클래스

■ DatagramPacket 클래스

✓ DatagramPacket 클래스

- 정보를 주고받기 위한 준비과정의 기능을 제공하는 클래스

✓ 생성자

- DatagramPacket(byte[] buffer, int size)

: 데이터를 수신하는 응용 프로그램에서 사용하는 생성자

. buffer: 수신되는 데이터를 저장할 바이트 배열

. size: 배열의 크기

- DatagramPacket(byte[] buffer, int size, InetAddress ia, int port)

: 데이터를 송신하는 응용프로그램에서 사용하는 생성자

. buffer : 송신될 데이터가 저장되어 있는 배열

. size : 배열의 크기

. ia : 정보가 보내질 컴퓨터의 주소이며 InetAddress 객체를 사용하여 지정

. port : 컴퓨터의 포트 번호

□ DatagramPacket 클래스의 메서드

메서드	기능
InetAddress getAddress()	데이터그램의 주소 반환
void setAddress(InetAddress iaddr)	데이터그램에 목적지 주소 설정
bytep[ getData()	데이터그램의 데이터 반환
void setData(byte[] buf)	데이터그램의 데이터 설정
void setData(byte[] buf, int offset, int length)	byte 배열의 offset부터 length 만큼을 데이터그램에 데이터로 설정
int getLength()	데이터의 길이나 수신할 데이터의 최대 크기 반환
void setLength(int length)	수신할 데이터의 최대 길이 설정
int getPort()	데이터그램의 포트 반환
void setPort(int iport)	데이터그램의 포트 설정

4. DatagramSocket 클래스

■ DatagramPacket 클래스

✓ DatagramSocket을 사용해 통신할 때의 순서

- DatagramScoket 클래스의 인스턴스를 구성

. 이때 클라이언트는 로컬 주소와 포트를 선택적으로 지정

. 서버의 경우 포트를 지정

- DatagramSocket 클래스의 send() receive() 메서드 사용,

DatagramPacket 클래스의 인스턴스를 주고받음으로써 통신

- 통신이 끝나면 DatagramSocket 클래스의 close() 메서드 호출로 소켓 차단

□ DatagramSocket 생성자

메서드	기능
DatagramSocket()	포트와 로컬 주소를 지정하지 않는 생성자
DatagramSocket(int port)	특정 포트의 데이터그램만을 수신하도록 포트번호를 지정하는 생성자
DatagramSocket(int port, InetAddress laddr)	특정 로컬 주소와 포트의 데이터그램만을 수신하도록 로컬 주소와 포트번호를 지정하는 생성자
DatagramSocket(SocketAdrress bindaddr)	로컬 주소와 포트번호가 바인딩 되어있는 주소 클래스인 SocketAddress를 인자로 사용하는 생성자

□ DatagramSocket 클래스의 메서드

메서드	기능
void connect(InetAddress address, int port)	특정 원격 주소와 포트를 지정, 주소가 지정이 되면 다른 주소나 포트로부터 수신한 데이터그램은 무시
void disconnect()	소켓에 지정된 주소와 포트 제거
InetAddress getInetAddress()	원격 소켓의 주소와 포트 반환
InetAddress getLocalAddress()	소켓의 주소와 포트 반환
int getLocalPort()	소켓의 포트 반환
int getSoTimeout()	receive() 메서드가 수신을 위해 대기하는 시간 반환
void setSoTimeout(int timeout)	receive() 메서드가 수신을 위해 대기하는 시간 설정
void receive(DatagramPacket p)	현재의 소켓으로부터 정보를 읽어 dgram 패킷에 저장
void send(DatagramPacket p)	현재의 소켓을 통하여 dgram 패킷을 전송

[JSP] 파일 업로드(File Upload) | Yoon's Dev

Yooniron — Sun, 6 Jun 2021 19:49:38 +0900

파일 업로드(File Upload)

목표: 웹 브라우저를 통해서 파일을 전송

1. 파일 업로드의 기본적인 폼

■ form 태그 구성

✓ <form name="폼이름" method="post" enctype="multipart/form-data">

■ Input 태그 지정

✓ <input type="file" name="파일명">

2. fileSelect.jsp

다음과 같이 user, title 그리고 선택된 file을 넘겨주는 페이지를 작성합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<%@ page contentType="text/html;charset=EUC-KR"%>
<html>
<body>
<form name="frmName" method="post" enctype="multipart/form-data" 
action="viewPage.jsp">
    user<br/> 
    <input name="user"><br/>
    title<br/> 
    <input name="title"><br/>
    file<br/> 
    <input type="file" name="uploadFile"><br/><br/>
    <input type="submit" value="UPLOAD"><br/>
</form>
</body>
</html>
Colored by Color Scripter

cs

3. cos.jar 파일

http://www.servlets.com/에 접속

Servlets.com

Home What's New? COS File Upload Library Servlet Polls Mailing Lists Servlet Engines Servlet ISPs Servlet Tools Documentation Online Articles The Soapbox "Java Servlet Programming, Second Edition" "Java Enterprise Best Practices" Speaking & Slides About Ja

www.servlets.com

COS File Upload Library. 클릭

com.oreilly.servlet 클릭

cos-20.08.zip 다운로드

그다음 cos.jar 파일을 이클립스 해당 프로젝트 lib 폴더에 복사해줍니다.

4. viewPage.jsp

fileSelect.jsp에서 넘겨준 값들을 확인하기 위해 viewPage.jsp를 작성합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<%@page contentType="text/html; charset=EUC-KR" %>
<%@page import="com.oreilly.servlet.MultipartRequest" %>
<%@page import="com.oreilly.servlet.multipart.DefaultFileRenamePolicy"%>
<%@page import="java.util.*,java.io.*"%>
<%
    //String saveFolder = "파일경로";
    String saveFolder = application.getRealPath("/filestorage") ;
    String encType = "EUC-KR";
    int maxSize = 5 * 1024 * 1024;
    try {
        MultipartRequest multi = null;
        multi = new MultipartRequest(request, saveFolder, maxSize,
                encType, new DefaultFileRenamePolicy());
        String user = multi.getParameter("user");
        String title = multi.getParameter("title");
        
        out.println("user: " + user + "<br/>");
        out.println("title: " + title + "<br/>");
        out.println("<hr>");
        
        String fileName = multi.getFilesystemName("uploadFile");
        String original = multi.getOriginalFileName("uploadFile");
        String type = multi.getContentType("uploadFile");
        File f = multi.getFile("uploadFile");
        
        out.println("저장된 파일 이름 : " + fileName + "<br/>");
        out.println("실제 파일 이름 : " + original + "<br/>");
        out.println("파일 타입 : " + type + "<br/>");
        if (f != null) {
            out.println("크기 : " + f.length()+"바이트");
            out.println("<br/>");
        }
    } catch (IOException ioe) {
        System.out.println(ioe);
    } catch (Exception ex) {
        System.out.println(ex);
    }
%>
Colored by Color Scripter

cs

5. 실행 결과

UPLOAD 전

UPLOAD 후

[Eclipse] 유용한 이클립스 단축키 모음 | Yoon's Dev

Yooniron — Thu, 3 Jun 2021 19:22:42 +0900

유용한 이클립스 단축키 모음

이클립스 단축키

Eclipse의 모든 단축키는 Window - Preferences - General - Keys 메뉴에서 확인 및 변경이 가능합니다.

그중에서도 가장 많이 쓰이고 유용한 단축키들을 정리해보았습니다.

1. Java Editor 단축키

Ctrl + Shift + B : Break point 설정 / 해제
Ctrl + Shift + F : 소스코드 자동 정리
Ctrl + Shift + G : 현재 커서가 위치한 특정 메서드나 객체, 필드를 참조하고 있는 곳을 찾는다.
Ctrl + Shift + J : 검색할 단어를 입력하면서 실시간으로 거꾸로 검색
Ctrl + Shift + K : 이전찾기
Ctrl + Shift + L : 단축키 보기 Hint
Ctrl + Shift + M : 캐럿이 위치한 대상에 필요한 특정 클래스 Import 시키기
Ctrl + Shift + O : 소스에 필요한 패키지를 자동으로 Import 시키기
Ctrl + Shift + R : Open Resource. 모든 프로젝트에서 파일명 검색.
Ctrl + Shift + S : 열린 모든 파일 저장 및 컴파일
Ctrl + Shift + / : 선택 영역 Block Comment 설정
Ctrl + Shift + \ : 선택 영역 Block Comment 제거

Ctrl + Alt + R
Ctrl + Alt + up/down : 한 줄 duplicate
Ctrl + F11 : 실행

Ctrl + 1 : Quick Fix.
Ctrl + 2 + R : Rename (리팩토링)

Ctrl + / : 한 줄 또는 선택영역 주석처리 / 제거
Ctrl + . : 다음 오류 부분으로 가기
Ctrl + , : 이전 오류 부분으로 가기

Ctrl + D : 한 줄 삭제
Ctrl + H : Find 및 Replace
Ctrl + I : 소스 깔끔 정리(자동 구문 정리)
Ctrl + J : 검색할 단어를 입력하면서 실시간으로 검색
Ctrl + K : 다음 찾기
Ctrl + L : 특정 줄번호로 가기
Ctrl + N : 새로운 파일 및 프로젝트 생성
Ctrl + O : Outline 창 열기
Ctrl + Q : 마지막 편집 위치로 가기
Ctrl + S : 저장 및 컴파일

Ctrl + space : 어휘의 자동완성(Content Assistance)

Ctrl + 객체 클릭(혹은 F3) : 클래스나 메서드 혹은 멤버를 정의한 곳으로 이동
Alt + Shift + UP : 커서를 기준으로 토큰단위 블록 지정
Alt + Shift + DOWN : 커서를 기준으로 토큰단위 블럭해제
Alt + Shift + J : 설정해 둔 기본 주석을 자동으로 달기
Alt + UP, DOWN : 현재 줄 위치 이동
Alt + Shift + 방향 : 선택
Alt + Shift + R : Rename
Alt + / : Word Completion
Alt + ->, Alt + <- : 이후, 이전

2. Window 이동

F10 : 메뉴창을 활성화
Ctrl + F8 : 다음 Perspective로 이동
Ctrl + N : 새로운 파일 및 프로젝트 생성.
Ctrl + Shift + Down : Java Editor에서 다음 member로 이동.
Ctrl + F7 : 다음 View로 이동.
Ctrl + Shift + F7 : 이전 View로 이동.
Alt + <- : 이전 작업 화면
Alt + -> : 다음 작업 화면
F12 : 컴파일 중 에러 등으로 포커스가 다른데로 갔을 때 Editor 로 커서 이동
Ctrl + 1 : 컴파일 에러에 대한 해결책을 제시

[Git] Github 로컬 저장소 및 원격 저장소 연결 해제 (.git 삭제) | Yoon's Dev

Yooniron — Sun, 30 May 2021 20:19:54 +0900

Github 로컬 저장소 및 원격 저장소 연결 해제 (.git 삭제)

해당 글은 이미 로컬 저장소가 되어있다고 가정하고 작성 한 내용입니다.

동기화하는 방법을 모르시겠다면 다음 글을 참고해주세요.

[Git] GitHub, 깃허브 repository에 파일 업로드(push)하는 방법 | Yoon's Dev

Github, 깃허브 repository에 파일 업로드(push)하는 방법 간단히 말해서 Git bash를 이용해 Github 저장소에 내 프로젝트, 소스들을 업로드하는 방법이다. Github desktop을 이용해 GUI로 쉽게 할 수 있지만, 이.

yooniron.tistory.com

1. 명령어를 통한 연결 해제 (Window, Mac)

다음과 같이 .git 폴더는 윈도우에서는 숨겨져 있습니다.

.git 이 들어있는 폴더에서 Git Bash Here을 눌러주세요

find 명령어로 .git 파일을 삭제할 수 있습니다.

해당 명령어는 하위 디렉터리 내의 .git 파일을 모두 찾아 삭제합니다.

MAC의 경우에 .git 파일은 숨겨져 있기 때문에 명령어를 통해 삭제할 수 있습니다.

2. 수동으로 파일을 삭제하는 방법 (Window만 가능)

파일 탐색기에서 다음과 같이 보기 탭에 있는 숨긴 항목을 체크해주시면 숨겨진 폴더들을 볼 수 있습니다.

[JAVA] 메모장(notepad) 만들기 - ActionListener 객체의 속성과 동작 구현 ③ | Yoon's Dev

Yooniron — Sat, 29 May 2021 20:44:07 +0900

메모장(notepad) 만들기 - 열기, 저장, 새 파일, 종료 메서드 구현 ③

TO Do.

■ 메모장 제작

✓ ActionListener 객체의 속성과 동작

✓ 속성

. 선택된 메뉴를 판별하기 위한 문자열

. Notepad 객체의 레퍼런스

✓ 동작

. 종료가 선택되면 Notepad의 종료 메서드를 호출

. 종료가 아닌 다른 메뉴가 선택되면 메모장을 초기화하는 메서드를 호출

목표: 열기, 저장, 새 파일, 종료 리스너 구현하기

1. 메모장의 인터페이스 구현

레이아웃은 메모장 만들기 1편의 인터페이스를 참고했습니다. 못 보신 분들은 먼저 1을 보고 와주세요!!

[JAVA] 메모장(notepad) 만들기 ① - 인터페이스 구현 | Yoon's Dev

메모장(notepad) 만들기 ① - 인터페이스 구현 TO Do. ■ 메모장 제작 ✓ 텍스트 파일을 읽고 쓰기 기능 구현 ✓ 자바의 입출력 적용 ✓ 자바의 그래픽 처리와 이벤트 처리 적용 목표: 메모장의 인

yooniron.tistory.com

2. 클래스 다이어그램

클래스 다이어그램

NoteActionListener 클래스의 중요 메서드

메서드	기능
public NoteActionListener (Notepad)	Notepad 클래스의 레퍼런스를 멤버변수에 저장
public void actionPerformed (ActionEvent)	메모장의 메뉴가 선택되어있을 때 이벤트를 받아 메뉴에 해당하는 Notepad 클래스의 메서드를 호출

3. ActionListener 객체의 속성과 동작

■ ActionListener 객체의 속성과 동작

✓ 속성

. 선택된 메뉴를 판별하기 위한 문자열

. Notepad 객체의 레퍼런스

✓ 동작

. 종료 선택 -> Notepad의 종료 메서드를 호출

. 읽기 선택 -> 파일 선택 다이얼로그를 출력하여 파일의 이름을 얻어와 Notepad 클래스 파일을 읽는 메서드 호출

. 저장 선택 -> 파일 선택 다이얼로그를 출력하여 파일의 이름을 얻어와 Notepad 클래스의 파일을 저장하는 메서드 호출 (새 파일 저장)

. 다른 이름으로 저장 -> 파일 선택 다이얼로그를 출력하여 파일의 이름을 얻어와 저장

. 새파일 선택 -> 메모장을 초기화하는 메서드 호출

4. NoteActionListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package notepad.step03;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
 
public class NoteActionListener implements ActionListener {
    // 멤버변수
    private Notepad frm;
    String cmd;
    // 생성자
    public NoteActionListener(Notepad n) {
        this.frm = n;
    }
 
    @Override
    public void actionPerformed(ActionEvent e) {
        cmd = e.getActionCommand();
        switch (cmd) {
 
        case "새파일":
            frm.newFile();
            break;
        case "열기":
            frm.openFile();
            break;
        case "저장":
            if(frm.fileName.equals("")) { //다른이름으로 저장과 일반 저장을 구분하기 위함, 처음 실행시 일반저장버튼을 눌렀을때 chooser가 열리도록 함
                   int ret = frm.chooser.showSaveDialog(null);
                   
                   if(ret != frm.chooser.APPROVE_OPTION) {
                      JOptionPane.showMessageDialog(null, "파일을 선택하지 않았습니다!", "경고", JOptionPane.WARNING_MESSAGE);
                      return;
                   }
                   
                   frm.fileName = frm.chooser.getSelectedFile().getPath();
                }
                frm.saveFile(frm.ta.getText()); //저장
                
                break;
        case "다른이름으로저장": //무조건 chooser로 다이얼로그 열어서 저장
                int ret = frm.chooser.showSaveDialog(null);
                if (ret == JFileChooser.APPROVE_OPTION) {
                    frm.fileName = frm.chooser.getSelectedFile().getPath();
                    frm.saveFile(frm.ta.getText());
                }
                
            break;
        case "종료":
            frm.windowClosing(null);
            break;
        }
 
    }
 
}
 
Colored by Color Scripter

cs

3. 함께 보면 좋은 글

[JAVA] 메모장(notepad) 만들기 - 열기, 저장, 새 파일, 종료 메서드 구현 ② | Yoon's Dev

메모장(notepad) 만들기 - 열기, 저장, 새 파일, 종료 메서드 구현 ② TO Do. ■ 메모장 제작 ✓ 텍스트 파일을 읽고 쓰기 기능 구현 ✓ 자바의 입출력 적용 ✓ 자바의 그래픽 처리와 이벤트

yooniron.tistory.com

[JAVA] JAVA의 5가지 리스너 이벤트 처리 방법 (독립, 내부, 프레임, 익명, 람다식) | Yoon's Dev

JAVA의 5가지 리스너 이벤트 처리 방법 (독립, 내부, 프레임, 익명, 람다식) 학습 목표 독립적인 클래스로 이벤트 처리기를 작성 내부 클래스로 이벤트 처리기를 작성 프레임 클래스에 이벤트 처리

yooniron.tistory.com

[JAVA] 메모장(notepad) 만들기 - 열기, 저장, 새 파일, 종료 메서드 구현 ② | Yoon's Dev

Yooniron — Wed, 26 May 2021 21:56:17 +0900

메모장(notepad) 만들기 - 열기, 저장, 새 파일, 종료 메서드 구현 ②

TO Do.

■ 메모장 제작

✓ 텍스트 파일을 읽고 쓰기 기능 구현

✓ 자바의 입출력 적용

✓ 자바의 그래픽 처리와 이벤트 처리 적용

목표: 열기, 저장, 새 파일, 종료 메서드 구현하기

1. 메모장의 인터페이스 구현

레이아웃은 메모장 만들기 1편의 인터페이스를 참고했습니다. 못 보신 분들은 먼저 1을 보고 와주세요!!

[JAVA] 메모장(notepad) 만들기 ① - 인터페이스 구현 | Yoon's Dev

yooniron.tistory.com

2. 클래스 다이어그램

Notepad 클래스 다이어그램

Notepad 클래스의 중요 메서드

메서드	기능
public Notepad()	메모장에 필요한 SWING 컴포넌트를 생성하고 배치
public void itemAdd(String, Menu)	메뉴바에 메뉴를 추가
public void newFile()	메모장을 초기화
public void loadFile(String)	파일이름을 인자로 받아 파일 객체와 스트림 객체를 생성하고 내용을 읽어와 텍스트 에어리어에 출력
public void saveFile(String)	텍스트 에어리어의 내용을 인자로 받은 파일이름으로 저장

3. Notepad.java

이벤트 처리에 대한 부분은 메모장 만들기 3편에서 작성하려고 합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

package notepad.step02;
 
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
 
public class Notepad extends JFrame {
    // 멤버변수
    public JTextArea ta = new JTextArea();
    JFileChooser chooser = new JFileChooser();
    JMenuBar mb = new JMenuBar();
    String fileName = "";
    // 생성자
    public Notepad() {
        
        this.setTitle("Notepad");
        this.setSize(500, 500);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
        
        
 
        // 2. 메뉴생성
        String[] smenu = { "파일" };
        JMenu[] mfile = new JMenu[10];
        for (int i = 0; i < smenu.length; i++) {
            mfile[i] = new JMenu(smenu[i]);
            mb.add(mfile[i]);
        }
 
 
        String[] ScrItem = { "새파일", "열기", "저장", "다른이름으로저장", "종료" };
        JMenuItem[] item = new JMenuItem[5];
        for (int i = 0; i < ScrItem.length; i++) {
            item[i] = new JMenuItem(ScrItem[i]);
            // 1. 이벤트 소스: JMenuItem
            // 2. 이벤트 종류: ActionEvent
            // 3. 리스너 구현: ActionListener - > 독립리스너
            // 4. 리스너 연결
            NoteActionListener nal = new NoteActionListener(this);
            item[i].addActionListener(nal);
            // 4. 메뉴바 설정
            this.setJMenuBar(mb);
            mfile[0].add(item[i]);
 
        }
        
        // 컴포넌트 추가
        this.add(ta);
 
        this.setVisible(true);
    }
    /* 새파일 */
    public void newFile() {
        ta.setText("");
    }
 
    /* 열기 */
    public void openFile() {
 
        int ret = chooser.showOpenDialog(null);
 
        if (ret != JFileChooser.APPROVE_OPTION) {
 
            JOptionPane.showMessageDialog(null, "파일을 선택하지 않았습니다.", "경고", JOptionPane.WARNING_MESSAGE);
            return;
 
        } else {
            File inFile = chooser.getSelectedFile();
            BufferedReader in;
            try {
                in = new BufferedReader(new FileReader(inFile));
                String c;
                ta.setText("");
                while ((c = in.readLine()) != null) {
                    ta.append(c + "\r\n");
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
 
        }
        fileName = chooser.getSelectedFile().toString();
        setTitle(chooser.getSelectedFile().getName());
    }
 
    /* 파일 저장 */
    public void saveFile(String fn) {
          BufferedWriter out = null;
          File file = new File(fileName);
          try {
             out = new BufferedWriter(new FileWriter(file));
             out.write(fn);
             this.setTitle(file.getName());
             out.close();
          }
          catch(IOException e) {
             e.printStackTrace();
          }
       }
 
    
    public static void main(String[] args) {
        new Notepad();
    }
 
}
 
Colored by Color Scripter

cs

소스에 대해 지적할 사항이나 잘못된 점이 있다면 댓글로 적극적인 피드백 부탁드립니다.!

[JAVA] 메모장(notepad) 만들기 ① - 인터페이스 구현 | Yoon's Dev

Yooniron — Tue, 25 May 2021 21:08:02 +0900

메모장(notepad) 만들기 ① - 인터페이스 구현

TO Do.

■ 메모장 제작

✓ 텍스트 파일을 읽고 쓰기 기능 구현

✓ 자바의 입출력 적용

✓ 자바의 그래픽 처리와 이벤트 처리 적용

목표: 메모장의 인터페이스를 SWING으로 구현

1. 메모장의 인터페이스 구현

■ 메모장의 인터페이스를 구현

✓ SWING 컴포넌트 중 입력, 저장, 끝내기와 같은 작업을 수행하기 위한 메뉴바

✓ 읽어온 문서를 출력할 텍스트 에어리어 객체 사용

✓ Notepad 객체의 속성과 동작

- 속성

. 메뉴바

. TextArea

. 메뉴바의 이벤트를 받아 처리할 객체

- 동작

. 사용자가 새 파일을 선택했을 때 텍스트 에어리어 초기화

. 메모장을 종료

2. 인터페이스

실행 화면

메뉴바

3. Notepad.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package notepad.step01;
 
 
 
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JTextArea;
 
public class Notepad extends JFrame  {
    // 멤버변수
    public JTextArea ta = new JTextArea();
    JFileChooser chooser = new JFileChooser();
    JMenuBar mb = new JMenuBar();
   
    // 생성자
    public Notepad() {
        
        this.setTitle("Notepad");
        this.setSize(500, 500);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
        
        
 
        // 2. 메뉴생성
        String[] smenu = { "파일" };
        JMenu[] mfile = new JMenu[10];
        for (int i = 0; i < smenu.length; i++) {
            mfile[i] = new JMenu(smenu[i]);
            mb.add(mfile[i]);
        }
 
 
        String[] ScrItem = { "새파일", "열기", "저장", "다른이름으로저장", "종료" };
        JMenuItem[] item = new JMenuItem[5];
        for (int i = 0; i < ScrItem.length; i++) {
            item[i] = new JMenuItem(ScrItem[i]);
            // 1. 이벤트 소스: JMenuItem
            // 4. 메뉴바 설정
            this.setJMenuBar(mb);
            mfile[0].add(item[i]);
 
        }
        
        // 컴포넌트 추가
        this.add(ta);
 
        this.setVisible(true);
    }
    public static void main(String[] args) {
        new Notepad();
    }
 
}
 
Colored by Color Scripter

cs

4. 함께 보면 좋은 글

[JAVA] JAVA의 GUI 기초, awt, swing 작성 절차, 컨테이너와 컴포넌트, 배치 관리자 | Yoon's Dev

JAVA의 GUI 기초, awt, swing 작성 절차, 컨테이너와 컴포넌트, 배치 관리자 학습 목표 JAVA의 GUI GUI 작성절차 기초 컨테이너와 컴포넌트 배치 관리자 1. JAVA의 GUI ■ 그래픽 사용자 인터페이스 ✓ Graphic

yooniron.tistory.com

[MySQL] 프로그래머스 SQL 고득점 Kit "JOIN" 문제 답안 | Yoon's Dev

Yooniron — Sat, 22 May 2021 21:02:15 +0900

프로그래머스 JOIN 문제 답안

프로그래머스 LEVEL 1 MySql로 푸는 JOIN 문 연습을 해보았습니다.

본 포스팅에서 작성하는 해답은 프로그래머스 예제에서 나온 문제를 바탕으로 작성하였습니다.

※본 답안은 무조건 이 답이다가 아닌 단순 참고용, 개인적인 답안입니다.
이 외에도 다양한 해결 방법이 있으니 참고용으로만 봐주시길 바랍니다.
(틀린 점이나 더 좋은 솔루션이 있으면 댓글로 적극 피드백 부탁드립니다!)

출처: https://programmers.co.kr/learn/courses/30/parts/17046

JOIN

■ LEFT JOIN

✓ A 값의 전체와 A의 Key값과 B Key 값이 같은 결과를 리턴

SELECT [테이블]

FROM TABLE_A

LEFT JOIN TABLE_B ON TABLE_A.KEY = TABLE_B.KEY

✓ LEFT JOIN (IS NULL)

- 순수 A의 값만 얻고자 할때 (where절이 추가됨)

+ where ~~ is null

■ INNER JOIN

✓ 일반적인 JOIN, 두 개의 테이블을 조건에 맞춰 연결해주는 작업

SELECT [테이블]

FROM TABLE_A

INNER JOIN TABLE_B ON TABLE_A.KEY = TABLE_B.KEY

■ OUTER JOIN

✓JOIN 할 테이블에 일치하는 레코드가 있으면 INNER 조인과 같은 결과를 만들어내지만,
INNER 테이블에 조건을 만족하는 레코드가 없는 경우에는 조인할 테이블의 칼럼을 모두 NULL로 채워서 가져옴

✓ INNER 테이블이 조인의 결과에 전혀 영향을 미치지 않고,

OUTER 테이블의 내용에 따라 조인의 결과가 결정되는 것이 OUTER JOIN의 특징.

SELECT [테이블]

FROM TABLE_A

[LEFT/RIGHT] OUTER JOIN TABLE_B ON TABLE_A.KEY = TABLE_B.KEY

1. 없어진 기록 찾기

실행 결과

2. 있었는데요 없었습니다

실행 결과

3. 오랜 기간 보호한 동물(1)

실행 결과

4. 보호소에서 중성화한 동물

실행 결과

※모든 문제에 대한 저작권은 프로그래머스(programmers.co.kr/)에 있습니다.

[JAVA] 스트림(Stream) 연산 옵션 타입 | Yoon's Dev

Yooniron — Thu, 20 May 2021 21:26:34 +0900

Java 스트림(Stream) 연산 옵션 타입

스트림 연산 옵션 타입

■ 스트림 연산 옵션 타입

✓ java.util 패키지 소속

✓ Optional은 null을 사용하지 않고 부재 값을 포함한 데이터를 저장하는 클래스

✓ 값의 존재 여부에 따라 다양하게 처리할 수 있는 기능을 제공

✓ 종류: Optional, OptionalInt, OptionalLong, OptionalDouble

Q) String과 Date는 상속 관계가 아닌데도 null???

옵션 타입

■ 옵션 타입

- Optional 및 OptionalInt 클래스가 제공하는 주요 연산

- OptionalInt는 파란색으로 표기

메서드	의미
static Optional empty()	빈 Optional 객체를 반환한다.
T get(), int getAsInt()	값을 반환하며, 없다면 예외를 던진다.
boolean isPresent()	값의 존재 여부를 반환한다.
void ifPresent(Consumer)	값이 있을 때 Consumer에서 처리한다.
static Optional of(T) static OptionalInt of(int)	주어진 값을 가진 Optional 타입으로 변환한다.
static Optional ofNullalble(T) static Optional ofNullable(int)	주어진 값을 가진 Optional을 반환한다. 만약 null이라면 빈 Optional을 반환한다.
T orElse(T), int orElse(int)	값이 없을 때 디폴트 값을 지정한다.

옵션 타입 예제

OptionalEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package lect12;
 
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
 
public class OptinalEx {
    
    public static OptionalDouble divide(double d, double e) {
        return e == 0 ? OptionalDouble.empty() : OptionalDouble.of(d / e);
    }
    
    public static void main(String[] args) {
        OptionalInt i = OptionalInt.of(100);
        OptionalDouble d = OptionalDouble.of(3.141592);
        Optional<String> s = Optional.of("Good Afternoon!");
        
        System.out.println(i.getAsInt());
        System.out.println(d.getAsDouble());
        System.out.println(s.get());
        
        System.out.println(i);
        System.out.println(d);
        System.out.println(s);
        
        System.out.println(divide(1.0, 2.0));
        System.out.println(divide(1.0, 0.0));
        
        System.out.println("======================");
        
//        String s1 = "Stream Test"; // 1차 테스트
        String s1 = null; // 2차 테스트
        Optional<String> so = Optional.ofNullable(s1);
        
        if(s1 != null) System.out.println(s1);
        else System.out.println("없음");
        
        if(so.isPresent()) System.out.println(so.get());
        else System.out.println("없음");
        
        String s2 = so.orElse("없음");
        System.out.println(s2);
        
        so.ifPresentOrElse(x -> System.out.println(x), () -> System.out.println("없음"));
    }
 
}
 
Colored by Color Scripter

cs

1차 테스트 결과

2차 테스트 결과

3. 함께 보면 좋은 글

[JAVA] 스트림(Stream) 연산 느긋한 연산, 조급한 연산, 병렬 처리 | Yoon's Dev

JAVA 스트림(Stream) 연산 느긋한 연산, 조급한 연산, 병렬 처리 스트림 연산과 옵션 타입 ■ 스트림 파이프라인 ✓ 스트림 연산의 결과가 Stream 타입이면 연속적으로 호출 가능 ✓ 스트림 연산의

yooniron.tistory.com

[JAVA] 스트림(Stream) 연산 느긋한 연산, 조급한 연산, 병렬 처리 | Yoon's Dev

Yooniron — Tue, 18 May 2021 22:01:29 +0900

JAVA 스트림(Stream) 연산 느긋한 연산, 조급한 연산, 병렬 처리

스트림 연산과 옵션 타입

■ 스트림 파이프라인

✓ 스트림 연산의 결과가 Stream 타입이면 연속적으로 호출 가능

✓ 스트림 연산의 연속 호출은 여러 개의 스트림이 연결되어 스트림 파이프 라인을 형성

느긋한 연산과 조급한 연산

■ 느긋한 연산과 조급한 연산

✓ 느긋한 연산

. 조급한 연산이 데이터 소스에게 원소를 요구할 때까지 아무 연산도 수행하지 않고 기다리는 특징

✓ 스트림의 최종 연산은 조급한 연산이지만 중간 연산은 느긋한 연산

✓ 최종 연산이 호출되기 전까지 중간 연산은 아무런 작업을 수행하지 않음

✓ 스트림의 중간 연산이 느긋한 연산이기 때문에

. 다운로드 방식처럼 저장 공간이 따로 필요 없음

. 스트림 연산은 빅데이터뿐만 아니라 무한 스트림에도 대응 가능

StreamOperatorEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package lect12;
 
import java.util.stream.IntStream;
 
//Stream의 연산 방식
public class StreamOperatorEx {
 
    public static void main(String[] args) {
        IntStream is = IntStream.rangeClosed(1, 5);
        
        is.filter( x -> {
            System.out.println("filter: " + x); // 느긋한 연산 (중간 연산)
            return x % 2 == 0;
        }).map(x -> {
            System.out.println("map: " + x); //느긋한 연산 (중간 연산)
            return x * x;
        }).forEach(x -> {
            System.out.println("forEach: " + x); // 조급한 연산(최종 연산)
        });
    }
 
}
Colored by Color Scripter

cs

실행 결과

연산 과정

병렬 처리

■ 병렬 처리

✓ 멀티 코어 CPU를 제대로 활용하여 데이터 소스를 병렬로 처리할 수 있도록 병렬 스트림 지원

✓ 컬렉션 혹은 순차 스트림으로부터 각각 parallelStream() 혹은 parallel() 메서드를 호출하여 병렬 스트림 획득

✓ 스트림을 부분 스트림으로 분할하기 어렵거나 데이터 소스의 크기가 작거나 혹은 싱글 코어 CPU라면 오히려 성능이 나빠질 수 있음

ParallelStreamEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package lect12;
 
import java.util.stream.IntStream;
 
//스트림 병렬처리
public class ParallelStreamEx {
 
    public static void main(String[] args) {
        //순차처리
        long total;
        checkExecutionTimer.setStartTime();
        IntStream seq = IntStream.rangeClosed(1, 100000000);
        total = seq.sum();
        System.out.println("순차처리: " + total);
        checkExecutionTimer.setEndTime();
        checkExecutionTimer.printExecutionTime();
        
        //병렬처리
        checkExecutionTimer.setStartTime();
        IntStream parallel = IntStream.rangeClosed(1, 100000000).parallel();
        total = parallel.sum();
        System.out.println("병렬처리: " + total);
        checkExecutionTimer.setEndTime();
        checkExecutionTimer.printExecutionTime();
        
    }
 
}
 
Colored by Color Scripter

cs

 

실행 결과

[MySQL] 프로그래머스 SQL 고득점 Kit "IS NULL" 답안 | Yoon's Dev

Yooniron — Sun, 16 May 2021 22:17:08 +0900

프로그래머스 SQL 고득점 Kit "IS NULL" 문제 답안

프로그래머스 LEVEL 1 MySql로 푸는 IS NULL 문 연습을 해보았습니다.

출처: https://programmers.co.kr/learn/courses/30/parts/17045

NULL값 처리

■ NULL 이란?

✓ NULL 값의 의미: NULL은 미확인 값 혹은 아직 결정되지 않은 값을 의미한다.

✓ NULL은 숫자 0이나 공백과는 다른 값이다.

■ IFNULL()

✓ 해당 Column의 값이 NULL을 반환할 때, 다른 값으로 출력할 수 있도록 하는 함수이다.

SELECT IFNULL(컬럼명, "Null일 경우 대체 값") FROM 테이블명;

1. 이름이 없는 동물의 아이디

실행 결과

2. 이름이 있는 동물의 아이디

실행 결과

3. NULL 처리하기

실행 결과

※모든 문제에 대한 저작권은 프로그래머스(programmers.co.kr/)에 있습니다.

[JavaScript] 자바스크립트(JavaScript)란? | Yoon's Dev

Yooniron — Sat, 15 May 2021 20:38:31 +0900

자바스크립트(JavaScript)란?

■ 자바스크립트(JavaScript)란?

✓ 자바스크립트(JavaScript)는 객체(object) 기반의 스크립트 언어이다.

✓ HTML에서 웹 내용을 작성하고, CSS로는 웹을 디자인하고, JavaScript로는 웹의 동작을 구현할 수 있다.

✓ 자바스크립트는 주로 웹 브라우저에서 사용되나, Node.js 같은 프레임워크를 사용하면 서버 측에서도 사용 가능하다.

1. 자바스크립트의 역사

■ 자바스크립트(JavaScript)의 역사

✓ 1995년에 넷스케이프(Netscape)의 브렌던 아이크(Brenden Eich)에 의해 만들어졌다.

✓ 모카(Mocha)라는 이름으로 처음에 개발되었으나, 그 후에 라이브스크립트(LiveScript), 최종적으로 자바스크립트(JavaScript)로 이름이 변경되었다.

2. 자바스크립트의 특징

■ 자바스크립트(JavaScript)의 역사

✓ 자바스크립트는 객체 기반의 스크립트 언어이다.

✓ 자바스크립트는 동적이며, 타입을 명시할 필요가 없는 인터프리터 언어이다.

✓ 자바스크립트는 객체 지향형 프로그래밍과 함수형 프로그래밍을 모두 표현할 수 있다.

3. 자바와 자바스크립트의 차이

■ 자바와 자바스크립트의 차이

자바 (JAVA)	자바스크립트 (JavaScript)
컴파일 언어	인터프리터 언어
타입 검사가 엄격함	타입을 명시하지 않음
클래스(class) 기반의 객체 지향 언어	프로토타입(prototype) 기반의 객체 지향 언어

4. 자바스크립트 표준

■ 자바스크립트(JavaScript) 표준안

ECMAScript: 넷스케이프가 인터넷 상의 다양한 스크립트 언어를 하나로 묶기 위해 제시한 표준안.

이 스펙을 구현한 JavaScript 구현체로는 구글의 V8 엔진, 모질라의 SpiderMonkey, Microsoft의 Chakra 등이 있다.

실제로 JavaScript에만 적용되는 표준안이 아니라, IE의 JScript나 Adobe Flash ActionScript의 표준이기도 하다.

현재는 ECMAScript 2020의 표준 (ES11)까지 나와있으며, 대부분의 JavaScript 런타임에서는 이 표준을 모두 구현한 상태는 아니다. 2018년 현재는 IE등의 구형 브라우저를 제외하고는 ES2016 표준까지는 적당히 구현이 되어있는 상태.

또한, 구현이 안된 브라우저를 지원하기 위해서 Babel 등의 Transpiler를 사용해서 ES2015 이상의 기능을 어느 정도 사용할 수 있다

5. 주요 라이브러리

jQuery: DOM Manipulating 라이브러리. 사실상 자바스크립트 개발에 필수였던 라이브러리였으나 리액트, 앵귤러 등의 프레임워크의 생산성이 워낙 높다 보니 2010년대 후반부터는 사실상 레거시가 되었으며 아주 간단한 웹사이트에서만 쓰이고 안 쓰는 추세다. 기본적으로 document.querySelectorAll('oooo')를 $('oooo')로 쓸 수 있는 등의 기능이 있다.
AngularJS: 구글에서 제작한 프론트엔드용 클라이언트 사이드 JavaScript 프레임워크. Angular 1으로도 불린다. 백엔드, 프런트엔드를 동시에 작업할 수 있다. MongoDB, Express, AngularJS, Node.js를 함께 사용하여 MEAN Stack으로 많이 사용한다. Angular 2 이후로는 이건 TypeScript를 이용한다. 기본적으로 많은 기능들이 내재되어 있다.
React: Facebook에서 만든 프론트엔드용 오픈소스 라이브러리다. 단방향 데이터 흐름과, Virtual DOM 개념을 도입한 UI 컴포넌트 라이브러리. 생산성이 높고, DOM 업데이트에 있어서 성능이 매우 빨라 동적인 웹 애플리케이션 구성에 유리하다. 그리고 이러한 동적 웹이 모던 웹 애플리케이션의 필수 요소가 되어버린 만큼 출시 이후 꾸준히 점유율을 늘려가며 업계 표준 라이브러리 중 하나로 자리 잡았다. 최근에는 React Hooks이라 불리는 메서드가 지원되면서 생산성이 더 좋아졌다. html로 뷰를 작성해야 하는 Angular와는 다르게 JSX라는 문법을 지원하면서 JavaScript만으로 애플리케이션을 작성하는 게 가능하다. 기존 문서에는 MVC의 V(View)를 담당하는 라이브러리라고 되어 있었으나 리액트는 MVC framework가 아니며 View뿐만 아니라 Controller 부분까지도 리액트 컴포넌트 내에서 작성이 가능하므로 정확한 설명이 아니다.
Vue.js: 중국계 미국인 에반 유가 만든 사용자 인터페이스를 만들기 위한 프론트엔드용 프레임워크이다. 굉장히 자유롭고 유연하게 추가 기능들을 불러올 수 있다는 특징이 있으나 추가 기능들을 무분별하게 사용하는 경우 안정성을 떨어뜨릴 수 있다.
Node.js: 브라우저 안에서만 작동하던 JavaScript를 브라우저 외의 환경에서 작동할 수 있게 만들어 준 런타임 환경이다.
Express.js: Node.js를 위한 웹 애플리케이션 프레임워크. 주로 Node로 백엔드 개발할 때 사용된다.
Deno: Node.js의 개발자 Ryan Dahl이 Node.js의 아쉬운점을 개선한 JavaScript 엔진이다.

[HTML5/CSS] form태그의 전송 방식 GET과 POST의 차이점 | Yoon's Dev

Yooniron — Fri, 14 May 2021 20:25:54 +0900

form태그의 전송 방식 GET과 POST의 차이점

HTTP

■ HTTP란?

□ HTTP(HyperText Transfer Protocol)

✓ W3 상에서 정보를 주고받을 수 있는 프로토콜이다.

✓ HTTP 메서드에는 GET 방식과 POST 방식으로 정보를 주고받을 수 있다.

GET

■ GET

□ URL에 파라미터를 포함시켜서 요청하는 방식

✓ URL에 파라미터를 포함시킨다.

✓ 데이터를 헤더에 포함시켜 전송한다.

✓ 캐싱이 가능하다.

✓ 글자 수의 제한이 있다.

특징

✓ 전송 속도가 POST 방식보다 빠르다

✓ 데이터베이스에 대한 질의어 데이터와 같은 요청 자체를 위한 정보를 전송할 때 사용된다.

✓ 데이터가 URL 뒤에 붙기에 보안이 매우 취약하다

1
2
3
4
5
6
7

<form action="" method="GET">
 
   텍스트를 입력하세요 :
 
    <input type="text" name="search">
     <input type="submit" value="전송">
</form>

cs

 

다음과 같이 Yoon's Dev를 입력하고 전송해보자.

위와 같이 URL을 보면 test.html? 이후에 데이터를 포함시킨 것을 확인할 수 있다.

POST

■ POST

□ URL에 붙여 보내지 않고 Body에 데이터를 넣어서 보내는 방식

✓ 클라이언트와 서버 간 인코딩하여 서버로 전송한다

✓ 데이터를 Body에 포함시켜 전송한다.

. Header에 Content-Type 필드 안에 데이터 타입을 명시하여야 한다

✓ 전송할 데이터의 길이의 제한이 없다

특징

✓ 복잡한 형태의 데이터를 전송할 때 유용하다.

✓ 데이터베이스에 대한 갱신 작업과 같은 서버 측에서의 정보 갱신 작업을 원할 때 사용한다.

✓ 입력한 데이터가 URL에 보이지 않으므로 보안에 GET방식보다 우수하다

1
2
3
4
5
6
7

<form action="" method="POST">
 
   텍스트를 입력하세요 :
 
    <input type="text" name="search">
     <input type="submit" value="전송">
</form>

cs

다음과 같이 Yoon's Dev를 입력하고 전송해보자.

다음과 같이 URL에 아무것도 뜨지 않는 것을 확인할 수 있다.

[JSP] 이클립스에서 JDBC로 MySQL 연동하기 | Yoon's Dev

Yooniron — Wed, 12 May 2021 21:34:58 +0900

이클립스에서 JDBC로 MySQL 연동하기

JDBC

■ JDBC란?

□ Java DataBase Connectivity

✓ 데이터베이스를 다루기 위한 자바 API

✓ JDBC를 통해서 DBMS의 종류와 관계없이 질의문을 던져서 데이터를 수신

✓ 각 데이터베이스의 접속에 대한 상세한 정보가 불필요

□ JDBC의 구성

✓ JDBC 인터페이스: 프로그래머에게 쉬운 데이터베이스와 연동되는 프로그램을 작성할 수 있게 하는 도구

✓ JDBC 드라이버: JDBC 인터페이스를 구현하여 실제로 DBMS를 작동시켜서 질의를 던지고 결과를 받음

JDBC Driver 설치

MySQL 사이트 http://dev.mysql.com/downloads/connector/j/

MySQL :: Download Connector/J

MySQL Connector/J 8.0 is highly recommended for use with MySQL Server 8.0, 5.7 and 5.6. Please upgrade to MySQL Connector/J 8.0.

dev.mysql.com

mysql-connector-java-8.0.24.zip 다운로드 후, 압축해제

드라이버 파일

다음 드라이버 파일(mysql-connector-java-8.0.24.jar)파일을 다음 셋 폴더 중 하나에 복사

[Tomcat 설치 폴더]/lib

program files/java/jreX/lib/ext

이클립스 라이브러리

이클립스를 열고, 동적 웹 프로젝트의 WebContent - lib 폴더에 복사한 드라이버 파일 붙여넣기

2. JDBC 연결 테스트

DriverTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package ch11;
 
import java.sql.*;
 
public class DriverTest{
    public static void main(String args[]){
        Connection con = null;
 
        try{
            Class.forName("com.mysql.cj.jdbc.Driver");
            con=DriverManager.getConnection(
                    "jdbc:mysql://localhost:포트번호/mydb?serverTimezone=UTC", // DB URL
                    "USER_NAME", "비밀번호");  // USER_NAME과 PASSWORD
            System.out.println("Success");
        }
        catch(SQLException ex){ 
            System.out.println("SQLException" + ex);
            ex.printStackTrace();
        }
        catch(Exception ex){ 
            System.out.println("Exception:" + ex);
            ex.printStackTrace();
        }
    }
}
 
Colored by Color Scripter

cs

"jdbc:mysql://localhost:포트번호/mydb?serverTimezone=UTC", // DB URL

"USER_NAME", "비밀번호" // USER_NAME과 PASSWORD

실행 후 다음과 같이 Success가 뜬다면 제대로 연동이 된 것이다.

실행결과

[MySQL] 프로그래머스 SQL 고득점 Kit "GROUP BY" 문제 답안 | Yoon's Dev

Yooniron — Mon, 10 May 2021 22:05:57 +0900

프로그래머스 SQL 고득점 Kit GROUP BY 문제 답안

프로그래머스 LEVEL 1 MySql로 푸는 GROUP BY문 연습을 해보았습니다.

출처: programmers.co.kr/learn/courses/30/parts/17044

GROUP BY

MySQL에서 유형별로 개수를 가져오고 싶을 때 컬럼의 데이터를 그룹화 할 수 있는 GROUP BY

SELECT 컬럼

FROM 테이블

GROUP BY 그룹화 할 컬럼

[HAVING 조건식]

1. 고양이와 개는 몇 마리 있을까

실행 결과

2. 동명 동물 수 찾기

실행 결과

3. 입양 시각 구하기(1)

hour("시:분:초")

시간을 알려준다.(0 ~ 23)

실행 결과

4. 입양 시각 구하기(2)

■ OUTER JOIN

✓ OUTER JOIN은 조인하는 테이블의 ON 절의 조건 중 한쪽의 데이터를 모두 가져옵니다.

■ WITH RECURSIVE

✓ WITH RECURSIVE는 메모리 상에 가상의 테이블을 저장합니다.

✓ 재귀 쿼리를 이용해 실제로 테이블을 생성하거나 삽입하지 않아도 가상 테이블을 구성합니다.

WITH RECURSIVE 테이블 AS(

SELECT 초기값 AS 컬럼별칭

UNION ALL

SELECT 컬럼별칭 계산식 FROM 테이블 WHERE 제어문)

실행 결과

※모든 문제에 대한 저작권은 프로그래머스(programmers.co.kr/)에 있습니다.

[JAVA] JAVA 람다식을 활용한 예제 (1) | Yoon's Dev

Yooniron — Sat, 8 May 2021 21:28:54 +0900

AVA 람다식을 활용한 예제 (1)

TO Do.

- 디젤 자동차만 모두 찾기

- 10년보다 오래된 자동차만 모두 찾기

- 10년보다 오래된 디젤 자동차만 모두 찾기

- 디젤 자동차를 출력하되 모델과 연식만 나타나도록 출력

- 10년보다 오래된 자동차를 출력하되 모델, 연식, 주행거리만 출력

목표: 람다식을 활용하여 조건에 맞는 자동차 찾는 프로그램을 만들어보자!

1. 필요한 메서드와 인터페이스

■ 필요한 메서드

List<Car> findCars(List<Car> all, CarPredicate p)

List<Car>: 요구 조건에 맞는 차들

List<Car> all: 다양한 종류의 자동차

CarPredicate p: 요구조건

void printCars(List<Car> all, CarConsumer c)

■ 필요한 인터페이스

1) CarConsumer.java

1
2
3
4
5

//필요한 함수형 인터페이스 1
public interface CarConsumer { //받기만하고 리턴하지 않음
    void apply(Car car);
}
 
Colored by Color Scripter

cs

2) CarPredicate.java

1
2
3
4
5

//필요한 함수형 인터페이스 2
public interface CarPredicate { //인자 값을 받아서 True/Flase 리턴
    boolean test(Car car);
}
 
Colored by Color Scripter

cs

 

2. Car.java

Car.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package hw;
 
import java.util.Arrays;
import java.util.List;
 
public class Car {
    //멤버변수
    private String model;
    private boolean gasoline;
    private int age;
    private int mileage;
    
    //생성자
    public Car(String model, boolean gasoline, int age, int mileage) {
        this.model = model;
        this.gasoline = gasoline;
        this.age = age;
        this.mileage = mileage;
    }
    
    //메소드
    public String getModel() {
        return model;
        }
    
    public boolean isGasoline() {
        return gasoline;
    }
    
    public int getAge() {
        return age;
    }
    
    public int getMileage() {
        return mileage;
    }
    
    public String toString() {
        return String.format("Car(%s, %s, %d, %d)", model, gasoline, age, mileage);
    }
 
    //Car 목록
    public static final List<Car> cars = Arrays.asList(
            new Car("소나타", true, 18, 210000),
            new Car("코란도", false, 15, 200000),
            new Car("그랜저", true, 12, 150000),
            new Car("산타페", false, 10, 220000),
            new Car("아반떼", true, 10, 70000),
            new Car("에쿠스", true, 6, 100000),
            new Car("그랜저", true, 5, 80000),
            new Car("소나타", true, 2, 35000),
            new Car("쏘렌토", false, 1, 10000),
            new Car("아반떼", true, 1, 7000));
}
 
Colored by Color Scripter

cs

3. CarDemo.java

CarDemo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package hw;
 
import java.util.ArrayList;
import java.util.List;
 
public class CarDemo {
    
    public static List<Car> findCars(List<Car> all, CarPredicate cp) {
        List<Car> result = new ArrayList();
        for (Car car : all) {
            if (cp.test(car)) { //test 메서드의 내용은 아래 람다식으로 정의
                result.add(car);
            }
        }
        return result;
    }
    
    public static void printCars(List<Car> all, CarConsumer cc) {
        for (Car car : all) {
            cc.apply(car);
        }
    }
    
    public static void main(String[] args) {
        //디젤자동차 찾기
        List<Car> dieselCars = findCars(Car.cars, c -> !c.isGasoline());
        System.out.println("디젤 자동차 = " + dieselCars);
        //10년보다 오래된 자동차만 모두 찾기
        List<Car> oldCars = findCars(Car.cars, c -> c.getAge() > 10);
        System.out.println("오래된 자동차 = " + oldCars);
        //10년보다 오래된 디젤 자동차만 모두 찾기
        List<Car> oldDieselCars = findCars(Car.cars, c -> c.getAge() > 10 && !c.isGasoline());
        System.out.println("오래된 디젤 자동차 = " + oldDieselCars);
        //디젤 자동차를 출력하되 모델과 연식만 나타나도록 출력
        System.out.print("디젤 자동차 = ");
        printCars(dieselCars, c -> System.out.printf("%s(%d) ", c.getModel(), c.getAge()));
        //10년보다 오래된 자동차를 출력하되 모델, 연식, 주행거리만 출력
        System.out.print("\n오래된 자동차 = ");
        printCars(oldCars, c -> System.out.printf("%s(%d, %d) ", c.getModel(), c.getAge(), c.getMileage()));
        
    }
 
}
 
Colored by Color Scripter

cs

4. 실행결과

함께 보면 좋은 글

[JAVA] JAVA의 람다식 사용법 및 다양한 작성 예제 | Yoon's Dev

JAVA의 람다식(lambda) 사용법 및 다양한 작성 예제 Java의 람다식 ■ 자바의 람다식 ✓ 람다식(lambda) - 자바에서는 함수를 메서드라고 부르고 메서드의 형태로 존재 - 자바 람다식의 구조 . (argument)

yooniron.tistory.com

[MySQL] 프로그래머스 SQL 고득점 Kit "SUM, MAX, MIN" 문제 답안 | Yoon's Dev

Yooniron — Thu, 6 May 2021 20:27:14 +0900

프로그래머스 SQL 고득점 Kit SUM, MAX, MIN 문제 답안

프로그래머스 LEVEL 1 MySql로 푸는 SUM, MAX, MIN 문 연습을 해보았습니다.

출처: programmers.co.kr/learn/courses/30/parts/17043

SUM, MAX, MIN

집계함수의 대표적인 함수들이다.

COUNT(): 행의 개수

SUM(): 합계

AVG(): 평균

MIN(): 최솟값

MAX(): 최댓값

DISTINCT: 중복을 제거하고 출력

1. 최댓값 구하기

실행 결과

2. 최솟값 구하기

실행 결과

3. 동물 수 구하기

실행 결과

4. 중복 제거하기

실행 결과

※모든 문제에 대한 저작권은 프로그래머스(programmers.co.kr/)에 있습니다.

[MySQL] 프로그래머스 SQL 고득점 Kit "SELECT" 문제 답안 | Yoon's Dev

Yooniron — Wed, 5 May 2021 21:57:56 +0900

프로그래머스 SQL 고득점 Kit SELECT 문제 답안

프로그래머스 LEVEL 1 MySql로 푸는 SELECT문 연습을 해보았습니다.

본 포스팅에서 작성하는 해답은 프로그래머스 SELECT 예제에서 나온 문제를 바탕으로 작성하였습니다.

※본 답안은 무조건 이 답이다가 아닌 단순 참고용, 개인적인 답안입니다.
이 외에도 다양한 해결 방법이 있으니 참고용으로만 봐주시길 바랍니다.
(틀린점이나 더 좋은 솔루션이 있으면 댓글로 적극 피드백 부탁드립니다!)

출처: programmers.co.kr/learn/courses/30/parts/17042

SELECT문

MySQL에서는 SELECT문을 사용하여 테이블의 레코드를 선택할 수 있다.

문법:

SELECT 필드 이름

FROM 테이블 이름

[WHERE 조건]

기본적으로 정렬은 오름차순(asc)이다.

1. 모든 레코드 조회하기

실행 결과

2. 역순 정렬하기

실행 결과

3. 아픈 동물 찾기

실행 결과

4. 어린 동물 찾기

실행 결과

5. 동물의 아이디와 이름

실행 결과

6. 여러 기준으로 정렬하기

실행 결과

7. 상위 n개 레코드

실행 결과

※모든 문제에 대한 저작권은 프로그래머스(programmers.co.kr/)에 있습니다.

[Android] 안드로이드 프레퍼런스(Preference)를 이용한 설정 정보 값 저장하기 | Yoon's Dev

Yooniron — Tue, 4 May 2021 21:36:54 +0900

안드로이드 프레퍼런스(Preference)를 이용한 설정 정보 저장하기

* 해당 글은 안드로이드 스튜디오 4.1.2 기준으로 설명되었습니다. *

TO Do.

기본 데이터, 입력, 설정 정보 저장 혹은 전달한 데이터를 저장, 관리하기 위한 데이터를 다루기

사용자가 입력한 정보, 환경 설정 정보 등을 간단히 저장 관 리 할 수 있는 프레퍼런스의 사용법을

간단한 액티비티 구현을 통해서 확인

프레퍼런스(Preference)

■ 프레퍼런스

✓ 제일 단순한 저장 형태

✓ 각 애플리케이션에 고유한 설정값을 지정

✓ <키, 값>의 조합으로 데이터 저장

. 값에 이름을 부여하여 저장

. 환경설정에 유용

✓ 주요 메서드

. SharedPreference 인터페이스

- getSharedPreference()에 의해 반환된 프레퍼런스 객체를 접근/수정 제공

- SharedPreference.Editor editor = pref.edit()

. 프레퍼런스 객체를 수정 후, commit() 연산으로 배치로 처리

프레퍼런스 예제

목표:

1. 처음 실행 시 기본 설정된 값으로 동작

2. 사용자 정보를 입력 후에 setting 버튼을 누르면 해당 정보를 저장, 다시 실행 시 해당 정보를 불러와 사용

1. 레이아웃 구성

activity_main.xml

ID를 입력받을 editText의 id 값: editText_id

ID를 입력받을 editText의 id 값

패스워드를 입력 받을 editText의 id 값: editText_pw

패스워드를 입력 받을 editText의 id 값

이번 포스팅에서는 프레퍼런스 기능을 확인하기 위한 부분이라 간단한 사용자 입력창으로만 구성하였다.

textView 2개와 editText 1개 그리고 패스워드를 받을 부분은 editText의 Password 형태 그리고 마지막으로 버튼 2개로 SETTING 버튼과 CLOSE 버튼으로 레이아웃을 구성하였다.

Baseline 설정

이런 식으로 옆 TextView와 editText의 높이를 맞추려면 Baseline을 이용하면 높이를 쉽게 맞출 수 있다.

2. Java Class 파일(기능 구현)

MainActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package com.example.preference;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
 
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
 
    EditText editText_id, editText_pw;
    Button btn01, btn02;
 
    SharedPreferences spref;
    SharedPreferences.Editor editor;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        editText_id = (EditText)findViewById(R.id.editText_id);
        editText_pw = (EditText)findViewById(R.id.editText_pw);
 
        btn01 = (Button)findViewById(R.id.btn01);
        btn02 = (Button)findViewById(R.id.btn02);
 
        btn01.setOnClickListener(this);
        btn02.setOnClickListener(this);
 
        spref = getSharedPreferences("gref", MODE_PRIVATE);
        editor = spref.edit();
 
        String temp1 = spref.getString("editText_id", "id를 입력하세요");
        String temp2 = spref.getString("editText_pw", "");
 
        editText_id.setText(temp1);
        editText_pw.setText(temp2);
    }
 
    @Override
    public void onClick(View v) {
        String txt01, txt02;
        txt01 = editText_id.getText().toString();
        txt02 = editText_pw.getText().toString();
 
        if(v.getId() == R.id.btn01) {
            editor.putString("editText_id", txt01);
            editor.putString("editText_pw", txt02);
            editor.commit();
        }
        if(v.getId() == R.id.btn02) {
            finish();
        }
    }
}
Colored by Color Scripter

cs

getSharedPreference()에 의해 반환된 프레퍼런스 객체를 접근/수정 제공

SharedPreference.Editor editor = spref.edit()

프레퍼런스 객체를 수정 후, commit() 연산으로 배치로 처리

3. 실행결과

setting 버튼을 누르기 전엔 이런 식으로 기본 화면이 구성되어있을 것이다.

기본 화면

하지만 다음과 같이 ID와 비밀번호를 입력하고 SETTING 버튼을 눌러주게 되면

실행결과

이렇게 앱을 재실행해도 사용자가 입력했던 값이 남아 있는 것을 확인할 수 있다.

[Android] 액티비티(Activity) 상태와 생명주기 | Yoon's Dev

Yooniron — Sun, 2 May 2021 21:22:02 +0900

Android Studio 액티비티(Activity) 상태와 생명주기

애플리케이션 개념

■ 액티비티, 태스크와 프로세스

□ 액티비티

✓ 같은 애플리케이션 내에 존재하는 액티비티뿐만 아니라 다른 애플리 케이션 내에 존재하는 액티비티까지 호출 가능

✓ 한 애플리 케이션에서 다른 애플리케이션의 컴포넌트를 거의 자유자재로 접근 가능

✓ 각 컴포넌트들, 특히 화면에 표시되면서 사용자와 상호작용하는 액티비티는 애플리케이션 단위보다 Task 단위로 관리

□ 태스크(Task)

✓ 사용자가 실질적으로 "하나의 애플리케이션처럼" 느끼는 액티비티들의 집합

✓ 다수의 프로세스와 APK에 걸쳐 존재 가능

✓ 다른 APK의 액티비티 호출 가능

□ 프로세스

✓ 커널 프로레스

✓ 기본적으로 APK는 하나의 프로세스에서 동작

✓ 하나의 APK에서 다수의 프로세스 매핑 가능

■ 액티비티 스택

액티비티 스택

액티비티 상태와 생명주기

■ 개요

✓ 안드로이드는 모바일 기기에서 구동되기 때문에 데스크탑 애플리케이션에 비해 더욱 효율적인 메모리 관리를 요구

✓ 애플리케이션 컴포넌트의 중요 요소인 액티비티도 효율적인 메모리 관리를 위하여 액티비티 생성 및 소멸 과정인

"생명주기"가 있음

✓ 액티비티가 중지 혹인 정지 상태일 경우, 해당 프로세스가 메모리에서 제거될 수 있음.

사용자에게 다시 보여질 때 이전 상태로 복구

✓ 액티비티는 액티비티 스택(Activity Stack)을 통해 관리

액티비티는 사용자와 상호 작용하는 단위이며 일반적으로 전체 화면을 차지한다.

■ 액티비티의 3가지 상태

□ 활성(active) 혹은 실행(running) 상태

✓ 전경 화면에 있을 경우

✓ 해당 액티비티가 사용자 동작에 대한 초점을 가짐

✓ 사용자와 상호 작용 가능

□ 중지(paused) 상태

✓ 초점을 보유하지 않았지만 사용자에게 일부 보임

✓ 메모리가 극도로 부족할 경우 시스템에 의하여 강제 종료

✓ 사용자와 상호 작용 불가

□ 정지(stopped) 상태

✓ 사용자에게 전혀 보이지 않지만 여전히 모든 상태와 멤버 정보는 유지

✓ 다른 컴포넌트가 메모리를 요청하면 시스템에 의하여 강제 종료

■ 액티비티의 생명주기

액티비티의 생명주기

액티비티를 위한 콜백 메서드

■ 액티비티를 위한 콜백 메서드

□ onCreate()

✓ 액티비티가 생성될 때 처음으로 호출되는 메서드

✓ 전역 상태의 모든 리소스를 초기화.

ex) layout과 data binding 등

✓ 액티비티는 기본적으로 버튼, 리스트, 체크박스, 입력 표시줄 등과 같은 위젯들이 배치되어있는 레이아웃을 구성하고 위젯들이 사용자와 상호작용하는 코드를 포함

□ onStart()

✓ 액티비티가 초기화 과정을 마친 후 사용자에게 보여줄 준비가 되었을 때 호출

□ onResume()

✓ 액티비티가 사용자에게 보여지고 사용자의 입력을 처리할 수 있음

✓ 액티비티 스택의 최상위에 위치

□ onPause()

✓ 사용자와 상호작용이 중지

✓ 액티비티 종료 등을 대비해 상태를 저장하는 등의 작업을 수행

□ onStop()

✓ 더 이상 액티비티가 사용자에게 보이지 않음

✓ 더 이상 액티비티 스택의 최상위에 위치하지 않음

□ onDestory()

✓ 존재하는 모든 리소스를 해제

✓ 시스탬 내에 액티비티가 존재하지 않게 됨

□ onRestart()

✓ onStop() 메서드 호출 이후 정지 상태에 있던 액티비티를 다시 화면에 표시할 때 호출

액티비티 상태 저장하기

■ 액티비티 상태 저장하기

✓ 일반적으로 정지된 액티비티는 사용자가 다시 사용할 것을 대비하여 메모리에 상주

if) 메모리가 부족하게 되면 강제 종료

✓ 액티비티를 다시 호출하면??

. 강제 종료된 상태: 다시 액티비티를 생성한 후 액티비티를 실행

. 강제 종료되지 않은 상태: 액티비티를 다시 만들 필요가 없고 액티비티를 다시 시작하여 화면에 표시

□ onSaveInstanceState()

✓ onPause() 혹은 onStop() 이후 메모리가 부족할 경우 프로세스가 메모리에서 제거될 수 있음

✓ 메모리에서 제거되기 전 액티비티 상태를 저장

✓ 매개변수로 액티비티의 동적 상태를 기록할 수 있는 번들(Bundle) 오브젝트를 가짐

□ onRestoreInstanceState()

✓ onCreate() 혹은 onStart() 이후 저장된 액티비티 상태를 복원

!! onSaveInstanceState()와 onRestoreInstanceState()는 생명주기 메서드가 아니기 때문에 항상 호출되지 않음.

개발자가 해당 코드의 메서드를 재정의 하여 구현해야 한다.

!! 매개변수로 사용되는 savedInstanceState는 저장된 인스턴의 상태, 즉 액티비티 UI 상태를 의미

[Git] GitHub, 깃허브 repository에 파일 업로드(push)하는 방법 | Yoon's Dev

Yooniron — Sat, 1 May 2021 22:43:52 +0900

Github, 깃허브 repository에 파일 업로드(push)하는 방법

간단히 말해서 Git bash를 이용해 Github 저장소에 내 프로젝트, 소스들을 업로드하는 방법이다.

Github desktop을 이용해 GUI로 쉽게 할 수 있지만, 이 포스팅에서는 Git bash를 이용한 commit-push 하는 방법이다.

1.Git 설치

우선, Git이 설치되어있지 않다면 아래 사이트에서 git을 설치해주도록 합니다.

(Windows/Mac/Linux/Unix)

https://git-scm.com/downloads

Git - Downloads

Downloads macOS Windows Linux/Unix Older releases are available and the Git source repository is on GitHub. GUI Clients Git comes with built-in GUI tools (git-gui, gitk), but there are several third-party tools for users looking for a platform-specific exp

git-scm.com

2. Github에 repository 만들기

Github 사이트에 접속 후 로그인한다.

(계정이 없으시면 회원가입을 해주시면 됩니다.)

1. 왼쪽에 있는 New 버튼으로 repository 생성하는 방법

2. 프로필 메뉴를 이용해 repository 생성하는 방법

Repository name: 저장소의 이름

Description: 저장소에 대한 간단한 설명

Public: 저장소를 모두에게 공개

Private: 지정된 사람에게만 공개

initialize this repository with a README를 체크해주면

저장소가 생성될 때 README.md 파일이 자동으로 함께 생성된다.

모두 작성했다면 아래의 Create repository 버튼을 눌러 저장소를 생성해줍니다.

3. 내 컴퓨터에서 원격 저장소 가져오기

로컬 저장소를 만들 디렉토리를 하나 생성해줍니다.

디렉터리 마우스 우클릭 - Git Bash here (윈도우 기준/Linux, Mac의 경우 터미널 열기)

git 초기 설정(Git을 설치하고 초기 설정이 안된 분들은 해주셔야 합니다.)

[] 생략해주시고 가입이름, 이메일을 넣어주시면 됩니다.

가입 이름 등록

가입 이메일 등록

앞서 생성한 저장소를 가져오기전에 먼저 생성한 Repository로 이동하여 HTTPS에 해당하는 url을 복사해줍니다.

그러고 나서 git init을 입력해줍니다.

그럼 이제 디렉터리 안에 .git이라는 폴더가 생긴 것을 확인합니다.

그다음 git add .를 해줍니다.

git add .(또는 특정 파일이나 폴더)

그다음은 git commit - "커밋 메세지"로 커밋 로그를 작성해줍니다.

만약 위와 같은 에러가 뜬다면 다시 git init을 해줍니다.

다시 git add . 와 git commit을 해주시면 됩니다.

3. push

마지막으로 commit한 파일을 원격 저장소로 업로드(push)를 해줍니다.

origin: 원격 저장소의 주소(Repository로 이동하여 HTTPS에 해당하는 url을 복사한 값 넣어주시면 됩니다.)

붙여넣기: Shift + insert

위 명령어를 입력하시고 나면

다음과 같은 Github 로그인 창이 뜨는데 이름과 비밀번호를 입력하고 로그인해주면 최종적으로 push가 됩니다.

최종적으로 Github 저장소로 가셔서 올린 파일과 커밋 로그가 정상적으로 올라가셨으면 성공입니다.

"킴킴"의 향후 인공지능에 대한 이야기를 읽고.... | Yoon's Dev

Yooniron — Fri, 30 Apr 2021 18:28:36 +0900

한국인이면서 MS의 클라우드와 인공지능 그룹 Localization 기획 설계자인 “킴킴”

그는 빅데이터로 활성화되는 AI가 인간의 영역에 근접해가는 현재, 그리고 생존과 관련된 모든 활동을 대신할 미래에 명상의 중요성을 거듭 강조했다.

과연 그의 생각 대로 빅데이터와 AI의 연관성은 아주 밀접해 있다는 것을 느꼈다.

우선 빅 데이터란 디지털 환경에서 생성되는 데이터로 그 규모가 방대하고, 생성 주기도 짧고, 형태도 수치 데이터 뿐 아니라 문자와 영상 데이터를 포함하는 대규모 데이터를 말한다.

인간의 몸으로 예를 들면 인간의 몸에는 지구가 생겨난 이후 약 35억 년 동안 구축된 빅 데이터가 있다. 그것이 유전돼 내려오고 있고, 바나나를 사람이 먹을 때는 사람 몸이 되는 것, 강아지가 먹으면 강아지의 몸이 되는 것, 이 역시 빅 데이터 때문이라고 볼 수 있다.

더울 때 누가 땀샘을 열고 닫는 것? 우리가 부모로부터 태어나기도 전에 구축된 인간의 빅 데이터라고 볼 수 있다.

2020년까지의 5엑사 바이트의 데이터를 생산하는데 2017년에서부터 2020년까지 하루가 걸렸다고 한다. 2013년까지 인류가 생산한 데이터가 하루에 축적되는 셈이다. 2020년에는 단 10초, 저녁 먹고 인증샷을 “페이스북”, "인스타그램"등에 올릴 때마다 빅 데이터가 생산된다.

이렇게 빅데이터는 무시무시한 속도로 확장되고 있는 것이다. 이렇게 급속도로 확장되고 있는 빅 데이터가 AI와 연관 짓는다면 빅 데이터에 기반한 인공지능이 발달할 것이고 인간에게는 여유가 생기며 노동 시간이 줄고 여가가 늘어날 것이다.

“킴킴”은 “인간의 몸은 지구가 생겨난 이후 35억 년 동안 빅데이터를 구축해 유전돼 왔다”며 그 빅데이터 역할로 우리의 몸을 좌지우지하고 있다 하지만 그 좌지우지하는 몸은 우리가 아니라고 역설했다. 이와 관련해서 그는 “독서에 집중하고 싶지만 배고프면 식욕이 일어난다. 일어나지도 않은 일을 미리 걱정한다. 인생은 이런 빅데이터의 무의식적인 생각, 감정, 오감의 끊임없는 경험과 반응의 연속”이라며 빅데이터처럼 무의식적으로 반응하는 몸은 우리가 아니라고 다시 한번 강조한 적 있다.

이렇게 “킴킴”이 말하듯 빅데이터는 현재 우리의 삶에 엄청난 영향을 미치고 있다. 바로 이 빅데이터를 기반한 인공지능 즉 AI가 현재를 넘어 미래를 향해 급속도로 발전해 나아가고 있다. 인류는 하늘을 나는 새를 보고 비행기를 만들었고, 바다의 물고기를 모델로 삼아 잠수함을 만들었다.

인류는 ‘만물의 영장’인 인류를 모델로 무엇을 만들어 낼까? 바로 인공지능이다.

인공 지능이 발달하게 되면 인간에게는 여유가 생기고 노동 시간이 줄어들고 여가가 늘어난다 여기서 핵심은 남아도는 시간을 어떻게 쓸지가 관건이다. 인류사를 돌아보면 시간과 여유가 남아돌 때마다 인간은 타락했고, 앞으로 인공지능의 발달로 라이프스타일의 변화는 폭발적일 것이다.

잉여 시간이 인류의 미래를 위해 쓰이지 않으면 미래가 없다고 한다. 이 때문에 인공지능이 발전함에 따라 앞으로 컴퓨터 알고리즘에 대해 어떻게 변화하는지 끊임없이 인간은 생각해야 한다.인공지능이 발달하고 빅 데이터가 쌓여갈수록 인공지능에 대한 컴퓨터 알고리즘은 더욱더 자세하면서 쉽게 발달할 것이다.

그러나 그 결과 인공지능을 둘러싼 다양한 법적 담론들이 제기될 것이다. 최근 이러한 담론들은 이론적이고 체계적인 관점보다는 현실적인 단기적 대응방안 모색에만 주력하고 있는 양상이다. 특히 인공지능 개체의 책임 및 권리부여를 중심으로 한 논의가 주축을 이루고 있다.

그러나 인공지능 기술이 어떠한 방식으로 현실에서 보편화될 것인지 예측하기 힘든 상황이어서, 이에 대한 법적 대안 마련에 어려움이 있다. 예를 들면 자율 주행 차량을 살펴보면 자율 주행 차량이 인명사고를 냈을 때, 법적인 책임은 누가지는 가? 에 대한 논의가 있다.

이렇듯 인공지능이 발전함에 따라 장기적 관점에서 대응방안 모색을 위해서는 보다 심층적이고 본질적인 변화에 대한 고민이 전제되어야 한다고 생각한다. 단순히 잉여 시간을 인류의 미래에만 투자한다고 하면 과도한 기대와 전망에 기반한 다소 허황된 논의는 인공지능 기술을 토대로 하는 안정적인 사회 발전을 저해할 가능성이 높다고 판단된다.

인공지능 발전에 따라 컴퓨터 알고리즘은 데이터 및 개인 정보 이슈, 일자리 대체 및 사회적 양극화, 오작동 및 책임 소재 설정 문제 등을 해결하기 위한 세심한 접근이 필요로 하는 알고리즘이 등장할 것으로 예상한다 이에 따라 인공지능을 개발하는 기업들은 인공지능 학습이 가능한 양질의 데이터 확보와 함께 오작동 등으로 인한 피해에 대하여, 기술의 발전을 저해하지 않으면서 법적 책임소재를 명확히 설정해 두어야 한다.

관리 주체들 간의 합의를 바탕으로 이해와 책임 관계를 면밀히 설정하여 해결해 나가야 한다는 것이다. 지금까지의 기술수준 향상 및 인프라 구축 등 기술 발전에만 집중해온 기존의 패러다임보다는 기술의 부작용을 염려하여 기술 발전을 무조건적으로 경계하는 것이 앞으로의 기술 경쟁력 확보에 도움이 된다는 것이다.

빅 데이터에 따른 적절한 기술개발 가이드라인을 마련하면 오히려 기술 발전에 긍정적으로 작용할 수 있을 것이며 인공지능 기술이 점차 상용화됨에 따라 일상생활에서 발생 가능한 모든 문제점들에 대해 미리 대책을 마련하는 것이 중요할 것이다. 인공지능 기술은 예측이 불가능하고, 결과에 대한 이해 및 설명이 어려우며, 오류 감지 및 변별 등이 어려운 특성을 지니므로, 다른 기술에 비해 책임소재 설정이 힘들어 피해를 예방하거나 보상을 결정하는데 있어서 많은 법적, 기술적 어려움이 있다는 점을 항상 생각하고 컴퓨터 알고리즘을 구축하는데 있어서 고민해봐야 할 문제라는 것이다.

컴퓨터 알고리즘이 이런 사회적인 측면까지 적용이 되려면 수많은 인공지능 개발이 필요로 할 것이며, 수많은 인공지능 개발을 위해 엄청난 양의 빅 데이터들이 쌓여 만들어진 인공지능의 시행착오들을 모아 또 다른 빅데이터를 모아서 최종적인 인공지능 시스템이 필요로 할 것이다. 그러기 위해선 빠르고 정확하게 많은 데이터를 수집하는 알고리즘 능력이 필요로 하다는 것이다.

빅 데이터를 모으기 위해서 빅 데이터를 수집하는 인공지능 또한 발달 할 것이라고 본다. 지금까지의 인공지능이 학습 알고리즘에 초점에 맞춰진 시스템이라면 앞으론 추론하고 인식하는 알고리즘이 필요해질 것이다. 이렇게 인식하고 추론하는 알고리즘이 발달하게 된다면 소프트웨어의 비약적인 발전과 더불어 인간의 욕구가 어우러져서 ‘편리한 세상’을 꿈꾸고 실현하는데 적합한 인공지능이 발달 할 것이라고 생각한다.

빅 데이터의 핵심인 ‘무슨 일이 일어났는지’, ‘왜? 어떻게 해서 일어났는지’, ‘앞으로 무슨 일이 일어날 것인지’가 왜 핵심인지 다시 한번 생각해보게 되었고 다시 돌고 돌며 갈수록 데이터가 커지듯 돌고 돌아 생각해보니 인공지능의 컴퓨터 알고리즘의 변화는 최종적으로 우리 인간의 삶에 영향을 가장 잘 반영하는 도덕적인 문제에 대한 고민으로 변화할 것이라고 학습이 아닌 추론하고 인식하는 알고리즘으로 변화할 것이라고 생각한다.

[DB] 데이터 베이스 마인드맵 (1) | Yoon's Dev

Yooniron — Fri, 30 Apr 2021 18:13:37 +0900

데이터 베이스 개념 정리 마인드맵 (1)

마인드맵

[Servlet] Servelt 서블릿 기초 문법, 클래스, 메서드, 라이프 사이클 | Yoon's Dev

Yooniron — Wed, 28 Apr 2021 23:09:13 +0900

Servelt 서블릿 기초 문법, 클래스, 메서드, 라이프 사이클

서블릿에 대해...

■ 서블릿에 대해...

✓ JSP 이전에 동적인 웹페이지 콘텐츠를 생성하는 기술로 제공

✓ 자바의 많은 장점 사용 가능

✓ HTML, CSS 및 자바스크립트 그리고 웹 디자인과 연동하기에는 단점이 많음

✓ 서블릿의 존재 이유

. jsp에는 없는 서버 측 프로그램의 기능

. 대규모 프로젝트에 사용되는 프레임워크의 기술을 사용

1. 서블릿의 주요 클래스와 메서드

✓ HttpServlet: 서블릿을 만들기 위해 반드시 상속해야 할 필수 클래스

✓ HttpServletRequest: 클라이언트가 데이터를 입력하거나 클라이언트의 정보에 대한 요청 값을 가지고 있는 클래스

✓ HttpServletResponse: 클라이언트가 요청한 정보를 처리하고 다시 응답하기 위한 정보를 담고 있는 클래스

✓ HttpSession: 클라이언트가 세션을 정보를 저장하고 세션 기능을 유지하기 위해서 제공되는 클래스

- httpServlet에서 제공되는 주요 메서드

메서드	설명
void int()	서블릿의 객체가 생성 될 때 호출되는 메서드
void destroy()	서블릿의 객체가 메모리에서 사라질 때 호출되는 메서드
void service(request, response)	서블릿의 요청이 있을 때 호출되는 메서드
void doGet(request, response)	html에서 form의 메서드가 get일때 호출되는 메서드
void doPost(request, response)	html에서 form의 메서드가 post일때 호출되는 메서드

- httpServletRequest에서 제공되는 주요 메서드

메서드	설명
String getParameter(name)	name에 할당된 값을 반환하며 지정된 파라미터 값이 없으면 null 값을 반환
String[] getParameterValues(name)	name의 모든 값을 String 배열로 반환
Enumeration getParameterNames()	요청에 사용된 모든 파라미터 이름을 java.util.Enumeration 타입으로 반환
void setCharacterEncoding(env)	post방식으로 요청된 문자열의 character encoding을 설정

- httpServletResponse에서 제공되는 주요 메서드

메서드	설명
void setHeader(name, value)	응답에 포함될 Header를 설정합니다.
void setContentType(type)	출력되는 페이지의 contentType을 설정
String getCharacterEncoding()	응답 페이지의 문자 인코딩 Type을 반환
void sendRedirect()	지정된 URL로 요청을 재전송

- httpSession에서 제공되는 주요 메서드

메서드	설명
String getId()	해당 세션의 세션 ID를 반환
long getCreationTime()	세션의 생성된 시간을 반환
long getLastAccessedTime()	클라이언트 요청이 마지막으로 시도된 시간을 반환
void setMaxInactiveInterval(time)	세션을 유지할 시간을 초단위로 설정
int getMaxinactiveInterval()	setMaxInactiveInterval(time)로 지정된 값을 반환. (기본값 30분)
boolean isNew()	클라이언트 세션 ID를 할당하지 않은 경우 true 값을 반환
void invalidate()	해당 세션을 종료

서블릿의 라이프 사이클

init(): 서블릿이 처음으로 요청되어 객체가 생성될 때 호출되는 메서드
service(): 클라이언트가 요청이 있을 때마다 호출되는 메서드
destroy(): 서블릿 서비스의 종료 및 재시작 그리고 서블릿 코드가 수정이 될 때 호출되는 메서드
doGet(): 클라이언트 요청할 때 form의 method가 get방식일 때 호출되는 메서드
doPost(): 클라이언트 요청할 때 form의 method가 post방식일 때 호출되는 메서드

서블릿 라이프 사이클 예제

- 서블릿 라이프 사이클 예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

 
 
import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * Servlet implementation class ExampleServlet02
 */
@WebServlet("/exampleServlet02")
public class ExampleServlet02 extends HttpServlet {
    private static final long serialVersionUID = 1L;
 
    /**
     * @see Servlet#init(ServletConfig)
     */
    public void init(ServletConfig config) throws ServletException {
        System.out.println("init 호출");
    }
 
    /**
     * @see Servlet#destroy()
     */
    public void destroy() {
        System.out.println("destroy 호출~~~~");
    }
 
    /**
     * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse response)
     */
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("service 호출");
    }
 
}
 
Colored by Color Scripter

cs

실행 결과

윈도우10 스티커 메모 단축키 모음 | Yoon's Dev

Yooniron — Tue, 27 Apr 2021 08:00:59 +0900

윈도우10 스티커 메모 단축키 모음

이번 포스팅에서는 제가 정말 유용하게 사용하고 있는 Windows 10 Sticky Notes에 대해서 포스팅하려고 합니다.

생각보다 사용법도 어렵지도 않고 할 일, 급하게 메모를 해야 할 때, 까먹지 않고 봐야 할 것들을 써놓으면 유용해서 자주 사용하고 있어요.

컴퓨터에 덕지덕지 포스트잇 붙여놓는 것보다 바탕화면에 스티커 메모해두면 정말 편한 것 같아 스티커 메모 사용하는 데 있어서 유용한 단축키들을 알려드리려고 합니다.

스티커 메모

윈도우 검색에 스티커만쳐도 나와요

Window에서 기본으로 지원하기 때문에 간단히 설치만 누르고 사용할 수 있습니다.!

단축키 모음

단축키

Bold: Ctrl + B
Italics: Ctrl + I
UnderLine: Ctrl + U
Strikethrough: Ctrl + T
글머리 기호 목록 생성: Ctrl +Shift + L

삭제: Ctrl + D
새로 만들기: Ctrl + N

이렇게 단축키를 이용해도 되지만 하단에 뜨는 UI를 이용해서 간단하게 글을 편집할 수 있습니다.

또한 이렇게 위에 ... 줄임표 버튼을 누르게 되면

이런 식으로 배경색도 원하는 대로 바꿀 수 있습니다.

컴퓨터를 종료해도 메모 내용이 사라지지 않고 계정 연동하게 되면 다른 디바이스에서도 메모 내용을 불러올 수 있어서 정말 편하다고 생각합니다.

[JAVA] 문자(Text) 스트림, 버퍼(Buffer) 스트림, File 클래스 | Yoon's Dev

Yooniron — Mon, 26 Apr 2021 21:26:22 +0900

문자(Text) 스트림, 버퍼(Buffer) 스트림, File 클래스

문자 스트림
파일 문자 스트림
버퍼 스트림
File 클래스

1. 문자 스트림

■ 문자 스트림

✓ 문자 스트림 연관 클래스

문자 스트림 연관 클래스

✓ Writer 클래스와 Reader 클래스

. 문자 스트림의 입출력에 필요로 되는 다양한 메서드를 제공하는 추상 클래스

- Writer 클래스의 주요 메서드

메서드	설명
void close()	출력 스트림을 닫기
void flush()	출력 버퍼에 저장된 모든 데이터를 출력장치로 전송
void write(int c)	c의 하위 16비트를 스트림으로 출력
void write(char buffer[])	buffer 배열에 있는 문자들을 스트림으로 출력
void write(char buffer[], int index, int size)	buffer 배열의 index부터 size만큼의 문자들을 스트림으로 출력
void write(String s)	문자열 s를 스트림으로 출력
void write(String s, int index, int size)	문자열 s의 index부터 size 만큼의 문자들을 스트림으로 출력

- Reader클래스의 주요 메서드

void close()	입력 스트림을 닫기
int read()	다음 문자를 읽어 반환, 입력 스트림에 읽을 문자가 없을 때는 대기, 읽은 문자가 파일의 끝이면 -1을 반환
int read(char buffer[])	buffer 크기만큼 문자를 읽어 buffer에 저장
int read(char buffer[], int offset, int numChars)	numChars에 지정한 만큼의 문자를 읽어 buffer의 offset 위치에 저장하고 읽은 문자의 개수를 반환
void mark(int numChars)	입력 스트림의 현재 위치에 마크
boolean markSupported()	현재의 입력 스트림이 mark()와 reset()를 지원하는지의 여부 반환
boolean ready()	다음 read()문을 수행할 수 있는지의 여부 반환
void reset()	입력 스트림의 입력 시작 부분을 현재의 위치에서 가장 가까운 이전 mark 위치로 설정
int skip(long numChars)	numChar로 지정된 문자수 만큼 건너뛰고 건너 뛴 문자수를 반환
String readLine()	BufferedReader 클래스의 메서드로 문자열을 한 줄 읽기

2. 파일 문자 스트림

■ 문자 스트림

✓ 파일 문자 스트림

- FileReader의 생성자

생성자	설명
FileReader(File file)	file에 지정된 파일로부터 읽는 FileReader 생성
FileReader(String name)	name 이름의 파일로부터 읽는 FileReader 생성

- FileReader의 주요 메서드

메서드	설명
int read()	한 개의 문자를 읽어 정수형으로 리턴
int read(char[] cbuf)	최대 cbuf 배열의 크기만큼 문자들을 읽어 cbuf 배열에 저장, 만일 읽는 도중 EOF를 만나면 실제 읽은 문자 개수 리턴
int read(char[] cbuf, int off, int len)	최대 len 크기만큼 읽어 cbuf 배열의 off부터 저장, 읽는 도중 EOF를 만나면 실제 읽은 문자 개수 리턴
String getEncoding()	스트림이 사용하는 문자 집합의 이름 리턴
void close()	입력 스트림을 닫고 관련된 시스템 자원 해제

- FileWriter의 생성자

생성자	설명
FileWriter(File file)	file에 데이터를 저장할 FileWriter 생성
FileWriter(String name)	name 파일에 데이터를 저장할 FileWriter 생성
FileWriter(File file, boolean append)	FileWriter를 생성하며, append가 true이면 파일의 마지막 부터 데이터 저장
FileWriter(String name, boolean append)	FileWriter를 생성하며, append가 true이면 파일의 마지막부터 데이터 저장

- FileWriter의 주요 메서드

메서드	설명
void write(int c)	c를 char로 변환하여 한 개의 문자 출력
void write(String str, int off, int len)	인덱스 off부터 len개의 문자를 str 문자열에서 출력
void write(char[] buf, int off, int len)	인덱스 off부터 len개의 문자를 배열 cbuf에서 출력
void flush()	스트림에 남아 있는 데이터 모두 출력
String getEncoding()	스트림이 사용하는 문자 집합의 이름 리턴
void close()	출력 스트림을 닫고 관련된 시스템 자원 해제

■ 문자 스트림으로 텍스트 파일 읽기

✓ 텍스트 파일을 읽기 위해 문자 스트림 FileReader 클래스 이용

1. 파일 입력 스트림 생성(파일 열기) // 스트림을 생성하고 파일을 열어 스트림과 연결

1

FileReader fin = new FileReader("파일경로");

cs

2. 파일 읽기 // read()로 문자 하나씩 파일에서 읽기

1

FileReader fin = new FileReader("파일경로");

cs

3. 스트림 닫기 // 스트림이 더 이상 필요 없으면 닫아야 함, 닫힌 스트림에서는 읽을 수 없음 close()

1

fin.close();

cs

■ 문자 스트림으로 텍스트 파일 쓰기

✓ 텍스트 파일을 쓰기 위해 문자 스트림 FileWriter 클래스 이용

1. 파일 출력 스트림 생성(파일 열기) // 스트림을 생성하고 파일을 열어 스트림과 연결

1

FileWriter fout = new FileWriter("파일경로");

cs

2. 파일 쓰기 // write()로 문자 하나 씩 파일에 기록

1

fout.write('A');

cs

// 블록 단위로 쓰기 가능

1
2

char buf = new char[1024];
fout.write(buf, 0, buf.length); // buf[0]부터 버퍼 

cs

3. 스트림 닫기 // close()로 스트림 닫기

1

fin.close();

cs

3. 버퍼 스트림

디스크에서 한번 읽을 때 왕창 읽어 놓고 버퍼(buffer)라는 데이터를 저장하는 창고에 넣어 두었다가 필요할 때 하나씩 꺼내 쓰는 것, 다 떨어지면 디스크에서 다시 읽는다.

■ 버퍼 스트림

✓ BufferedWriter 클래스와 BufferedReader 클래스

□ 버퍼 스트림의 종류

✓ 바이트 스트림

. 바이트 단위의 바이너리 데이터를 처리하는 버퍼 스트림

. BufferedInputStream과 BufferedOutputStream

✓ 문자 스트림

. 유니코드의 문자 데이터만을 처리하는 버퍼 스트림

. BufferedReader와 BufferedWriter

□ BufferedWriter 클래스

✓ Writer 클래스의 하위 클래스

✓ 문자 스트림의 출력 시 버퍼를 사용

✓ 생성자

BufferedWriter(Writer outputStream)

BufferedWriter(Writer outputStream, int bufSize)

outputStream: Writer 타입의 객체, 출력 스트림을 의미

bufSize: 버퍼의 크기를 지정, 지정하지 않으면 묵시적인 크기의 버퍼 사용

✓ 메서드

void newLine() throws IOException // 새로운 라인에 출력

□ BufferedReader 클래스

✓ Reader 클래스의 하위 클래스

✓ 문자 스트림의 입력 시 버퍼를 사용

✓ 생성자

BufferedReader(Reader inputStream)

BufferedReader(Reader inputStream, int bufSize)

inputStream: Reader 타입의 객체로서 입력 스트림을 의미

bufSize: 버퍼의 크기 지정

✓ 메서드

void readLine() throws IOException // 한 라인을 읽어 온다.

■ 버퍼 입출력(Buffered I/O)

✓ 버퍼 입출력은 입출력 장치와 프로그램 사이에 버퍼를 두어 효율적으로 입출력 처리

✓ 프로그램의 실행 속도와 입출력 장치의 데이터 처리 속도의 불일치에 대처하기 쉽다.

4. File 클래스

■ File 클래스

✓ 파일의 경로명 및 속성을 다루는 클래스

. java.io.File

. 파일과 디렉터리 경로명의 추상적 표현

✓ 파일 이름 변경, 삭제, 디렉터리 생성, 크기 등 파일 관리

✓ File 객체에는 파일 읽기/쓰기 기능 없음

. 파일 입출력은 파일 입출력 스트림 이용

✓ File 객체와 스트림을 연결하여 파일 접근

○File 객체 생성

✓ 생성자에 파일 경로명을 주어 File 객체 생성

1

File f = new File("파일경로 + 파일명");

cs

✓ 디렉터리와 파일명을 나누어 생성자 호출

1

File f = new File("파일경로", "파일 이름");

cs

- File 클래스의 생성자

메서드	설명
File(File parent, String child)	parent 디렉터리에 child 이름의 디렉터리나 파일을 나타내는 File 객체 생성
File(String pathname)	pathname의 완전 경로명이 나타내는 File 객체 생성
File(String parent, String child)	parent 디렉터리에 child 이름의 디렉터리나 파일을 나타내는 FIle 객체 생성
File(URI uri)	file:URI를 추상 경로명으로 변환하여 FIle 객체 생성

- File 클래스의 주요 메서드

메서드	설명
boolean() mkdir	새로운 디렉터리 생성
String[] list()	디렉터리 내의 파일과 서브 디렉터리 리스트를 문자열 배열로 리턴
File [] listFiles()	디렉터리 내의 파일과 서브 디렉터리 리스트를 File [] 배열로 리턴
boolean renameTo(Fiile dest)	dest가 지정하는 경로명으로 파일 이름 변경
boolean delete()	파일 또는 디렉터리 삭제
long length()	파일의 크기 리턴
String getPath()	경로명 전체를 문자열로 변환하여 리턴
String getParent()	파일이나 디렉터리의 부모 디렉터리 이름 리턴
String getName()	파일 또는 디렉터리 이름을 문자열로 리턴
boolean isFile()	일반 파일이면 true 리턴
boolean isDirectory()	디렉터리이면 true 리턴
long lastModified()	파일이 마지막으로 변경된 시간 리턴
boolean exists()	파일 또는 디렉터리가 존재하면 true 리턴

■ File 클래스 활용

✓ 파일 크기

1

long size = f.length();

cs

✓ 파일 경로명

1
2
3
4

File f = new File("파일경로\\파일명");
String filename = f.getName(); //파일명
String path = f.getPath(); // 파일경로+파일명
String parent = f.getParent(); // 파일경로 부모폴더

cs

✓ 파일 타입

1
2
3
4
5

if(f.isFile())
    System.out.println(f.getPath() + "는 파일입니다."); //파일
else if(f.isDirectory())
    System.out.println(f.getPath() + "는 디렉터리입니다."); // 디렉터리
 
Colored by Color Scripter

cs

✓ 디렉터리 파일 리스트 얻기

1
2
3
4
5
6
7

File f = new File("파일디렉터리")
File[] subfiles = f.listFiles(); // 디렉터리의 파일 및 서브 디렉터리 리스트 얻기
 
for(int i=0; i<filenames.length; i++) {
    System.out.print(subfiles[i].getName(); // 서브 파일명 출력
    System.out.print("\t파일 크기: " + subfiles[i].length()); //서브 파일크기 
}
Colored by Color Scripter

cs

[Android] 안드로이드(Android) 프로젝트 구조 | Yoon's Dev

Yooniron — Sun, 25 Apr 2021 22:20:12 +0900

안드로이드(Android) 프로젝트 구조

* 해당 글은 안드로이드 스튜디오 4.1.2 기준으로 설명되었습니다. *

프로젝트 구조
AndroidManifest.xml
레이아웃
코드

1. 프로젝트 구조

■ manifests

✓ AndroidManifest.xml - 애플리케이션 수행에 필요한 필수 정보

■ java

✓ 소스코드

✓ (androidTest) 단위 테스트 등을 위한 것으로 중급 이후에 사용

■ res

✓ 각종 리소스 저장 폴더

✓ 레이아웃, 그림, 문자열 등의 리소스 저장

✓ drawable: 그려질 수 있는 객체(이미지)

✓ layout: 레이아웃(화면 디자인), 화면 구성 형태, 관련 내용

✓ mipmap: 앱 아이콘이 배치

✓ values: 문자열, 배열, 색상, 스타일 등등 저장

■ Gradle Script

✓ 빌드 스크립트

2. AndroidManifest.xml

✓ 애플리케이션의 이름, 버전 등의 정보 저장

✓ 애플리케이션에서 선언한 구성 요소, 기능, 요구사항 등에 대하여 기록하는 파일,

애플리케이션에 적재된 모든 컴포넌트에 대하여 기술하는 파일

✓ 외부 라이브러리에 대한 정의 포함

AndroidManifest.xml

3. 레이아웃(layout/~~.xml)

✓ 사용자 인터페이스 작성

* 안드로이드 스튜디오 버전에 따라 메뉴 모양 등 차이가 있을 수 있다.

Design

code

android:layout_width="wrap_content" // View의 너비 조정

android:layout_height="match_parent" // View의 높이 조정

match_parent : 부모 객체를 기준으로

wrap_content: 필요한 만큼

4. 코드(code)

MainActivity.java

onCreate() // 애플리케이션 실행, 메서드가 호출되면서 액티비티 작성

setContentView() // 액티비티의 화면을 구성하는 역할, 화면에 표시할 뷰를 설정,

제공 리소스 이용(R.layout.activity_main)

super.onCreate() // 상위 클래스의 onCreate() 메서드를 호출하여 정의된 작업을 수행

[JAVA] JAVA의 입출력, 바이트 스트림(ByteStream) | Yoon's Dev

Yooniron — Sat, 24 Apr 2021 20:55:47 +0900

JAVA의 입출력, 바이트 스트림(ByteStream)

바이트 스트림

■ 바이트 스트림

✓ 바이트 단위의 입출력

바이트 스트림과 연관된 클래스

✓ OutputStream 클래스와 InputStream 클래스

- 바이트 스트림의 입출력에 필요로 되는 다양한 메서드를 제공하는 추상 클래스

- OutputStream 클래스의 주요 메서드

메서드	설명
void close()	출력 스트림을 닫기
void flush()	버퍼에 남아있는 출력 스트림을 출력
void write(int i)	정수 i의 하위 비트 8비트를 출력
void write(byte buffer[])	buffer 내용을 출력
void write(byte buffer[], int index, int size)	buffer의 index부터 size 만큼의 바이트를 출력

-InputStream 클래스의 주요 메서드

메서드	설명
int available()	현재 읽기 가능한 바이트 수를 반환
void close()	입력 스트림을 닫기
int read()	한 바이트를 읽어 int 형으로 반환, 더 이상 읽을 값이 없다면 -1을 반환
int read(byte buffer[])	buffer의 크기만큼 읽어 buffer에 저장하고 읽은 바이트 수를 반환
int read(byte buffer[], int offset, int numBytes)	numbytes 만큼을 읽어 buffer의 offset 위치에 저장하고 읽은 바이트 수를 반환
int skip(long numBytes)	numBytes로 지정된 바이트를 건너뛰고 건너 뛴 바이트 수를 반환
void mark(int numBytes)	입력 스트림의 현재 위치를 마크
boolean markSupported()	mark()와 reset()를 지원하면 true를 반환
void reset()	입력 시작 부분을 현재의 위치에서 가장 가까운 이전의 마크 위치로 설정

■ FileInputStream과 FileOutputStream

✓ 파일이 입출력 대상

-FileOutputStream 클래스 생성자와 주요 메서드

생성자	설명
FileOutputStream(File file)	file이 지정하는 파일에 출력하는 FileOutputStream 생성
FileOutputStream(String name)	name이 지정하는 파일에 출력하는 FileOutputStream 생성
FileOutputStream(File file, boolean append)	FileOutputStream을 생성하며 append가 true이면 file이 지정하는 파일의 마지막부터 데이터 저장
FileOutputStream (String name, boolean append)	FileOutputStream을 생성하며 append가 true이면 name 이름의 파일의 마지막부터 데이터 저장

메서드	설명
void write(int b)	int형으로 넘겨진 한 바이트를 출력 스트림으로 출력
void write(byte[] b)	배열 b의 바이트를 모두 출력 스트림으로 출력
void write(byte[] b, int off, int len)	len 크기만큼 off부터 배열 b를 출력 스트림으로 출력
void flush()	출력 스트림에서 남아 있는 데이터 모두 출력
void close()	출력 스트림을 닫고 관련된 시스템 자원 해제

- FileInputStream 클래스 클래스 생성자와 주요 메서드

생성자	메서드
FileInputStream(File file)	file이 지정하는 파일로부터 읽는 FileInputStream 생성
FileInputStream(String name)	name이 지정하는 파일로부터 읽는 FileInputStream 생성

메서드	설명
int read()	입력 스트림에서 한 바이트를 읽어 int 형으로 리턴
int read(byte[] b)	최대 배열 b의 크기만큼 바이트를 읽음, 읽는 도중 EOF를 만나면 실제 읽은 바이트 수 리턴
int read(byte[] b, int off, int len)	최대 len개의 바이트를 읽어 b 배열의 off 위치에 저장, 읽는 도중 EOF를 만나면 실제 읽은 바이트 수 리턴
int available()	입력 스트림에서 현재 읽을 수 있는 바이트 수 리턴
void close()	입력 스트림을 닫고 관련된 시스템 자원 해제

■ 바이트 스트림으로 바이너리 파일 쓰기

✓ 바이너리 값을 파일에 저장하기

- 프로그램 내의 변수, 배열, 버퍼에 있는 바이너리 값을 파일에 그대로 기록

1. 파일 출력 스트림 생성(파일 열기) // 스트림을 생성하고 파일을 열어 스트림과 연결

ex) FileOutputStream fout = new FileOutputStream("파일경로")

2. 파일 쓰기 // write()로 문자 하나 씩 파일에 기록

3. 스트림 닫기 // close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package practice;
 
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileOutputStreamEx {
    
    public FileOutputStreamEx() {
        byte b[] = {7, 51, 3, 4, -1, 24};
        
        try {
            FileOutputStream fout = new FileOutputStream("파일경로");
            for(int i=0; i<b.length; i++) // 배열 b의 수를 바이너리 그대로 기록
                fout.write(b[i]);
            fout.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        new FileOutputStreamEx();
 
    }
 
}
 
Colored by Color Scripter

cs

■ 바이트 스트림으로 바이너리 파일 읽기

✓ 바이너리 파일에서 읽기 위해 FileInputStream 클래스 이용

1. 파일 입력 스트림 생성(파일 열기) // 스트림을 생성하고 파일을 열어 스트림과 연결

ex) FileInputStream fin = new FileInputStream("파일경로");

2. 파일 읽기 // read()로 문자 하나 씩 파일에서 읽기, 블록 단위로 읽기 가능

3. 스트림 닫기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package practice;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
 
public class FileInputStreamEx {
    
    public FileInputStreamEx() {
        byte b[] = new byte[6];
        try {
            FileInputStream fin = new FileInputStream("파일경로");
            int n=0, c;
            while((c=fin.read()) != -1 ) {
                b[n] = (byte)c; //읽은 바이트를 배열에 저장
                n++;
            }
            // 배열 b의 바이트 값을 모두 화면에 출력
            for(int i=0; i<b.length; i++)
                System.out.print(b[i] + " ");
            
            fin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        new FileInputStreamEx();
    }
 
}
 
Colored by Color Scripter

cs

■ FilterOutputStream 클래스와 FilterInputStream 클래스

✓ 일반적으로 필터를 사용하기 위해서 사용

□ FilterOutputStream 클래스

- OutputStream 클래스로부터 상속된 클래스

- 필터를 사용하여 원하는 정보만 출력시켜주는 기능을 제공

- FilterOutputStream(OutputStream outputStream)

□ FilterInputStream 클래스

- InputStream 클래스로부터 상속된 클래스

- 필터를 사용하여 원하는 정보만 입력할 수 있는 기능을 제공

- FileInputStream(InputStream inputStream)

■ BufferedOutputStream 클래스와 BufferedInputStream 클래스

✓ FilterOutputStream, FilterInputStream 클래스로부터 상속

□ BufferedOutputStream 클래스

- 버퍼를 사용하여 스트림을 출력

- 생성자

. BufferedOutputStream(OutputStream outputStream)

. BufferedOutputStream(OutputStream outputStream, int buffSize)

□ BufferedInputStream 클래스

- 버퍼를 사용하여 스트림을 입력

- 생성자

. BufferedInputStream(InputStream inputStream)

. BufferedInputStream(InputStream inputStream, int bufSize)

■ DataOutputStream 클래스와 DataInputStream 클래스

✓ 자바의 기본 자료형 데이터를 바이트 스트림으로 출력하는 클래스

□ DataOutputStream 클래스

- FilterOutputStream 클래스로부터 상속되었다

- DataOutput 인터페이스를 사용한 클래스

- 기본 자료형 데이터를 바이트 스트림으로 출력

. DataOutputStream(OutputStream outputStream)

- readByte(), readInt(), readDouble()과 같은 메서드 제공

□ DataInputStream 클래스

- FilterInputStream 클래스로부터 상속되었다

- DataInput 인터페이스를 사용한 클래스

- 바이트 스트림으로부터 자바의 기본 자료형 데이터를 입력

. DataInputStream(InputStream inputStream)

- writeByte(int v), writeInt(int v), writeDouble(double v)과 같은 메서드 제공

■ PrintStream 클래스

✓ FilterOutputStream 클래스로부터 상속된 클래스

✓ 모든 형식의 데이터를 출력하는 기능을 제공

✓ System.out.println문장의 System.out(클래스 변수)은 항상 PrintStream 클래스로부터 생성된 객체를 참조한다.

[JAVA] JAVA의 입출력 스트림(Stream) | Yoon's Dev

Yooniron — Fri, 23 Apr 2021 21:30:08 +0900

JAVA의 입출력 스트림(Stream)

입출력 스트림

클래스와 메모리, 저장 장치 사이에서 객체는 모두 메모리에 만들어지고 이것들은 모두 전원이 꺼지면 사라지게 된다. 이를 해결하기 위해 하드 디스크와 같은 저장 장치에 파일 형태로 저장하면 전원이 꺼지더라도 데이터가 보존된다.

데이터를 영구히 보관하기 위해 파일에 저장해야 하는데 스트림을 이용하면 파일을 저장할 수 있다.

■ 스트림(Stream)

✓ 자바의 입출력

-> 모든 하드웨어에 독립적으로 설계

✓ 자바는 입출력을 스트림(Stream)으로 처리한다.

✓ 스트림(Stream)

. 스트림은 '개울을 따라 시냇물이 졸졸 흘러간다.'라는 의미에서 순서가 있는 데이터의 연속적인 흐름이다.

. Java에서는 데이터를 읽고 쓸 때 스트림 형태로 읽고 쓴다.

✓ 스트림을 이용하여 실제 다양한 하드웨어와 입출력을 수행하는 일은 JVM에 의해 실행된다.

✓ 자바는 입출력을 위한 클래스들을 java.io 패키지로 제공하고있다.

■ 스트림(Stream)의 특징

✓ 스트림은 단방향이다. (방향에 따라 입력 스트림, 출력 스트림)

✓ 스트림은 선입선출, FIFO 구조이다.

✓ 스트림은 연결될 수 있다.

✓ 스트림은 지연될 수 있다.

. 입력 스트림이 흐르는 통로인 파이프가 비어 있다면, 컴퓨터는 읽어갈 데이터가 없으므로 기다림

. 출력 스트림이 흐르는 통로인 파이프에 데이터가 꽉 차 있다면 컴퓨터는 빈 공간이 생길 때까지 기다린다.

■ 스트림(Stream)의 분류

□ 바이트 스트림

✓ 바이트(8비트)를 읽고 쓰기 위한 스트림

✓ InputStream, OutputStream 클래스와 그 하위 클래스를 이용

✓ 문자 데이터든 바이너리 데이터든 상관없이 처리 가능

□ 문자 스트림

✓ 16비트 문자나 문자열을 읽고 쓰기 위한 스트림

- Reader, Writer 클래스와 하위 클래스를 이용

✓ 문자가 아닌 바이너리 데이터는 스트림에서 처리하지 못함

✓ 문자가 아닌 데이터를 문자 스트림으로 출력하면 깨져서 출력된다.

스트림의 분류

■ Java의 입출력 스트림

✓ 입출력 장치와 자바 응용 프로그램 연결

- 입력 스트림: 입력 장치로부터 자바 프로그램으로 데이터를 전달하는 객체

- 출력 스트림: 자바 프로그램에서 출력 장치로 데이터를 보내는 객체

✓ 특징

- 입출력 스트림 기본 단위: 바이트(Byte)

- 단방향 스트림, 선입선출 구조

■ 스트림 연결

✓ 여러 개의 스트림을 연결하여 사용할 수 있다.

ex) 키보드에서 문자를 입력받는 System.in과 InputStreamReader를 연결

InputStreamReader rd = new InputStreamReader(System.in);

■ 파일 입출력과 예외 처리

✓ 파일 입출력 동안 예외 발생 가능

1. 스트림 생성 동안FileNotFoundException 발생 가능!!

----> 파일의 경로명이 틀리거나 디스크의 고장 등으로 파일을 열 수 없을 때

2. 파일 읽기, 쓰기, 닫기를 하는 동안: IOException 발생 가능!!

----> 디스크 오동작, 파일이 중간에 깨진 경우, 디스크 공간이 모자라서 파일 입출력이 불가능한 경우.

✓ try-catch 블록이 반드시 필요하다.

■ 기본적인 메서드

✓ InputStream 클래스

- abstract int read() // 한 바이트를 읽어서 반환(0에서 255 사이의 정수)

✓ OutputStream 클래스

- abstract void write(int b) // 한 바이트를 특정한 장치에 씀

✓ Reader 클래스

- abstract int read() // 한 문자를 읽어서 반환

✓Writer 클래스

- abstract void write(int c) // 한 문자를 특정한 장치에 씀

[JSP] JSP 기초문법 선언문(Declaration), 스크립트릿(Scriptlet), 표현식(Expression) | Yoon's Dev

Yooniron — Thu, 22 Apr 2021 21:45:14 +0900

JSP 기초문법 선언문(Declaration), 스크립트릿(Scriptlet), 표현식(Expression)

학습 목표

JSP의 기본 문법인 선언문, 스크립트릿, 표현식과 주석

JSP의 기본 제어문

스크립트릿(Scriptlet)
표현식(Expression)
선언문(Declaration)
주석(Comment)

■ 스크립트 태그

✓ <% ... %>를 사용

✓ <과 % 그리고 % 와 > 사이에 빈 공간 문자가 있으면 안 된다.

- 종류

종류	태그 형식	사용 용도
지시어(directives)	<%@ %>	JSP 페이지의 속성을 지정
선언(declaration)	<%! %>	소속변수 선언과 메서드 정의
표현식(expression)	<%= %>	변수, 계산식, 함수 호출 결과를 문자열 형태로 출력
스크립트릿(scriptlet)	<% %>	자바 코드를 기술
주석(comments)	<%-- --%>	JSP 페이지의 설명 추가

■ 액션 태그와 커스텀 태그

✓ 액션 태그

- XML 스타일의 태그로 기술한 동작 기능을 수행하는 방식

✓ 커스텀 태그

- 새로운 태그를 정의하여 이용하는 방법으로 JSP 만의 고유한 방식

종류	태그 형식	사용 용도
액션 태그 (action Tag)	<jsp:include page="test.jsp />	현재 JPS 페이지에서 다른 페이지를 포함
	<jsp:foward page="test.jsp />	현재 JSP 페이지의 제어를 다른 페이지에 전달
	<jsp:plugin type="applet" code="test" />	자바 애플릿을 플러그인
	<jsp:useBean id="login" class="LoginBean" />	자바 빈을 사용
	<jsp:setProperty name="login" property="pass" />	자바빈의 속성을 지정하는 메서드를 호출
	<jsp:getProperty name="login" property="pass" />	자바빈의 속성을 변환하는 메서드를 호출
커스텀 태그(Custom Tag)	<tag:printData dbname="mydb" table="memb" />	사용자가 직접 정의한 태그를 이용

스크립트 요소

■ 스크립트 요소란?

✓ JSP 프로그래밍에서 사용되는 문법의 표현 형태!

■ 스크립트릿

✓ JSP에 자바 코드를 삽입할 때 사용

✓ JSP 페이지가 서블릿으로 변환되고 요청될 때 _jspService() 메서드 안에 선언되는 요소

✓ 스크립트릿은 선언문과 달리 선언된 변수는 지역 변수로 선언이 되고 메서드 선언은 할 수 없음

------> 만약 메서드를 선언하게 되면 메서드 안에 메서드를 선언한 것!! XXXX

✓ 스크립트릿 문법

이곳에 필요한 자바 코드를 삽입(지역 변수 선언, for, while, if 등등..)

스크립트릿 예제)

1
2
3
4

<%
    String str = "스크립트 태그";
    out.print(str);
%>

cs

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <% int i=24; %>
    <%
        out.println("하루는 " + i + "시간이며, <br>");
        out.println("하루는 " + i*60 + "분 입니다.");
    %>
</body>
</html>
Colored by Color Scripter

cs

 

실행 결과

■ 표현식(expression)

✓ 동적인 JSP 페이지를 브라우저로 표현을 하기 위한 요소

✓ 변수를 출력하거나, 계산식 또는 메서드의 결괏값을 브라우저에 출력

✓ 스크립트릿 코드 내에서 out 이라는 내장 객체를 통해 브라우저에 출력하는 것과 결과가 같음

✓ 스크립트릿과 달리 변수나 메서드를 출력하고자 할 때 세미콜론(;)을 표기하지 않음

✓ 표현식 문법

<%= 변수 혹은 메서드 %> // <% 와 = 사이에 공백이 있으면 안 됨

표현식 예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <% int year=365; %>
    <% out.println("1년은 약 몇 주일까요??"); %>
    <%= year/7 %>
    <%= " 주 입니다." %>
</body>
</html>
Colored by Color Scripter

cs

실행 결과

■ 선언문(Declaration)

✓ JSP에서 사용될 변수나 메서드를 선언할 수 있는 요소

✓ JSP페이지 내에서 변수 및 메서드를 선언 후, 변수나 메서드를 이용하여 동적으로 HTML 코드를 생성하는 데 사용

✓ 선언문에 선언된 변수를 멤버 변수라 한다.

✓ 선언문 문법

<%!

멤버 변수 및 메서드를 선언하는 영역

선언문 예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <h1>Declaration Example</h1>
    <%!
        int one;
        int two = 1;
        String msg;
        int three;
        
        public int plusMethod(){
            return one + two;
        }
        
    %>
    one + two?: <%=plusMethod() %> <p>
    String msg의 값??: <%=msg %> <p>
    int three의 값??: <%=three %> 
</body>
</html>
Colored by Color Scripter

cs

 

실행 결과

■ 주석

✓ 프로그램에 직접적인 영향을 미치지는 않지만 개발자들의 소스 분석 내용 및 파일 설명 처리를 위해서 없어서는 안 될 꼭 필요한 요소

✓ HTML 형식의 주석

✓ JSP 형식의 주석

<%-- JSP 형식의 주석 --%>

✓ 스크립트 요소의 주석

<% /* 여러 줄 주석 및 부분 주석 */ %>

<% // 한 줄 주석 %>

[JAVA] JAVA의 람다식 사용법 및 다양한 작성 예제 | Yoon's Dev

Yooniron — Wed, 21 Apr 2021 21:15:19 +0900

JAVA의 람다식(lambda) 사용법 및 다양한 작성 예제

Java의 람다식

■ 자바의 람다식

✓ 람다식(lambda)

- 자바에서는 함수를 메서드라고 부르고 메서드의 형태로 존재

- 자바 람다식의 구조

. (argument) -> { body } 구문을 사용하여 작성

자바의 람다식 구조

＠매개변수 리스트

- 함수에 전달되는 매개변수들이 나열

- 매개변수를 생략하면 컴파일러가 추론 기능을 이용하여 알아서 처리

- 매개변수가 하나인 경우 괄호를 생략 가능

@애로우 토큰

- 매개변수 리스트와 함수 코드를 분리시키는 역할

- "->" 기호: 매개변수들을 전달하여 함수 바디 { }에 작성된 코드를 실행

@함수 바디

- 함수의 코드

- 중괄호 ({ })로 둘러싸는 것이 일반적이지만, 한 문장인 경우 중괄호({ })를 생략 가능

- 한 문장이더라도 return 문이 있으면 반드시 중괄호로 둘러싸야함

람다식을 이용하는 방법

■ 람다식을 이용하는 방법

✓ 람다식(lambda) 만들기: 람다식은 함수형 인터페이스를 구현한 객체

- 자바에서 람다식은 함수형 인터페이스에 선언된 추상 메서드를 구현하는 방식으로 작성

- 함수형 인터페이스(functional interface) 작성

. 추상 메서드 하나만 있는 인터페이스

1
2
3
4
5

@FunctionalInterface
interface MyFunction { // 함수형 인터페이스
    int calc(int x, int y); // 추상 메소드
}
 
Colored by Color Scripter

cs

 

.@FunctionalInterface

컴파일러에게 함수형 인터페이스임을 알리는 annotation

=> 컴파일러에게 인터페이스가 추상 메서드가 1개만 있는 함수형 인터페이스인지 확인하도록 하여,

처음부터 잘못된 인터페이스 작성을 막는 장점

- 함수형 인터페이스의 추상 메서드를 람다식으로 구현

. 람다식의 작성: 함수형 인터페이스의 추상 메서드에 코드를 작성

. 인터페이스를 상속받은 클래스를 명시적으로 작성하지 않고 익명의 클래스가 만들어지는 방식

@@ 자바에서 람다식은 함수형 인터페이스를 구현한 객체(익명의 클래스)로 다루어

람다식을 인터페이스 타입의 변수에 치환 가능!!

람다식을 이용한 다양한 예제

인자 x, y를 받아들여 x+y를 리턴하는 람다식 만들기

1) LambdaEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package practice;
 
//인자 x, y를 받아들여 x+y를 리턴하는 람다식 만들기
//함수형 인터페이스
@FunctionalInterface
interface MyFunction {
    int calc(int x, int y);
}
 
public class LambdaEx {
    
    public LambdaEx() {
//        MyFunction f = new MyFunction() {
//
//            @Override
//            public int calc(int x, int y) {
//                return x+y;
//            }
//            
//        };
        
        MyFunction f1 = (x, y) -> {return x+y;};
        System.out.println("f1의 결과: " + f1.calc(22, 100));
        
        MyFunction f2 = (x, y) -> {return x-y;};
        System.out.println("f2의 결과: " + f2.calc(99, 9));
    }
 
    public static void main(String[] args) {
        new LambdaEx();
 
    }
 
}
 
Colored by Color Scripter

cs

 

LambdaEx.java

인자 x를 받아들여 제곱을 리턴하는 람다식 만들기

2) LambdaEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package practice;
 
//인자 x를 받아들여 제곱을 리턴하는 람다식 만들기
//함수형 인터페이스
@FunctionalInterface
interface Myfunction2 {
    int calc(int x);
}
public class LambdaEx2 {
    
    public LambdaEx2() {
        //Myfunction2 fsquare = (x) -> {return x*x;};
        Myfunction2 fsquare = (x) -> {return x*x;};
        System.out.println("fsquare의 결과: "+fsquare.calc(5));
    }
    public static void main(String[] args) {
        new LambdaEx2();
    }
 
}
 
Colored by Color Scripter

cs

LambdaEx2.java

//매개변수가 없는 람다식 만들기

3) LambdaEx3.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package practice;
 
//매개변수가 없는 람다식 만들기
//함수형 인터페이스
@FunctionalInterface
interface MyFunction3 {
    void print();
}
public class LambdaEx3 {
 
    
    public LambdaEx3() {
        MyFunction3 fprint = () -> {System.out.println("Yoon's Dev");};
        fprint.print();
    }
    public static void main(String[] args) {
        new LambdaEx3();
    }
 
}
 
Colored by Color Scripter

cs

LambdaEx3.java

//메서드의 인자로 람다식 전달

4) LambdaEx4.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package practice;
 
//메소드의 인자로 람다식 전달
//함수형 인터페이스
@FunctionalInterface
interface MyFunction4 {
    int calc(int x, int y);
}
 
public class LambdaEx4 {
    //메소드 정의 (메소드의 인자로 람다식 전달)
    
    static void printMultiply(int x, int y, MyFunction4 f) {
        System.out.println("실행 결과: " + f.calc(x, y));
    }
    public LambdaEx4() {
        printMultiply(100, 100, (x, y) -> {return x * y;});
    }
 
    public static void main(String[] args) {
        new LambdaEx4();
 
    }
 
}
 
Colored by Color Scripter

cs

lambdaEx4.java

//제네릭을 이용한 함수형 인터페이스

5) lambdaEx5.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package practice;
 
//제네릭을 이용한 함수형 인터페이스
@FunctionalInterface
interface MyFunction5<T>{
    void println(T x);
}
 
public class lambdaEx5 {
 
    public lambdaEx5() {
        MyFunction5<String> f1 = x -> {System.out.println(x.toString());};
        f1.println("String Generic 사용 람다식");
        f1.println("Yoon's Dev");
        
        MyFunction5<Integer> f2 = x -> {System.out.println(x.toString());};
        f2.println(Integer.valueOf(100));
    }
    public static void main(String[] args) {
        new lambdaEx5();
    }
 
}
 
Colored by Color Scripter

cs

lambdaEx5.java

[JAVA] JAVA의 5가지 리스너 이벤트 처리 방법 (독립, 내부, 프레임, 익명, 람다식) | Yoon's Dev

Yooniron — Tue, 20 Apr 2021 22:28:28 +0900

JAVA의 5가지 리스너 이벤트 처리 방법 (독립, 내부, 프레임, 익명, 람다식)

학습 목표

독립적인 클래스로 이벤트 처리기를 작성
내부 클래스로 이벤트 처리기를 작성
프레임 클래스에 이벤트 처리를 구현
익명의 클래스를 사용하는 방법
람다식을 이용하는 방법

1. 독립적인 클래스로 이벤트 처리기를 작성

■ 독립적인 클래스 작성

✓ 일반적인 방법

- 이벤트 리스너를 완전한 클래스로 작성

- GUI 컴포넌트에서 발생하는 전형적인 이벤트 처리 형태 ex) 버튼

. 이벤트와 연관된 인터페이스를 사용하여 클래스 생성

. GUI 구축을 위한 컴포넌트 객체를 생성

. 이벤트를 받아들인 컴포넌트 객체에 리스너를 등록

. add() 메소드를 사용하여 컨테이너에 추가

ActionEventTest1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package practice;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
class MyListener implements ActionListener{
 
    @Override
    public void actionPerformed(ActionEvent e) {
        JButton button  = (JButton)e.getSource();
        button.setText("버튼이 눌렸습니다.");
        
    }
    
}
 
class MyFrameTest extends JFrame{
    
    private JButton button;
    private JLabel label;
    //생성자
    public MyFrameTest() {
        this.setSize(300, 200);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setTitle("독립 리스너");
        
        JPanel panel = new JPanel();
        button = new JButton("버튼을 누르세요");
        label = new JLabel("Yoon's Dev");
        button.addActionListener(new MyListener());
        panel.add(button);
        panel.add(label);
        this.add(panel);
        this.setVisible(true);
    }
}
 
public class IndepClassListener {
 
    public static void main(String[] args) {
        new MyFrameTest();
 
    }
 
}
 
Colored by Color Scripter

cs

 

버튼 클릭 전

버튼 클릭 후

2. 내부 클래스(inner class)로 작성

■ 내부 클래스(inner class)로 작성

✓ Listener 클래스를 별도의 클래스(독립 클래스)로 하면 Frame안의 멤버 변수들을 쉽게 사용할 수 없음

✓ 일반적으로 Listener 클래스를 내부 클래스로 만듦

InnerClassListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package practice;
 
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class InnerClassListener extends JFrame{
    
    public InnerClassListener() {
        setTitle("InnerClassListener 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        Container c = getContentPane();
        c.setLayout(new FlowLayout());
        JButton btn = new JButton("Action");
        btn.addActionListener(new MyActionListener());
        
        c.add(btn);
        setSize(300, 200);
        setVisible(true);
    }
    
    private class MyActionListener implements ActionListener {
 
        @Override
        public void actionPerformed(ActionEvent e) {
            JButton b = (JButton)e.getSource();
            if(b.getText().equals("Action")) {
                b.setText("액션");
            } else b.setText("Action");
            
            
            //InnerClassListener의 멤버나 JFrame의 멤버를 호출할 수 있음
            InnerClassListener.this.setTitle(b.getText());
        }
        
    }
 
    
    public static void main(String[] args) {
        new InnerClassListener();
 
    }
 
}
 
Colored by Color Scripter

cs

버튼 클릭 전

버튼 클릭 후

3. Frame에서 이벤트 처리하는 방법

■ Frame에서 이벤트 처리하는 방법

✓ Frame 클래스가 JFrame을 상속받으면서 동시에 Listener 인터페이스도 구현하는 경우

✓ 많이 사용되는 방법

MyListenerFrame.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package practice;
 
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class InnerClassListener extends JFrame{
    
    public InnerClassListener() {
        setTitle("InnerClassListener 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        Container c = getContentPane();
        c.setLayout(new FlowLayout());
        JButton btn = new JButton("Action");
        btn.addActionListener(new MyActionListener());
        
        c.add(btn);
        setSize(300, 200);
        setVisible(true);
    }
    
    private class MyActionListener implements ActionListener {
 
        @Override
        public void actionPerformed(ActionEvent e) {
            JButton b = (JButton)e.getSource();
            if(b.getText().equals("Action")) {
                b.setText("액션");
            } else b.setText("Action");
            
            
            //InnerClassListener의 멤버나 JFrame의 멤버를 호출할 수 있음
            InnerClassListener.this.setTitle(b.getText());
        }
        
    }
 
    
    public static void main(String[] args) {
        new InnerClassListener();
 
    }
 
}
 
Colored by Color Scripter

cs

 

버튼 클릭 전

버튼 클릭 후

4. 익명 클래스(Anonymous class)로 작성

■ 익명의 클래스(Anonymous class)로 작성

✓ 클래스 몸체는 정의되지만 이름이 없는 클래스

✓ 클래스를 정의하면서 동시에 객체를 생성

✓ 이름이 없으므로 한 번만 사용

✓ 안드로이드 프로그램에서 일반적으로 사용하는 방법

AnonymousListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package practice;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class AnonymousListener extends JFrame{
    
    //멤버변수
    private JButton btn;
    
    //생성자
    public AnonymousListener() {
        this.setTitle("Yoon's Dev");
        this.setSize(300, 200);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel jp = new JPanel();
        
        btn = new JButton("Action");
        
        // 리스너 구현
        btn.addActionListener(new ActionListener() {
 
            @Override
            public void actionPerformed(ActionEvent e) {
                if(e.getActionCommand().equals("Action"))
                    btn.setText("확인");
                else btn.setText("Action");
            }
        });
        
        jp.add(btn);
        
        this.add(jp);
        this.setVisible(true);
    }
    
    
    
    public static void main(String[] args) {
        new AnonymousListener();
 
    }
 
}
 
Colored by Color Scripter

cs

버튼 클릭 전

버튼 클릭 후

5. 람다식을 이용하는 방법

■ 람다식을 이용하는 방법

✓ 람다식 만들기: 람다식은 함수형 인터페이스를 구현한 객체

- 함수형 인터페이스의 추상 메소드를 람다식으로 구현한다.

✓ 레퍼런스 변수를 이용하면서 람다식을 호출

[JAVA] Java 람다식 사용법 및 다양한 작성 예제 | Yoon's Dev

Java 람다식(lambda) 사용법 및 다양한 작성 예제 Java의 람다식 ■ 자바의 람다식 ✓ 람다식(lambda) - 자바에서는 함수를 메서드라고 부르고 메서드의 형태로 존재 - 자바 람다식의 구조 . (argument) ->

yooniron.tistory.com

LambdaListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package practice;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class LambdaListener extends JFrame {
    
    private JButton btn;
 
    public LambdaListener() {
        this.setTitle("Yoon's Dev");
        this.setSize(300, 200);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel jp = new JPanel();
        btn = new JButton("Action");
        
        ActionListener ll =(ActionEvent e) -> {
            if(e.getActionCommand().equals("Action"))
                btn.setText("확인");
            else btn.setText("Action");
        };
        
        btn.addActionListener(ll);
        
        jp.add(btn);
        
        this.add(jp);
        this.setVisible(true);
    }
    public static void main(String[] args) {
        new LambdaListener();
    }
 
}
 
Colored by Color Scripter

cs

버튼 클릭 전

버튼 클릭 후

[JAVA] JAVA의 GUI 기초, awt, swing 작성 절차, 컨테이너와 컴포넌트, 배치 관리자 | Yoon's Dev

Yooniron — Mon, 19 Apr 2021 22:44:01 +0900

JAVA의 GUI 기초, awt, swing 작성 절차, 컨테이너와 컴포넌트, 배치 관리자

학습 목표

JAVA의 GUI
GUI 작성절차
기초 컨테이너와 컴포넌트
배치 관리자

1. JAVA의 GUI

■ 그래픽 사용자 인터페이스

✓ Graphical User Interface, 간단히 GUI

- 사용자가 편리하게 입출력할 수 있도록 그래픽으로 화면을 구성하고, 마우스나 키보드로 입력받을 수 있도록 지원하는 사용자 인터페이스

✓ 자바 언어에서 GUI 프로그램 작성

- 컴포넌트들로 구성

■ 자바 GUI 특징

✓ 강력한 GUI 컴포넌트 제공

✓ 쉬운 GUI 프로그래밍

■ 자바의 GUI 프로그래밍 방법

✓ GUI 컴포넌트 이용

- AWT 패키지와 Swing 패키지

- AWT

. java.awt패키지

- Swing

.javax.swing 패키지

- JavaFX

. JAVA 11에서 제거 (CORBA, Java EE, Java FX, 애플릿, 자바 웹 스타트 기능)

GUI	설명
AWT	AWT는 운영 체제가 제공하는 자원을 이용하여서 컴포넌트를 생성
Swing	컴포넌트가 자바로 작성되어 있기 때문에 어떤 플랫폼에서도 일관된 화면 작성 가능

■ Swing 컴포넌트 예시

JButton
JCheckBox
JRadioButton
JTextField
JPassewordField
JTextArea
JComboBox
JList
JProgeressBar
JTooTip
JScrollPane
JMenu
JDialog
JFrame

이 밖에도 JApplet, JTable, JTree, JEditorPane, JTextPane, JToolBar, JSplitPane, JTabbedPane 등 여러 가지의 컴포넌트가 있다.

■ Swing의 특징

✓ 스윙 GUI 컴포넌트

- 형식화된 텍스트 입력이나 패스워드 필드 동작과 같은 복잡한 기능들이 제공

✓ 자바 2D API

- 그림이나 이미지, 애니메이션 기능을 제공

- 교체 가능한 룩앤필(Look-and-Feel) 지원

✓ 데이터 전송

- 자르기, 복사, 붙이기, 드래그 앤 드롭 등의 데이터 전송 기능 제공

대부분의 프로그램은 스윙 API 중에서 아주 작은 부분 집합만을 사용한다. 따라서 대부분의 경우 다음의 두 가지 패키지만 포함하면 된다.

* javax.swing

* javax.swing.event

Swing 패키지 계층구조

■ 컨테이너와 컴포넌트

✓ 컨테이너

- 다른 컴포넌트를 포함할 수 있는 GUI 컴포넌트

- 다른 컨테이너에 포함될 수 있음

. AWT 컨테이너: Panel, Frame, Applet, Dialog, Window

. Swing 컨테이너: JPanel, JFrame, JApplet, JDialog, JWindow

✓ 컴포넌트

- 컨테이너에 포함되어야 비로소 화면에 출력될 수 있는 GUI 객체

- 다른 컴포넌트를 포함할 수 없는 순수 컴포넌트

- 모든 GUI 컴포넌트가 상속받는 클래스: java.awt.Compnent

- 스윙 컴포넌트가 상속받는 클래스: javax.swing.JComponent

■ GUI 작성 절차

1) 컨테이너를 생성한다.

2) 컴포넌트를 추가한다.

GUI 작성 절차를 코드로 보도록 하자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package practice;
 
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class MyFrame extends JFrame {
    //생성자
    public MyFrame() {
        setSize(300, 200); //크기 설정
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("프레임 작성예시");
        
        setLayout(new FlowLayout()); //배치 관리자 설정
        JButton button = new JButton("버튼");
        
        //컴포넌트 생성 및 추가
        this.add(button);
        setVisible(true);
    }
    public static void main(String[] args) {
        new MyFrame();
    }
 
}
 
Colored by Color Scripter

cs

프레임 작성 예시

2. 기초 컨테이너와 컴포넌트

■ JFrame 컨테이너 클래스

✓ Swing 클래스 계층구조

- Component

. 화면에 표시되어서 사용자와 상호 작용하는 시각적인 객체를 나타냄.

- Container

. 내부에 다른 컴포넌트를 추가할 수 있는 기능을 제공

. 이 클래스의 add()를 사용하면 컨테이너 안에 컴포넌트를 추가

- Window

. 경계선, 타이틀 바, 버튼을 가지고 있는 윈도우를 정의

- Frame

. 자바 GUI 애플리케이션의 기초(AWT)

- JFrame

. Frame 클래스를 스윙의 출시에 맞추어 변경

✓ 중요한 메소드

- setLocation(x, y), setBounds(x, y, width, height), setSize(width, height) // 프레임의 위치와 크기를 설정

- setIconImage(IconImage) // 윈도우 시스템에 타이틀 바, 태스크 스위처에 표시할 아이콘을 알려줌

- setTitle() //타이틀 바의 제목 변경

- setResizable(boolean) //사용자가 크기를 조절할 수 있는지를 설정

ContentPane과 JFrame의 예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package practice;
 
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class ContentPaneEx extends JFrame {
    
    public ContentPaneEx() {
        setTitle("ContentPane과 JFrame 예제"); //프레임 타이틀
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        Container contentPane = getContentPane(); // 컨텐트팬 알아내기
        contentPane.setBackground(Color.orange); // 배경색 : oragne
        contentPane.setLayout(new FlowLayout()); // 컨텐트팬에 FlowLayout 배치관리자 달기
        
        contentPane.add(new JButton("OK")); // OK버튼
        contentPane.add(new JButton("Cancel")); // Cancel 버튼
        contentPane.add(new JButton("Ignore")); // Ignore 버튼
        
        setSize(300, 150); // 프레임 크기 300 x 150
        setVisible(true); // 화면에 프레임 출력
        
    }
    public static void main(String[] args) {
        new ContentPaneEx();
 
    }
 
}
 
Colored by Color Scripter

cs

ContentPane과 JFrame의 예제

18번째 줄의 FlowLayout의 배치 관리자는 컴포넌트를 순서대로 부착하는 일을 맡은 객체이다.

✓ 스윙 응용프로그램의 종료

- System.exit(0); //언제 어디서나 무조건 종료, 응용 프로그램 내에서 스스로 종료

- 프레임의 오른쪽 상단의 종료 버튼(x)이 클릭되면?????

---> 프레임 종료, 프레임 윈도우를 닫음(프레임이 화면에서 보이지 않게 됨)

But 프레임이 보이지 않게 되지만 응용프로그램이 종료한 것 아님

---> 키보드나 마우스 입력을 받지 못함

---> 다시 setVisible(true)를 호출하면, 보이게 되고 이전처럼 작동함

이를 해결하기 위해 프레임 종료 버튼이 클릭될 때, 프레임과 함께 프로그램을 종료시키는 방법이

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 를 사용하는 것이다.

■ 기초 컴포넌트

레이블(label)
버튼(button)
텍스트 필드(TextField)

✓ 레이블(label)

- 편집이 불가능한 텍스트를 표시

ex) JLabel label = new JLabel("Hello World");

label

✓ 버튼(Button)

- 편집이 불가능한 텍스트를 표시

ex) JButton btn = new JButton("클릭");

Button

버튼의 종류

JButton
JCheckBox
JRadioButton

✓ 텍스트 필드(TextField)

- 입력이 가능한 한 줄의 텍스트 필드

ex) JTextField text = new JTextField(20);

TextField

텍스트 필드의 종류

JTextField // 기본적인 텍스트 필드
JFormattedTextField // 사용자가 입력할 수 있는 문자를 제한
JPasswordField // 사용자가 입력하는 내용이 보이지 않음
JComboBox // 사용자가 직접 입력할 수도 있지만 항목 중에서 선택할 수 있음
Jspinner // 텍스트 필드와 버튼이 조합된 것

3. 배치 관리자

■ 컨테이너와 배치 개념

✓ 컴포넌트는 컨테이너에 부착되지 않으면 화면상 나타날 수 없음

✓ 컨테이너마다 하나의 배치 관리자가 존재하며, 삽입되는 모든 컴포넌트의 위치와 크기를 결정하고 적절히 배치

✓ 컨테이너의 크기가 변하면 내부 컴포넌트들의 위치와 크기를 모두 재 조절하고 재배치해야 함

■ 배치 관리자 대표 유형 3가지

FlowLayout
BorderLayout
GridLayout

AWT와 스윙의 컨테이너	디폴트 배치관리자
Window	BorderLayout
Frame, JFrame	BorderLayout
Dialog, JDialog	BorderLayout
Panel, JPanel	FlowLayout
Applet, JApplet	FlowLayout

JPanel 패널에 BorderLayout 배치 관리자를 설정하는 예시

JPanel p = new JPanel();

p.setLayout(new BorderLayout());

■ FlowLayout 배치 관리자

✓ 배치관리자를 지정하지 않으면 묵시적으로 FlowLayout으로 지정한다.

✓ 컴포넌트를 수평 방향으로 배치하는 관리자

- 왼쪽에서 오른쪽, 위에서 아래로 순차적으로 배열

- if) 한 줄에 모두 배치하지 못한다면 다음 줄에 연속하여 배열

✓ 생성자

- FlowLayout()

- FlowLayout(int align)

- FlowLayout(int align, int hgap, int vgap)

align: 정렬 방식

ex) LEFT, CENTER, RIGHT

hgap, vgap: 컴포넌트 사이의 수직, 수평 간격을 지정하는 값 --> 픽셀 단위

FlowLayoutEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package practice;
 
import java.awt.Container;
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class FlowLayoutEx extends JFrame {
 
    public FlowLayoutEx() {
        setTitle("FlowLayout 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane = getContentPane();
        
        contentPane.setLayout(new FlowLayout(FlowLayout.LEFT, 30, 40));
        
        contentPane.add(new JButton("버튼 1"));
        contentPane.add(new JButton("버튼 2"));
        contentPane.add(new JButton("버튼 3"));
        contentPane.add(new JButton("버튼 4"));
        contentPane.add(new JButton("버튼 5"));
        contentPane.add(new JButton("버튼 6"));
        
        setSize(300, 200);
        setVisible(true);
    }
    public static void main(String[] args) {
        new FlowLayoutEx();
 
    }
 
}
 
Colored by Color Scripter

cs

 

FlowLayout

■ BorderLayout 배치 관리자

✓ 컴포넌트를 추가할 때 방향을 지정하여 추가할 수 있는 기능을 제공

✓ 배치 방향: 동, 서, 남, 북, 중앙

- East(LINE_END), West(LINE_START)

- South(PAGE_END), North(PAGE_START), Center

✓ 배치 방법

- add(Component comp, int index) //comp를 index의 공간에 배치

✓ 생성자

- BorderLayout()

- BorderLayout(int hGap, int vGap)

✓ add() 메소드

- void add(Component comp, int index)

BorderLayoutEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package practice;
 
import java.awt.BorderLayout;
import java.awt.Container;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class BorderLayoutEx extends JFrame {
 
    public BorderLayoutEx() {
        setTitle("FlowLayout 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane = getContentPane();
        
        contentPane.setLayout(new BorderLayout(30, 20));
        
        contentPane.add(new JButton("버튼 1"), BorderLayout.CENTER);
        contentPane.add(new JButton("버튼 2"), BorderLayout.NORTH);
        contentPane.add(new JButton("버튼 3"), BorderLayout.SOUTH);
        contentPane.add(new JButton("버튼 4"), BorderLayout.EAST);
        contentPane.add(new JButton("버튼 5"), BorderLayout.WEST);
        
        setSize(300, 200);
        setVisible(true);
    }
    public static void main(String[] args) {
        new BorderLayoutEx();
 
    }
 
}
 
Colored by Color Scripter

cs

BorderLayout

■ GridLayout 배치 관리자

✓ 컴포넌트를 행과 열을 가진 배열 형태로 배치

✓ 컨테이너 공간을 동일한 사각형 격자(그리드)로 분할하고 각 셀에 컴포넌트 하나씩 배치

- 생성자에 행수와 열수 지정

- 셀에 왼쪽에서 오른쪽으로, 다시 위에서 아래로 순서대로 배치

✓ 생성자

- GridLayout()

- GridLayout(int row, int cols)

- GridLayout(int rows, int cols, int hgap, int vgap)

rows, cols: 배치할 행과 열(Default: 1)

hgap, vgap: 컴포넌트 사이의 간격, 픽셀 단위

----> rows x cols 만큼의 셀을 가진 격자로 컨테이너 공간을 분할 배치

GridLayoutEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package practice;
 
 
import java.awt.Container;
import java.awt.GridLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class GridLayoutEx extends JFrame {
 
    public GridLayoutEx() {
        setTitle("GridLayout 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane = getContentPane();
        
        contentPane.setLayout(new GridLayout(1, 10));
        
        for(int i=0; i<10; i++) {
            String text = Integer.toString(i);
            JButton btn = new JButton(text);
            this.add(btn);
        }
        
        setSize(300, 200);
        setVisible(true);
    }
    public static void main(String[] args) {
        new GridLayoutEx();
 
    }
 
}
 
Colored by Color Scripter

cs

GridLayout

■ 배치 관리자 선택 기준

✓ 컴포넌트를 가능한 크게 나타내고 싶은 경우

- GridLayout, BorderLayout 사용

✓ 몇 개의 컴포넌트를 자연스러운 크기로 한줄로 나타내고 싶은 경우

- FlowLayout

✓ 몇개의 컴포넌트를 행과 열로 동일한 크기로 나타내고 싶은 경우

- GridLayout

■ 절대 위치로 배치하기

✓ 배치 관리자가 없는 컨테이너에 컴포넌트를 삽입할 때

- 프로그램에서 컴포넌트의 절대 크기와 위치 설정

- 컴포넌트들이 서로 겹치게 할 수 있음

✓ 컴포넌트의 크기와 위치 설정 메소드

- void setSize(int width, int height) // 컴포넌트 크기 설정

- void setLocation(int x, int y) // 컴포넌트 위치 설정

- void setBounds(int x, int y, int width, int height) // 위치와 크기 동시 설정

NullCotainerEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package practice;
 
import java.awt.Container;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
 
public class NullContainerEx extends JFrame {
 
    
    public NullContainerEx() {
        setTitle("배치관리자 없이 절대 배치");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane = getContentPane();
        contentPane.setLayout(null);
        
        JLabel la = new JLabel("Yoon's Dev!");
        la.setLocation(130, 50);
        la.setSize(200, 20);
        
        this.add(la);
        
        // 9개의 버튼 컴포넌트 생성하고 동일한 크기로 설정, 위치는 겹치게
        for(int i=0; i<10; i++) {
            JButton btn = new JButton(Integer.toString(i));
            btn.setLocation(i*15, i*15);
            btn.setSize(50, 20);
            this.add(btn);
        }
        
        setSize(300, 200);
        setVisible(true);
        
    }
    public static void main(String[] args) {
        new NullContainerEx();
    }
 
}
 
Colored by Color Scripter

cs

 

NullContainerEx

[HTML/CSS] form, input 태그의 다양한 타입 요소 | Yoon's Dev

Yooniron — Sat, 17 Apr 2021 21:02:15 +0900

form, input 태그의 다양한 타입 요소

form 요소

웹 페이지에서는 form태그를 사용하여 사용자로부터 입력을 받을 수 있다.

또한, 사용자가 입력한 데이터를 서버로 보낼 때 form 요소를 사용한다.

form 태그는 다음과 같은 문법으로 사용한다.

1

<form action="처리 할 페이지주소" method="get|post"></form>

cs

action="" 은 입력받은 데이터를 처리할 스크립트 파일의 주소를 명시한다.

이것을 form-handler라고 한다.

method=""는 입력받은 데이터를 서버에 전달할 방식이다.

method의 속성은 다음과 같다

속성	설명
get	주소에 데이터를 추가하여 전달하는 방식, 데이터가 주소 창에 그대로 나타나고 데이터의 크기가 제한적
post	데이터를 별도로 첨부하여 전달, 데이터가 외부에 드러나지않으며 데이터의 크기가 제한이 없음, 보안성 뛰어남

다양한 타입의 input 요소

HTML에서 사용할 수 있는 대표적인 input 요소의 타입들이 있다.

텍스트 입력 (text, textarea)
비밀번호 입력 (password)
라디오 버튼 (radio)
체크 박스 (checkbox)
파일 선택 (file)
선택 입력 (select)
버튼 (button)
전송 (submit)
필드셋 (fieldset)

<input> 태그는 다음과 같이 사용한다.

1

<input type="타입" name="파라미터 이름">

cs

1. 텍스트 입력(text, textarea)

<input> 태그의 type 속성 값을 "text"로 설정하면, 한 줄의 텍스트를 입력받을 수 있다.

1
2
3
4
5
6
7

<form action="">
 
   텍스트를 입력하세요 :
 
    <input type="text" name="search">
 
</form>
Colored by Color Scripter

cs

tpye="text"

<input> 태그의 type 속성 값을 "textarea"로 설정하면 문장을 입력받을 수 있다.

1
2
3
4
5
6
7

<form action="">
 
    문장을 입력하세요 :
 
    <input type="textarea" name="search">
 
</form>
Colored by Color Scripter

cs

type="textarea"

2. 비밀번호 입력 (password)

<input> 태그의 type 속성 값을 "password"로 설정하면 비밀번호를 입력 받을 수 있다.

입력받은 문자는 별표나 작은 원으로 표시된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
 
      비밀번호 : 
      <input type="password" name="password">
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="password"

3. 라디오 버튼 (radio)

<input> 태그의 type 속성 값을 "radio"로 설정하면, 여러 개의 라디오 버튼 옵션 중에서 단 하나만의 값을 받을 수 있다.

※ 반드시 모든 input 요소의 name 속성이 같아야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
 
    <input type="radio" name="language" value="html" checked> HTML <br>
 
    <input type="radio" name="language" value="css"> CSS <br>
 
    <input type="radio" name="language" value="java"> JAVA <br>
 
    <input type="radio" name="language" value="cpp"> C
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="radio"
 
4. 체크 박스 (checkbox) 
<input> 태그의 type 속성 값을 "checkbox"로 설정하면, 사용자로부터 여러 개의 체크박스 중에서 여러 개의 옵션 값을 받을 수 있다.
※ 반드시 모든 input 요소의 name 속성이 같아야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
 
    <input type="checkbox" name="language" value="html" checked> HTML <br>
 
    <input type="checkbox" name="language" value="css"> CSS <br>
 
    <input type="checkbox" name="language" value="java"> JAVA <br>
 
    <input type="checkbox" name="language" value="cpp"> C
</form>
 
</body>
</html>
Colored by Color Scripter

cs

 

type="checkbox"

4. 파일 선택 (file)

<input> 태그의 type 속성 값을 "file"로 설정하면, 사용자로부터 파일을 받을 수 있다.

accept 속성을 이용하여 입력받을 수 있는 파일의 확장자 및 종류를 명시할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
    <input type="file" name="upload_file" accept="image/*">
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="file"
 
5. 선택 입력 (select) 
<input> 태그의 type 속성 값을 "select"로 설정하면, 여러 개의 드롭다운 리스트(drop-down-list) 중에서 한 개의 옵션을 입력받을 수 있다.
<option>은 드롭다운 리스트(drop-down-list)에서의 각각의 옵션을 명시한다.
 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
    <select name="language">
 
        <option value="java"> JAVA
 
        <option value="css" selected> CSS
 
        <option value="html"> HTML
 
        <option value="c"> C
 
</select>
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="select"

6. 버튼 (button)

<input> 태그의 type 속성 값을 "button"로 설정하면, 버튼을 나타낸다.

onclick="" 사용자가 클릭했을 때 작업을 나타낸다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
    <button type="button" onclick="alert('클릭하셨습니다.')">
 
    버튼
 
</button>
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="button"

6. 전송 (submit)

<input> 태그의 type 속성 값을 "submit"으로 설정하면, 입력받은 데이터(data)를 폼 핸들러로 제출하는 버튼을 생성한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
    이름을 입력하세요: <br>
 
    <input type="text" name="name" value="">
    <input type="submit" value="전송">
</form>
 
</body>
</html>
Colored by Color Scripter

cs

type="submit"
 
7. 필드셋 (fieldset) 
<input> 태그의 type 속성 값을 "fieldset"으로 설정하면, form 요소와 관련된 데이터를 하나로 묶어준다.
<legend>는 fieldset 안에서만 사용 가능하며, fieldset 요소의 제목을 나타낸다.
 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
 
<form action="">
    <fieldset>
 
        <legend>학생 정보</legend>
 
        이름 : <br>
 
        <input type="text" name="name"><br>
 
        이메일 : <br>
 
        <input type="text" name="email"><br><br>
 
        학번 : <br>
 
        <input type="text" name="studentNum"><br><br>
     
 
    </fieldset>
 
</body>
</html>
Colored by Color Scripter

cs

 
type="fieldset"
 
 

[HTML/CSS] table 테이블 태그 속성 및 사용법, 표 만들기 | Yoon's Dev

Yooniron — Fri, 16 Apr 2021 21:18:16 +0900

table 테이블 태그 속성 및 사용법, 표 만들기

colsapn과 rowspan 속성을 이용하여 행, 열 합치기

html5에서의 표를 만드는 방법에 대해서 알아보자.

테이블 태그는 단순히 표를 나타내는 것뿐만 아니라 웹 페이지의 레이아웃을 구성할 때에도 유용하게 쓰인다.

다만 div 태그를 활용하는 것이 더 좋지만 테이블 태그는 유용하게 쓰이니 알아보도록 하자.

1. <Table>태그의 기본

<table>: 표를 생성하는 가장 상위 태그
<tr>: 행을 나타내는 태그
<td>: 열을 나타내는 태그
<th>: 표의 제목을 나타내는 태그

아래와 같은 표를 테이블 태그를 이용해 구현해 보도록 하자.

1행 1열	1행 2열	1행 3열
2행 1열	2행 2열	2행 3열
3행 1열	3행 2열	3행 3열

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
 
<body>
    <table border="1">
      
        <tr>
            <td>1행 1열</td>
            <td>1행 2열</td>
            <td>1행 3열</td>
        </tr>
        <tr>
            <td>2행 1열</td>  
            <td>2행 2열</td>   
            <td>2행 3열</td>  
        </tr>
        <tr>
            <td>3행 1열</td>  
            <td>3행 2열</td>    
            <td>3행 3열</td>    
        </tr>
    </table>
 
</body>
</html>

cs

 
실행 결과
 
표를 만들기 위해서는 <table></table>안에 정의를 해주면 된다.
행을 정의하기 위해 <tr>태그를 이용하고, 열을 정의하기 위해 <td> 태그를 이용한다.
 
여기서 table border="1"을 안해주게 되면 테이블의 테두리가 보이지 않는데
border=""를 이용해서 테이블의 테두리 두께를 표현해주도록 하자. 

2. colspan / rowsapn 속성 (테이블 행, 열 병합)

colspan=""과 rowspan=""을 이용하여 행과 열을 합칠 수 있다.

다음과 같이 1행 1열과 2행 1열을 합치고 4행 1열과 4행 2열을 합치는 표를 만들어 보자.

rowspan="합칠 행의 개수"

colspan="합칠 열의 개수"

를 이용하면 된다.

2행 합침	1행 2열	1행 3열
2행 합침	2행 2열	2행 3열
3행 1열	3행 2열	3행 3열
2열 합침		4행 3열

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
 
<body>
    <table border="1">
       <tr>
            <td rowspan="2"> 2행 합침</td>
            <td>1행 2열</td>
            <td>1행 3열</td>
           
        </tr>
        <tr>
            <td>2행 2열</td>   
            <td>2행 3열</td>
            
        </tr>
        <tr>
            <td>3행 1열</td>  
            <td>3행 2열</td>    
            <td>3행 3열</td>    
        </tr>
        <tr>
            <td colspan="2">2열 합침</td>  
            <td>4행 3열</td>    
              
        </tr>
    </table>
 
</body>
</html>
Colored by Color Scripter

cs

실행 결과

3. <Table> 태그 속성 정리

<table> 태그의 대표적인 속성들을 정리해보았다.

속성	설명
border	표의 테두리를 설정 (숫자가 높을수록 두꺼워짐)
bordercolor	표의 테두리의 색상
width	표 가로 크기
height	표 세로 크기
align	표 정렬방식
bgcolor	표의 배경색
colspan	표 열 합치기 (가로)
rowspan	표 행 합치기 (세로)

[JSP] getParameter(), getParameterValues()를 이용한 학생 정보 입력 값 전달 | Yoon's Dev

Yooniron — Thu, 15 Apr 2021 14:56:39 +0900

[JSP] getParameter(), getParameterValues()를 이용한 학생 정보 입력 값 전달

TO Do.

- 학생 정보 테이블 작성하는 페이지에서 학생 정보 값 넘기기

- student.jsp에 학생 정보 출력하기

- checkBox를 여러 개 선택해서 getParameterValues로 여러 값 전달하기

목표: student.jsp에 학생 정보 출력하기

1. student.jsp

먼저 학생 정보를 입력하기 위해 <table> 태그를 이용해 학생 정보 입력하는 페이지를 만들자.

student.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <!-- submit시 studentProc.jsp로 post 형식으로 값 전달 -->
    <form action="studentProc.jsp" method="post">
    <table border="1" style="width:800px;">
        <th colspan="2"><h1>학생 정보</h1></th>
        <tr>
            <td >이름</td>
            <td width="700px"><input type="text" name="name"></td>
        </tr>
        <tr>
            <td>성별</td>
            <td>
                <input type="radio" name="sex" value="남자">남자
                <input type="radio" name="sex" value="여자">여자
            </td>
        </tr>
        <tr>
            <td>전공</td>
            <td>
                <select name="major">
                    <option value="국문학과" selected>국문학과</option>
                    <option value="영문학과" >영문학과</option>
                    <option value="수학과" >수학과</option>
                    <option value="정치학과" >정치학과</option>
                    <option value="체육학과" >체육학과</option>
                </select>
            </td>
        </tr>
        <tr>
            <td>취미</td>
            <td>
                <input type="checkbox" name="hobby" value="수영">수영
                <input type="checkbox" name="hobby" value="여행">여행
                <input type="checkbox" name="hobby" value="독서">독서
                <input type="checkbox" name="hobby" value="영화감상">영화감상
            </td>
        </tr>
        <tr>
            <td colspan="2" align="center">
                <input type="submit" value="회원정보 보내기">&nbsp;&nbsp;&nbsp;
                <input type="reset" value="다시 쓰기">
            </td>
            
        </tr>
    </table>
    </form>
</body>
</html>
Colored by Color Scripter

cs

student.jsp를 studentProc.jsp에 post 형식으로 보낼 것 이다.

파라미터

이름: name

성별: sex

전공: major

취미: hobby

다음과 같이 정보를 입력해보고 넘겨보자!

studentProc로 보낼 정보

2. studentProc.jsp

studentProc.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <%!
        String depart = ""; //전공을 담을 String 멤버변수
    %>
    <%
        request.setCharacterEncoding("EUC-KR"); //인코딩 형식
        
        //student.jsp에서 넘긴 값 저장
        String name = request.getParameter("name");
        String sex = request.getParameter("sex");
        String major = request.getParameter("major");
        String hobby[] = request.getParameterValues("hobby"); //checkBox의 여러 내용을 저장하기위해 getParameterValues 사용
        
        // <select>태그의 전공에 따라 depart에 다르게 저장
        if (major.equals("국문학과")) {
            depart="국문학과";
        } else if (major.equals("영문학과")){
            depart="영문학과";
        } else if (major.equals("수학과")){
            depart="수학과";
        } else if (major.equals("정치학과")){
            depart="정치학과";
        } else depart="체육학과";
    %>
    <table border="1" style="width:800px;">
        <th colspan="2"><h1>학생 정보</h1></th>
        <tr>
            <td >이름</td>
            <td width="700px"><%=name %></td>
        </tr>
        <tr>
            <td>성별</td>
            <td><%=sex %></td>
        </tr>
        <tr>
            <td>전공</td>
            <td><%=depart %></td>
        </tr>
        <tr>
            <td>취미</td>
            <td><% for(String s: hobby) out.print(s + " "); %> 
            </td>
        </tr>
        <tr>
            <td colspan="2" align="center">
                <input type="submit" value="회원정보 보내기">&nbsp;&nbsp;&nbsp;
                <input type="reset" value="다시 쓰기">
            </td>
            
        </tr>
    </table>
 
</body>
</html>
Colored by Color Scripter

cs

20번째 줄에서 getParameterValues()를 하게 되면 배열로 이용해서 값을 여러 개 저장할 수 있다.!!

String hobby[] = request.getParameterValues("hobby");

그러고 나서, 배열로 저장한 것을 for-each 문으로 출력해주었다.

for(String s: hobby) out.print(s + " ");

<select> 태그 안에 있는 전공 값은 if문으로 major.equals로 비교해 선택한 전공이 나오게 조건문을 작성해주었다.

3. 함께 보면 좋은 글

[JSP] getParameter()를 이용한 간단한 사칙연산 계산기 | Yoon's Dev

[JSP] getParameter()를 이용한 간단한 사칙연산 계산기 TO Do. - 각각의 input 태그 안에 들어있는 피연산자와 연산자 두 개를 +, -, *, / 를 해서 보내기(submit) - calcProc.jps 에 연산결과 출력하기 목표: ca..

yooniron.tistory.com

[HTML/CSS] table 테이블 태그 속성 및 사용법, 표 만들기 | Yoon's Dev

table 테이블 태그 속성 및 사용법, 표 만들기, colsapn과 rowspan 속성을 이용하여 행, 열 합치기 html5에서의 표를 만드는 방법에 대해서 알아보자. 테이블 태그는 단순히 표를 나타내는 것뿐만 아니라

yooniron.tistory.com

[JSP] getParameter()를 이용한 간단한 사칙연산 계산기 | Yoon's Dev

Yooniron — Wed, 14 Apr 2021 21:25:27 +0900

[JSP] getParameter()를 이용한 간단한 사칙연산 계산기

TO Do.

- 각각의 input 태그 안에 들어있는 피연산자와 연산자 두 개를 +, -, *, / 를 해서 보내기(submit)

- calcProc.jps 에 연산결과 출력하기

목표: calcProc.jsp 에 연산결과 출력!

1. calc.jsp

calc.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <h1>피연산자와 연산자를 입력하시오.</h1>
    <form action="calcProc.jsp" method="post">
        숫자1: <input type="text" name="num1"><br>
        숫자2: <input type="text" name="num2"><br>
        연산자: <select name="operator">
                <option value="+">+</option>
                <option value="-">-</option>
                <option value="*">*</option>
                <option value="/">/</option>
            </select>
        <br>
        <input type="submit" value="보내기">
    </form>
</body>
</html>
Colored by Color Scripter

cs

 

<form> 태그의 action 값을 calcProc.jsp로 향하고 post 형식으로 넘겨주었다

파라미터

숫자 1: num1

숫자 2: num2

연산자: operator

위와 같이 피연산자와 연산자를 calcProc.jsp로 넘길 것이다.

2. calcProc.jsp

간단하게 40 + 20과 100 / 2 연산을 해보도록 하자.

calcProc.jsp // 40 + 20

calcProc.jsp // 10 / 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    <h1>연산 결과</h1>
    <%
        request.setCharacterEncoding("EUC-KR"); //인코딩 형식
        
        int num1 = Integer.parseInt(request.getParameter("num1"));
        int num2 = Integer.parseInt(request.getParameter("num2"));
        
        String operator = request.getParameter("operator"); //select 태그의 name 값 operator에 저장
        
    %>
    <%
    //select 태그 option 값에 따라 사칙연산
    if (operator.equals("+")) { %>
           <%=num1%> + <%=num2%> = <%=num1+num2 %>
       <%
        } else if (operator.equals("-")) { %>
            <%=num1%> - <%=num2%> = <%=num1-num2 %>
       <%
        }else if (operator.equals("*")){ %>
            <%=num1%> * <%=num2%> = <%=num1*num2 %>
       <%
        }else{    %>
            <%=num1%> / <%=num2%> = <%=num1/num2 %>
       <%
        }
        %>
 
</body>
</html>
Colored by Color Scripter

cs

이 코드에서 request.getParameter("calc.jsp에서 받아 오고 싶은 name 값");을

원하는 변수에 저장해주면 된다.

저는 int num1과 num2, String operator에 저장하기로 했어요!

그러고 나서, calc.jsp의 select 태그 안에 값에 따라 계산이 되게 하려면 if 문으로 operator의 값이 일치하는지 비교해주면서 연산을 해주면 된다.!!

operator.equlas()로 비교해 주는 이유는 위에서 operator를 String 형식으로 저장해 주었기 때문이다.

40 + 20 연산결과

100 / 2 연산결과

3. 함께 보면 좋은 글

[JSP] getParameter()를 이용하여 구구단 출력하기 | Yoon's Dev

request.getParameter()를 이용하여 구구단 출력하기 TO Do. - gugudan.jsp에서 input 태그 안에 숫자에 따라 보내기(submit) - gugudanProc.jsp에서 해당하는 숫자에 따른 구구단 출력! 목표: gugudanProc.jsp에..

yooniron.tistory.com

[JSP] getParameter()를 이용하여 구구단 출력하기 | Yoon's Dev

Yooniron — Wed, 14 Apr 2021 16:14:13 +0900

[JSP] request.getParameter()를 이용하여 구구단 출력하기

TO Do.

- gugudan.jsp에서 input 태그 안에 숫자에 따라 보내기(submit)

- gugudanProc.jsp에서 해당하는 숫자에 따른 구구단 출력!

목표: gugudanProc.jsp에서 해당하는 숫자에 따른 구구단 출력!

1. gugudan.jsp

첫번째로 몇 단을 입력할 것 인지 gugudan.jsp 파일을 만들어보도록 하자

gugudan.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
 
    <h1>단을 입력하시오</h1>
    <!-- post 형식으로 gugudanProc.jsp에 input태그의 dan 값 전달 -->
    <form action="gugudanProc.jsp" method="post"> 
        <input type="number" min="1" max="9" name="dan">
        <input type="submit" value="보내기">
    </form>
</body>
</html>
Colored by Color Scripter

cs

<form> 태그의 action 값을 gugudanProc.jsp로 향하고 post 형식으로 넘겨주었다

1단부터 9단까지 출력하고 싶었기에

<input type="number" min="1" max="9" name="dan">로 설정!!

*여기서 일반 익스플로러나 이클립스에 뜨는 브라우저에는 제대로 출력이 되지 않을 수 있다.

해당 글에서는 chrome 브라우저를 이용함.

여기서 넘길 파라미터 값을 name="dan"으로 해놓고 gugudan.jsp에서 dan을 받아올 것이다.

2. gugudanProc.jsp

다음과 같이 4단으로 두고 submit 해보았다.

gugudanProc.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
    
    <%
        request.setCharacterEncoding("EUC-KR"); //인코딩 형식
    
        int dan = Integer.parseInt(request.getParameter("dan")); //input태그의 dan 을 int형으로 변환해서 저장
        
        
    %>
    
    <h1>구구단:<%=dan%>단</h1>
    
    <%
        for(int i=1; i < 10; i++){ //구구단 for문 단수 * 9까지만
    %>
        <%=dan%> * <%=i%> = <%=dan*i%><br> <%-- 단수 * i를 바로 표현식으로 표현 --%>
    <%
        }
    %>        
    
 
</body>
</html>
Colored by Color Scripter

cs

이 코드에서 핵심은 int dan = Integer.parseInt(request.getParameter("dan")); 이 부분이라고 할 수 있다.

일반적으로 getParameter()로 값을 넘기게 되면 int형으로 받지 못하기에 int형으로 형 변환을 해서 dan에 저장해 두었다.

다음 for문을 이용해서 바로 표현식으로 단수 * i를 출력해주었다.

3. 함께보면 좋은글

[JSP] getParameter()를 이용한 간단한 사칙연산 계산기 | Yoon's Dev

getParameter()를 이용한 간단한 사칙연산 계산기 TO Do. - 각각의 input 태그 안에 들어있는 피연산자와 연산자 두개를 +, -, *, / 를 해서 보내기(submit) - calcProc.jps 에 연산결과 출력하기 목표: calcProc...

yooniron.tistory.com

[Android] Intent를 이용한 사용자 입력 값 다른 Activity 전달 | Yoon's Dev

Yooniron — Tue, 13 Apr 2021 21:47:16 +0900

[Android] Intent를 이용한 사용자 입력 값 다른 Activity 전달

TO Do.

- 사용자 입력 정보를 전달할 수 있도록 구현

- 버튼의 글씨의 대소문자 구분 처리 및 EditText에 MultiLine 적용 등 위젯 속성 변경 방법 확인

* 해당 글은 안드로이드 스튜디오 4.1.2 기준으로 설명되었습니다. *

목표: activity_main.xml의 editText의 내용을 activity_2.xml로 입력값을 전달

1. 레이아웃 구성

activity_main.xml

editText의 id값 : main_edit_input

editText의 id 값

editText의 Constraint Widget은 하단의 Button이 위치해있고 위 TextView에 맞춰서 화면을 차지하고 싶기에

editText -> 하단의 Button으로 연결해주었다.

그리고 layout_width와 layout_height는 match_constraint로 설정.

width와 height는 match_constraint

그리고 난 뒤 입력을 여러 줄로 표현하기 위해 android:inputType="textMultiLine"을 주었다.

글씨 크기는 가독성을 위해 24sp!

main_edit_input의 속성

다음은 버튼을 만들어주자.

값 전달 버튼인 Move와 종료 Close버튼

Move 버튼의 id 값: main_btn_move

Close 버튼의 id 값: main_btn_close

이렇게 첫 번째 activity_main의 레이아웃이 끝났고 다음 activity_2로 넘어가 보도록 하자.

activity_2.xml

activity_2의 textView id값: a2_text_result

activity_2의 textView id값

CLOSE 버튼

CLOSE 버튼의 id 값: a2_btn_close

2. Java Class 파일(기능 구현)

1)MainActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package com.example.practice04;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
 
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 
    EditText input;
    Button btn01, btn02;
 
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        input = (EditText)findViewById(R.id.main_edit_input);
 
        btn01 = (Button)findViewById(R.id.main_btn_move);
        btn02 = (Button)findViewById(R.id.main_btn_close);
 
        btn01.setOnClickListener(this);
        btn02.setOnClickListener(this);
    }
 
    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.main_btn_move) {
            // 데이터 첨부를하고 액티비티 실행
            String temp = input.getText().toString();
            Intent intent01 = new Intent(this, Activity2.class);
            intent01.putExtra("key01", temp);
            startActivity(intent01);
        }
        if (v.getId() == R.id.main_btn_close) {
            // 종료
            finish();
        }
    }
}
Colored by Color Scripter

cs

View.OnClickListener 연결 및 구현

1) main_btn_move 클릭 시 // editText에 작성된 내용을 Activity_2로 전달

input(editText)의 값을 getText()로 뽑아서 toString 문자열로 변환해서 temp에 저장! temp는 보낼 데이터

inten01안에 new Intent( packageContext:this, Activity2.class) //this는 MainActivity.this와 동일하다

**new Intent( 보내는 애, 받는 애 )

intent01.putExtra(name:"key01", temp) //key01이란 이름으로 temp를 보내겠다!

2)main_btn_close 클릭 시

finish(); // 종료

2)Activity2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.example.practice04;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
 
public class Activity2 extends AppCompatActivity implements View.OnClickListener {
 
    Button btn01;
    TextView result_textView;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_2);
 
        btn01 = (Button)findViewById(R.id.a2_btn_close);
        btn01.setOnClickListener(this);
 
        result_textView = (TextView)findViewById(R.id.a2_text_result);
 
        Intent receive_intent = getIntent();
 
        String temp = receive_intent.getStringExtra("key01");
 
        result_textView.setText(temp);
    }
 
    @Override
    public void onClick(View v) {
        //액티비티 종료
        finish();
    }
}
Colored by Color Scripter

cs

*전달된 데이터에 대한 처리

Intent receive_intent = getIntent();

String temp = receive_intent.getStringExtra("key01");

이렇게 전달된 데이터를 갖고 result_textView에 setText(temp);를 해주면 두 번째 레이아웃의 editText가 변경될 것이다.

3. 실행결과

실행 결과