반응형





 SQL Study





1. 테이블 생성 : 테이블명 (flower) / 컬럼명 (name, color) / 컬럼타입 (문자열, 문자열)


CREATE TABLE flower (

name varchar(50),

color varchar(30)

);


2. 데이터 입력 : rose, red/ rose, yellow / herb, green


INSERT INTO flower (name,color) VALUES ('rose','red');

INSERT INTO flower (name, color) VALUES ('rose','yellow');

INSERT INTO flower (name,color) VALUES ('herb','green');


3. 데이터 수정 : 두 번째 데이터의 색을 pink로 update
 

UPDATE flower SET color = 'pink' WHERE color='yellow';


4. 데이터 삭제 : 세 번째 데이터를 삭제


DELETE FROM flower WHERE name='herb';

반응형

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 1  (0) 2017.07.06
반응형

세상에 나쁜개는 없다
루샤는 개줄을 싫어해


개줄을 싫어하는 차가운 도시견 루샤!

어떤 사연인지 영상으로 만나볼까요?






반응형
반응형

세상에 나쁜개는 없다
퍼피특집 우리 강아지가 달라졌어요


오늘은 퍼피특집!!

강아지 시절부터 사회화와 적절한 교육을 통해 문제견이 아닌 사랑스런 반려견으로!!

강아지 교육방법 영상으로 확인하시죠~ 







반응형
반응형





 SQL Study



- cmd창에서 초기 접속

c:> Mysql -uroot -papmsetup mysql


- 기초함수 익히기


 round

 반올림 값을 구함

 select round(1.58);



abs

 절대 값을 구함

 select abs(-100);



mod

 나눈 나머지 값을 구함

 select mod(35,10);



 least

 주어진 인수 값 중 가장 작은 값을 구함

 select least(1,2,3);



 greatest

 주어진 인수 값 중 가장 큰 값을 구함

 select greatest(1,2,3);



 floor

 주어진 인수 값 보다 크지 않은 최대 정수

 select floor(10.23);



 length

 내용 : 문자열의 길이를 구한다.

 select length('school');



left

 주어진 인수 값(문자)의 왼쪽에서 특정길이 만큼 보여줌

 select left('my school',2);



 right

 주어진 인수 값(문자)의 오른쪽에서 특정길이 만큼 보여줌

 select right('my school',5);



 substring

 지정 위치에서 지정 길이만큼 보여줌

 select substring('my school',4,6);



 concat

 여러 개의 문자열을 이어줌

 select concat('my','sql');



 password

 일반 문자열을 암호화

 select password('mysql');



 lpad

 지정된 길이의 부족한 공간을 왼쪽으로 채우기

 select lpad('mysql',7,'?');



 rpad

 일반 문자열을 암호화

 select rpad('mysql',7,'?');



 lcase

 영문을 소문자로 바꿈

 select lcase('MYSQL');



 ucase

 영문을 대문자로 바꿈

 select ucase('mysql');


- 중요용어정리 ( DML / DCL )


1. DDL (Data Definition Language)

: 데이터 베이스의 스키마 객체를 생성, 변경, 제거, 자료의 버림, 주석을 수행


(1) CREATE


(2) ALTER


(3) DROP


(4) TRUNCATE


(5) COMMENT


2. DML (Data Manipulation Language)

: 스키마 객체의 데이터를 입력, 수정, 조회, 삭제 등의 작업을 말함


(1) SELECT


(2) INSERT


(3) UPDATE


(4) DELETE


3. DCL (Data Control Language)

: 트랜잭션의 성격을 제어하는 것


(1) SET TRANSACTION


(2) COMMIT


(3) ROLLBACK


(4) SAVEPOINT // 작업 위치를 임시로 저장하여 롤백에 사용


- 데이터 형 (데이터 TYPE)

: 숫자 Type M : 최대 출력사이즈, D: 소숫점 자릿수


(1) TINYINT [(M)][UNSINGED]

: 가장 작은 숫자형, 부호에 있을 때 -128~127, 업을 때 0~255 까지 다룰 수 있다. (1 byte 필요) 


(2) SMALLINT[(M)][UNSINGED]

: 부호가 있을 때 -32768 ~ 32767, 없을 때 0~65535 까지 다룰 수 있다. (2 byte 필요)


