मिनट और सेकंड के लिए मिलीसेकंड परिवर्तित?

83

मैंने पिछले प्रश्नों को देखा है, लेकिन मेरे पास कोई उत्तर नहीं था। मैं मिलीसेकंड को स्टॉपवॉच विधि से मिनट और सेकंड में कैसे परिवर्तित करूं? मेरे पास है:

 watch.start();

स्टॉपवॉच शुरू करने के लिए और

  watch.stop();

घड़ी रोकना। मेरे पास बाद में है

  watch.getTime();

जो मिलिसेकंड देता है। मैं चाहता हूं कि यह सेकंड्स और मिनट्स में लौटे। मैं ऐसा करने के बारे में कैसे जाना है? मैं 1000 से गुणा / भाग किए बिना इसे करने का एक तरीका ढूंढ रहा हूं, बल्कि एक ऐसी विधि है जो संपूर्ण गणना को अधिक पठनीय और कम त्रुटि वाला बना देगा।

java  time  type-conversion  stopwatch  watch 
— एवी
स्रोत
x मिलीसेकंड = x / 1000 सेकंड। फिर z सेकंड = z / 60 मिनट। शेष सेकंड की संख्या ज्ञात करने के लिए आप z% 60 कर सकते हैं।
— कोन
4
बुनियादी गणित: 1000 मिलीसेकंड = 1 सेकंड। 60 सेकंड = 1 मिनट।
— मार्क बी
1
इस पोस्ट को देखें: stackoverflow.com/questions/625433/… । आपको जो चाहिए वो आपको मिलना चाहिए।
— bmac151
1
यह वास्तव में एक बहुत ही सरल प्रश्न है। आपने क्या प्रयास किया है?
— मोनिका को बहाल करें -
आप इस तरह
— तैयार

जवाबों:

192

मैं उपयोग करने का सुझाव दूंगा TimeUnit। आप इसे इस तरह से उपयोग कर सकते हैं:

long minutes = TimeUnit.MILLISECONDS.toMinutes(millis);
long seconds = TimeUnit.MILLISECONDS.toSeconds(millis);
— एवी
स्रोत
मेरा एकमात्र मुद्दा यह है कि मुझे नहीं पता: मिलिस को कैसे परिभाषित किया जाए (यह "मिलिस को एक चर के रूप में हल नहीं किया जा सकता है" के रूप में लौट रहा है और मुझे नहीं पता कि इसे System.out.println (); विधि में कैसे एक्सेस किया जाए।
आप इसे केवल संख्याओं का उपयोग करके कर सकते हैं यदि मिलीसेकंड पहले से ही एक लंबे समय जैसा कुछ है। एक साधारण गणना करने के लिए एक नई लाइब्रेरी शुरू करने की बहुत कम आवश्यकता है। minutes = ((milliseconds / 1000) / 60)
— काइल फाल्कनर
2
यह 5 के माध्यम से जावा 5 के लिए सबसे अच्छा जवाब प्रतीत होता है
— शॉन बार्ब्यू
7
@ सोती ब्रिलियंट? यह प्रश्न को संबोधित नहीं करता है! प्रश्न स्टॉपवॉच के रीडआउट के रूप में मिनट और सेकंड के लिए पूछता है , उदाहरण के लिए 1 minute 30 secondsयह उत्तर उदाहरण के लिए मिनट या सेकंड प्रदान करता है 1 minute 90 seconds।
— तुलसी बोरक
1
मैं इसका उपयोग करना चाहूंगा, लेकिन सेकंड के रूप में सेकंड के साथ, नहीं, स्याही, उदाहरण के लिए 1.5 s। क्या यह संभव है?
— लाइन
49

मिलिस को सेकंड (1000 से विभाजित करके) में परिवर्तित करने के बाद, आप / 60मिनट मूल्य प्राप्त करने के लिए उपयोग कर सकते हैं , और % 60(शेष) "सेकंड इन मिनट" मूल्य प्राप्त करने के लिए।

long millis = .....;  // obtained from StopWatch
long minutes = (millis / 1000)  / 60;
int seconds = (int)((millis / 1000) % 60);
— इत्ते ममान
स्रोत
आप इस तरह
— तैयार
25

tl; डॉ

Duration d = Duration.ofMillis( … ) ;
int minutes = d.toMinutesPart() ;
int seconds = d.toSecondsPart() ;

जावा 9 और बाद में

जावा 9 और बाद में, ए बनाएँ Durationऔर to…Partविधियों को कॉल करें । इस मामले में: toMinutesPartऔर toSecondsPart।

अपनी स्टॉपवॉच की शुरुआत और स्टॉप पर कब्जा करें।

Instant start = Instant.now(); 
…
Instant stop = Instant.now();

किसी Durationवस्तु में बीता हुआ समय ।

Duration d = Duration.between( start , stop );

प्रत्येक भाग, मिनट और सेकंड के लिए पूछताछ करें।

int minutes = d.toMinutesPart();
int seconds = d.toSecondsPart();

आप यह भी देखना चाहते हैं कि क्या आपकी स्टॉपवॉच अपेक्षित रूप से लंबी चलेगी।

Boolean ranTooLong = ( d.toDaysPart() > 0 ) || ( d.toHoursPart() > 0 ) ;

जावा 8

जावा 8 में, Durationक्लास में to…Partतरीकों की कमी है। आपको गणित करने की आवश्यकता होगी जैसा कि अन्य उत्तरों में दिखाया गया है।

long entireDurationAsSeconds = d.getSeconds();

या Durationगणित करते हैं।

long minutesPart = d.toMinutes(); 
long secondsPart = d.minusMinutes( minutesPart ).getSeconds() ;

IdeOne.com में लाइव कोड देखें ।

अंतराल: 2016-12-18T08: 39: 34.099Z / 2016-12-18T08: 41: 49.099Z

d.toString (): PT2M15S

d.getSeconds (): 135

बीता हुआ: 2M 15S

संकल्प

FYI करें, nowजावा 8 और जावा 9 के बीच तरीकों का रिज़ॉल्यूशन बदल गया है । इस प्रश्न को देखें ।

  • जावा 9 एक रिज़ॉल्यूशन के साथ ही नैनोसेकंड्स के रूप में पल को कैप्चर करता है। रिज़ॉल्यूशन आपके कंप्यूटर के हार्डवेयर की क्षमता पर निर्भर करता है। मैं macOS सिएरा के साथ मैकबुक प्रो रेटिना पर माइक्रोसेकंड (दशमलव अंश के छह अंक) देखता हूं।
  • Java 8 केवल क्षण को मिलीसेकंड तक कैप्चर करता है। के कार्यान्वयन Clockको मिलीसेकंड के एक संकल्प तक सीमित है। तो आप नैनोसेकंड में मान स्टोर कर सकते हैं लेकिन केवल उन्हें मिलीसेकंड में कैप्चर कर सकते हैं ।

जावा के बारे में

Java.time ढांचे जावा 8 और बाद में बनाया गया है। इन कक्षाओं परेशानी वर्ष प्रतिस्थापित विरासत जैसे तिथि-समय कक्षाएं java.util.Date, Calendar, और SimpleDateFormat।

अधिक जानने के लिए, Oracle ट्यूटोरियल देखें । और कई उदाहरणों और स्पष्टीकरणों के लिए ढेर अतिप्रवाह खोजें। विशिष्टता JSR 310 है ।

Joda समय परियोजना, अब में रखरखाव मोड , प्रवास करने की सलाह देता java.time कक्षाएं।

आप अपने डेटाबेस से सीधे java.time ऑब्जेक्ट्स का आदान-प्रदान कर सकते हैं । JDBC 4.2 या उसके बाद के JDBC ड्राइवर का अनुपालन करें । तार की कोई जरूरत नहीं, कक्षाओं की कोई जरूरत नहीं ।java.sql.*

Java.time कक्षाएं कहाँ से प्राप्त करें?

जावा या एंड्रॉइड के किस संस्करण के साथ उपयोग करने के लिए java.time लाइब्रेरी की तालिका

— तुलसी Bourque
स्रोत
एंड्रॉइड कॉल के लिए एपीआई स्तर 26 की आवश्यकता होती है।
— किलर
@ किलर पहले के एंड्रॉइड के लिए, थ्रीटेन-बैकपोर्ट और थ्रीटेनबप प्रोजेक्ट देखें।
— तुलसी Bourque
12

यह सिर्फ बुनियादी गणित है। 1000 मिलीसेकंड = 1 सेकंड और 60000 मिलीसेकंड = 1 मिनट; तो बस करो,

int seconds=(millis/1000)%60;

long minutes=((millis-seconds)/1000)/60;
— Dulanga
स्रोत
16
एक गलती है - दूसरी पंक्ति होनी चाहिए(millis/1000-seconds)/60
— नायुकी
10

मैं एंड्रॉइड के लिए एक एमपी 3 प्लेयर ऐप बना रहा था, इसलिए मैंने वर्तमान समय और अवधि प्राप्त करने के लिए इसे पसंद किया

 private String millisecondsToTime(long milliseconds) {
    long minutes = (milliseconds / 1000) / 60;
    long seconds = (milliseconds / 1000) % 60;
    String secondsStr = Long.toString(seconds);
    String secs;
    if (secondsStr.length() >= 2) {
        secs = secondsStr.substring(0, 2);
    } else {
        secs = "0" + secondsStr;
    }

    return minutes + ":" + secs;
}
— ZeroErr0r
स्रोत
7

यहाँ पूरा कार्यक्रम है

import java.util.concurrent.TimeUnit;

public class Milliseconds {

public static void main(String[] args) {
    long milliseconds = 1000000;

    // long minutes = (milliseconds / 1000) / 60;
    long minutes = TimeUnit.MILLISECONDS.toMinutes(milliseconds);

    // long seconds = (milliseconds / 1000);
    long seconds = TimeUnit.MILLISECONDS.toSeconds(milliseconds);

    System.out.format("%d Milliseconds = %d minutes\n", milliseconds, minutes );
    System.out.println("Or");
    System.out.format("%d Milliseconds = %d seconds", milliseconds, seconds );

}
}

मुझे यह कार्यक्रम यहां " लिंक " मिला, इसे विस्तार से बताया गया है।

— आशीष यादव
स्रोत
1
यह प्रश्न को संबोधित नहीं करता है । प्रश्न स्टॉपवॉच के रीडआउट के रूप में, मिनट और सेकंड के लिए पूछता है । आप दो अलग-अलग परिणाम, मिनट या सेकंड देते हैं।
— तुलसी बोर्क
6

एक्स मिलीसेकंड = एक्स / 1000 सेकंड = (एक्स / 1000) / 60 मिनट

यदि आपके पास 100,000 मिलीसेकंड हैं, तो इस मूल्य को 1,000 से विभाजित करें और आप 100 सेकंड के साथ छोड़ दें। अब 100/60 = 1.666 ~ मिनट, लेकिन भिन्नात्मक मिनटों का कोई मूल्य नहीं है, इसलिए: शेष को खोजने के लिए 100% 60 = 40 सेकंड करें, फिर पूर्णांक विभाजन 100/60 = 1 मिनट, 40 सेकंड शेष है। उत्तर: 1 मिनट, 40 सेकंड।

— कॉन
स्रोत
5

मिलिस में समय को सीधे मिनटों में बदलने के लिए: दूसरा प्रारूप आप इसका उपयोग कर सकते हैं

String durationText = DateUtils.formatElapsedTime(timeInMillis / 1000));

