सेकंड मान को घंटे मिनट सेकंड में बदलें?

109

मैं एक एडिटटेक्स्ट जैसे "1 घंटा 22 मिनट 33 सेकंड" या किसी चीज़ के कुछ सेकंड में एक मान (एक बिगडीकल चर में) में बदलने की कोशिश कर रहा हूं।

मैंने यह कोशिश की है:

String sequenceCaptureTime = "";
BigDecimal roundThreeCalc = new BigDecimal("0");
BigDecimal hours = new BigDecimal("0");
BigDecimal myremainder = new BigDecimal("0");
BigDecimal minutes = new BigDecimal("0");
BigDecimal seconds = new BigDecimal("0");
BigDecimal var3600 = new BigDecimal("3600");
BigDecimal var60 = new BigDecimal("60");

(मेरे पास एक राउंड थ्रीकैल्क है जो सेकंड में मूल्य है इसलिए मैं इसे यहां बदलने की कोशिश करता हूं।)

hours = (roundThreeCalc.divide(var3600));
myremainder = (roundThreeCalc.remainder(var3600));
minutes = (myremainder.divide(var60));
seconds = (myremainder.remainder(var60));
sequenceCaptureTime =  hours.toString() + minutes.toString() + seconds.toString();

फिर मैंने editText को sequnceCaptureTime स्ट्रिंग पर सेट किया। लेकिन वह काम नहीं किया। इसने हर बार ऐप को बंद कर दिया। मैं अपनी गहराई से पूरी तरह से यहाँ हूँ, किसी भी मदद की बहुत सराहना की है। हैप्पी कोडिंग!

java  android  string  android-edittext  bigdecimal 
— Rabbitt
स्रोत
1
— रिचर्ड श्नाइडर
किसी भी कारण से आप BigInteger के बजाय BigDecimal का उपयोग कर रहे हैं?
— टेड हॉप
मुझे एक दूसरे के अंशों को बाद में देव में लागू करना होगा, अभी मैं केवल पहली जगह में काम करने के लिए गणना प्राप्त करने की कोशिश कर रहा हूं।
— रब्बीट
1
मैं रिचर्ड की दूसरी टिप्पणी करता हूं - आप अपने लिए बहुत सारे काम करने के लिए टाइम यूनेट एनम का उपयोग कर सकते हैं। डेवलपर
— बेन जे
मैं समय-सीमा का उपयोग करके बिगडेसिमल से सेकेंड में HHMMSS में बदलने के बारे में कैसे जाऊंगा?
— खरगोश का बच्चा

जवाबों:

65

आपको अधिक भाग्य के साथ होना चाहिए

hours = roundThreeCalc.divide(var3600, BigDecimal.ROUND_FLOOR);
myremainder = roundThreeCalc.remainder(var3600);
minutes = myremainder.divide(var60, BigDecimal.ROUND_FLOOR);
seconds = myremainder.remainder(var60);

यह प्रत्येक विभाजन के बाद दशमलव मान छोड़ देगा।

संपादित करें: यदि वह काम नहीं करता है, तो यह प्रयास करें। (मैंने अभी इसे लिखा और परीक्षण किया है)

public static int[] splitToComponentTimes(BigDecimal biggy)
{
    long longVal = biggy.longValue();
    int hours = (int) longVal / 3600;
    int remainder = (int) longVal - hours * 3600;
    int mins = remainder / 60;
    remainder = remainder - mins * 60;
    int secs = remainder;

    int[] ints = {hours , mins , secs};
    return ints;
}
— बेतरतीब
स्रोत
6
यह समाधान अधिक सुशोभित है: stackoverflow.com/questions/625433/…
— एलेक्स कुचेन्को
@AlexKucherenko को छोड़कर वह समाधान मिलीसेकंड के साथ काम करता है
— मिखाइल
1
@ मिखाइल टाइम यूनीट। #### आपको समय की किसी भी इकाई के साथ करने की अनुमति देगा।
— अमीर ओमिदी
1
जब भी आप अपने आप को समय और दिनांक मानों के साथ गणित करते हुए पाते हैं, तो आपको अपने आप को रोकने और भाषा में सही एपीआई खोजने की आवश्यकता होती है। अगर आपको सिर्फ एचएच: एमएम: एसएस-प्रकार की प्रतिक्रिया की आवश्यकता है, तो आप इसके साथ बेहतर होंगे DateUtils.formatElapsedTime...
— ड्वेटकॉक
229