(3) MEDIUMINT[(M)][UNSINGED]

: 부호가 있을 때 -8388608~ 8388607, 없을 때 0~16777215까지 다룰 수 있다. (3 byte 필요)


(4) INT[(M)][UNSINGED] / (INTEGER)

: 일반적으로 사용하는 숫자형, 부호가 있을 때 -2147483648 ~ 2147483647 (4 byte 필요)


(5) BIGINT[(M)][UNSINGED]

: 부호가 있을 때 -9223372036854775808 ~ 9223372036854775807 (8 byte 필요)


(6) FLOAT[(M,D)]

: 값의 범위는 최소 +-1.175494351E-38, 최대 +-3.402823466E+38 (4 byte 필요)


(7) DOUBLE[(M,D)]

: 값의 범위는 최소 +-1.7976931348623157E-308 (8 byte 필요)


- 문자 TYPE

(1) CHAR


(2) VARCHAR


(3) TINYBLOB / TINYTEXT (255 byte)


(4) TEXT / BLOB (65535 byte)


(5) MEDIUMTEXT (16777215 byte)


(6) LONGTEXT (429496729 byte)


(7) ENUM


- 날짜 TYPE

(1) DATE

: 1001-01-01 부터 9999-12-31 까지의 값이 들어갈 수 있음

: 저장 시 3byte 필요

: 'YYYY-MM-DD' 포맷


(2) DATETIME

: 날짜와 시간이 같이 들어감 '1001-01-01 00:00:00' 부터 '9999-12-31 23:59:59'까지의 값을 다룸

: 저장 시 8 byte 필요

: 'YYYY-MM-DD HH:MM:SS' 포맷

반응형

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 예제  (0) 2017.07.07
반응형

           

  JAVA Study





1. 객체지향 언어


- 객체지향의 기본개념 

: 실제 세계는 사물(객체)로 이루어져 있으며, 발생하는 모든 사건들은 사물간의 상호작용이다

: 상속, 캡슐화, 추상화 개념을 중심으로 구체적으로 발전됨


- 객체지향 언어

: 코드의 재사용성이 높다 - 기존코드를 이용하여 새로운 코드 작성이 쉬움

: 코드의 관리가 용이하다 - 코드간의 관계를 이용해 쉽게 코드변경 가능

: 신뢰성이 높은 프로그래밍을 가능하게 한다 - 제어자와 메서드를 이용해 데이터를 보호하고 올바른 값을 유지하게 하며, 코드 중복 제거, 코드 불일치로 인한 오동작 방지

: 객체지향 프로그래밍은 프로그래머에게 거시적 관점에서 설계할 수 있는 능력을 요구



2. 클래스와 객체


- 클래스

: 객체를 정의해 놓은 것

: 객체의 설계도

: 객체를 생성하는데 사용되며


- 객체

: 클래스에 정의된 내용대로 메모리에 생성됨

: 객체의 용도는 객체가 가지고 있는 기능과 속성에 따라 다름


- 먼저 클래스를 작성한 후, 클래스로부터 객체를 생성해 사용한다


- 인스턴스화

: 클래스로부터 객체를 만드는 과정

: 어떤 클래스로부터 만들어진 객체를 그 클래스의 인스턴스라고 함

: 객체는 모든 인스턴스를 대표, 인스턴스는 어떤 클래스에서 생성된 객체인지를 강조하는 보다 구체적 표현


- 객체의 속성과 기능

: 객체는 다수의 속성과 다수의 기능을 가짐 ( 속성과 기능의 집합 )

: 클래스는 객체를 정의한 것이므로, 클래스에 객체의 모든 속성과 기능이 정의되어있음

: 클래스로부터 객체 생성 -> 클래스에 정의된 속성과 기능을 가진 객체가 만들어짐

: 속성 - 멤버변수, 특성, 필드, 상태

: 기능 - 메서드, 함수, 행위


- 인스턴스 생성

: 클래스명 변수명= new 클래스명();   ( ex. Tv t = new Tv(); )

-> Tv 클래스 타입의 참조변수 t 선언& 초기화

-> 인스턴스 속성을 사용하려면 '참조변수.멤버변수'로 작성 ( ex. t.멤버변수 )