यह उचित स्वरूपण में समय के साथ एक स्ट्रिंग लौटाएगा। इसने मेरे लिए काम किया।

— Priyankchoudhary
स्रोत
अहा, अच्छा! मैंने सिर्फ एक टाइमर पर परीक्षण किया जो मिलीसेकंड में था और काम किया!
— esQmo_
5

वास्तविक घंटे प्राप्त करने के लिए, घड़ी और सेकंड के रूप में घड़ी पर दिखाई देते हैं इस कोड का प्रयास करें

val sec = (milliSec/1000) % 60
val min = ((milliSec/1000) / 60) % 60
val hour = ((milliSec/1000) / 60) / 60
— हरप्रीत सिंह
स्रोत
5

आप इस तरह आगे बढ़ने की कोशिश कर सकते हैं:

से ms मान पास करें

Long ms = watch.getTime();

सेवा

getDisplayValue(ms)

कोटलिन कार्यान्वयन:

fun getDisplayValue(ms: Long): String {
        val duration = Duration.ofMillis(ms)
        val minutes = duration.toMinutes()
        val seconds = duration.minusMinutes(minutes).seconds

        return "${minutes}min ${seconds}sec"
}

जावा कार्यान्वयन:

public String getDisplayValue(Long ms) {
        Duration duration = Duration.ofMillis(ms);
        Long minutes = duration.toMinutes();
        Long seconds = duration.minusMinutes(minutes).getSeconds();

        return minutes + "min " + seconds "sec"
}
— इरविन नवारोकी
स्रोत
5 
  public static String getIntervalTime(long longInterval) {

    long intMillis = longInterval;
    long dd = TimeUnit.MILLISECONDS.toDays(intMillis);
    long daysMillis = TimeUnit.DAYS.toMillis(dd);
    intMillis -= daysMillis;
    long hh = TimeUnit.MILLISECONDS.toHours(intMillis);
    long hoursMillis = TimeUnit.HOURS.toMillis(hh);
    intMillis -= hoursMillis;
    long mm = TimeUnit.MILLISECONDS.toMinutes(intMillis);
    long minutesMillis = TimeUnit.MINUTES.toMillis(mm);
    intMillis -= minutesMillis;
    long ss = TimeUnit.MILLISECONDS.toSeconds(intMillis);
    long secondsMillis = TimeUnit.SECONDS.toMillis(ss);
    intMillis -= secondsMillis;

    String stringInterval = "%02d days - %02d:%02d:%02d.%03d";
    return String.format(stringInterval , dd, hh, mm, ss, intMillis);
  }