क्या BigDecimal का उपयोग करना आवश्यक है? यदि आपके पास नहीं है, तो मैं सेकंड के लिए एक इंट या लंबे समय का उपयोग करूंगा, और यह चीजों को थोड़ा सरल करेगा:

hours = totalSecs / 3600;
minutes = (totalSecs % 3600) / 60;
seconds = totalSecs % 60;

timeString = String.format("%02d:%02d:%02d", hours, minutes, seconds);

आप यह सुनिश्चित करने के लिए प्रत्येक को पैड कर सकते हैं कि वे स्ट्रिंग में दो अंकों के मान (या जो भी) हैं, हालांकि।

— Geobits
स्रोत
मुझे एक दूसरे के अंशों को बाद में देव में लागू करना होगा, अभी मैं केवल पहली जगह में काम करने के लिए गणना प्राप्त करने की कोशिश कर रहा हूं।
— रब्बीट
13
String.format("%02d:%02d:%02d", hours, minutes, seconds);
— जेफरी ब्लाटमैन 20
यह बस प्रभावशाली है। मुझे आश्चर्य है कि इस तरह से मापांक कैसे काम कर सकता है।
— PSo
लोकेल का उपयोग करें अन्यथा यह आपको चेतावनी देगा। String.format(Locale.ENGLISH, "%02d:%02d:%02d", hours, minutes, seconds)
— प्रतीक बुटानी
1
जब भी आप अपने आप को समय और दिनांक मानों के साथ गणित करते हुए पाते हैं, तो आपको अपने आप को रोकने और भाषा में सही एपीआई खोजने की आवश्यकता होती है। अगर आपको सिर्फ एचएच: एमएम: एसएस-प्रकार की प्रतिक्रिया की आवश्यकता है, तो आप इसके साथ बेहतर होंगे DateUtils.formatElapsedTime...
— ड्वेटकॉक
75

DateUtils.formatElapsedTime(long), " MM:SS" या " H:MM:SS" रूप में एक बीता समय को प्रारूपित करता है । यह वह स्ट्रिंग लौटाता है जिसे आप ढूंढ रहे हैं। आप यहाँ दस्तावेज़ पा सकते हैं

— ब्लैक बेल्ट
स्रोत
3
यह एक सरल और वास्तव में मुझे क्या चाहिए। मैं दूसरों को इस विधि की सलाह देता हूं
— नबीन
1
यह मत भूलो कि यह सेकंड में पैरामीटर की उम्मीद करता है। तो आपको मिलिस को सेकंड में बदलने की जरूरत है
— किरान्किंग
28

यहाँ काम कर कोड है:

private String getDurationString(int seconds) {

    int hours = seconds / 3600;
    int minutes = (seconds % 3600) / 60;
    seconds = seconds % 60;

    return twoDigitString(hours) + " : " + twoDigitString(minutes) + " : " + twoDigitString(seconds);
}

private String twoDigitString(int number) {

    if (number == 0) {
        return "00";
    }

    if (number / 10 == 0) {
        return "0" + number;
    }

    return String.valueOf(number);
}
— रहीम
स्रोत
3
मुझे यह उत्तर पसंद है लेकिन आपको '% 10' को '/ 10' में बदलने की आवश्यकता है
— हकीम जायद
जब भी आप अपने आप को समय और दिनांक मानों के साथ गणित करते हुए पाते हैं, तो आपको अपने आप को रोकने और भाषा में सही एपीआई खोजने की आवश्यकता होती है। अगर आपको सिर्फ एचएच: एमएम: एसएस-प्रकार की प्रतिक्रिया की आवश्यकता है, तो आप इसके साथ बेहतर होंगे DateUtils.formatElapsedTime...
— ड्वेटकॉक
28

