मुझे JSP / Java में डबल से पूरे और भिन्नात्मक भाग कैसे मिलते हैं?

104

मुझे JSP / Java में डबल से पूरे और भिन्नात्मक भाग कैसे मिलते हैं? यदि मान 3.25 है तो मैं प्राप्त करना चाहता हूं fractional =.25,whole = 3

हम जावा में यह कैसे कर सकते हैं?

java  math  jsp 
— विनायक बेविनकत्ती
स्रोत
4
आपको लगता है कि मंटिसा और प्रतिपादक क्या हैं, इसका एक गलत विचार है। वे केवल "संपूर्ण भाग" और "आंशिक भाग" नहीं हैं। देखें en.wikipedia.org/wiki/Floating_point
— जॉन स्कीट
वास्तव में मैंने 'हे ​​.. जाने से पहले लगभग 5 पोस्ट पढ़ी हैं, जिसे एक्सपोज़र नहीं कहा जाता'। मेरे मस्तिष्क ने शब्दों को बाहर फेंक दिया और समस्या को हल करना शुरू कर दिया .. प्रोग्रामिंग सामान पढ़ने की बुरी आदतों ने मुझे दिया :)
— गिशु
1
अन्य कारणों के बीच उत्तरोत्तर प्रश्न के लिए कृपया ओपी .. पर सवाल उठाएं।
— गिशु
1
एक होमवर्क समस्या की तरह संदिग्ध लगता है।
— ब्रायन नोबलुच
ओह अछा। मैं पहले से ही कैसे वह इतना अजीब परिणाम प्राप्त होता है सोचा
— litb - Johannes Schaub

जवाबों:

102

http://www.java2s.com/Code/Java/Data-Type/Obtainingtheintegerandfractionalparts.htm

double num;
long iPart;
double fPart;

// Get user input
num = 2.3d;
iPart = (long) num;
fPart = num - iPart;
System.out.println("Integer part = " + iPart);
System.out.println("Fractional part = " + fPart);

आउटपुट:

Integer part = 2
Fractional part = 0.2999999999999998
— Gishu
स्रोत
61
वास्तव में यह पृष्ठ "Google पर आंशिक और डबल जावा से पूरे भाग के लिए खोज" पर पहली हिट है =))
— क्रिस
12
वास्तव में यह उत्तर गलत है, लंबे समय से बड़े मूल्यों के लिए यह प्रतिनिधित्व कर सकता है कि यह भिन्नात्मक भाग में बड़ी संख्या देगा। नीचे डैन विंटन का जवाब सरल है और हमेशा सही परिणाम देता है।
— arberg
2
इसलिए वास्तव में, यह सही नहीं है, जैसा कि आप आउटपुट में देख सकते हैं। इनपुट 3 का अंश है और आउटपुट 29999999 है ... डबल के बजाय बिगडेसिमल का उपयोग करने से चाल चलेगी
— एलेक्स
2
@Alex नहीं, इनपुट एक संख्या है जो बहुत करीब है 2.3, लेकिन निश्चित रूप से नहीं 2.3। और आउटपुट में कुछ भी गलत नहीं है, जब तक कि आप 10 से अधिक वैध अंक नहीं चाहते हैं। आपको केवल प्रत्येक आउटपुट (जैसे, प्रारूप %.9f) में कुछ राउंडिंग की आवश्यकता होती है जो आमतौर पर दर्द की तुलना में कम है BigDecimal। यहां एकमात्र समस्या अतिप्रवाह है।
— मआर्टिनस
1
डबल को इंट में बदलना लगभग हमेशा एक बुरा विचार है। क्योंकि उदाहरण के लिए (long)1.0e100आपके लिए 0. बहुत बार आपको डबल मूल्य की आवश्यकता होगी बस "फ्लोर्ड" जिसके लिए वहाँ है floor()। यदि आप अभिन्न और अंश दोनों भागों का उपयोग करना चाहते हैं modf()। वाकई, यह एक बुरा जवाब है।
— मोजुबा
155 
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
— दान विंटन
स्रोत
12
यह क्यों ठुकराया गया है? ठीक काम करता है, और मेरे संपादन के साथ नकारात्मक मूल्यों के साथ भी काम करेगा।
— HRJ
पूर्णांक भाग => लंबा लॉन्गपार्ट = (लंबा) 3.25
— jdurango
2
नकारात्मक काम नहीं करेगा। मान। यानी -3.25% 1 = 0.75 0.25 नहीं। तो इंटीग्रलपार्ट -3.25 - 0.75 = -4 होगा।
— विंडराइडर
2
@IndRider, मैंने नकारात्मक .. और उसके कार्यों के लिए जाँच की .. हालाँकि दशमलव स्थानों के लिए जो संख्या में छोटे हैं, थोड़ी सी भी त्रुटि होगी। पूर्व। -०३.००२५ के लिए यह रिटर्न -0.0024999999999999467 और -3.0
— justshams
5
यहाँ भ्रम इसलिए है क्योंकि कुछ भाषाएँ, जैसे कि पायथन, %माध्यूलो ( -3.25 % 1 == 0.75) और अन्य का उपयोग करती हैं, जैसे कि जावा, फोरट्रान, सी और सी ++, का %अर्थ है शेष ( -3.25 % 1 == -0.25) का उपयोग करें । हो सकता है कि विंडराइडर ने शीघ्रता के लिए इसे पायथन आरईपीएल में टाइप किया हो, लेकिन यह उत्तर भ्रामक है क्योंकि यह सवाल जेवीएम के बारे में है।
— जिम पीवार्स्की
24