: 인스턴스는 오직 참조변수를 통해서만 다룰 수 있음

: 참조변수의 타입은 인스턴스의 타입과 일치해야 함

: 같은 클래스로부터 생성되어도 각 인스턴스의 속성은 서로 다른 값을 유지할 수 있음, 메서드의 내용은 모든 인스턴스에 동일


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
class Tv{
    // Tv 속성 (멤버변수)
    String color;     //색상
    boolean power;    //전원상태 (on/off)
    int channel;    //채널
 
    // Tv기능 (메서드)
    void power() {
        power = !power;    //Tv를 켜거나 끄는 메서드
    }
    void channelUp() {
        ++channel;        //채널을 높이는 메서드
    }
    void channelDown() {
        --channel;        //채널을 낮추는 메서드
    }
}
 
class TvTest2{
    public static void main(String args[]){
        Tv t1 = new Tv();
        Tv t2 = new Tv();
        
        System.out.println("t1의 channel 값은 : "+t1.channel +"입니다.");    //t1의 channel 값은 : 0
        System.out.println("t2의 channel 값은 : "+t2.channel +"입니다.");    //t2의 channel 값은 : 0
 
        t1.channel = 7//채널 7 저장
        System.out.println("t1의 channel 값은 : "+t1.channel +"입니다.");  //t1의 channel 값은 : 7
        System.out.println("t2의 channel 값은 : "+t2.channel +"입니다.");    //t2의 channel 값은 : 0
        
    }
}
cs


- 객체배열

: 많은 수의 객체를 다룰 때 배열 사용

: 객체 배열안에 객체의 주소 저장, 참조변수를 하나로 묶은 참조변수 배열


- 클래스의 또다른 정의 (프로그래밍적 관점)

: 변수 - 하나의 데이터를 저장할 수 있는공간

: 배열 - 같은 종류의 여러 데이터를 하나의 집합으로 저장할 수 있는 공간

: 구조체 - 서로 관련된 여러 데이터를 종류에 관계없이 하나의 집합으로 저장할 수 있는 공간

: 클래스 - 데이터와 함수의 결합 (구조체 + 함수)

: 자바와 같은 객체지향언어는 변수(데이터)와 함수를 하나의 클래스에 정의하여 서로 관계 깊은 변수와 함수를 함께 다룰 수 있게 한다



3. 변수와 메서드


- 선언 위치에 따른 변수의 종류

: 클래스 변수 / 인스턴스 변수 / 지역변수

: 변수의 선언된 위치가 변수의 종류를 결정

: 멤버변수를 제외한 나머지는 모두 지역변수

: 멤버변수 중 static이 붙은 것은 클래스변수, 붙지 않은 것은 인스턴스변수


1
2
3
4
5
6
7
8
9
10
11
class Tv{
 
    String color;     // 인스턴스 변수
    static int channel;    // 클래스변수, 공유변수, static변수
 
 
    void method() {
        String color = 0// 지역변수
    }
        
}










cs

: ㄴㅇ라ㅓ

- 인스턴스 변수 

: 클래스영역에 선언

: 클래스의 인스턴스를 생성할 때 만들어짐

: 인스턴스 변수의 값을 읽어 오거나 저장하기 위해서 먼저 인스턴스 생성해야 함

: 독립적 저장공간을 가지므로 서로 다른 값을 가질 수 있음

: 인스턴스마다 고유한 상태를 유지해야 하는 속성의 경우 인스턴스변수로 선언


- 클래스 변수

: 인스턴스 변수 앞에 static을 붙이면 클래스 변수 선언됨

: 모든 인스턴스가 공통된 저장공간을 공유

: 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야 하는 경우 클래스 변수로 선언

: 인스턴스를 생성하지 않고 바로 사용 가능

: 클래스가 메모리에 로딩될 때 생성되어 프로그램이 종료될 때까지 유지

: public을 앞에 붙이면 같은 프로그램 내 어디서나 접근가능한 ' 전역변수 ' 성격을 가짐


- 지역 변수 

: 메서드 내에 선언되어 메서드 내에서만 사용 가능, 메서드 종료 시 소멸

