밀리 초가 있습니다. 날짜 형식으로 변환해야합니다.

예:

2011 년 10 월 23 일

그것을 달성하는 방법?

이 샘플 코드를 사용해보십시오 :-

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;


public class Test {

/**
 * Main Method
 */
public static void main(String[] args) {
    System.out.println(getDate(82233213123L, "dd/MM/yyyy hh:mm:ss.SSS"));
}


/**
 * Return date in specified format.
 * @param milliSeconds Date in milliseconds
 * @param dateFormat Date format 
 * @return String representing date in specified format
 */
public static String getDate(long milliSeconds, String dateFormat)
{
    // Create a DateFormatter object for displaying date in specified format.
    SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);

    // Create a calendar object that will convert the date and time value in milliseconds to date. 
     Calendar calendar = Calendar.getInstance();
     calendar.setTimeInMillis(milliSeconds);
     return formatter.format(calendar.getTime());
}
}

도움이 되었기를 바랍니다.

밀리 초 값을 Date인스턴스로 변환하고 선택한 포맷터에 전달합니다.

SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy"); 
String dateString = formatter.format(new Date(dateInMillis)));

public static String convertDate(String dateInMilliseconds,String dateFormat) {
    return DateFormat.format(dateFormat, Long.parseLong(dateInMilliseconds)).toString();
}

이 함수를 호출

convertDate("82233213123","dd/MM/yyyy hh:mm:ss");

DateFormat.getDateInstance().format(dateInMS);

이 코드를 시도하면 도움이 될 수 있으며 필요에 맞게 수정하십시오.

SimpleDateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss z yyyy");
Date d = format.parse(fileDate);

마침내 나를 위해 작동하는 일반 코드를 찾았습니다.

Long longDate = Long.valueOf(date);

Calendar cal = Calendar.getInstance();
int offset = cal.getTimeZone().getOffset(cal.getTimeInMillis());
Date da = new Date(); 
da = new Date(longDate-(long)offset);
cal.setTime(da);

String time =cal.getTime().toLocaleString(); 
//this is full string        

time = DateFormat.getTimeInstance(DateFormat.MEDIUM).format(da);
//this is only time

time = DateFormat.getDateInstance(DateFormat.MEDIUM).format(da);
//this is only date

tl; dr

Instant.ofEpochMilli( myMillisSinceEpoch )           // Convert count-of-milliseconds-since-epoch into a date-time in UTC (`Instant`).
    .atZone( ZoneId.of( "Africa/Tunis" ) )           // Adjust into the wall-clock time used by the people of a particular region (a time zone). Produces a `ZonedDateTime` object.
    .toLocalDate()                                   // Extract the date-only value (a `LocalDate` object) from the `ZonedDateTime` object, without time-of-day and without time zone.
    .format(                                         // Generate a string to textually represent the date value.
        DateTimeFormatter.ofPattern( "dd/MM/uuuu" )  // Specify a formatting pattern. Tip: Consider using `DateTimeFormatter.ofLocalized…` instead to soft-code the formatting pattern.
    )                                                // Returns a `String` object.

java.time

현대적인 접근 방식은 다른 모든 Answers에서 사용하는 귀찮은 이전 레거시 날짜-시간 클래스를 대체 하는 java.time 클래스를 사용합니다 .

longUTC 1970-01-01T00 : 00 : 00Z에서 1970 년 첫 순간의 epoch 참조 이후 몇 밀리 초가 있다고 가정합니다 .

Instant instant = Instant.ofEpochMilli( myMillisSinceEpoch ) ;

날짜를 얻으려면 시간대가 필요합니다. 주어진 순간에 날짜는 지역별로 전 세계적으로 다릅니다.

ZoneId z = ZoneId.of( "Pacific/Auckland" ) ;
ZonedDateTime zdt = instant.atZone( z ) ;  // Same moment, different wall-clock time.

날짜 전용 값을 추출하십시오.

LocalDate ld = zdt.toLocalDate() ;

표준 ISO 8601 형식을 사용하여 해당 값을 나타내는 문자열을 생성합니다.

String output = ld.toString() ;

사용자 지정 형식으로 문자열을 생성합니다.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd/MM/uuuu" ) ;
String output = ld.format( f ) ;

팁 : 형식화 패턴을 하드 코딩하는 대신 java.time이 자동으로 현지화 되도록하십시오 . DateTimeFormatter.ofLocalized…방법을 사용하십시오 .

java.time 정보

java.time의 프레임 워크는 나중에 자바 8에 내장되어 있습니다. 이 클래스는 까다로운 기존에 대신 기존 과 같은 날짜 - 시간의 수업을 java.util.Date, Calendar, SimpleDateFormat.

Joda 타임 프로젝트는 지금에 유지 관리 모드 의로 마이그레이션을 조언 java.time의 클래스.

자세한 내용은 Oracle Tutorial을 참조하십시오 . 그리고 많은 예제와 설명을 위해 Stack Overflow를 검색하십시오. 사양은 JSR 310 입니다.

java.time 객체를 데이터베이스와 직접 교환 할 수 있습니다 . JDBC 4.2 이상을 준수 하는 JDBC 드라이버를 사용하십시오 . 문자열이나 클래스 가 필요하지 않습니다 .java.sql.*

java.time 클래스는 어디서 구할 수 있습니까?

• 자바 SE 8 , 자바 SE 9 , 나중에
  • 내장.
  • 번들로 구현 된 표준 Java API의 일부입니다.
  • Java 9에는 몇 가지 사소한 기능과 수정 사항이 추가되었습니다.