चूँकि इस 1 साल पुराने प्रश्न को किसी ऐसे व्यक्ति ने दबाया था जिसने प्रश्न विषय को सही किया था, और इस प्रश्न के साथ टैग किया गया है jsp, और यहाँ कोई भी एक JSP लक्षित उत्तर देने में सक्षम नहीं था, यहाँ मेरा JSP- लक्षित योगदान है।

उपयोग JSTL (बस छोड़ JSTL-1.2.jar में /WEB-INF/lib) fmt taglib। एक <fmt:formatNumber>टैग है जो वास्तव में वही करता है जो आप चाहते हैं और काफी आसान तरीके से maxFractionDigitsऔर maxIntegerDigitsविशेषताओं की मदद से ।

यहाँ एक SSCCE है , बस इसे copy'n'paste'n'r'un करें।

<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

<%
    // Just for quick prototyping. Don't do this in real! Use servlet/javabean.
    double d = 3.25;
    request.setAttribute("d", d);
%>

<!doctype html>
<html lang="en">
    <head>
        <title>SO question 343584</title>
    </head>
    <body>
        <p>Whole: <fmt:formatNumber value="${d}" maxFractionDigits="0" />
        <p>Fraction: <fmt:formatNumber value="${d}" maxIntegerDigits="0" />
    </body>
</html>

आउटपुट:

सम्पूर्ण: ३

अंश: ।25

बस। कच्चे जावा कोड की मदद से इसे मालिश करने की आवश्यकता नहीं है।

— BalusC
स्रोत
8

भिन्नात्मक और पूरे भाग के बजाय प्रतिपादक और मंटिसा से पूछा गया मूल प्रश्न।

प्रतिपादक और मंटिसा को एक डबल से प्राप्त करने के लिए आप इसे IEEE 754 प्रतिनिधित्व में बदल सकते हैं और बिट्स को इस तरह से निकाल सकते हैं:

long bits = Double.doubleToLongBits(3.25);

boolean isNegative = (bits & 0x8000000000000000L) != 0; 
long exponent      = (bits & 0x7ff0000000000000L) >> 52;
long mantissa      =  bits & 0x000fffffffffffffL;
— रासमस फेबर
स्रोत
पहली बार सेट नहीं किया गया मंटिंसा का पहला बिट नहीं है, इसलिए मंटिसा होना चाहिए (बिट्स और 0x000fffffffffffL) | 0x0010000000000000L?
— अग्नुल
रैसमस यह एक आरईटी आउटपुट आउटपुट नहीं था: एक्सपोनेंट 0 और मैन्टिसा 2814749767106560 और अगर आप urs का चयन करते हैं तो मैन्टिसा एग्नुल 0 है
— विनायक बेविनकट्टी 12
4 वोटों के साथ टूटी हुई :) हालांकि मैं देख रहा हूं कि कोड अपने जोड़ों पर दोगुना मूल्य लेने के साथ क्या करने की कोशिश कर रहा है, कोड सही मानों का उत्पादन नहीं करता है।
— गिशु
@ नागुल: मुझे लगता है कि "मंटिसा" आमतौर पर बिट्स के मूल्य को संदर्भित करता है। आप इसे केवल (कभी-कभी) 1 बिट के लिए महत्व देकर इसे बदल सकते हैं। लेकिन विकिपीडिया के अनुसार, मंटिसा शब्द अब "अंश" के पक्ष में पदावनत हो गया है।
— रासमस फेबर
5

