반응형

1.6 Arrays

 

* Arrays 클래스 : 배열을 다루는데 유용한 메서드가 정의되어 있음. 아래 정의된 toString(), 모든 기본형 배열, 참조형 배열 별로 하나씩 정의됨.

 

static String toString(boolean[ ]a)

static String toString(byte[ ] a)

static String toString(char[ ] a)

static String toString(short[ ] a)

static String toString(int[ ] a)

static String toString(long[ ] a)

static String toString(float[ ] a)

static String toString(double[ ] a)

static String toString(object[ ] a)

 

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

 

* 배열의 복사

- copyOf() : 배열 전체 복사

- copyOfRange() : 배열의 일부를 복사

하여 새로운 배열을 만들어 반환.

 

int[ ] arr = {0,1,2,3,4,};

int[ ] arr2 = Arrays.copyOf(arr, arr.length);

int[ ] arr3 = Arrays.copyOf(arr, 3);

int[ ] arr4 = Arrays.copyOf(arr, 7);

 

int[ ] arr5 = Arrays.copyOfRange(arr,2,4);

int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

 

 

// 배열의 복사

package Collection_Framework;
import java.util.*;
public class Arrays1 {
 public static void main(String[]arge) {

  int[ ] arr = {0,1,2,3,4,};
  int[ ] arr2 = Arrays.copyOf(arr, arr.length);
  int[ ] arr3 = Arrays.copyOf(arr, 3);
  int[ ] arr4 = Arrays.copyOf(arr, 7);

  int[ ] arr5 = Arrays.copyOfRange(arr,2,4);
  int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.toString(arr2));
  System.out.println(Arrays.toString(arr3));
  System.out.println(Arrays.toString(arr4));
  System.out.println(Arrays.toString(arr5));
  System.out.println(Arrays.toString(arr6));
 }
}

 

출력결과 :

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2]
[0, 1, 2, 3, 4, 0, 0]
[2, 3]
[0, 1, 2, 3, 4, 0, 0]


 

* 배열 채우기

- fil() : 배열의 모든 요소를 지정된 값으로 채운다.

- setAll() : 배열을 채우는데 사용할 함수형 인터페이스를 매겨변수로 받는다.

 

package Collection_Framework;
import java.util.*;
public class Arrays2 {

 public static void main(String[] args) {

  int[]arr = new int[5];
  Arrays.fill(arr, 9);
  Arrays.setAll(arr, () -> (int)(Math.random()*5)+1); // 람다식을 지정해야 함.

 System.out.println(Arrays.toString(arr));
 }

}

 

출력 결과 :

[9, 9, 9, 9, 9]

* 배열의 정렬과 검색

- sort() : 배열을 정렬할 때 사용

- binarySearch() : 저장된 요소를 검색 할 때 사용, 배열에서 지정된 값이 저장된 위치(index)를 찾아서 반환하는데, 반드시 배열이 정렬된 상태이어야 올바른 결과를 얻음.

 

package Collection_Framework;
import java.util.*;
public class Arrays3 {

 public static void main(String[] args) {
  int[] arr = {3,2,0,1,4};
  int idx = Arrays.binarySearch(arr, 2);
  System.out.println(Arrays.toString(arr));
 
  Arrays.sort(arr);
  System.out.println(Arrays.toString(arr));
  int idx2 = Arrays.binarySearch(arr,2);
 
  
 }

}

 

출력 결과 :

[3, 2, 0, 1, 4]
[0, 1, 2, 3, 4] 
<- 올바른 결과.
 

 

 

* 문자열의 비교와 출력

- equals() : 두 배열에 저장된 모든 요소를 비교해서 같으면 true, 다르면 false를 반환. 일차원 배열에서만 사용가능

- toString() : 일차원 배열에서 문자열로 편하게 출력함.

 

다차원 배열에서

- deepToString(), deepToEquals() 사용

 

package Collection_Framework;
import java.util.*;
public class Arrays4 {

 public static void main(String[] args) {
  int[] arr = {0,1,2,3,4};
  int[] [] arr2D = {{11,12},{21,22}};
  
  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.deepToString(arr2D));
  