: for문, while문의 블럭 내에 선언된 지역변수는 블럭을 벗어나면 소멸되어 사용 불가


- 메서드

: 특정 작업을 수행하는 일련의 문장들을 하나로 묶은 것

: 높은 재사용성 / 중복된 코드 제거 / 프로그램의 구조화

: 선언부와 구현부로 이루어짐

: 메서드 선언부 

- 메서드의 이름, 매개변수의 선언, 반환타입으로 구성  ( ex. int add ( int z, int b) )

: 매개변수 선언 

- 메서드가 작업을 수행하는데 필요한 값을 제공받기 위한 것

- 필요한 값의 개수만큼 변수를 선언하며 구분은 ','로 함

- 선언할 수 있는 매개변수의 개수는 거의 제한이 없지만, 배열이나 참조변수 사용

- 값을 받을 필요가 없다면 괄호안에 아무것도 적지 않음

: 메서드의 이름

- 동사인 경우가 많고, 메서드의 기능을 쉽게 알 수 있도록 함축적이면서 의미있는 이름을 사용

: 반환타입

- 메서드 작업수행 결과인 '반환값'의 타입

- 반환값이 없는 경우 반환타입으로 'void' 작성

: 메서드의 구현부

- 메서드를 호출했을 때 수행될 문장을 넣음

: return문

- 반환타입이 void가 아닌경우, 구현구 안에 'return 반환값;'을 반드시 포함

- 작업 수행 결과를 호출한 메서드로 전달

- 반환타입과 일치하거나 자동 형변환이 가능한 것

- 단 하나의 값만 반환할 수 있음


- 메서드의 호출

: 메서드 정의 후 호출하지 않으면 아무일도 발생하지 않음

: 인자와 매개변수

- 메서드를 호출할 때 괄호안에 지정한 값을 '인자' 또는 '인수'라고 함

- 인자의 개수와 순서는 호출된 메서드에 선언된 매개변수와 일치해야 함

- 인자는 메서드가 호출되면서 매개변수에 대입되므로 , 인자의 타입은 매개변수의 타입과 일치하거나 자동형변환되어야 함

: 메서드의 실행흐름

- 같은 클래스 내의 메서드끼리는 참조변수를 사용하지 않고도 서로 호출이 가능

- static메서드는 같은 클래스 내의 인스턴스 메서드를 호출할 수 없음

- 메서드가 호출되면 지금까지 실행중이던 메서드는 실행을 멈추고 호출된 메서드의 문장이 실행됨


- return문

: 현재 실행중인 메서드를 종료하고 호출한 메서드로 돌아감

: 반환타입이 void가 아닌 경우, 반드시 return문을 작성해야함


- JVM메모리 구조

: method area / heap / call stack

: method aret (메서드 영역)

- 클래스에 대한 정보 저장

: heap

- 인스턴스가 생성되는 공간, 인스턴스 변수들이 생성되는 공간

: call stack or executive stack (호출스택)

- 메서드의 작업에 필요한 메모리 공간 제공

- 메서드가 작업을 마치면 할당된 메모리 공간이 반환되어 비워짐

- 호출스택 제일 상위에 위치하는 메서드가 현재 실행중인 메서드이며 나머지는 대기상태

- 아래에 있는 메서드가 바로 위의 메서드를 호출한 메서드임


- 기본형 매개변수 

: 변수의 값을 읽기만 할 수 있음


- 참조형 매개변수

: 변수의 값이 저장된 곳이 주소를 알 수 있기 때문에 값을 읽고 변경할 수 있음


- 참조형 반환타입

: 메서드가 '객체의 주소'를 반환


- 재귀호출

: 매서드 내부에서 매서드 자신을 다시 호출하는 것

: 재귀호출하는 메서드를 '재귀메서드'라 함

: 재귀호출만 하게되면 무한히 자기 자신을 호출하기 때문에 조건문을 필수적으로 사용


- 클래스 메서드( static 메서드 ) 와 인스턴스 메서드

: 메서드 앞에 static을 붙이면 클래스 메서드, 붙어있지 않으면 인스턴스 메서드

: 메서드작업 수행 시 인스턴스 변수를 필요로하는 메서드를 인스턴스메서드로 정의, 인스턴스를 생성해야 호출가능