मुख्य तर्क आपको पहले यह पता लगाना होगा कि दशमलव बिंदु के बाद कितने अंक हैं।
यह कोड 16 अंकों तक किसी भी संख्या के लिए काम करता है। यदि आप BigDecimal का उपयोग करते हैं तो आप इसे केवल 18 अंकों तक चला सकते हैं। इनपुट मान (आपकी संख्या) को चर "संख्या" पर रखें, यहां एक उदाहरण के रूप में मैंने इसे कठिन कोडित किया है।

double num, temp=0;
double frac,j=1;

num=1034.235;
// FOR THE FRACTION PART
do{
j=j*10;
temp= num*j;
}while((temp%10)!=0);       

j=j/10;
temp=(int)num;
frac=(num*j)-(temp*j);

System.out.println("Double number= "+num);      
System.out.println("Whole part= "+(int)num+" fraction part= "+(int)frac);
— OnePunchMan
स्रोत
यार, यह एक साधारण समस्या के लिए एक अत्यंत जटिल उत्तर है। क्या आपने स्वीकृत जवाब पर एक नज़र डाली?
— ग्रे
1
अब जिस व्यक्ति ने डाउन-वोट किया (मुझे btw नहीं), यह बताना चाहिए था कि डाउन-वोट क्यों था। यह अच्छा नहीं है। लेकिन हम सभी का स्कोर किसी ना किसी मौके पर 1 रहा।
— ग्रे
2
@ प्रश्न 3.25 को '3' और '25' के रूप में अलग करना था, और स्वीकृत उत्तर कभी भी '25' नहीं देगा, यह हमेशा '2599999999' देगा
— OnePunchMan
@ मुझे पता है कि किसने इसे डाउनवोट किया था, यह एक लड़का था जिसका नाम Eji (पुराना उपयोगकर्ता) था जो मेरी हर टिप्पणी, उत्तर और सवालों का मज़ाक उड़ाता था, जो मैं इस ब्लॉग में पोस्ट करता हूँ। अंत में मैं मॉडरेटर से शिकायत करता हूं।
— वनपंचमन
2
यह anwer बहुत उपयोगी है अगर आप एक पूर्णांक के रूप में आंशिक हिस्सा चाहते हैं
— गुइलहर्मे कैम्पोस Hazan
5

IEEE डबल फ़्लोटिंग पॉइंट संख्या का मंटिसा और एक्सपोनेंट ऐसे मान हैं

value = sign * (1 + mantissa) * pow(2, exponent)

अगर मंटिसा फॉर्म 0.101010101_base 2 का है (यानी इसका सबसे सिगंनट बिट बाइनरी पॉइंट के बाद होने के लिए शिफ्ट हो जाता है) और एक्सफोलिएंट को बायस के लिए समायोजित किया जाता है।

1.6 के बाद से, java.lang.Math भी निष्पक्ष घातांक प्राप्त करने के लिए एक सीधा तरीका प्रदान करता है (जिसे getExponent (डबल) कहा जाता है)

हालाँकि, आप जो संख्या पूछ रहे हैं, वह संख्या के अभिन्न और भिन्नात्मक भाग हैं, जिनका उपयोग करके प्राप्त किया जा सकता है

integral = Math.floor(x)
fractional = x - Math.floor(x)

यद्यपि आप अलग-अलग संख्याओं के साथ नकारात्मक व्यवहार करना चाहते हैं (floor(-3.5) == -4.0), इस पर निर्भर करता है कि आप दोनों भागों को क्यों चाहते हैं।

मैं दृढ़ता से सुझाव देता हूं कि आप इन मंटिसा और प्रतिपादक को न बुलाएं।

— पीट किरखम
स्रोत
4

अगर यह तेज़ है तो नहीं पता, लेकिन मैं उपयोग कर रहा हूँ

float fp = ip % 1.0f;
— QED
स्रोत
3

[संपादित करें: सवाल मूल रूप से कहा जाता है कि मंटिसा और घातांक कैसे प्राप्त करें।]

जहां वास्तविक मंटिसा / प्रतिपादक प्राप्त करने के लिए n संख्या है:

exponent = int(log(n))
mantissa = n / 10^exponent

या, आप जिस उत्तर की तलाश में थे:

exponent = int(n)
mantissa = n - exponent

ये जावा बिल्कुल नहीं हैं, लेकिन इन्हें परिवर्तित करना आसान होना चाहिए।

— स्टीफन डार्लिंगटन
स्रोत
3