  String[] [] str2D = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  String[] [] str2D2 = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  System.out.println(Arrays.equals(str2D, str2D2));
  System.out.println(Arrays.deepEquals(str2D, str2D2));
 }

}

출력결과 :

[0, 1, 2, 3, 4]
[[11, 12], [21, 22]]
false
true

* 배열을 List로 변환 // 이해가 잘 안감...

- asList(Object... a)

 

package Collection_Framework;
import java.util.*;
public class Arrays5 {

 public static void main(String[] args) {
  List list = Arrays.asList(new Integer[] {1,2,3,4,5,});
  List<Integer> list = Arrays.asList(1,2,3,4,5);
  list.add(6);
  
 }

}

 

 

* parallel로 시작하는 메서드(), spliterator(), tream()등등

 

 

 

반응형
반응형

1.5 lterator, Listlterator, Enumeration

 

lterator, Listlterator, Enumeration 모두 컬렉션에 저장된 요소를 접근하는데 사용하는 인터페이스 이다.

 

Enumeration은 Iterator의 구버전이다. ListIterator은 Iterator의 기능을 향상 시킨 것이다.

 

* Iterator  

 

- interface 메서드
 public interface Iterator {
  boolean hasNext(); // 읽어 올 요소가 남아 있는지 확인 한다. 있으면 true, 없으면 false.
  Object next(); // 다음 요소를 읽어 온다. next()를 호출 하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전.
  void remove(); // next()로 읽어 온 요소를 삭제한다. next()를 호출한 다음에 remove()를 호출해야 한다.(선택적)
 }
  public interface Collection{
  public Iterator iterator();
 }

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

 

package Collection_Framework;
import java.util.*;
public class Iterator1 {

 public static void main(String[] args) {

  ArrayList<String> list = new ArrayList<String>();
  
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  Iterator<String> iter = list.iterator();
  
  while(iter.hasNext()) {
   Object obj = iter.next();
   System.out.println(obj);
  }
 }
}

 

출력 결과 :

1
2
3
4
5

 

===========================================================================================

* ListIterator

 : 양방향으로 이동하기 때문에 각 요소간의 이동이 자유롭다.

다만 이동하기 전에 반드시 hasNext() 나 hasPrevious()를 호출하여 이동할 수 있는지 확인해야 한다.

 

- interface 메서드

void add(Object o) // 컬렉션에 새로운 객체 o를 추가한다.

boolean hasNext() // 읽어 올 다음 요소가 남아있는지 확인한다. 있으면 true, 없으면 false를 반환

boolean hasPrevious() // 읽어 올 이전 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false를 반환

Object next() //다음 요소를 읽어 온다. next()를 호출하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

Object previous() // 이전 요소를 읽어온다. previous()를 초훌하기 전에 hasPrevious()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

int nextindex() // 다음 요소의 index를 반환한다.

int previousindex() // 이전 요소의 index를 반환한다.

void remove() // next() 또는 previous()로 읽어 온 요소를 삭제한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야 한다.

void set(Object o) // next()또는 previous()로 읽어 온 요소를 지정된 객체(o)로 변경한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야한다.

 

예제.

package Collection_Framework;
import java.util.*;
public class listlterator1 {
 public static void main(String[]args) {
  ArrayList<String> list = new ArrayList<String>();
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  ListIterator<String> iter = list.listIterator();
  
  while (iter.hasNext()) {
   System.out.print(iter.next());
  }
  System.out.println();
  
  while(iter.hasPrevious()) {
   System.out.print(iter.previous());
  }
  System.out.println();
 }
}

 

 

출력 결과 :

12345
54321


 

* Enumeration

- interface 메서드

boolean hasMoreElements() // 읽어 올 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false 반환. Iterator의 hasNext()와 같음

Object nextElement() // 다음 요소를 읽어 온다. nextElement()를 호출하기 전에 hasMoreElements()를 호출해서 읽어올 요소가 남아 있는지 확인하는 것이 안전한다. Iterator의 next()와 같다.

