24일차 22.10.25
1.Arrays
import java.util.Arrays;
public class ArraysMain {
public static void main(String[] args) {
//문자열 배열 생성
String [] singers = {"장원영", "카리나", "지젤", "민지", "태연", "아이유", "수지"};
//이분 검색 수행 - sort를 하지 않아서 잘못된 결과가 리턴됨
int result = Arrays.binarySearch(singers, "태연");
System.out.println(result);
//데이터 정렬
Arrays.sort(singers);
//정렬한 데이터 확인
System.out.println(Arrays.toString(singers));
result = Arrays.binarySearch(singers, "태연");
if(result >= 0) {
System.out.printf("%s 는 %d 번째 존재\n" , singers[result], result + 1);
}else {
System.out.printf("%s 는 존재하지 않음\n" , "태연");
}
}
}
2.Fibonacci 수열
1) 피보나치 수열
-> 첫번째와 두번째 데이터는 무조건 1
-> 세번째 부터는 앞의 2개 항의 합
1, 1, 2, 3 , 5, 8 ,13, 21, 34, 55
2) 재귀를 이용한 해결 - 시간이 오래 걸리지만 이해하기는 쉬움
package java_1025;
public class RecursionFibonacci {
//n번째 피보나치 수열의 값을 리턴해주는 메서드
public static int fibonacci(int n) {
//첫번째와 두번째는 1
if(n == 1 || n == 2) {
return 1;
}
//세번째 부터는 앞의 2개 항의 합
else {
return fibonacci(n-1) + fibonacci(n-2);
}
}
public static void main(String[] args) {
System.out.println(fibonacci(50)); // 스택이 축적되서 시간이 너무 오래걸림
//실제 코테에서는 지양해야함
}
}3) 재귀를 이용하지 않고 해결 - 시간을 단축할 수 있지만 이해가 어려움
package java_1025;
public class NoRecursionFibonacci {
//n번째 피보나치 수열의 값을 리턴해주는 메서드
public static long fibonacci(int n) {
//이전 항의 값과 이전의 이전 항의 값을 저장할 변수
Long f1 = (long) 1;
Long f2 = (long) 1;
//피보나치 값을 저장할 변수
Long fibo = (long) 1;
//첫번째와 두번째는 처리할 필요가 없어서 반복문을 세번째부터 적용
for(int i = 3; i <= n; i++ ) {
fibo = f1 + f2;
f1 = f2;
f2 = fibo;
}
return fibo;
}
public static void main(String[] args) {
System.out.println(fibonacci(4999));
}
}3.날짜 관련 클래스
1) 종류
-> java.util.Date
-> java.sql.Date, java.sql.Time
-> java.util.Calendar, java.util.GregorianCalendar
-> LocalDateTime(요새는 이거로 많이씀)
2) epoch time
-> 1970년 1월 1일 자정
3) java.util.Date
-> 1970년 1월 1일 자정을 기준으로 지나온 시간을 밀리초 단위의 long타입으로 관리
-> 년도를 설정할 때는 1900년 이후 지나온 년 수로 설정
-> 월을 설정할 때는 1을 빼서 설정 - 0부터 시작하기 때문
-> toString 메서드와 단위별로 추출하는 메서드 제공
-> 출력을 할 때는 java.text.SimpleDateFormat 클래스아 같이 사용하는 경우가 많다
SimpleDateFormat sdf = new simpleDateFormat("날짜 서식");
sdf.format(Date 객체)를 이용해서 날짜 서식이 저용된 문자열을 리턴 받을 수 있다.
년도- yy, yyyy
월 - M, MM, MMM
일 - d, dd
요일 - E, EE, EEE
시간 - H, HH
오전/ 오후 - a
분 - m, mm
초 - s, ss
package java_1025;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateCreate {
private static final String DEPRECATION = "deprecation";
@SuppressWarnings(DEPRECATION)
public static void main(String[] args) {
//현재 시간을 갖는 Date 인스턴스 생성
Date currentTime = new Date();
//출력
System.out.println(currentTime);
//원하는 날짜를 가지고 생성 : 1995년 5월 5일 13:00:00 로 설정
Date firstMeetingTime = new Date((1995-1900), (12-1), 26, 9, 30, 0);
Date today = new Date((2022-1900), (10-1), 25, 10, 30, 0);
Date today1 = new Date((2022-1900), (10-1), 25, 10, 58, 0);
Date yesterday = new Date((2022-1900), (10-1), 24, 10, 30, 0);
Date tomorrow = new Date((2022-1900), (10-1), 26, 10, 30, 0);
//출력
System.out.println(firstMeetingTime);
//년도만 추출해서 출력
System.out.println(firstMeetingTime.getYear() + 1900 + "년");
//원하는 포멧으로 출력
//1995년 12월 26일 화요일 이라고 출력
SimpleDateFormat sdf = new SimpleDateFormat("yyyy년 M월 d일 E요일");
System.out.println(sdf.format(firstMeetingTime));
//연습 해볼만한 과제 - 년월일을 비교해서 년월일이 같으면 시간과 분을 그렇지 않으면 년월일을 출력
}
}
4) java.sql.Date 와 java.sql.Time
-> 날짜와 시간이 분리된 클래스로 관계형 데이터 베이스와 연동할 때 사용할 수 있는 클래스
5) java.util.Calendar 와 java.util.GregorianCalendar
-> java.util.Calendar는 날짜 관련된 메서드를 가진 추상 클래스(abstract class - 인스턴스를 생성할 수 없는 클래스)
-> java.util.GregorianCalendar 클래스는 Calendar클래스의 메서드를 구현한 하위 클래스
-> 인스턴스 생성
Calendar calendar = new GregorianCalendar();
여러 종류의 생성자가 제공되서 날짜 및 시간을 설정해서 생성하는 것도 가능
Date 클래스에 비해 많은 양의 정보 제공
6) LocalDateTime
-> 최근에 데이터베이스의 날자 및 시간 데이터에 매핑할 때 많이 이용하는 클래스
-> 월을 계산할 떄 -1을 해주지 않아도 된다
-> 날짜와 시간 데이터를 많이 사용할 것 같으면 학습이 조금 필요 (Spring Batch)
(회원 정보: 마지막 로그인한 날짜 필요, 로그인한 주소 -> 패턴 정보: ex) 만약 일반적인 패턴과 다르다면 경고)
7) 날짜와 시간에서 조금 더 학습해 볼만한 내용
-> Calendar클래스나 LocalDateTime 클래스에서 시간의 연산 부분(특히 뺄셈)
-> Calendar클래스나 LocalDateTime 클래스에서 지역이나 시간대 설정하는 부분
package java_1025;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class DateETC {
public static void main(String[] args) {
//날짜와 시간을 다른 형태로 사용하는 클래스
Calendar calendar = new GregorianCalendar();
//Date보다 많은 정보를 출력
System.out.println(calendar);
//특정한 데이터를 조회 - 년도 추출
System.out.println(calendar.get(calendar.YEAR));
System.out.println(calendar.get(calendar.MONTH ) + 1);
//최근에 많이 사용하는 날짜 타입
LocalDateTime meetingTime = LocalDateTime.of(2022, 10, 27, 18, 50);
System.out.println(meetingTime);
}
}
4.Random
1) Random 클래스: seed(난수표)를 만든 후 seed에서 숫자를 하나씩 추출하는 클래스
-> 생성자
random(): seed를 현재 시간에 생성 - 어느정도 랜덤 보장
Random(long seed) : seed를 고정 - 랜덤이 아니고 일정한 패턴의 숫자를 가져온다
-> 데이터를 추출하는 메서드
next자료형()
nextInt(int n): 0 부터 n 보다 작은 수까지 범위에서 추출
2) UUID
-> 랜덤한 문자열을 만들어 주는 클래스
-> (문자열)UUID.randomUUID().toString() 을 이용해서 랜덤한 문자열을 만들어준다
-> 고유한 식별자를 생성할 때 주로 이용
3) 실습
->seed를 사용하는 경우가 그렇지 않은 경우를 구분하고 배열 않에서 랜덤한 요소를 추출해보고 UUID를 생성
package java_1025;
import java.util.Random;
import java.util.UUID;
public class RandomTest {
public static void main(String[] args) {
//seed를 사용하지 않는 경우와 사용하는 경우의 차이
//여러번 실행해 보고 확인
//java에서는 seed를 설정하지 않으면 seed가 랜덤
Random r = new Random();
System.out.println(r.nextInt());
//seed를 설정하면 고정된 패턴의 숫자가 리턴
r = new Random(42);
System.out.println(r.nextInt());
//배열 내에 존재하는 요소만 랜덤하게 추출
r = new Random();
// int[] ar = {-1, 1, 2, 3, 4, 5};
// for(int i = 0; i < 10; i++) {
// System.out.println(ar[r.nextInt(ar.length)]);
// }
String[] ar = {"오미크론", "오미크론", "오미크론", "다크스펙터", "다크스펙터", "라투"};
for(int i = 0; i < 10; i++) {
System.out.println(ar[r.nextInt(ar.length)]);
}
//랜덤한 문자열 추출
System.out.println(UUID.randomUUID().toString());
}
}5.Data분류
1) Mutable Data(변경 가능) 와 Immutable Data(변경 불가능)
-> 변경 가능한 데이터는 동시에 접근 할 수 있게 하면 안된다. LOCK걸어줘야함
2) Scala Data(1개 소문자로 쓰는 데이터 Primitive Data) 와 Vector Data(0개 이상 - collection) 벡터라는 클래스가 있어서 collection 이라함
(보통 Object라는 클래스가 있기 때문에 객체를 칭하는 표현도 instance 혹은 occurance라고 한다)
인덱스 가지고 구분 - 배열, List(리스트에서 나오는 클래스는 외워야한다)
이름 가지고 구분 - 클래스, Map
3) 정형, 비정형, 반정형
정형(똑같은 모양으로 있는 것) - Table, Class
비정형(마음대로 확장하고 축소 시킬 수 있음) -Map
반정형( 문자열 -> 정형으로 변환 가능) - html, xml, json, yml등
실제로 제네릭을 사용하는 이유는 다야한 형태로 생성자 호출을 할 때 타입을 정할 수 있기 때문이다. 어떤 데이터 타입으로 할 지 애매할 때 그리고 인스턴스 같은 경우에는 타입 캐스팅을 해줘야 하는 경우가 있는데 이 경우에 잘못된 형변환을 하면 에러가 발생하기 때문에 이를 방지할 수 있다.
package java_1025;
/*
* 로직은 같은데 매개 변수의 자료형이 달라서 Overloading을 이용해서 구현한 클래스
class Algorithm{
//애플 같은 경우에는 이름을 길게 만들어준다 따라서 오버로딩을 별로 사용하지 않음
//항상 오버로딩이 좋은 것만은 아니다
//함축적인 의미가 좋을지 아니면 이해하기 좋은게 좋을지 잘 사용해보자
public static int integerAddWithInteger(int n1, int n2) {
return n1 + n2;
}
//정수 2개를 더해서 결과를 리턴하는 메서드
public static int add(int n1, int n2) {
return n1 + n2;
}
//실수 2개를 더해서 결과를 리턴하는 메서드
public static double add(double n1, double n2) {//메서드 오버로딩
return n1 + n2;
}
}*/
//자료 형의 이름을 임시로 만들어두고 내부에서 임시로 만든 자료형을 사용한 후
//인스턴스를 생성할 때 자료형을 결정하는 방식을 이용
//단, 인스턴스를 만들 때 또는 메서드를 호출할 때 실제 자료형을 기재해야한다
//이 때 사용되는 자료형은 Object로 부터 상속받은 클래스의 자료형만 가능하다
//int와 같은 primitive type의 경우는 Integer와 같은 Wrapper 클래스를 이용해야한다.
//미지정 자료형의 개수는 제한이 없다
//인스턴스를 만들 때 자료형을 설정하지 않으면 경고가 발생한다
class Algorithm<T>{
//두개의 데이터를 받아서 내용을 변경하는 메서드
public void swap(T n1 , T n2) {
T imsi = n1;
n1 = n2;
n2 = imsi;
}
}
//어떤 종류의 데이터든지 생성자에서 개수에 상관없이 받아서 처리하는 제너릭스
class Generics <T>{//보통 한글자 대문자로
private T[] data;
//...은 variable args로 개수에 상관없이 매개변수를 받고자 할 때 사용
//받은 매개변수들은 배열로 만들어 진다.
public Generics(T...n) {
this.data = n;
}
//배열의 데이터를 순차적으로 접근해서 출력하는 메서드
public void display() {
for(T temp: data) {
System.out.println(temp);
}
}
}
public class TemplateProgramming {
public static void main(String[] args) {
// double result = Algorithm.add(10.7,20.4);
// System.out.println(result);
//
//
// int result1 = Algorithm.integerAddWithInteger(2, 3);
// System.out.println(result1);
//
// int result2 = Algorithm.add(2, 3);
// System.out.println(result2);
//제너릭이 적용된 클래스의 인스턴스를 만들 때는 자료형을 기재해야한다
//자료형을 기재하지 않으면 경고가 발생하고 Object타입으로 간주
Algorithm<Integer> algorithm = new Algorithm<>();
Integer n1 = 20;
Integer n2 = 30;
algorithm.swap(n1,n2);
System.out.println(n1);
System.out.println(n2);
Generics <String> g1 = new Generics<String>("Karina", "Suzi", "IU");
g1.display();
Generics <Integer> g2 = new Generics<>(100, 200, 300, 400);
g2.display();
}
}
6.Generic
1) Template Programming(일반화 프로그래밍)
-> 동일한 알고리즘을 사용하는 메서드나 자료구조의 구현때문에 등장
-> 작업은 함수나 메서드가 수행하게 되는데 함수나 메서드는 매개변수에 자료형을 지정해야한다
알고리즘은 같은데 사용하는 데이터의 자료형이 달라서 별도의 메서드나 함수를 구현하는 번거로움이 발생
Template(Generic으로 쓰기도함) Method Patern(인터페이스= 메뉴 보여주고(needs 파악) 후에-> 구현 ) 은
-> 모양이 되는 메서드를 먼저 보여주고 구현을 한다는 것
Template Programming이랑 다른 거임
2) Generics
-> 자바에서 템플릿 프로그래밍을 구현하기 위한 문법
-> 클래스 이름 뒤에 <>를 추가하고 미지정 자료형 이름을 나
-> 클래스 내부에서 미지정 자료형을 사용해서 메서드를 구현
-> 인스턴스를 생성할 때 실제 자료형을 기재해서 생성
실제 자료형을 기재하지 않으면 Objcet타입으로 간주
변수에 실제 데이터 타입을 기재하면 생성자를 호출할 때는 기재하지 않고<>
3) 용도
-> 자료구조 클래스를 만들 때 모든 자료형의 데이터를 저장할 수 있도록 하기 위해서 사용
-> 특정 자료형의 데이터만 대입받기 위한 용도로도 사용: 이 경우는 대부분 템플릿에 인터페이스를 설정하는 경우
-> 처음 공부를 할 때는 제너릭이 적용된 클래스의 인스턴스를 만드는 방법을 먼저 학습을 하고,
제너릭을 적용하는 클래스를 만들어 가는 형태로 하는 것이 좋음
7.List 구조: 데이터를 입력하는 순서대로 연속해서 저장하는 자료구조
1) java.util.List 인터페이스
-> List구조에서 공통으로 사용하는 메서드의 원형을 가진 메서드
booleand add(E e)
void add(int index, E element)
void set(int index, E element)
E get(int index)
E remove(int index 또는 E element)
void sort(Compartor comprator)
-> List 인터페이스는 제너릭이 구현되어 있어서 인스턴스를 생성할 때 저장하고자 하는 데이터의 자료형을 설정해야 한다.
2)종류
package java_1025;
import java.util.Arrays;
public class CollectionTest1 {
public static void main(String[] args) {
String[] ar = {"List", "Set", "Map"};
//배열의 데이터를 수정하는 것은 가능
ar[2] = "HashTable";
System.out.println(Arrays.toString(ar));
//ar 배열에 데이터를 추가
//ar 배열보다 1개 더 큰 공간을 갖는 배열을 생성
String[] br = new String[ar.length + 1];
//ar의 내용을 복사
for(int i = 0; i < ar.length; i++) {
br[i] = ar[i];
}
//br의 마지막에 데이터 추가
br[br.length-1] = "Properties";
//br이 가리키는 곳을 ar이 가리키도록 한다.
ar = br;
System.out.println(Arrays.toString(ar));
//연습: Set을 삭제하기
String[] br1 = new String[ar.length - 1];
int j = 0;
for(int i = 0; i < ar.length; i++) {
if(ar[i].equals("Set")) {
continue;
}
br1[j] = ar[i];
j++;
}
ar = br1;
System.out.println(Arrays.toString(ar));
}
}
(1) Array(배열): 크기가 고정인 List
-> 한 번 만들면 크기를 변경할 수 없음
-> 저장된 데이터를 변경하는 것은 가능하지만 데이터를 추가하거나 삭제하는 것은 안됨
-> 데이터를 추가하거나 삭제를 하고자하는 경우는 배열을 복사해서 작업을 수행해야함
-> 불필요한 공간이 없기 때문에 메모리 효율은 높음
-> 데이터의 크기 변경이 없을 가능성이 높을 때 사용
ex) {50, 30, 10, 40, 20} 중간에 있는 데이터 삽입, 삭제 불가능
(2) Vector(ArrayList): 크기가 가변인 배열(뒤쪽이 열려 있음)
ex) {50, 30, 10, 40, 20 뒤에가 열려 있음 중간에 있는 데이터 삽입과 삭제 어려움(매우 느림)
(3) Linked List: 다음 데이터의 해시코드를 가리키는 구조
ex) 보통 HEAD, BOF -> TAIL, EOF 삽입과 삭제는 매우 유리하지만, 조회가 느리다.
단점: 공간을 더 많이 사용한다(다음 데이터를 가리키는 포인터가 있다), 순서대로 가기 때문에 조회속도가 느리고, 메모리 많이 사용
(4) Double Linked List: 다음 데이터도 가리키고 앞의 데이터도 가리킨다.
(5) Stack: Last In First Out - 함수(메서드)에 사용 (사용하기 직전에 호출하는게 좋음)
-> 넣는 거 push, 빼는 거 pop
(6) Queue: First In First Out - 스케줄링 -> 작업의 순서 결정
(7) Dequeue: 양쪽에서 삽입과 삭제 (재사용 데큐 Reusable Dequeue)
(8) Priority Queue:
package java_1025;
import java.util.ArrayList;
import java.util.LinkedList;
public class CollectionTest2 {
public static void main(String[] args) {
//문자열을 저장하는 ArrayList 생성
ArrayList <String> al = new ArrayList<>();
//샘플 데이터 추가
al.add("One");
al.add("Three");
long start = System.currentTimeMillis();
for(int i=0; i<500000; i++) {
al.add(1, "Two");
}
System.out.println(al);
long end = System.currentTimeMillis();
System.out.println("ArrayList 데이터 삽입시간 " + (end - start) * 0.001 +"초");
//문자열을 저장하는 LinkedList 생성
LinkedList <String> li = new LinkedList<>();
//샘플 데이터 추가
li.add("One");
li.add("Three");
start = System.currentTimeMillis();
for(int i=0; i<500000; i++) {
li.add(1, "Two");
}
System.out.println(li);
end = System.currentTimeMillis();
System.out.println("LinkedList 데이터 삽입시간 " + (end - start) * 0.001 +"초");
}
}
package java_1025;
import java.util.ArrayList;
import java.util.LinkedList;
public class CollectionTest3 {
public static void main(String[] args) {
//100000개의 데이터를 가진 ArrayList와 LinkedList 생성
ArrayList<Integer> al = new ArrayList<>();
for(int i = 0; i < 100000; i++) {
al.add(i);
}
LinkedList<Integer> li = new LinkedList<>();
for(int i = 0; i < 100000; i++) {
li.add(i);
}
//ArrayList에서 100000 개의 데이터를 읽는데 걸리는 시간
//데이터를 가져오는 메서드는 get(인덱스)
//실행해서 가장 마지막에 나오는 숫자를 확인을 한후 al을 li로 변경해서 실행하고 숫자는 확인
long start = System.currentTimeMillis();
for(int i=0; i<100000; i++) {
al.get(i);
}
long end = System.currentTimeMillis();
System.out.println("ArrayList 조회 시간 " + (end - start) * 0.001 + "초");
start = System.currentTimeMillis();
for(int i=0; i<100000; i++) {
li.get(i);
}
end = System.currentTimeMillis();
System.out.println("LinkedList 조회 시간 " + (end - start) * 0.001 + "초");
}
}
실제 데이터 삽입, 삭제는 LinkedList가 ArrayList보다 훨씬 효율적으로 빠르다
데이터 조회는 ArrayList가 LinkedList보다 훨씬 빠르기 때문에 효율적이다.
-> 조회를 주로 하는 작업에서는(게시판) Array List를 이용하고 삽입과 삭제가 많은 게임 같은 분야에서는 Linked List를 많이 사용
3) java.util.ArrayList - 예전에는 Vector라는 클래스를 이용했음
-> List 인터페이스를 구현한 클래스로 데이터를 연속해서 순서대로 저장하는 자료구조 클래스
-> 배열과 달리 크기가 가변이라서 데이터를 추가하거나 삭제하는 것이 가능
-> 장점: 데이터만 저장하기 때문에 LinkedList 보다는 메모리 효율이 좋을 수 있음
전체 데이터를 순회하는 속도가 LinkedList 보다는 빠름
-> 단점: 중간에 데이터를 삽입하거나 삭제할 때 데이터의 복사 작업이 필요하기 때문에 속도가 느림
연속된 빈 공간이 없으면 생성이 불가능
4) java.util.LinkedList - 예전에는 Vector라는 클래스를 이용했음
-> List 인터페이스를 구현한 클래스로 데이터를 논리적인 순서(실제 연속해서 저장되는 것이아니고 앞의 데이터가 뒤의 데이터를 가리키는 구조)대로 저장하는 자료구조 클래스
-> 링크가 1개이면 Single Linked List라고 하고 2개(앞과 뒤 모두 가리키거나 트리 구조에서는 부모나 앞의 형제를 가리키고 다른 하나는 자식이나 형제를 가리킴)이면 Double Linked List라고 함
-> 장점: 중간에 데이터를 삽입하거나 삭제할 때 데이터의 이동없이 포인터만 이동하기 때문에 빠르게 작업이 가능
포인터를 이용해서 다음 데이터를 가리키는 구조이므로 연속된 빈 공간이 없어도 생성이 가능
-> 단점: 데이터 이외에 포인터도 저장해야 하므로 메모리 효율이 ArrayList에 비해서 떨어질 수 있음
포인터를 따라 다니므로 조회 속도가 느림
**Git Hub에 프로젝트 소스코드 업로드
1.용어
-> repository : 저장소, 가장 큰 개념의 저장소
-> branch: 저장소 안에 변경 내용을 저장하는 저장점
-> merge: branch를 통합 - pull request라고 함
-> commit: 변경 내용을 로컬 git에 반영
-> push: 변경 내용을 웹의 git에 반영
-> pull: 서버에서 변경 내용을 받아옴
2. git hub에서 토큰을 생성
-> 최근에는 아이디와 비밀번호로 계속해서 로그인하지 않고 처음 한 번만 아이디와 비밀번호를 이용해서 로그인하고
token을 발급 받아서 token을 이용해서 로그인 여부를 판단하는 방식을 많이 사용(**매우 중요)
-> Git Hub 사이트에 로그인
-> 오른쪽 상단의 이미지 부분을 클릭해서 [settings 메뉴 실행]
-> 다음 화면에서 왼쪽 하단의 [Developer settings 메뉴를 실행] OAuth(방법?)
-> personal access tokens 클릭해서 classic token 클릭
-> generated tokens를 클릭한 후 옵션을 설정한 후 나오는 토큰을 확인 - 한 번만 보여주므로 어딘가에 복사해서 사용
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
3. eclipse의 경우에는 github에서 repository를 먼저 생성한 후 업로드 하므로 repository 생성하고 URL 복사
-> main 페이지 에서 new를 누르고 repository 이름을 작성
https://github.com/srlee3637/20221025.git
GitHub - srlee3637/20221025: 20221025
20221025. Contribute to srlee3637/20221025 development by creating an account on GitHub.
github.com
4. 프로젝트 업로드
1) eclipse에서 [window] - [show view] - others 선택하고 [git] 에서 git repository를 선택
2) git repository 창에서 clone a git repository 나 녹색 화살표가 있는 아이콘을 클릭 후 url 붙이기
3) 프로젝트에 git을 연결
프로젝트를 선택하고 마우스 오른쪽을 누른후 [Team] - [Share Project] - repository 선택
4)변경 내용을 서버에 전송
프로젝트를 선택하고 마우스 오른쪽 누른 후 team - commit을 누르고 적용할 파일들을 아래로 드래그 하고 메세지를 입력한 후 commit and puch 누르고 아이디와 토큰 번호 입력