इंटीग्रेटर भाग साधारण कास्टिंग से और फ्रैक्शनल के लिए मिलता है - स्ट्रिंग विभाजन:

double value = 123.004567890

int integerPart = (int) value; // 123

int fractionPart = 
  Integer.valueOf(String.valueOf(value)
      .split(".")[1]); // 004567890

/**
* To control zeroes omitted from start after parsing.
*/
int decimals =
  String.valueOf(value)
      .split(".")[1].length(); // 9
— Zon
स्रोत
1

अगर आपका नंबर 2.39999999999999 है तो क्या करें मुझे लगता है कि आप सटीक दशमलव मान प्राप्त करना चाहते हैं। फिर BigDecimal का उपयोग करें:

Integer x,y,intPart;
BigDecimal bd,bdInt,bdDec;
bd = new BigDecimal("2.39999999999999");
intPart = bd.intValue();
bdInt = new BigDecimal(intPart);
bdDec = bd.subtract(bdInt);
System.out.println("Number : " + bd);
System.out.println("Whole number part : " + bdInt);
System.out.println("Decimal number part : " + bdDec);
— roybraym
स्रोत
0

चूंकि fmt:formatNumberटैग हमेशा सही परिणाम नहीं देता है, इसलिए यहां एक और JSP- केवल दृष्टिकोण है: यह सिर्फ संख्या को स्ट्रिंग के रूप में प्रारूपित करता है और स्ट्रिंग पर बाकी गणना करता है, क्योंकि यह आसान है और आगे चल बिंदु शामिल नहीं करता है अंकगणित।

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>

<%
  double[] numbers = { 0.0, 3.25, 3.75, 3.5, 2.5, -1.5, -2.5 };
  pageContext.setAttribute("numbers", numbers);
%>

<html>
  <body>
    <ul>
      <c:forEach var="n" items="${numbers}">
        <li>${n} = ${fn:substringBefore(n, ".")} + ${n - fn:substringBefore(n, ".")}</li>
      </c:forEach>
    </ul>
  </body>
</html>
— रोलैंड इलिग
स्रोत
बस मेरे उदाहरण से सभी संख्याओं का प्रयास करें। fmt:formatNumberअपने तर्क को गोल करता है, जो इस मामले में नहीं चाहता है।
— रोलैंड इलिग
0

इनमें से बहुत से जवाबों में भयानक दौर की त्रुटियां हैं क्योंकि वे एक प्रकार से दूसरे में नंबर डाल रहे हैं। कैसा रहेगा:

double x=123.456;
double fractionalPart = x-Math.floor(x);
double wholePart = Math.floor(x);
— benofben
स्रोत
@justshams का उपयोग करने के बारे में क्या Math.abs?
— Stephan
0

स्वीकृत उत्तर -0 और -1.0 के बीच नकारात्मक संख्याओं के लिए अच्छी तरह से काम नहीं करता है।

उदाहरण के लिए: संख्या -0,35 के लिए

रिटर्न

पूर्णांक भाग = 0 आंशिक भाग = -0.35

अगर wou GPS निर्देशांक के साथ काम कर रहे हैं, तो पूर्णांक भाग पर साइनम के साथ परिणाम के रूप में बेहतर है:

पूर्णांक भाग = -0 आंशिक भाग = 0.35

GPS निर्देशांक के लिए उदाहरण के लिए Theses नंबरों का उपयोग किया जाता है, जहाँ Lat या Long स्थिति के लिए महत्वपूर्ण संकेत हैं

प्रस्ताव कोड:

    double num;
    double iPart;
    double fPart;

    // Get user input
    num = -0.35d;
    iPart = (long) num;
    //Correct numbers between -0.0 and -1.0
    iPart = (num<=-0.0000001 && num>-1.0)? -iPart : iPart ;
    fPart = Math.abs(num - iPart);
    System.out.println(String.format("Integer part = %01.0f",iPart));
    System.out.println(String.format("Fractional part = %01.04f",fPart));

आउटपुट:

Integer part = -0
Fractional part = 0,3500
— user1817835
स्रोत
0

जावा 8 के बाद से, आप उपयोग कर सकते हैं Math.floorDiv।

यह सबसे बड़ा (सकारात्मक अनंत के निकटतम) लौटाता है int मान है जो बीजगणितीय भागफल से कम या बराबर होता है।

कुछ उदाहरण:

floorDiv(4, 3) == 1
floorDiv(-4, 3) == -2

वैकल्पिक रूप से, /ऑपरेटर का उपयोग किया जा सकता है:

(4 / 3) == 1
(-4 / 3) == -1

