반응형

           

  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
반응형
반응형

           

  JAVA Study





1. 연산자(operator) 


- 연산을 수행하는 기호


- 연산자

: 연산을 수행하는 기호 ( +, -, *, /, % )


- 피연산자

: 연산자의 작업대상 ( 변수, 상수, 리터럴, 수식 )


- 연산자는 피연산자로 연산을 수행 후 항상 결과값을 반환


- 연산자의 종류

 종류

 연산자 

 설명 

 산술 연산자

    +        -        *         /       %      <<      >>

 사칙연산과 나머지 연산(%)

 비교 연산자

    >      <       >=       <=      ==       !=

 크고 작음, 같고 다름을 비교

 논리 연산자

   &&      ||       !      &       |       ^      ~

 'and'와 'or'로 조건 연결

 대입 연산자

   = 

 우변의 값을 좌변에 저장

 기타

   (type)             ? :               instanceof 

 형변환연산자, 삼항연산자, instanceof연산자



- 연산자의 우선순위

: 산술 > 비교 > 논리 > 대입

: 단항 > 이항 > 삼항

: 단항 연산자와 대입 연산자를 제외한 모든 연산의 진행방향은 왼쪽에서 오른쪽




2. 단항 연산자 
 

- 증감 연산자 

: ++  피연산자의 값을 1 증가

: --  피연산자의 값을 1 감소 

: 전위형 (++i) - 값이 참조되기 전에 증가

: 후위형 (i--) - 값이 참조된 후에 증가



3. 산술 연산자 

- 사칙 연산자 (+-*/)


- 나머지 연산자 (%)

: 나누는 수는 0을 사용할 수 없고, 피연산자로 정수만 허용
 


4. 비교 연산자 
 

- > 좌변 값이 크면 true 아니면 false


- < 좌변 값이 작으면 true 아니면 false


- >= 좌변 값이 크거나 같으면 true 아니면 false


- <= 좌변 값이 작거나 같으면 true 아니면 false


- == 두 값이 같으면 true 아니면 false


- != 두 값이 다르면 true 아니면 false


- 문자열의 비교

: equalse() 메서드 사용

 ( ex. 변수이름.equalse("abc"); )



5. 논리 연산자 
 

- || (or) 피연산자 중 어느 한쪽만 true이면 결과는 true


- && (and) 피연산자 양쪽모두 true이어야 결과는 true


- | (or 연산자) 피연산자 중 한쪽 값이 1이면, 1을 결과로 얻음, 그 외에는 0


- & (and연산자) 피연사 양 쪽 모두 1이어야 1을 결과로 얻음, 그 외에는 0


- ^ (xor연산자) 피연산자의 값이 서로 다를 때만 1을 결과로 얻음. 같을 때는 0


- ~ (비트 전환 연산자) 피연산자의 1의 보수를 얻을 수 있음, 부호있는 타입에서는 반대부호로 변경


- << ,  >> (쉬프트 연산자) 2진수로 표현된 피연산자의 각 자리를 오른쪽(>>), 왼쪽(<<)으로 이동함



6. 그 외의 연산자 


- ? / : (조건 연산자) 

: '(조건식) ? 식1 : 식2' 형식의 삼항 연산자, 조건식이 참일 경우 '?' 이하 식1을 실행, 거짓일 경우 ':' 이하 식2를 실행

: if 문으로 바꿔 사용가능


- = , op= (대입 연산자)

: 변수같은 저장공간에 값 또는 수식의 연산결과를 저장하는데 사용

: 오른쪽 피연산자 ( rvalue ) 의 값을 왼쪽 피연산자 ( lvalue ) 에 저장

: 대입 연산자는 다른연산자 ( op )와 결합하여 'op='형식으로 사용가능 ( ex. i = i+2; --> i+=2; )

: op=연산자는 반드시 공백없이 붙여써야 함  



 자바의 정석 저자 강의

- 연산자

반응형
반응형

           

  JAVA Study




1. 변수와 상수 
 

- 변수 (Variable)

: 단 하나의 값을 저장할 수 있는 메모리상의 공간

: 저장된 값이 변경될 수 있음


- 변수의 선언과 초기화

: 선언 방법 - 변수타입 + 변수이름; ( ex. int a; )

: 변수타입은 변수에 저장 될 값의 타입을 지정하는 것

: 변수이름은 변수에 붙인 이름

: 메모리에 변수와 같은 이름으로 지정된 값이 있을 수 있기 때문에 초기화를 해야함

: 초기화란 변수를 사용하기 전에 처음으로 값을 저장하는 것

: 변수에 값을 저장할 때는 '='을 사용 (ex. int a = 398; )

 

- 변수 값 출력 예제


public class tistory {


public static void main(String[] args) {

int coffee = 3000;

int cake = 5000;

System.out.println(coffee);

System.out.println(cake);


}


}


결과값 3000 / 5000 출력