: 인스턴스와 관계 없는 메서드를 클래스 메서드로 정의 


- 클래스 설계 시, 모든 인스턴스에 공통적으로 사용하는 것에 static을 붙임

- 클래스 변수(static변수)는 인스턴스를 생성하지 않아도 사용 가능

- 클래스 메서드(static 메서드)는 인스턴스 변수를 사용할 수 없음

- 메스드 내에서 인스턴스 변수를 사용하지 않는다면, static을 붙이는 것을 고려

- 클래스 멤버가 인스턴스 멤버를 참조, 호출 할 때는 인스턴스를 생성해야 함

- 같은 클래스 내의 메서드는 서로 객체의 생성이나 참조변수 없이 직접호출이 가능하지만 static 메서드는 인스턴스 메서드를 호출할 수 없음

- 인스턴스멤버 간의 호출은 가능, 하나의 인스턴스멤버가 존재한다는 것은 이미 인스턴스가 생성되었다는 의미이기 때문



4. 오버로딩


- 한 클래스 내에 같은 이름을 가진 메서드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메서드를 정의할 수 있음

- 한 클래스 내에 같은 이름의 메서드를 여러 개 정희하는 것을 '메서드 오버로딩', '오버로딩(overloading)'이라 함


- 오버로딩 조건

: 메서드 이름이 같아야 함

: 매개변수의 개수 또는 타입이 달라야 함


- 오버로딩의 장점

: 메서드 이름 절약 - 하나의 이름으로 여러개의 메서드를 정의할 수 있음


- 가변인자와 오버로딩

: 가변인자는 '타입...변수명' 과 같은 형식으로 선언

: 가변인자를 매개변수 중 가장 마지막에 선언

: 가변인자가 선언된 메서드를 호출할 때마다 배열이 새로 생성



5. 생성자


- 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메서드' 


- 인스턴스 변수의 초기화 작업에 주로 사용됨


- 클래스 내에 선언되며, 리턴값이 없음


- 생성자의 이름은 클래스 이름과 같아야 함


- 오버로딩이 가능하므로 하나의 클래스에 여러개의 생성자가 존재할 수 있음


1
2
3
4
5
6
7
8
9
10
class Tv{
    
    Tv() {
        //매개변수 없는 생성자
    }
 
    Tv(int a, String b) {
        //매개변수 있는 
    }        
}
cs


- 모든 클래스에는 반드시 하나 이상의 생성자가 정의되어야 함


