시스템의 밀리초 구하기.(국제표준시각(UTC, GMT) 1970/1/1/0/0/0 으로부터 경과한 시각)

1
2
3
// 밀리초 단위(*1000은 1초), 음수이면 이전 시각
long time = System.currentTimeMillis ( );
System.out.println ( time.toString ( ) );

현재 시각을 가져오기.

1
2
Date today = new Date ();
System.out.println ( today );


결과 : Sat Jul 12 16:03:00 GMT+01:00 2000

경과시간(초) 구하기

1
2
3
long time1 = System.currentTimeMillis ();
long time2 = System.currentTimeMillis ();
system.out.println ( ( time2 - time1 ) / 1000.0 );

Date를 Calendar로 맵핑하기

1
2
3
Date d = new Date ( );
Calendar c = Calendar.getInstance ( );
c.setTime ( d );

날짜(년/월/일/시/분/초) 구하기

1
2
3
4
5
6
import java.util.*;
import java.text.*;
SimpleDateFormat formatter = new SimpleDateFormat ( "yyyy.MM.dd HH:mm:ss", Locale.KOREA );
Date currentTime = new Date ( );
String dTime = formatter.format ( currentTime );
System.out.println ( dTime );

날짜(년/월/일/시/분/초) 구하기2

1
2
3
4
5
6
7
8
9
10
GregorianCalendar today = new GregorianCalendar ( );
int year = today.get ( today.YEAR );
int month = today.get ( today.MONTH ) + 1;
int yoil = today.get ( today.DAY_OF_MONTH ); <p></p>
<p>GregorianCalendar gc = new GregorianCalendar ( );</p>
<p>System.out.println ( gc.get ( Calendar.YEAR ) );
System.out.println ( String.valueOf ( gc.get ( Calendar.MONTH ) + 1 ) );
System.out.println ( gc.get ( Calendar.DATE ) );
System.out.println ( gc.get ( DAY_OF_MONTH ) );
</p>

날짜(년/월/일/시/분/초) 구하기3

1
2
3
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.KOREA);
Calendar cal = Calendar.getInstance(Locale.KOREA);
nal = df.format(cal.getTime());

- 표준시간대를 지정하고 날짜를 가져오기.

1
2
3
4
5
6
7
8
9
10
11
TimeZone jst = TimeZone.getTimeZone ("JST");
Calendar cal = Calendar.getInstance ( jst );
// 주어진 시간대에 맞게 현재 시각으로 초기화된 GregorianCalender 객체를 반환.
// 또는 Calendar now = Calendar.getInstance(Locale.KOREA);
System.out.println ( cal.get ( Calendar.YEAR ) + "년 "
                    + ( cal.get ( Calendar.MONTH ) + 1 ) + "월 "
                    + cal.get ( Calendar.DATE ) + "일 "
                    + cal.get ( Calendar.HOUR_OF_DAY ) + "시 "
                    + cal.get ( Calendar.MINUTE ) + "분 "
                    + cal.get ( Calendar.SECOND ) + "초 "
                    );


결과 : 2000년 8월 5일 16시 16분 47초

영어로된 날짜를 숫자로 바꾸기

1
2
Date myDate = new Date ( "Sun,5 Dec 1999 00:07:21" );
System.out.println ( myDate.getYear ( ) + "-" + myDate.getMonth ( ) + "-" + myDate.getDay ( ) );

"Sun, 5 Dec 1999 00:07:21"를 "1999-12-05"로 바꾸기

1
2
3
4
5
6
7
SimpleDateFormat formatter_one = new SimpleDateFormat ( "EEE, dd MMM yyyy hh:mm:ss",Locale.ENGLISH );
SimpleDateFormat formatter_two = new SimpleDateFormat ( "yyyy-MM-dd" );
String inString = "Sun, 5 Dec 1999 00:07:21";
ParsePosition pos = new ParsePosition ( 0 );
Date frmTime = formatter_one.parse ( inString, pos );
String outString = formatter_two.format ( frmTime );
System.out.println ( outString );

숫자 12자리를, 다시 날짜로 변환하기

1
2
3
4
5
6
7
8
Date conFromDate = new Date();
long ttl = conFromDate.parse ( "Dec 25, 1997 10:10:10" );
System.out.println ( ttl );
//예 938291839221
Date today = new Date ( ttl );
DateFormat format = DateFormat.getDateInstance ( DateFormat.FULL,Locale.US );
String formatted = format.format ( today );
System.out.println ( formatted );

특정일로부터 n일 만큼 이동한 날짜 구하기

특정일의 시간을 long형으로 읽어온다음..
날짜*24*60*60*1000 을 계산하여.
long형에 더해줍니다.
그리고 나서 Date클래스와 Calender클래스를 이용해서 날짜와 시간을 구하면 됩니다