परिक्षण

long delay = 1000*60*20 + 1000*5 + 10;
LOGGER.log(Level.INFO, "Delay Expected {0}", getIntervalTime(delay));

उत्पादन

INFO: Delay Expected 00 days - 00:20:05.010
— joseluisbz
स्रोत
3

मुझे नहीं लगता कि जावा 1.5 समवर्ती समयावधि का समर्थन करता है। अन्यथा, मैं TimeUnit के लिए सुझाव दूंगा। नीचे शुद्ध गणित दृष्टिकोण पर आधारित है।

stopWatch.stop();
long milliseconds = stopWatch.getTime();

int seconds = (int) ((milliseconds / 1000) % 60);
int minutes = (int) ((milliseconds / 1000) / 60);
— मिकी
स्रोत
1

आप आसानी से सेकंड, मिनट और घंटे में मिलिसेकंड को बदल सकते हैं।

                val millis = **milliSecondsYouWantToConvert**
                val seconds = (millis / 1000) % 60
                val minutes = ((millis / 1000) / 60) % 60
                val hours = ((millis / 1000) / 60) / 60

                println("--------------------------------------------------------------------")
                println(String.format("%02dh : %02dm : %02ds remaining", hours, minutes, seconds))
                println("--------------------------------------------------------------------")
**RESULT :** 
--------------------------------------------------------------------
  01h : 23m : 37s remaining
--------------------------------------------------------------------
— कामरान अली
स्रोत
1

नीचे कोड एमएस को मिनट में बदलने के लिए कार्य करता है: [m: ss] प्रारूप के साथ सेक

int seconds;
int minutes;
String Sec;
long Mills = ...;  // Milliseconds goes here
minutes = (int)(Mills / 1000)  / 60;
seconds = (int)((Mills / 1000) % 60);
Sec = seconds+"";

TextView.setText(minutes+":"+Sec);//Display duration [3:40]
— राघव गुप्ता
स्रोत
0 
package com.v3mobi.userpersistdatetime;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Toast;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class UserActivity extends AppCompatActivity {

    Date startDate;
    Date endDate;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_user);
        startDate = java.util.Calendar.getInstance().getTime(); //set your start time
    }

    @Override
    protected void onStop() {
        super.onStop();
        endDate = java.util.Calendar.getInstance().getTime(); // set  your end time

        chekUserPersistence();

    }

    private void chekUserPersistence()
    {
        long duration = endDate.getTime() - startDate.getTime();
//        long duration = 301000;

        long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);         // minutes ok
        long secs = (duration/1000) % 60;         // minutes ok


        Toast.makeText(UserActivity.this, "Diff  "
                +  diffInMinutes + " : "+ secs , Toast.LENGTH_SHORT).show();

        System.out.println("Diff  " + diffInMinutes +" : "+ secs );

        Log.e("keshav","diffInMinutes -->" +diffInMinutes);
        Log.e("keshav","secs -->" +secs);
        finish();
    }
}
— केशव गेरा
स्रोत
-2

यहाँ एक सरल उपाय है। उदाहरण कॉल जिन्हें किसी भी विधि में उपयोग किया जा सकता है:

  • StopWatch.start();
  • StopWatch.stop();

  • StopWatch.displayDiff();प्रारंभ और रोक के बीच मिनट और सेकंड में अंतर प्रदर्शित करता है। (बीता हुआ समय)

    import java.time.Duration;
import java.time.Instant;


public class StopWatch {

    private static Instant start;
    private static Instant stop;

    private void StopWatch() {
        // not called
    }

    public static void start() {
        start = Instant.now();
    }

    public static void stop() {
        stop = Instant.now();
    }

    public static void displayDiff() {
        Duration totalTime = Duration.between(start, stop);
        System.out.println(totalTime.toMinutes() + " Minutes " 
                           + totalTime.toMillis() / 1000 + " Seconds");
    }
}
— R.Lansing
स्रोत
1
गलत। toMillisविधि रिपोर्ट पूरे मिलीसेकेंड के रूप में अवधि।
— बेसिल बोर्के
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.