- 변수 이름 규칙

: 프로그래밍에서 사용하는 모든 이름을 '식별자'라고 함

: 식별자는 같은 영역 내에서 구분가능해야 함

: 대소문자 구분됨, 길이 제한 없음

: 예약어 사용안됨

: 숫자로 시작하면 안됨

: 특수문자는 '_'와 '$'만 허용




2. 변수의 타입 
 

- 자료형은 사용하는 값의 종류에 따라 값이 저장될 공간의 크기와 저장형식을 정의한 것

- 자료형에는 문자형, 정수형, 실수형 등이 있음

- 변수 선언 시 알맞은 자료형을 변수의 타입으로 선택


- 기본형 변수는 실제 값을 저장

: 논리형 (boolean) 

: 문자형 (char)

: 정수형 (byte, short, int, long)

실수형 (float, double)


- 참조형 변수는 값이 저장된 주소를 저장


- 상수는 한번 저장하면 다른 값으로 변경할 수 없음

- 상수 선언 방법은 변수 타입 앞에 'final'을 붙여줌 ( ex. final int coffee =3000; )

- 상수이름은 암묵적으로 모두 대문자 사용 ( ex. final int COFFEE = 3000; )

- 이름이 여러 단어로 이루어져 있을 때 '_' 사용 ( ex. final int STARBUCKS_COFFEE = 3000; )


- 리터럴  상수와 변수의 값 ( 상수 스타벅스의 리터럴은 3000 )

- 리터럴 타입과 접미사

: 정수형타입과 실수형타입들을 구분하기 위해 리터럴에 접미사를 붙임

: long 타입 리터럴에는 접미사 'L', float 타입 리터럴에는 접미사 'f', double 타입 리터럴에는 접미사 'd'를 붙임

 ( ex. long cream = 50_000_000_000L;  float cream2 = 2.14f;  double cream3 = 2,345d; )

- 타입 불일치

: 저장범위가 넓은 타입에 좁은 타입 값을 저장하는 것은 허용됨


- 문자 리터럴 , 문자열 리터럴

: 'A'같이 작은 따옴표로 문자 하나를 감싼 것이 문자 리터럴

: "ABC"두 문자 이상은 큰따옴표 사용한 문자열 리터럴

: ""안에 아무 것도 넣지 않은 빈 문자열을 허용


- printf() 

: 지시자를 통해 값을 어떻게 출력할 것인지 지정해주는 역할

( ex. '%d' - 정수형 변수에 저장된 값을 10진수로 출력할 때 )


- Scanner()

: 화면에서 입력받을 때 사용됨

: import.java.util.*; //Scanner 클래스 사용위해 추가

: Scanner test = new Scanner(System.in); //Scanner 클래스 객체 생성

: int num = test.nextInt(); //입력받은 정수를 변수 num에 저장

: 실행 후 콘솔창에 숫자 입력



- 변수 타입에 따른 기본값


자료형 

기본값 

 boolean

false 

 char

'\u0000' 

 byte, short, int

 long

0L 

 float

0.0f 

 double

0.0d 또는 0.0 

참조형 변수 

null 




3. 기본형(primitive type) 
 

- boolean (논리형)

: true,false 값만 가지는 변수

: default = false


- char (문자형)

: 단 하나의 문자를 저장

: 특수문자 표현


 특수 문자

문자 리터럴 

 tab 

 \t

 backspace

 \b

 form feed

 \f 

 new line

 \n 

 carriage return

 \r 

 역슬래쉬(\)

 \\ 

 작은따옴표

 \' 

 큰따옴표

 \" 

 유니코드 (16진수) 문자 

 \u 유니코드 ( ex. char a='\u0041' ) 


-byte, short, int, long (정수형) 

: 정수형 크기 순서 byte < short < int < long


- float, double (실수형)

: 실수형에서는 오버플로우 발생시 변수의 값은 무한대가 됨

: 언더플로우가 발생하면 변수의 값은 0이 됨


4. 형변환  (casting)
 

- 서로 다른 타입간의 연산을 수행하기 위해 값들의 타입을 일치시키는 것

- 형변환 방법

: 변환하고자 하는 변수나 리터럴 앞에 변환하고자 하는 타입을 작성 ( ex. (타입)피연산자 )


- 자동 형변환

: 기존의 값을 최대한 보존할 수 있는 타입으로 자동 형변환 됨


- boolean을 제외한 나머지 7개의 기본형은 서로 형변환 가능

- 기본형과 참조형은 서로 형변환할 수 없음

- 서로 다른 타입의 변수간 연산은 형변환을 하는 것이 원칙이나, 값의 범위가 작은 타입->큰 타입이라면 생략가능 



 자바의 정석 저자 강의

- 변수의 선언


- 변수의 타입




- 상수와 리터럴




- printf()와 Scanner ( 형식 출력과 화면 입력 )



반응형

+ Recent posts