특정일에서 일정 기간후의 날짜 구하기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
//iDay 에 입력하신 만큼 빼거나 더한 날짜를 반환 합니다.
import java.util.*;
public String getDate ( int iDay )
{
    Calendar temp=Calendar.getInstance ( );
    temp.add ( Calendar.DAY_OF_MONTH, iDay );
     
    int nYear = temp.get ( Calendar.YEAR );
    int nMonth = temp.get ( Calendar.MONTH ) + 1;
    int nDay = temp.get ( Calendar.DAY_OF_MONTH );
     
    StringBuffer sbDate=new StringBuffer ( );
    sbDate.append ( nYear );
     
    if ( nMonth < 10 )
        sbDate.append ( "0" );
        sbDate.append ( nMonth );
 
    if ( nDay < 10 )
        sbDate.append ( "0" );
        sbDate.append ( nDay );
 
    return sbDate.toString ( );
}

현재날짜에서 2달전의 날짜를 구하기

1
2
3
4
5
6
7
8
//오늘 날짜를 기준으루..
Calendar cal = Calendar.getInstance ( );
//2개월 전....
cal.add ( cal.MONTH, -2 );
 
System.out.println ( cal.get ( cal.YEAR ) );
System.out.println ( cal.get ( cal.MONTH ) + 1 );
System.out.println ( cal.get ( cal.DATE ) );

달에 마지막 날짜 구하기

1
2
3
4
5
for ( int month = 1; month <= 12; month++ )
{
    GregorianCalendar cld = new GregorianCalendar ( 2001, month - 1, 1 );
    System.out.println ( month + "/" + cld.getActualMaximum ( Calendar.DAY_OF_MONTH ) );
}

해당하는 달의 마지막 일 구하기

1
2
3
GregorianCalendar today = new GregorianCalendar ( );
int maxday = today.getActualMaximum ( ( today.DAY_OF_MONTH ) );
System.out.println ( maxday );

특정일을 입력받아 해당 월의 마지막 날짜를 구하는 간단한 예제.(달은 -1 해준다.)...윤달 30일 31일 알아오기.

1
2
3
4
5
Calendar cal = Calendar.getInstance ( );
cal.set ( Integer.parseInt ( args[0] ), Integer.parseInt ( args [1] ) - 1, Integer.parseInt ( args [2] ) );
SimpleDateFormat dFormat = new SimpleDateFormat ( "yyyy-MM-dd" );
System.out.println ( "입력 날짜 " + dFormat.format ( cal.getTime ( ) ) );
System.out.println ( "해당 월의 마지막 일자 : " + cal.getActualMaximum ( Calendar.DATE ) );

해당월의 실제 날짜수 구하기 ( 1999년 1월달의 실제 날짜수를 구하기 )

1
2
3
Calendar calendar = Calendar.getInstance ( );
calendar.set ( 1999, 0, 1 );
int maxDays = calendar.getActualMaximum ( Calendar.DAY_OF_MONTH );

어제 날짜 구하기

오늘날짜를 초단위로 구해서 하루분을 빼주고 다시
셋팅해주면 쉽게 구할수 있죠..
setTime((기준일부터 오늘까지의 초를 구함) - 24*60*60)해주면 되겠죠..

어제 날짜 구하기2

1
2
3
4
5
6
7
8
9
10
11
import java.util.*;
public static Date getYesterday ( Date today )
{
    if ( today == null )
        throw new IllegalStateException ( "today is null" );
 
    Date yesterday = new Date ( );
    yesterday.setTime ( today.getTime ( ) - ( (long) 1000 * 60 * 60 * 24 ) );
     
    return yesterday;
}

내일 날짜 구하기

1
2
Date today = new Date ( );
Date tomorrow = new Date ( today.getTime ( ) + (long) ( 1000 * 60 * 60 * 24 ) );

내일 날짜 구하기2

1
2
3
Calendar today = Calendar.getInstance ( );
today.add ( Calendar.DATE, 1 );
Date tomorrow = today.getTime ( );

오늘날짜에서 5일 이후 날짜를 구하기

1
2
Calendar cCal = Calendar.getInstance();
c.add(Calendar.DATE, 5);

날짜에 해당하는 요일 구하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//DAY_OF_WEEK리턴값이 일요일(1), 월요일(2), 화요일(3) ~~ 토요일(7)을 반환합니다.
//아래 소스는 JSP일부입니다.
import java.util.*;
Calendar cal= Calendar.getInstance ( );
int day_of_week = cal.get ( Calendar.DAY_OF_WEEK );
if ( day_of_week == 1 )
    m_week="일요일";
else if ( day_of_week == 2 )
    m_week="월요일";