जावा 8 में वास्तव में कुछ सहायक

import java.time.LocalTime;

private String ConvertSecondToHHMMSSString(int nSecondTime) {
    return LocalTime.MIN.plusSeconds(nSecondTime).toString();
}
— Epicurist
स्रोत
नोट: गणना प्लससैंड्स (लंबे सेकंड) का उपयोग करते समय आधी रात के आसपास लपेटता है, उदाहरण के लिए: यदि सेकंड 86400 (24 घंटे) है तो यह 00:00 आउटपुट करता है।
— कार्ति
यह वही करता है जिसका नाम 'ConvertSecondToHHMMSSString' बताता है। अन्य (थकाऊ) समाधान भी चारों ओर लपेट रहे हैं।
— एपिक्यूरिस्ट
@Epicurist यह वह समाधान था जिसकी मुझे तलाश थी! बहुत अधिक सुरुचिपूर्ण और अन्य सभी की तुलना में! :)
— पाउलो ओलिवेरा
20

मुझे लगता है कि जावा टाइमटाइम लाइब्रेरी में निर्मित है

long seconds = TimeUnit.MINUTES.toSeconds(8);
— Ajji
स्रोत
12 
private String ConvertSecondToHHMMString(int secondtTime)
{
  TimeZone tz = TimeZone.getTimeZone("UTC");
  SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss");
  df.setTimeZone(tz);
  String time = df.format(new Date(secondtTime*1000L));

  return time;

}
— खोपड़ी
स्रोत
कोड क्या करता है और यह कैसे समस्या हल करता है, यह बताकर आप अपने उत्तर को और बेहतर बना सकते हैं
— ;;
9

यह मेरा सरल उपाय है:

String secToTime(int sec) {
    int seconds = sec % 60;
    int minutes = sec / 60;
    if (minutes >= 60) {
        int hours = minutes / 60;
        minutes %= 60;
        if( hours >= 24) {
            int days = hours / 24;
            return String.format("%d days %02d:%02d:%02d", days,hours%24, minutes, seconds);
        }
        return String.format("%02d:%02d:%02d", hours, minutes, seconds);
    }
    return String.format("00:%02d:%02d", minutes, seconds);
}

Test Results: 

Result: 00:00:36 - 36
Result: 01:00:07 - 3607
Result: 6313 days 12:39:05 - 545488745
— शोहन अहमद सिजान
स्रोत
6

मैं चीजों को सरल रखना पसंद करता हूं इसलिए:

    int tot_seconds = 5000;
    int hours = tot_seconds / 3600;
    int minutes = (tot_seconds % 3600) / 60;
    int seconds = tot_seconds % 60;

    String timeString = String.format("%02d Hour %02d Minutes %02d Seconds ", hours, minutes, seconds);

    System.out.println(timeString);

परिणाम होगा: 01 घंटा 23 मिनट 20 सेकंड

— Nello
स्रोत
सबसे छोटा जवाब, बहुत बढ़िया
— Kaveh Garshasp
5

यदि आप इकाइयों चाहते हैं h , minऔर secएक अवधि के लिए आप इसका उपयोग कर सकते हैं:

public static String convertSeconds(int seconds) {
    int h = seconds/ 3600;
    int m = (seconds % 3600) / 60;
    int s = seconds % 60;
    String sh = (h > 0 ? String.valueOf(h) + " " + "h" : "");
    String sm = (m < 10 && m > 0 && h > 0 ? "0" : "") + (m > 0 ? (h > 0 && s == 0 ? String.valueOf(m) : String.valueOf(m) + " " + "min") : "");
    String ss = (s == 0 && (h > 0 || m > 0) ? "" : (s < 10 && (h > 0 || m > 0) ? "0" : "") + String.valueOf(s) + " " + "sec");
    return sh + (h > 0 ? " " : "") + sm + (m > 0 ? " " : "") + ss;
}

int seconds = 3661;
String duration = convertSeconds(seconds);

यह सशर्त ऑपरेटरों का एक बहुत है। विधि उन तारों को लौटा देगी:

0    -> 0 sec
5    -> 5 sec
60   -> 1 min
65   -> 1 min 05 sec
3600 -> 1 h
3601 -> 1 h 01 sec
3660 -> 1 h 01
3661 -> 1 h 01 min 01 sec
108000 -> 30 h
— निकोलस
स्रोत
अच्छा समाधान (Y)
— अक्षय रयानी
4

यह कोड ठीक काम कर रहा है:

txtTimer.setText(String.format("%02d:%02d:%02d",(SecondsCounter/3600), ((SecondsCounter % 3600)/60), (SecondsCounter % 60)));
— Chathura
स्रोत
4

ग्रेगोरियन कैलेन्डर का उपयोग करने का एक अच्छा और आसान तरीका

परियोजना में इन्हें आयात करें:

import java.util.GregorianCalendar;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Scanner;

और तब:

Scanner s = new Scanner(System.in);

System.out.println("Seconds: ");
int secs = s.nextInt();

GregorianCalendar cal = new GregorianCalendar(0,0,0,0,0,secs);
Date dNow = cal.getTime();
SimpleDateFormat ft = new SimpleDateFormat("HH 'hours' mm 'minutes' ss 'seconds'");
System.out.println("Your time: " + ft.format(dNow));
— कॉनर काउलिंग
स्रोत
1
मुझे यह पसंद है!
— eduyayo
2

मैं इसका उपयोग करता हूं:

 public String SEG2HOR( long lnValue) {     //OK
        String lcStr = "00:00:00";
        String lcSign = (lnValue>=0 ? " " : "-");
        lnValue = lnValue * (lnValue>=0 ? 1 : -1); 

        if (lnValue>0) {                
            long lnHor  = (lnValue/3600);
            long lnHor1 = (lnValue % 3600);
            long lnMin  = (lnHor1/60);
            long lnSec  = (lnHor1 % 60);            

                        lcStr = lcSign + ( lnHor < 10 ? "0": "") + String.valueOf(lnHor) +":"+
                              ( lnMin < 10 ? "0": "") + String.valueOf(lnMin) +":"+
                              ( lnSec < 10 ? "0": "") + String.valueOf(lnSec) ;
        }

        return lcStr;           
    }
— cesin
स्रोत
2

समस्या का समाधान करने का मेरा कार्य यहाँ है:

public static String getConvertedTime(double time){

    double h,m,s,mil;

    mil = time % 1000;
    s = time/1000;
    m = s/60;
    h = m/60;
    s = s % 60;
    m = m % 60;
    h = h % 24;

    return ((int)h < 10 ? "0"+String.valueOf((int)h) : String.valueOf((int)h))+":"+((int)m < 10 ? "0"+String.valueOf((int)m) : String.valueOf((int)m))
            +":"+((int)s < 10 ? "0"+String.valueOf((int)s) : String.valueOf((int)s))
            +":"+((int)mil > 100 ? String.valueOf((int)mil) : (int)mil > 9 ? "0"+String.valueOf((int)mil) : "00"+String.valueOf((int)mil));
}
— leokash
स्रोत
क्यों इस शिशु के लिए आवश्यक टाइप्स को स्टोर करने के लिए डबल टाइप किए गए चर का उपयोग करना है?
— एपिक्यूरिस्ट
2

मुझे पता है कि यह बहुत पुराना है, लेकिन जावा 8 में:

LocalTime.MIN.plusSeconds(120).format(DateTimeFormatter.ISO_LOCAL_TIME)
— Causteau
स्रोत
2

केवल कुछ मिनटों और सेकंड के लिए इसका उपयोग करें 

String.format("%02d:%02d", (seconds / 3600 * 60 + ((seconds % 3600) / 60)), (seconds % 60))
— Asthme
स्रोत
1