반응형
반응형

1. 개념적 모델 (concecptual model)

1) 개체 - 관계 모델 (entity - relation diagram)

- entity, relation, atribute

 

2. 논리적 모델(logical model)

- 테이블 형식 (relation)

1) Key

* 기본키 (primary key)

* 외래키 (foreign key)

* 슈퍼키 : 키의 집합

* 후보키 (candidate key)

* 복합키 : atribute가 2개이상으로 구성된 키

 

* 슈퍼키 > 후보키 > 기본키 = 대체키

 

* 정규화 : 불필요한 중복을 없애는 방식

 

3. 물리적 모델(physical model)

 

 

 

* DDL & DML

 

 

*SQL DEV 실습

select * from Customer;
select * from buy;

CREATE TABLE Customer (
id varchar(20) Not NULL,
name varchar(20) not null,
Levels varchar(20),
적립금 INT DEFAULT 0,
address varchar(20),
job varchar(20),
CONSTRAINT CustomerPK PRIMARY KEY (id));
);

CREATE TABLE buy (
num INT,
id varchar(20) NOT NULL,
CNO INT NOT NULL,
DATES INT,
count INT
CONSTRAINT CustomerForeignkey FOREIGN KEY ();
);

CREATE TABLE 상품 (
num INT,
name varchar(20),
price INT,
company varchar(20),
usabledate varchar(20)
);
DROP Table Customer;
DROP Table buy;

insert into Customer values('jhs', '조', '1', 0, '대전', 'job');

 

 

 

 

 

//select * from Customer; 실행시 , buy table 재설계 필요

 

반응형
반응형

 

Orcle

Database 12c 설치 후

JavaEE에서 http://localhost:8080

접속시 Tomcat 페이지 출력된다.

 

 

1. oracle 12c. 11g

 


 - https://localhost:5500/em
 >> DB 종합정보

 

SQL DEVELOPER

1. system 생성

2. sys 생성(dba)

3. scott 생성 // 사용자 이름 c##scott

 

반응형
반응형

 

// 소스 코드 :

 

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
#include <avr/io.h>
#include <util/delay.h>
#define F_CPU 16000000UL
#include <avr/interrupt.h>
 