else if ( day_of_week == 3 )
    m_week="화요일";
else if ( day_of_week == 4 )
    m_week="수요일";
else if ( day_of_week == 5 )
    m_week="목요일";
else if ( day_of_week == 6 )
    m_week="금요일";
else if ( day_of_week == 7 )
    m_week="토요일";

콤보박스로 선택된 날짜(예:20001023)를 통해 요일을 영문으로 가져오기

1
2
3
4
5
//gc.get(gc.DAY_OF_WEEK); 하면 일요일=1, 월요일=2, ..., 토요일=7이 나오니까,
//요일을 배열로 만들어서 뽑아내면 되겠죠.
GregorianCalendar gc=new GregorianCalendar ( 2000, 10 - 1 , 23 );
String [] dayOfWeek = { "", "Sun", "Mon", .... , "Sat" };
String yo_il = dayOfWeek ( gc.get ( gc.DAY_OF_WEEK ) );

두 날짜의 차이를 일수로 구하기

각각의 날짜를 Date형으로 만들어서 getTime()하면 
long으로 값이 나오거든요(1970년 1월 1일 이후-맞던가?- 1/1000 초 단위로..)
그러면 이값의 차를 구해서요. (1000*60*60*24)로 나누어 보면 되겠죠.

두 날짜의 차이를 일수로 구하기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
import java.io.*;
import java.util.*;
 
 
Date today = new Date ( );
Calendar cal = Calendar.getInstance ( );
cal.setTime ( today );
 
// 오늘로 설정.
Calendar cal2 = Calendar.getInstance ( );
cal2.set ( 2000, 3, 12 );
 
// 기준일로 설정. month의 경우 해당월수-1을 해줍니다.
int count = 0;
while ( !cal2.after ( cal ) )
{
    count++;
    cal2.add ( Calendar.DATE, 1 );
    //다음날로 바뀜
    System.out.println ( cal2.get ( Calendar.YEAR ) + "년 "
            + ( cal2.get ( Calendar.MONTH ) + 1 )
            + "월 " + cal2.get ( Calendar.DATE ) + "일"
    );
}
System.out.println ( "기준일로부터 " + count + "일이 지났습니다." );

두 날짜의 차이를 일수로 구하기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
import java.io.*;
import java.util.*;
public class DateDiff
{
    public static int GetDifferenceOfDate ( int nYear1, int nMonth1, int nDate1, int nYear2, int nMonth2, int nDate2 )
    {
        Calendar cal = Calendar.getInstance ( );
        int nTotalDate1 = 0, nTotalDate2 = 0, nDiffOfYear = 0, nDiffOfDay = 0;
        if ( nYear1 > nYear2 )
        {
            for ( int i = nYear2; i < nYear1; i++ )
            {
                cal.set ( i, 12, 0 );
                nDiffOfYear += cal.get ( Calendar.DAY_OF_YEAR );
            }
            nTotalDate1 += nDiffOfYear;
        }
        else if ( nYear1 < nYear2 )
        {
            for ( int i = nYear1; i < nYear2; i++ )
            {
                cal.set ( i, 12, 0 );
                nDiffOfYear += cal.get ( Calendar.DAY_OF_YEAR );
            }
            nTotalDate2 += nDiffOfYear;
        }
         
        cal.set ( nYear1, nMonth1-1, nDate1 );
        nDiffOfDay = cal.get ( Calendar.DAY_OF_YEAR );
        nTotalDate1 += nDiffOfDay;
        cal.set ( nYear2, nMonth2-1, nDate2 );
        nDiffOfDay = cal.get ( Calendar.DAY_OF_YEAR );
        nTotalDate2 += nDiffOfDay;
         
        return nTotalDate1-nTotalDate2;
    }
     
    public static void main ( String args[] )
    {
        System.out.println ( "" + GetDifferenceOfDate (2000, 6, 15, 1999, 8, 23 ) );
    }
}

파일에서 날짜정보를 가져오기

1
2
3
4
5
6
7
8
9
10
11
File f = new File ( directory, file );
Date date = new Date ( f.lastModified ( ) );
Calendar cal = Calendar.getInstance ( );
cal.setTime ( date );
 
System.out.println("Year : " + cal.get(Calendar.YEAR));
System.out.println("Month : " + (cal.get(Calendar.MONTH) + 1));
System.out.println("Day : " + cal.get(Calendar.DAY_OF_MONTH));
System.out.println("Hours : " + cal.get(Calendar.HOUR_OF_DAY));
System.out.println("Minutes : " + cal.get(Calendar.MINUTE));
System.out.println("Second : " + cal.get(Calendar.SECOND));

날짜형식으로 2000-01-03으로 처음에 인식을 시킨후
7일씩 증가해서 1년정도의 날짜를 출력해 주고 싶은데요.