मैं इसका उपयोग अजगर में घंटे, मिनट, सेकंड, और माइक्रोसेकंड के लिए सेकंड का प्रतिनिधित्व करने वाले फ्लोट में परिवर्तित करने के लिए करता हूं। यह यथोचित रूप से सुरुचिपूर्ण है और इसे बदलने के लिए स्ट्रैप्टम के माध्यम से डेटाइम प्रकार में परिवर्तित करने के लिए आसान है। जरूरत पड़ने पर इसे आसानी से लंबे अंतराल (सप्ताह, महीने आदि) तक बढ़ाया जा सकता है।

    def sectohmsus(seconds):
        x = seconds
        hmsus = []
        for i in [3600, 60, 1]:  # seconds in a hour, minute, and second
            hmsus.append(int(x / i))
            x %= i
        hmsus.append(int(round(x * 1000000)))  # microseconds
        return hmsus  # hours, minutes, seconds, microsecond
— rtphokie
स्रोत
1

मैंने सबसे अच्छा तरीका और कम कोड की कोशिश की है, लेकिन हो सकता है कि यह समझना थोड़ा मुश्किल हो कि मैंने अपना कोड कैसे लिखा लेकिन अगर आप गणित में अच्छे हैं तो यह कितना आसान है 

import java.util.Scanner;

कक्षा घंटे {

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    double s;


    System.out.println("how many second you have ");
    s =input.nextInt();



     double h=s/3600;
     int h2=(int)h;

     double h_h2=h-h2;
     double m=h_h2*60;
     int m1=(int)m;

     double m_m1=m-m1;
     double m_m1s=m_m1*60;






     System.out.println(h2+" hours:"+m1+" Minutes:"+Math.round(m_m1s)+" seconds");





}

}

अधिक सही है!

— अबदिहाकिम यूसुफ अदन
स्रोत
1

जावा 8 के साथ, आप आसानी से स्ट्रिंग प्रारूप में समय प्राप्त कर सकते हैं जैसे कि,

LocalTime.ofSecondOfDay(86399L)

यहां, दिए गए मान को अधिकतम 24 घंटे तक बदलने की अनुमति है और परिणाम होगा 

23:59:59

पेशेवरों: 1) मैन्युअल रूप से परिवर्तित करने और एकल अंक के लिए 0 को जोड़ने की कोई आवश्यकता नहीं है

विपक्ष: केवल 24 घंटे तक काम करें

— चिराग शाह
स्रोत
1

जावा 8 के साथ, आप आसानी से स्थानीय सेकंड प्रारूप में समय प्राप्त कर सकते हैं जैसे कि,

LocalTime.ofSecondOfDay(86399L)

यहां, दिए गए मान को अधिकतम 24 घंटे तक बदलने की अनुमति है और परिणाम होगा 

23:59:59

पेशेवरों: 1) मैन्युअल रूप से परिवर्तित करने और एकल अंक के लिए 0 को जोड़ने की कोई आवश्यकता नहीं है

विपक्ष: केवल 24 घंटे तक काम करें

— चिराग शाह
स्रोत
1

Java.time से अवधि

    BigDecimal secondsValue = BigDecimal.valueOf(4953);
    if (secondsValue.compareTo(BigDecimal.valueOf(Long.MAX_VALUE)) > 0) {
        System.out.println("Seconds value " + secondsValue + " is out of range");
    } else {
        Duration dur = Duration.ofSeconds(secondsValue.longValueExact());
        long hours = dur.toHours();
        int minutes = dur.toMinutesPart();
        int seconds = dur.toSecondsPart();

        System.out.format("%d hours %d minutes %d seconds%n", hours, minutes, seconds);
    }

इस स्निपेट से आउटपुट है:

1 घंटे 22 मिनट 33 सेकंड

यदि BigDecimalइस कोड में गैर-शून्य अंश दूसरा होता, तो यह काम नहीं करता क्योंकि यह खड़ा होता है, लेकिन आप इसे संशोधित करने में सक्षम हो सकते हैं। कोड जावा 9 और बाद में काम करता है। जावा 8 Durationमें घंटे मिनट और सेकंड से रूपांतरण थोड़ा और अधिक चिंताजनक है, नीचे दिए गए लिंक को देखें कि कैसे। मैं शब्दों का सही एकवचन या बहुवचन रूप ( घंटे या घंटे) चुनने के लिए आपके पास जा रहा हूं , आदि) ।

लिंक

— ओले वी.वी.
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.