#define OFF 0
#define ON 1
volatile unsigned char digit_c[10= {0x000x270x090x030x260x120x100x060x000x02}; // 0 ~ 10
volatile unsigned char digit_b[10= {0x040x04, ~0x04, ~0x04, ~0x04, ~0x04, ~0x040x04, ~0x04, ~0x04}; // 0 ~ 10
volatile unsigned char fnd_sel[4= {0x100x200x400x80}; // fnd_sel c1, c2, c3, c4
 
volatile unsigned int msec, sec,min,hour = 0// time
volatile unsigned int play = ON; // play ON/OFF
 
 
 
int main(){
 
 
 DDRB = 0x04;
 DDRC = 0xff;
 DDRD = 0xf0;
 
 
 while(1){
  
  if ((PIND & 0x01== 0x00){ 
  play = ON; continue;}
  if ((PIND & 0x02== 0x00){
  play = OFF; continue;}
    
  if(play == ON){
  
  msec++
  if(msec>40){msec=0; sec++;}
  if(sec>59){sec=0; min++;}
  if(min>59){min=0; hour++;}
  if(hour>23){hour=0;}
 
  PORTC = digit_c[hour/10]; PORTB = digit_b[hour/10]; PORTD = fnd_sel[3];_delay_ms(3);
  PORTC = digit_c[hour%10]; PORTB = digit_b[hour%10]; PORTD = fnd_sel[2];_delay_ms(3);
  PORTC = digit_c[min/10]; PORTB = digit_b[min/10]; PORTD = fnd_sel[1];_delay_ms(3);
  PORTC = digit_c[min%10]; PORTB = digit_b[min%10]; PORTD = fnd_sel[0];_delay_ms(3);
  }
 
  if(play == OFF){
 
  cli();
  GICR = 0xc0;
  MCUCR = 0x0a;
  GIFR = 0x00;
  sei();
  
  PORTC = digit_c[hour/10]; PORTB = digit_b[hour/10]; PORTD = fnd_sel[3]; _delay_ms(3);
  PORTC = digit_c[hour%10]; PORTB = digit_b[hour%10]; PORTD = fnd_sel[2]; _delay_ms(3);
  PORTC = digit_c[min/10]; PORTB = digit_b[min/10]; PORTD = fnd_sel[1]; _delay_ms(3);
  PORTC = digit_c[min%10]; PORTB = digit_b[min%10]; PORTD = fnd_sel[0]; _delay_ms(3);
 
  }
 }
 
}
 
ISR(INT0_vect){
 if(min <= 59){
 min++;
 }
 if(min >59){
 min = 0; hour++;
 }
}
ISR(INT1_vect){
 if(hour <= 23){hour++;
 }
 if(hour >23){
 hour =0;
 }
}
 
 
/*
SW 1,2,3,4,
SW 1: Play Mode
SW 2: STOP Setting Mode
SW 3: Hour ++;
SW 4: Min ++;
 
스위치 4개로 시간을 설정/재생 할 수 있다.
 
시간측정을해보니 약 5~10초정도 오차가 있다. 몇달 몇년으로 따지면 엄청난 오차.
 
차후엔 ds3231 rtc모듈을 이용하여 만들어 볼 예정.
*/
 

// 그전에 Timer/Counter로 먼저 만들어 봐야 할 것 같다. 

 
cs

 

 

http://cafe.naver.com/carroty/291041

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

[NPAVR Board] AVR -Atmega128 (FND, Switch)  (0) 2018.09.03
[NPAVR Board] AVR -Atmega128 (FND)  (0) 2018.09.03
B/T LED 부품 선정 및 견적서  (1) 2017.04.10
B/T LED Control circuit  (0) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
반응형

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

[NPAVR Board] AVR -Atmega128 (FND)  (0) 2018.09.03
Atmgea8 FND 시계  (0) 2018.02.21
B/T LED Control circuit  (0) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경시 참조  (0) 2015.06.11
반응형

start_4.pdf

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

Atmgea8 FND 시계  (0) 2018.02.21
B/T LED 부품 선정 및 견적서  (1) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경시 참조  (0) 2015.06.11
pwm duty  (0) 2015.06.11
반응형

 연산자

기능 

결합방향 

 =

 연산자 오른쪽에 있는 값을 연산자 왼쪽에 있는 변수에 대힙한다 

 <- 

 +

 두 피연산자의 값을 더한다 

 ->

 -

 왼쪽의 피연산자 값에서 오른쪽의 피연산자 값을 뺀다 

 -> 

 *

 두 피연산자의 값을 곱한다 

 -> 

 /

 왼쪽의 피연산자 값을 오른쪽의 피연산자 값으로 나눈다 

 -> 

 %

 왼쪾의 피연산자 값을 오른쪽의 피연산자 값으로 나눴을 때 얻게 되는 나머지를 반환한다. 

 ->

 ++num

 값을 1 증가후, 속한 문장의 나머지를 진행(선증가 후 연산) 

 <- 

 num++

 속한 문장을 먼저 진행한 후 값을 1증가(선연산 후 증가) 

 ->

 --num

 값을 1 감소후, 속한 문장의 나머지를 진행(선 감소후 연산) 

 <-

 num--

  속한 문장을 진행한 후 값을 1 감소(선 연산후 감소)

 ->

 <

 예  n1<n2

 n1이 n2보다 작은가? 

 -> 

 >

 예 n1>n2

 n1이 n2보다 큰가? 

 ->

 ==

 예 n1==n2

 n1과 n2가 같은가?

 ->

 !=

 예 n1 != n2

 n1과 n2가 다른가?

 ->

 <=

 예 n1<=n2

 n1이 n2보다 같거나 작은가?

 ->

 >=

 예 n1>=n2

 n1이 n2보다 같거나 큰가?

 ->

 &&

 예 A&&B

 A와 B모두 참이면 연산결과로 참을 반환(논리 AND 

 ->

 ||

 예 A||B

 A와 B 둘중 하나라도 참이면 연산결과로 참을 반환(논리 OR) 

 ->

 !

 예 A!

 A가 참이면 거짓, A가 거짓이면 참을 반환(논리 NOT) 

 <-

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 배열 (빙고판 만들기)  (0) 2018.08.24
C언어 - 배열 (2차원배열)  (0) 2018.08.24
C언어 - 배열 (로또번호 난수발생기)  (0) 2018.08.24
C언어 과제1  (0) 2018.08.21
C언어 과제2  (0) 2018.08.21
반응형

1. Ring Counter // 1->2->4->8->16->32->64->128->1 순으로 1초마다 변함

int main()
{
 
  unsigned char count = 1;
 DDRA = 0xff;
 while(1)
 { 
  PORTA = count;
  _delay_ms(300);
  if(count<=64)
  count = count*2;
  else 
  count = 1;
 }
 
}

2.LED를 맨 오른쪽 1개만 켜고 이를 1초에 한칸씩 왼쪽으로 이동시키고 
왼쪽 끝에 도달하면 다시 오른쪽으로 한칸씩 이동시키기 (Boundary Detector)
int main()
{
 DDRA = 0xff;
 PORTA = 0x01;
 unsigned int i = 0;
 
 while(1){
  for(i=1;i<=0x80;i<<=1){
  PORTA = i;
  _delay_ms(50);
 }
  for(i=0x40;i>=0x01;i>>=1){
   PORTA = i;
   _delay_ms(50);
   if(!i)
    break;
  }
 }

}

반응형

'Project > j-kit-128-1실습' 카테고리의 다른 글

Serial 통신_Uart0_문자 1개  (0) 2018.10.01
FND_Display with Timer/Counter  (0) 2018.10.01
FND 실습  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
회로도 참고  (0) 2016.02.26
반응형

 // FND 숫자 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
 // 0 = 0x0f; 1 = 0x06; 2 = 0x5b; 3 = 0x4f; 4 = 0x66; 5 = 0x6d;
 // 6 = 0x7d; 7 = 0x27; 8 = 0x7f; 9 = 0x6f; A = 0x77; B = 0x7c;
 // C = 0x5e; D = 0x5e; E = 0x79; F = 0x71;
 // H = 0x76; E = 0x79; L = 0x38; P = 0x73;

 

FND에 ‘HELP’라고 디스플레이해 보기
int main()
{
 DDRC = 0xff;
 DDRG = 0xff;
 while(1){
 PORTC = 0x76;
 PORTG = 0x08;
 _delay_ms(5);
 PORTC = 0x79;
 PORTG = 0x04;
 _delay_ms(5);
 PORTC = 0x38;
 PORTG = 0x02;
 _delay_ms(5);
 PORTC = 0x73;
 PORTG = 0x01;
 _delay_ms(5);
 
} }

 

‘HELP’ 깜빡이면서 디스플레이

int main()
{
 DDRC = 0xff;
 DDRG = 0xff;
 unsigned int i;
 while(1){

  for(i=0;i<15;i++)
  {
 PORTC = 0x76;
 PORTG = 0x08;
 _delay_ms(5);
 PORTC = 0x79;
 PORTG = 0x04;
 _delay_ms(5);
 PORTC = 0x38;
 PORTG = 0x02;
 _delay_ms(5);
 PORTC = 0x73;
 PORTG = 0x01;
 _delay_ms(5);
 }
 PORTC = 0x00;
 PORTG = 0xff;
 _delay_ms(500);

} }

반응형

'Project > j-kit-128-1실습' 카테고리의 다른 글

FND_Display with Timer/Counter  (0) 2018.10.01
LED 제어  (0) 2016.02.26
FND 실습 1/100초 스탑워치, 24시간 디지털 시계만들기  (0) 2016.02.26
회로도 참고  (0) 2016.02.26
jkit switch 제어/ 인터럽트사용  (0) 2016.02.26

+ Recent posts