1
2
3
4
5
6
7
8
9
10
SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy-mm-dd" );
Calendar c = Calendar.getInstance ( );
for ( int i = 0; i < 48; i++ )
{
    c.clear ( );
    c.set ( 2000, 1, 3 - ( i * 7 ) );
    java.util.Date d = c.getTime ( );
    String thedate = sdf.format ( d );
    System.out.println ( thedate );
}

쓰레드에서 날짜 바꾸면 죽는 문제

Main화면에 날짜와시간이Display되는 JPanel이 있습니다.
date로 날짜와 시간을 변경하면 Main화면의 날짜와 시간이 Display되는 Panel에 
변경된 날짜가 Display되지 않고 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
public void run ( )
{
    while ( true )
    {
        try{
            timer.sleep ( 60000 );
        }
        catch ( InterruptedException ex ) { }
     
        lblTimeDate.setText ( fGetDateTime ( ) );
        repaint ( );
    }
}
 
public String fGetDateTime ( )
{
    final int millisPerHour = 60 * 60 * 1000;
    String DATE_FORMAT = "yyyy / MM / dd HH:mm";
    SimpleDateFormat sdf = new SimpleDateFormat ( DATE_FORMAT );
    SimpleTimeZone timeZone = new SimpleTimeZone ( 9 * millisPerHour, "KST" );
    sdf.setTimeZone ( timeZone );<p></p>
    long time = System.currentTimeMillis ( );
    Date date = new Date ( time );
    return sdf.format ( date );
}

해답:

1
2
3
4
5
6
7
8
// 날짜와 요일 구한다. timezone 으로 날짜를 다시 셋팅하시면 됨니다.
public String getDate ( )
{
    Date now = new Date ( );
    SimpleDateFormat sdf4 = new SimpleDateFormat ( "yyyy/MM/dd HH:mm EE" );
    sdf4.setTimeZone ( TimeZone.getTimeZone ( "Asia/Seoul" ) );
    return sdf4.format ( now );
}

날짜와 시간이 유효한지 검사하려면...?

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
import java.util.*;
import java.text.*;
 
public class DateCheck
{
    boolean dateValidity = true;
     
    DateCheck ( String dt )
    {
    try
    {
    DateFormat df = DateFormat.getDateInstance ( DateFormat.SHORT );
    df.setLenient ( false );
    Date dt2 = df.parse ( dt );
    }
    catch ( ParseException e ) { this.dateValidity = false; }
    catch ( IllegalArgumentException e ) { this.dateValidity = false; }
    }
 
    public boolean datevalid ( )
    {
        return dateValidity;
    }
 
    public static void main ( String args [] )
    {
        DateCheck dc = new DateCheck ( "2001-02-28" );
        System.out.println ( " 유효한 날짜 : " + dc.datevalid ( ) );
    }
}

두 날짜 비교하기(아래보다 정확)

그냥 날짜 두개를 long(밀리 세컨드)형으로 비교하시면 됩니다...

이전의 데이타가 date형으로 되어 있다면, 이걸 long형으로 변환하고.
현재 날짜(시간)은 System.currentTimeMillis()메소드로 읽어들이고,
두수(long형)를 연산하여 그 결과 값으로 비교를 하시면 됩니다.

만약 그 결과값이 몇시간 혹은 며칠차이가 있는지를 계산할려면,
결과값을 Calender의 setTimeInMillis(long millis) 메소드를 이용해
설정한다음 각각의 날짜나 시간을 읽어오시면 됩니다

두 날짜 비교하기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
import java.util.*;
import java.util.Calendar.*;
import java.text.SimpleDateFormat;
 
public class DayComparisonTest
{
    public static void main(String args[])
    {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dateForm = new SimpleDateFormat("yyyy-MM-dd");
        Calendar aDate = Calendar.getInstance();
        // 비교하고자 하는 임의의 날짜
        aDate.set(2001, 0, 1);
        Calendar bDate = Calendar.getInstance();
        // 이것이 시스템의 날짜
 
        // 여기에 시,분,초를 0으로 세팅해야 before, after를 제대로 비교함
        aDate.set( Calendar.HOUR_OF_DAY, 0 );
        aDate.set( Calendar.MINUTE, 0 );
        aDate.set( Calendar.SECOND, 0 );
        aDate.set( Calendar.MILLISECOND, 0 );
        bDate.set( Calendar.HOUR_OF_DAY, 0 );
        bDate.set( Calendar.MINUTE, 0 );
        bDate.set( Calendar.SECOND, 0 );
        bDate.set( Calendar.MILLISECOND, 0 );
 
        if (aDate.after(bDate))
            // aDate가 bDate보다 클 경우 출력
            System.out.println("시스템 날짜보다 뒤일 경우 aDate = " + dateForm.format(aDate.getTime()));
        else if (aDate.before(bDate))
            // aDate가 bDate보다 작을 경우 출력
            System.out.println("시스템 날짜보다 앞일 경우 aDate = " + dateForm.format(aDate.getTime()));
        else
            // aDate = bDate인 경우
            System.out.println("같은 날이구만");
    }
}