- 소스파일(*.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
class Tv{
    int channel;
    String brand;    
 
    Tv() {
        //매개변수 없는 생성자
    }
 
    Tv(int a, String b) {
        channel = a;
        brand = b;
    }        
 
}
 
class TvTest{
    public static void maint(String args[]){
        Tv t = new Tv();
        t.channel = 2;
        t.brand = samsung;
 
        Tv t2 = new Tv(8,"LG");
 
    }
}
cs


- 생성자에서 다른 생성자 호출 

: 생성자 간에도 서로 호출이 가능

- 생성자의 이름으로 클래스이름 대신 this를 사용

- 한 생성자에서 다른생성자를 호출할 때는 반드시 첫번째 출에서만 호출이 가능

: 매개변수의 이름과 인스턴스변수 이름이 같을 경우 서로 구별되지 않기때문에 인스턴스 변수이름 앞에 'this.'을 붙인다

- 만약 붙이지 않은 상태로 작성하면 둘 다 지역변수로 간주된다.


- this 

: 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있음

: 모든 인스턴스메서드에 지역변수로 숨겨진 채 존재함


- this(), this(매개변수)

: 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용


- 생성자를 이용한 인스턴스 복사

: 현재 사용 중인 인스턴스와 같은 상태를 갖는 인스턴스를 하나 더 만들고자 할 때 생성자 활용 가능



6. 변수의 초기화


- 변수를 선언하고 처음으로 값을 저장하는 것

: 멤버변수는 초기화를 하지 않아도 자동적으로 변수의 자료형에 맞는 기본값으로 초기화 됨 

  ( 변수 타입 별 기본값 확인하기 http://blog.naver.com/kegljk/221034527671 )

: 지역변수는 사용하기 전에 반드시 초기화 해야 함


- 멤버변수의 초기화 방법

: 명시적 초기화

: 생성자

: 초기화 블럭

- 인스턴스 초기화 블럭 : 인스턴스 변수를 초기화 하는데 사용

- 클래스 초기화 블럭 : 클래스 변수를 초기화 하는데 사용


- 명시적 초기화

: 변수 선언과 동시에 초기화하는 것  ( ex. int age = 20; )


- 초기화 블럭

: 클래스 초기화 블럭

- 클래스 변수의 복잡한 초기화에 사용

- 클래스가 메모리에 처음 로딩될 때 한번만 수행

: 인스턴스 초기화 블럭

- 인스턴스 변수의 복잡한 초기화에 사용

- 인스턴스를 생성할 때마다 수행

- 생성자보다 인스턴스 초기화 블럭이 먼저 수행됨


- 멤버변수의 초기화 시기와 순서

: 클래스변수의 초기화시점

- 클래스가 처음 로딩될 때 단 한번 초기화

: 인스턴스 변수의 초기화 시점

- 인스턴스가 생성될 때마다 각 인스턴스 별로 초기화가 이루어짐

: 클래스변수의 초기화 순서

- 기본값 -> 명시적 초기화 -> 클래스 초기화 블럭

- 기본값 -> 명시적 초기화 -> 인스턴스 초기화 블럭 -> 생성자







반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 7 객체지향 프로그래밍 2-2  (0) 2017.07.21
[JAVA] 7 객체지향 프로그래밍 2-1  (0) 2017.07.11
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
[JAVA] 제어구조 예제 6 - while문  (0) 2017.07.02
반응형

세상에 나쁜개는 없다
개 부부의 사랑과 전쟁


왜 너는 나를 만나서~~

보기만해도 예쁜 강아지부부의 사랑과 전쟁 

어떤사연인지 영상으로 확인할까요?








반응형
반응형

           

  JAVA Study





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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
import java.util.Arrays;
public class tistory {
    public static void main(String[] args) {
        //배열 출력
        int[] score = new int[5];
        int k=1;
        
        score[0= 50;
        score[1= 60;
        score[k+1= 70;
        score[3= 80;
        score[4= 90;
        
        int tmp  = score[k+2+score[4];
        
        for(int i=0; i<score.length; i++){ //score.length는 score배열의 길이값
            System.out.println("score ["+i+"] :"+score[i]); //score[0]~score[4] 의 합
        }
        
        System.out.println("tmp : "+tmp); // score[3] + score[4]의 값
//        System.out.println("score[7] : "+score[7]); //배열 범위를 벗어나므로 오류
        
System.out.println("====================");
        
        //배열의 복사
        int[] arr = new int[5];
        
        for(int i=0; i<arr.length; i++){
            arr[i] = i+1//배열arr에 1~5를 저장한다
        }
        
        System.out.println("[변경전]");
        System.out.println("arr.length:"+arr.length);
        
        for(int i=0;i<arr.length;i++){
            System.out.println("arr["+i+"] : "+arr[i]);
        }
        
        int[] temp = new int[arr.length*2];  // arr배열보다 두배 긴 길이의 temp 배열 생성
        
        for(int i=0; i<arr.length;i++){
            temp[i] = arr[i]; // arr배열의 값들을 temp배열에 저장
        } 
        
        arr = temp; //tmp에 저장된 값들을 arr에 저장
        
        System.out.println("[변경후]");
        System.out.println("arr.length:"+arr.length);
        
        for(int i=0;i<arr.length;i++){
            System.out.println("arr["+i+"] : "+arr[i]);
        }
        
System.out.println("====================");
        
        // 배열 일부 복사
        char[] abc = {'A','B','C','D'};
        char[] num = {'0','1','2','3','4','5','6','7','8','9'};
        System.out.println(abc);
        System.out.println(num);
        
            //배열 abc와 num을 붙여서 하나의 배열(result)로 만듦
        char[] result = new char[abc.length+num.length];
        System.arraycopy(abc,0,result,0,abc.length); 
        System.out.println(result);//ABCD
        
        System.arraycopy(num,0,result,abc.length,num.length);
        System.out.println(result);//ABCD0123456789
        
        System.arraycopy(abc, 0, num, 0, abc.length);
        System.out.println(num);//ABCD456789
        
        System.arraycopy(abc, 0, num, 63);
        System.out.println(num);//ABCD45ABC9
    
System.out.println("====================");
        
        //배열 값 총합과 평균
        int sum = 0;
        float avg = 0f;
        
        int[] score1 = {100,88,100,100,90};
        
        for(int i=0;i<score1.length;i++){
            sum += score1[i];
        }
        avg = sum /(float)score.length;
        
        System.out.println("총점 : "+sum);
        System.out.println("평균 : "+avg);
    
System.out.println("====================");
        
        //최대값 최소값
        int max = score1[0];
        int min = score1[0];
        
        for(int i=1; i<score1.length;i++){
            if(score1[i] >max){
                max = score1[i];
            } else if(score1[i]<min){
                min = score1[i];
            }
        }
        
        System.out.println("최대값 : "+max);
        System.out.println("최소값 : "+min);
System.out.println("====================");
        //섞기
        int[] numArr = new int[10];
        
        for(int i=0; i<numArr.length; i++){
            numArr[i] = i;
            System.out.print(numArr[i]);
        }
        System.out.println();
        
        for(int i=0;i<100; i++){
            int n = (int)(Math.random()*10);
            int tmp1 = numArr[0];
            numArr[0= numArr[n];
            numArr[n] = tmp1;
        }
        
        for(int i=0;i<numArr.length; i++){
            System.out.print(numArr[i]);
        }
        System.out.println();
System.out.println("====================");
        
        //로또번호 생성예제
        int[] ball = new int[45]; //45개 정수를 저장할 수 있는 배열
        
            //배열의 각 요소에 1~45의 값을 저장한다.
        for (int i=0; i<ball.length; i++){
            ball[i] = i+1;
        }
        
        int temp3 =0//두 값을 바꾸는데 사용할 임시변수
        int j=0// 임의 값을 얻어서 저장할 변수
        
            //배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
            //0번재 부터 5번째 요소까지 모두 6개만 바꾼다.
        for (int i=0; i<6; i++){
            j=(int)(Math.random()*45); // 0~44까지 임의의 값
            temp3 = ball[i];
            ball[i] = ball[j];
            ball[j] = temp3;
        }
        
            //배열 ball의 앞에서 부터 6개 요소 출력
        for(int i=0; i<6; i++){
            System.out.println("ball ["+i+"] = "+ball[i]);
        }
        
System.out.println("====================");
        
        //임의의 값으로 배열 채우기
        int[] code = {-4,-1,3,6,11}; //불 연속적 값으로 구성된 배열
        int[] arr4 = new int[10];
        
        for(int i=0; i<arr4.length; i++){
            int tmp4 = (int)(Math.random() * code.length);
            arr4[i] = code[tmp4];
        }
        System.out.println(Arrays.toString(arr4));
System.out.println("====================");
        //정렬하기
        int[] numArr5 = new int[10];
        
        for(int i=0; i<numArr5.length; i++){
            System.out.print(numArr5[i] = (int)(Math.random() *10));
        }
        System.out.println();
        for(int i=0; i<numArr5.length-1; i++){
            boolean changed= false//자리바꿈이 발생했는지 체크
            
            for(int j5=0; j5<numArr5.length-1-i; j5++){
                if(numArr5[j5] > numArr5[j5+1]){ //옆 자리 값이 작으면 서로 바꿈
                    int tmp5 = numArr5[j5];
                    numArr5[j5] = numArr5[j5+1];
                    numArr5[j5+1= tmp5;
                    changed = true//자리바꿈 발생 시 true로 변환
                }
            }
            
            if (!changed) break//자리바꿈 없으면 반복문 벗어남
            
            for(int k5=0; k5<numArr5.length; k5++){
                System.out.print(numArr5[k5]);
            }
            System.out.println();
        }
        
    }
}
 
cs
반응형
반응형

세상에 나쁜개는 없다
은둔형 외톨이, 영심이


산책을 거부하는 영심이는 어떤 사연을 가지고 있을까요

태어나 한번도 벗꽃을 본적이 없는 영심이의 사연 영상으로 확인할까요~








반응형

+ Recent posts