संदर्भ:

— स्टीफ़न
स्रोत
0

मैं समाधान के लिए BigDecimal का उपयोग करूंगा। ऐशे ही:

    double value = 3.25;
    BigDecimal wholeValue = BigDecimal.valueOf(value).setScale(0, BigDecimal.ROUND_DOWN);
    double fractionalValue = value - wholeValue.doubleValue();
— Endery
स्रोत
0 
String value = "3.06";

if(!value.isEmpty()){
    if(value.contains(".")){    
        String block = value.substring(0,value.indexOf("."));
        System.out.println(block);
    }else{
        System.out.println(value);
    }
}
— मोहम्मद साबिरुल्ला
स्रोत
इस उत्तर को निम्न गुणवत्ता के रूप में चिह्नित किया गया है। यदि यह प्रश्न का उत्तर देता है, तो यह समझाने के लिए कि यह कैसे काम करता है, थोड़ा सा पाठ जोड़ने पर विचार करें।
— lmo
0 
// target float point number
double d = 3.025;

// transfer the number to string
DecimalFormat df = new DecimalFormat();
df.setDecimalSeparatorAlwaysShown(false);
String format = df.format(d);

// split the number into two fragments
int dotIndex = format.indexOf(".");
int iPart = Integer.parseInt(format.substring(0, dotIndex)); // output: 3
double fPart = Double.parseDouble(format.substring(dotIndex)); // output: 0.025
— w__
स्रोत
0

ठीक है, यह शायद देर हो चुकी है, लेकिन मुझे लगता है कि बिगडेसिमल का उपयोग सबसे अच्छा और अधिक सटीक दृष्टिकोण है

double d = 11.38;

BigDecimal bigD = BigDecimal.valueOf(d);
int intPart = bigD.intValue();
double fractionalPart = bigD.subtract(BigDecimal.valueOf(intPart)).doubleValue();

System.out.println(intPart); // 11
System.out.println(fractionalPart ); //0.38
— उमर एलाश्री
स्रोत
यदि आपके पास एक डबल है, तो यह फ्लोटिंग अपरिपक्वता है। इसे BigDecimal में परिवर्तित करने से जादुई रूप से इसकी शुद्धता बहाल नहीं होगी।
— तस्कीन
@ तस्ची मुझे लगता है कि सवाल अंतर और भिन्नात्मक भाग को अलग करने के बारे में है, न कि इसकी शुद्धता को बहाल करने के बारे में!
— उमर एलाश्री
उमर, आपने विशेष रूप से अपने दृष्टिकोण को "अधिक सटीक" होने के बारे में बात की थी, जो मुझे लगता है कि सिर्फ सच नहीं है। आपका उत्तर पूरी तरह से स्वीकार्य है लेकिन यह शब्द मुझे भ्रामक लगता है, यही कारण है कि मैंने इस पर टिप्पणी की।
— तस्करी
@ तस्ची, मैंने कहा कि क्योंकि कई जवाबों में आप आउटपुट प्राप्त करते समय मूल्य खो input (5.03) output int = 5 , fractional = 0.0299999देते हैं , उदाहरण के लिए , हम इनपुट और आउटपुट के बारे में बात कर रहे हैं, यू वैल्यू डालते हैं और 0.001% का नुकसान किए बिना अपना मूल्य वापस प्राप्त करते हैं! और यह सटीक, भ्रामक नहीं है!
— उमर इलाश्री
हाँ। जब आप किसी चीज़ को पहली जगह में डबल के रूप में संग्रहीत करते हैं तो आप सटीकता खो देते हैं। बिगडेसिमल में कनवर्ट करते समय गोलाई भी सटीक खो देती है। परिशुद्धता के वे दो नुकसान एक-दूसरे को रद्द कर सकते हैं, लेकिन यह "सटीकता" को बहाल नहीं करता है, क्योंकि परिशुद्धता को पुनर्स्थापित करना गणितीय रूप से असंभव है। आप पतली हवा से जानकारी नहीं खींच सकते।
— ताशी
-2 
public class MyMain2 {
    public static void main(String[] args) {
        double myDub;
        myDub=1234.5678;
        long myLong;
        myLong=(int)myDub;
        myDub=(myDub%1)*10000;
        int myInt=(int)myDub;
        System.out.println(myLong + "\n" + myInt);
    }
}
— माइकल मायर्स
स्रोत
यह केवल तभी काम करता है जब संख्या में 4 दशमलव स्थान हों। अन्यथा नहीं।
— लोर्ने का
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.