// 현재 년도 -100년 리스트 가져오기.

   Calendar oCalendar = Calendar.getInstance( );  // 현재 날짜/시간 등의 각종 정보 얻기

   List<Object> years  = new ArrayList<>();

   int thisYear = oCalendar.get(Calendar.YEAR); // 올해

   int beforeYear = oCalendar.get(Calendar.YEAR) - 100; // 올해

   for (int i = thisYear; i > beforeYear; i--){

    years.add(i);

   }


mav.addObject("years",years);



// 객체형

years = getCalender(); //호출


public static List<Object> getCalender(){

Calendar oCalendar = Calendar.getInstance( );  // 현재 날짜/시간 등의 각종 정보 얻기

    List<Object> years  = new ArrayList<>();

    int thisYear = oCalendar.get(Calendar.YEAR); // 올해

    int beforeYear = oCalendar.get(Calendar.YEAR) - 100; // 올해

    for (int i = thisYear; i > beforeYear; i--){

years.add(i);

    }

   return years; //계산후 리턴

}


//* 현재날짜에서 DataVo에 입력된 값(생년) 가져와서 현재 나이 구하기.

Calendar oCalendar = Calendar.getInstance( );  // 현재 날짜/시간 등의 각종 정보 얻기

int resultYear = ((oCalendar.get(Calendar.YEAR)) - Integer.valueOf(param.getAge()));


//*Java 생일로 나이 구하기

public static int getAgeFromBirthday(Date birthday) {

    Calendar birth = new GregorianCalendar();

    Calendar today = new GregorianCalendar();


    birth.setTime(birthday);

    today.setTime(new Date());


    int factor = 0;

    if (today.get(Calendar.DAY_OF_YEAR) < birth.get(Calendar.DAY_OF_YEAR)) {

        factor = -1;

    }

    return today.get(Calendar.YEAR) - birth.get(Calendar.YEAR) + factor;

}



import java.util.Calendar;

public class Foo {
  public static void main(String args[]) {

    Calendar oCalendar = Calendar.getInstance( );  // 현재 날짜/시간 등의 각종 정보 얻기

    System.out.println("현재 년: " +  oCalendar.get(Calendar.YEAR));
    System.out.println("현재 월: " + (oCalendar.get(Calendar.MONTH) + 1));
    System.out.println("현재 일: " +  oCalendar.get(Calendar.DAY_OF_MONTH));
    System.out.println(); // 다음줄로 행갈이 하기

    System.out.println("현재 시: " +  oCalendar.get(Calendar.HOUR_OF_DAY)); // 24시간제
    System.out.println("현재 분: " +  oCalendar.get(Calendar.MINUTE));
    System.out.println("현재 초: " +  oCalendar.get(Calendar.SECOND));
    System.out.println();

    // 12시간제로 현재 시
    System.out.print("현재 시: " +  oCalendar.get(Calendar.HOUR));
    if (oCalendar.get(Calendar.AM_PM) == 0) System.out.println("am");
    else System.out.println("pm");

    System.out.println("현재 초의 1000분의1초: " +  oCalendar.get(Calendar.MILLISECOND));

    System.out.println("현재 요일: " +  oCalendar.get(Calendar.DAY_OF_WEEK)); // 일요일 = 1
    System.out.println("올해 몇 번째 날: " + oCalendar.get(Calendar.DAY_OF_YEAR)); // 1월 1일 = 1
    System.out.println("올해 몇 번째 주: " + oCalendar.get(Calendar.WEEK_OF_YEAR)); // 1월 1일은 = 1

    System.out.println("이번 달의 몇 번째 주: " + oCalendar.get(Calendar.WEEK_OF_MONTH)); // 첫째 주 = 1

  }
}
----------------------------------------------------------------------------------

실행 결과:

D:\Z>javac Foo.java && java Foo
현재 년: 2006
현재 월: 10
현재 일: 14

현재 시: 16
현재 분: 12
현재 초: 16

현재 시: 4pm
현재 초의 1000분의1초: 505
현재 요일: 7
올해 몇 번째 날: 287
올해 몇 번째 주: 41
이번 달의 몇 번째 주: 2



저작자표시 비영리 변경금지

'JAVA' 카테고리의 다른 글