• Java SE 6 및 Java SE 7
  • java.time 기능의 대부분은 ThreeTen-Backport의 Java 6 및 7로 백 포트됩니다 .
• 기계적 인조 인간
  • java.time 클래스의 최신 버전의 Android 번들 구현.
  • 이전 Android (<26)의 경우 ThreeTenABP 프로젝트는 ThreeTen-Backport (위에서 언급)를 채택합니다 . ThreeTenABP 사용 방법…을 참조하십시오 .

ThreeTen - 추가 프로젝트 추가 클래스와 java.time를 확장합니다. 이 프로젝트는 java.time에 향후 추가 될 수있는 가능성을 입증하는 곳입니다. 당신은 여기에 몇 가지 유용한 클래스와 같은 찾을 수 있습니다 Interval, YearWeek, YearQuarter, 그리고 더 .

짧고 효과적 :

DateFormat.getDateTimeInstance().format(new Date(myMillisValue))

public class LogicconvertmillistotimeActivity extends Activity {
    /** Called when the activity is first created. */
     EditText millisedit;
        Button   millisbutton;
        TextView  millistextview;
        long millislong;
        String millisstring;
        int millisec=0,sec=0,min=0,hour=0;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        millisedit=(EditText)findViewById(R.id.editText1);
        millisbutton=(Button)findViewById(R.id.button1);
        millistextview=(TextView)findViewById(R.id.textView1);
        millisbutton.setOnClickListener(new View.OnClickListener() {            
            @Override
            public void onClick(View v) {   
                millisbutton.setClickable(false);
                millisec=0;
                sec=0;
                min=0;
                hour=0;
                millisstring=millisedit.getText().toString().trim();
                millislong= Long.parseLong(millisstring);
                Calendar cal = Calendar.getInstance();
                SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
                if(millislong>1000){
                    sec=(int) (millislong/1000);
                    millisec=(int)millislong%1000;
                    if(sec>=60){
                        min=sec/60;
                        sec=sec%60;
                    }
                    if(min>=60){
                        hour=min/60;
                        min=min%60;
                    }
                }
                else
                {
                    millisec=(int)millislong;
                }
                cal.clear();
                cal.set(Calendar.HOUR_OF_DAY,hour);
                cal.set(Calendar.MINUTE,min);
                cal.set(Calendar.SECOND, sec);
                cal.set(Calendar.MILLISECOND,millisec);
                String DateFormat = formatter.format(cal.getTime());
//              DateFormat = "";
                millistextview.setText(DateFormat);

            }
        });
    }
}

    public static Date getDateFromString(String date) {

    Date dt = null;
    if (date != null) {
        for (String sdf : supportedDateFormats) {
            try {
                dt = new Date(new SimpleDateFormat(sdf).parse(date).getTime());
                break;
            } catch (ParseException pe) {
                pe.printStackTrace();
            }
        }
    }
    return dt;
}

public static Calendar getCalenderFromDate(Date date){
    Calendar cal =Calendar.getInstance();
    cal.setTime(date);return cal;

}
public static Calendar getCalenderFromString(String s_date){
    Date date = getDateFromString(s_date);
    Calendar cal = getCalenderFromDate(date);
    return cal;
}

public static long getMiliSecondsFromString(String s_date){
    Date date = getDateFromString(s_date);
    Calendar cal = getCalenderFromDate(date);
    return cal.getTimeInMillis();
}

나는 이것을 꽤 오랫동안 수행하는 효율적인 방법을 찾고 있었고 내가 찾은 최선의 방법은 다음과 같습니다.

DateFormat.getDateInstance(DateFormat.SHORT).format(new Date(millis));

장점 :

1. 현지화 됨
2. API 1 이후 Android 사용
3. 아주 간단

단점 :

1. 제한된 형식 옵션. 참고 : SHORT는 2 자리 연도입니다.
2. 매번 Date 객체를 굽습니다. 다른 옵션에 대한 소스를 살펴 보았으며 이는 오버 헤드에 비해 상당히 사소합니다.

java.text.DateFormat 객체를 캐시 할 수 있지만 스레드 세이프가 아닙니다. UI 스레드에서 사용하는 경우 괜찮습니다.

public static String toDateStr(long milliseconds, String format)
{
    Date date = new Date(milliseconds);
    SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.US);
    return formatter.format(date);
}

Android N 이상에서는 SimpleDateFormat을 사용합니다. 예를 들어 이전 버전의 달력을 사용하십시오.

if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        fileName = new SimpleDateFormat("yyyy-MM-dd-hh:mm:ss").format(new Date());
        Log.i("fileName before",fileName);
    }else{
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH,1);
        String zamanl =""+cal.get(Calendar.YEAR)+"-"+cal.get(Calendar.MONTH)+"-"+cal.get(Calendar.DAY_OF_MONTH)+"-"+cal.get(Calendar.HOUR_OF_DAY)+":"+cal.get(Calendar.MINUTE)+":"+cal.get(Calendar.SECOND);

        fileName= zamanl;
        Log.i("fileName after",fileName);
    }

출력 :
fileName before : 2019-04-12-07 : 14 : 47  // SimpleDateFormat 사용
fileName after : 2019-4-12-7 : 13 : 12        // Calender 사용

Kotlin을 사용하는 가장 쉬운 방법입니다.

private const val DATE_FORMAT = "dd/MM/yy hh:mm"

fun millisToDate(millis: Long) : String {
    return SimpleDateFormat(DATE_FORMAT, Locale.US).format(Date(millis))
}

밀리 초 단위로 java.util.Date를 생성 할 수 있습니다. 그런 다음 java.text.DateFormat을 사용하여 문자열로 변환합니다.