2. 저장된 파일에서 필요한 값 찾기. readLine  (0) 2014.07.23
1. URL 경로 파일 다운로드해서 TXT형 저장하기  (0) 2014.07.23
[Java] 나머지 %  (0) 2014.06.01
JCF(Java Collection Framework) : List / Map / Set  (0) 2014.01.18
[JAVA] static , final  (0) 2013.12.18

◈ JCF(JAVA Collection Framework)
- 데이터 관리의 목적으로 만들어진 클래스

- List / Map / Set  세가지 종류가 있다.

 

 

⊙ Generic  
 - JCF는 모든 값을 입력할 수 있다는 편의성이 있지만 값을 꺼내서 사용할 때는 서로 다른 데이터형 때문에 문제가 발생 할 수도 있다. 
 - 그 문제를 해결하기 위해서 값 추가시 하나의 데이터형만 받도록 설정하는 것이 Generic이 하는 일이다.  

 

// JDK 1.5 ~ JDK 1.6

List<입력받을 데이터형> 객체명 = new 자식클래스<입력받을 데이터형>();   

 

// JDK 1.7 (생성자 쪽의 Generic은 생략하고 사용할 수 있다.) 
List<입력받을 데이터형> 객체명 = new 자식클래스<>();  

 

 

 
⊙ autoboxing 
 - JDK 1.5에서 나온 기능으로 개발자가 JCF(List/Map/Set)에 기본형 데이터형 값을 입력 하면 컴파일러가 자동으로 Wrapper 클래스를 

  이용하여 객체로 만들어 주는 일을 한다. 
    

 ※ 원래 기본형 데이터형 값은 참조형 데이터형인 Object형 변수에 넣을 수 없지만 JDK 1.5이상에서는 autoboxing을 해주기 때문에 넣을 수 있다.

 

⊙ unboxing
 - JDK 1.5에서 나온 기능으로 JCF에 입력된 기본형데이터형 값을 원래 형으로 풀어서 내보내는 일을 한다.
 

 

 

 

◈ List (java.util 패키지)

 - 1차원배열의 모양을 가지고 있다.

 - 데이터의 양에 따라 크기가 달라지는 가변자료형이다. (크기의 자동 증가/감소)

 - 데이터의 추가와 삭제가 편리하다.

 - 검색의 기능이 있으며 중복데이터를 저장 할 수 있다.

 - interface이므로 직접 객체화는 불가능하고 자식클래스를 객체화 하여 사용할 수 있다.

 - 자식클래스 중에서는 ArrayList와 Vector를 많이 사용한다. 사용법은 같다.

 - JDK 1.4 까지는 Generic을 사용하지 않고 객체만 입력 할 수 있다. 
 - JDK 1.5 부터는 Generic을 사용 할 수 있으며 모든 값을 입력할 수가 있다.

   (JDK 1.7에서 Generic은 JDK 1.5와 다른 형태로 사용 할 수 있다.)

 - autoboxing, unboxing 을 이용할 수 있다.

 

 - 사용방법

 

※ ArrayList : Multi Thread에서 동시접근이 가능하고 속도가 빠르다.   

        ※ Vector : Multi Thread에서 동시접근이 불가능하고 속도가 느리다.

 

 

1. List는 인터페이스이기 때문에 직접 객체화가 안되므로 자식클래스를 이용하여 객체화 한다. (is a 관계)

------------------------------------------- JDK 1.4 이하 --------------------------------------------

List list = new ArrayList();          

List list = new Vector();       

 

------------------------------------------- JDK 1.5 이상 --------------------------------------------

Generic 미사용 : List list = new ArrayList();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : List<String> list = new ArrayList<String>();    // 지정된 데이터형 값만 입력 가능  

 

------------------------------------------- JDK 1.7 이상 --------------------------------------------

Generic 미사용 : List list = new ArrayList();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : List<String> list = new ArrayList();    // 지정된 데이터형 값만 입력 가능  

 

 

2. 값 추가 : add();

list.add(값);     // 크리가 자동으로 증가한다.   

 

 

3. list의 크기 구하기 : size();

llist.size();    

 

 

4. list에 들어있는 값 얻기 : get();

list.get(인덱스);

list.get(값);

 

 

5. list의 값 삭제 : remove();

list.remove(인덱스);

list.remove(값);

 

 

6. list의 값들 전체 삭제 : clear();

list.clear();  

 

 

7. 데이터를 배열에 복사 : toArray();

list.toArray(배열명) // 리스트 값들의 데이터형과 배열의 데이터형이 일치할 때에만 해당 배열로 복사 됨. 

 

 

8. 모든 방의 값 출력

for(int i=0; i<l.size; i++){
      list.get(i);
}

 

 

 

 

 

◈ Map (java.util 패키지)

 - 2차원배열의 모양을 가지고 있다. (행은 여러개 열은 두개) / (n*2) 
 - 키와 값의 쌍 (key, value) 으로 데이터를 저장한다.
 - 키를 이용하여 값을 검색 할 수 있다.  
 - 키는 중복될 수 없고 값은 중복이 가능하다.

 - 데이터의 추가와 삭제가 편리하다.

 - interface이므로 직접 객체화는 불가능하고 자식클래스를 객체화 하여 사용할 수 있다. 
 - 자식클래스 중에서는 HashMap, HashTable을 많이 사용한다.

 - JDK 1.4 까지는 Generic을 사용하지 않고 객체만 입력 할 수 있다. 
 - JDK 1.5 부터는 Generic을 사용 할 수 있으며 모든 값을 입력할 수가 있다.

   (JDK 1.7에서 Generic은 JDK 1.5와 다른 형태로 사용 할 수 있다.)

 - autoboxing, unboxing 을 이용할 수 있다.

 

 - 사용방법 : Map<k, v>

 

※ HashTable : 기본생성자를 이용하면 10개의 행의 범위를 가진다.

※ HashMap : 기본생성자를 이용하면 16개의 행의 범위를 가진다.

   -> 전체 행의 약 75%의 데이터가 있을때 검색하는 속도가 가장 빠르다.  

 

 

1. Map은 인터페이스이기 때문에 직접 객체화가 안되므로 자식클래스를 이용하여 객체화 한다. (is a 관계)

------------------------------------------- JDK 1.4 이하 --------------------------------------------

Map map = new HashTable;          

Map map = new HashMap();

   ㄴ 행의 크기 지정 가능

 

------------------------------------------- JDK 1.5 이상 --------------------------------------------

Generic 미사용 : Map map = new HashTable();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : Map<String, String> map = new HashTable<String, String>(); 

      // 지정된 데이터형 값만 입력 가능  

 

------------------------------------------- JDK 1.7 이상 --------------------------------------------

Generic 미사용 : Map map = new HashTable();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : Map<String, String> map = new HashTable();    // 지정된 데이터형 값만 입력 가능  

 

 

2. 값 추가 : put();

map.put(키, 값);   // 동일 키가 입력되면 기존의 키는 사라진다.

 

 

3. Map의 크기 구하기 : size();

map.size();    

 

 

4. Map에 들어있는 값 얻기 : get();

map.get(키);   // 키가 없다면 값은 null이다.  

 

 

5. Map의 값 삭제 : remove();

map.remove(키);

 

 

6. Map의 값들 전체 삭제 : clear();

mpa.clear();  

 

 

 

 

 

◈ Set

 - 1차원배열의 모양을 가지고 있다.

 - 데이터의 양에 따라 크기가 달라지는 가변자료형이다. (크기의 자동 증가/감소)
 - interface이므로 직접 객체화는 불가능하고 자식클래스를 객체화 하여 사용할 수 있다. 
 - 자식클래스 중에서는 HashSet을 많이 사용한다.

 - JDK 1.4 까지는 Generic을 사용하지 않고 객체만 입력 할 수 있다. 
 - JDK 1.5 부터는 Generic을 사용 할 수 있으며 모든 값을 입력할 수가 있다.

   (JDK 1.7에서 Generic은 JDK 1.5와 다른 형태로 사용 할 수 있다.)

 - autoboxing, unboxing 을 이용할 수 있다. 

 

 - list와 다른 점 : 검색의 기능이 없고 중복 데이터를 저장 할 수 없다. (유일한 값만 저장 가능)
                         Iterator를 이용해 검색한다.  
                         입력한 순서대로 출력되지 않는다.

 - 사용방법

※ HashSet 

 

 

1. Set은 인터페이스이기 때문에 직접 객체화가 안되므로 자식클래스를 이용하여 객체화 한다. (is a 관계)

------------------------------------------- JDK 1.4 이하 --------------------------------------------

Set set = new HashSet();          

 

------------------------------------------- JDK 1.5 이상 --------------------------------------------

Generic 미사용 : Set set = new Set();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : Set<String> set = new Set<String>();    // 지정된 데이터형 값만 입력 가능  

 

------------------------------------------- JDK 1.7 이상 --------------------------------------------

Generic 미사용 : Set set = new Set();    // 데이터형에 상관 없이 모든 값 입력 가능

Generic 사용 : Set<String> set = new Set();    // 지정된 데이터형 값만 입력 가능  

 

 

2. 값 추가 : add();

set.add(값);     // 크리가 자동으로 증가한다.   

 

 

3. Set의 크기 구하기 : size();

set.size();    

 

 

4. Set에 들어있는 값 얻기 : 검색이 안되기 때문에 Iterator를 사용한다.(Iterator : pointer를 사용하는 객체)

 

// 인덱스를 사용하지 않고 포인터를 움직여서 데이터를 얻는다.

 Iterator <String> ita = set.Iterator();


    while(ita.hasNext()){      // hasNext();  현재 포인터에서 다음이 있는지?

 

  ita.next();             // next();  값을 얻고 포인터를 이용한다.

  } 

 

 

※ Collection는 검색의 기능이 없어서 Iterator를 사용하여 검색을 해야한다.
 - List와 Set의 부모는 Collection이기 때문에 List도 Iterator를 사용하여 검색 할 수 있다. . 

 

          Collection<String> col = new ArrayList<String>();
          Collection<String> col = new Vector<String>();
          Collection<String> col = new HashSet<String>(); 

 

 

 

출처: http://blog.naver.com/PostList.nhn?blogId=lunatic918&from=postList&categoryNo=1 <더보기>

 

저작자표시 비영리 변경금지

'JAVA' 카테고리의 다른 글

2. 저장된 파일에서 필요한 값 찾기. readLine  (0) 2014.07.23
1. URL 경로 파일 다운로드해서 TXT형 저장하기  (0) 2014.07.23
[Java] 나머지 %  (0) 2014.06.01
Date  (0) 2014.02.01
[JAVA] static , final  (0) 2013.12.18

일단 static과 final을 분리해서 생각하시는게 좋을듯합니다.


static은 사용 시에 객체의 선언 없이 클래스명을 가지고 바로 이용할 때 사용됩니다.


예를 들면

 

public class Exmain {

    // 클래스

    public static class EX1 {    

        public static int x;         // static 변수 선언

        public int y;                  //   일반 변수 선언

    }

    // 사용

    public Exmain() {
        EX1.x = 1;                    // static 변수 사용
        EX1 ex1 = new EX1();    //   일반 변수 사용
        ex1.y = 2;                    //
        System.out.println("x=" + EX1.x + "  y=" + ex1.y);
    }

    // 실행

    public static void main(String[] args) {
        new Exmain();

    }

}

 

이해가 되시는지... 위에서는 변수만 이용했는데 메소드(함수)에 사용할때도 동일합니다.

 

final 은 의미 그대로 최종값을 세팅한다는 거죠 final 다음에는 그 값을 세팅하거나 변경할

수 없습니다.

형태는 변수로 사용될 때는

    final 타입 변수명 = 최종값;  // 포함된 범위에서 변경불가

                                         // 클래스 멤버변수면 클래스 안에서만 고정상수

                                         // 메소드내 변수면 메소드 안에서만 고정상수

메소드 인수로 사용될 때는

    메소드이름(final 인수명) {   // 인수로 넘겨온 값이 메소드 안에서 변경불가

   }

 

이제 예제로 제시해 주신 부분을 보면

1.번 클래스

public class Foo5 {

    // 외부에서 값을 이용할 수 있는 상수

    static final int x = 12;

    // 매개변수로 메소드내에서 상수

    public void  go (final int x){

        // 매개변수로 전달된 상수값 출력 (위의 멤버변수 x가 아님)

        // 멤버변수 x를 사용하려면 this.x를 쓰거나

        // 인수 x를 다른 명칭으로 사용해서 구별해야 합니다.

        System.out.println(x);

    }

}

 

2.번 클래스

public class Foo6 {

    int x =12;

    public static void go (final int y) {    // 인수명을 변경했습니다.

        System.out.println(y);                 // 이러면 안 헷갈리시겠죠

    }

}

 

3.번 클래스

public class Foo3 {
    final int x ;                        // 초기값을 세팅하지 않아서 에러

                                           // final int x = 2; 이런식으로 사용
    public void go () {
        System.out.println(x);
    }
}

// 1번, 2번 클래스 사용 예제를 만들어 보았습니다.

public class Exmain5 {

    public Exmain1() {
        System.out.println("x=" + Foo5.x);     // static 변수
        Foo5 foo = new Foo5();

        foo.go(5);

        foo.go(7);

        Foo6.go(9);                                    // static 함수

        Foo6.go(11);                                  // static 함수
    }

    public static void main(String[] args) {
        new Exmain1();

    }

}

// 실행결과

x=12

5

7

9

11

 

도움이 되셨는지요.... 즐플하세요 ^^

저작자표시 비영리 변경금지

'JAVA' 카테고리의 다른 글

2. 저장된 파일에서 필요한 값 찾기. readLine  (0) 2014.07.23
1. URL 경로 파일 다운로드해서 TXT형 저장하기  (0) 2014.07.23
[Java] 나머지 %  (0) 2014.06.01
Date  (0) 2014.02.01
JCF(Java Collection Framework) : List / Map / Set  (0) 2014.01.18

+ Recent posts

티스토리툴바