в 18:01, 31 мая 2010

2010-05-31T18:01:44Z

Новая страница

== byte Array To Hex String ==



<source lang="java">

public class Main {
public static void main(String arg[]) {
byteArrayToHexString(("abc").getBytes());
}
public static String byteArrayToHexString(byte[] b) {
StringBuffer sb = new StringBuffer(b.length * 2);
for (int i = 0; i < b.length; i++) {
int v = b[i] & 0xff;
if (v < 16) {
sb.append("0");
}
sb.append(Integer.toHexString(v));
}
return sb.toString().toUpperCase();
}
}

</source>



== Byte class creates primitives that wrap themselves around data items of the byte data type ==



<source lang="java">

public class MainClass {
public static void main(String[] args) {
byte by = (byte) "A";
Byte by2 = new Byte(by);
System.out.println(by2.byteValue());
}
}

</source>



== Compare Two Java byte Arrays Example ==



<source lang="java">

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
byte[] a1 = new byte[] { 7, 25, 12 };
byte[] a2 = new byte[] { 7, 25, 12 };
System.out.println(Arrays.equals(a1, a2));
}
}

</source>



== Convert an UNSIGNED byte to a JAVA type ==



<source lang="java">

public class Main {
public static void main(String args[]) {
byte b1 = 127;
System.out.println(b1);
System.out.println(unsignedByteToInt(b1));
}
public static int unsignedByteToInt(byte b) {
return (int) b & 0xFF;
}
}

</source>



== Convert byte[ ] array to String ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};
String value = new String(byteArray);
System.out.println(value);
}
}
//WOW...

</source>



== Convert Byte to numeric primitive data types example ==



<source lang="java">

public class Main {
public static void main(String[] args) {
Byte bObj = new Byte("10");
byte b = bObj.byteValue();
System.out.println(b);
short s = bObj.shortValue();
System.out.println(s);
int i = bObj.intValue();
System.out.println(i);
float f = bObj.floatValue();
System.out.println(f);
double d = bObj.doubleValue();
System.out.println(d);
long l = bObj.longValue();
System.out.println(l);
}
}

</source>



== Convert byte to String: Creating a byte array and passing it to the String constructor ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte b = 65;

System.out.println(new String(new byte[] {b}));
}
}
//A

</source>



== Convert byte to String: Using simple concatenation with an empty String ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte b = 65;

System.out.println(b + "");
}
}
//65

</source>



== Convert byte to String: Using the static toString method of the Byte class ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte b = 65;

System.out.println(Byte.toString(b));
}
}

</source>



== Convert Java String to Byte example ==



<source lang="java">

public class Main {
public static void main(String[] args) {
Byte bObj1 = new Byte("100");
System.out.println(bObj1);
Byte bObj2 = Byte.valueOf("100");
System.out.println(bObj2);
}
}

</source>



== Convert String to byte ==



<source lang="java">

public class Main {
public static void main(String[] args) {
String s = "65";
byte b = Byte.valueOf(s);
System.out.println(b);
// Causes a NumberFormatException since the value is out of range
System.out.println(Byte.valueOf("129"));
}
}
/*
65
Exception in thread "main" java.lang.NumberFormatException: Value out of range. Value:"129" Radix:10
at java.lang.Byte.parseByte(Byte.java:153)
at java.lang.Byte.valueOf(Byte.java:184)
at java.lang.Byte.valueOf(Byte.java:208)
at Main.main(Main.java:11)
*/

</source>



== Convert String to byte array ==



<source lang="java">

public class Main {
public static void main(String[] args) {
String stringToConvert = "this is a test";

byte[] theByteArray = stringToConvert.getBytes();

System.out.println(theByteArray.length);
}
}
//14

</source>



== Convert String to primitive byte Example ==



<source lang="java">

public class Main {
public static void main(String[] args) {
String str = new String("10");
byte b = Byte.parseByte(str);
System.out.println(b);
}
}

</source>



== Gets the maximum of three byte values. ==



<source lang="java">

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
* Provides extra functionality for Java Number classes.
*
* @author
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/
public class Main {
/**
* Gets the maximum of three <code>byte</code> values.
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static byte max(byte a, byte b, byte c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
}

</source>



== Gets the minimum of three byte values. ==



<source lang="java">

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
* Provides extra functionality for Java Number classes.
*
* @author
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/
public class Main {
/**
* Gets the minimum of three <code>byte</code> values.
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static byte min(byte a, byte b, byte c) {
if (b < a) {
a = b;
}
if (c < a) {
a = c;
}
return a;
}
}

</source>



== hex String To Byte Array ==



<source lang="java">

public class Main {

public static byte[] hexStringToByteArray(String s) {
byte[] b = new byte[s.length() / 2];
for (int i = 0; i < b.length; i++) {
int index = i * 2;
int v = Integer.parseInt(s.substring(index, index + 2), 16);
b[i] = (byte) v;
}
return b;
}
}

</source>



== Immutable byte list ==



<source lang="java">

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
*
* @xerces.internal
*
* @author Ankit Pasricha, IBM
*
* @version $Id: ByteListImpl.java 446747 2006-09-15 21:46:20Z mrglavas $
*/
public class ByteListImpl {
// actually data stored in a byte array
protected final byte[] data;

// canonical representation of the data
protected String canonical;

public ByteListImpl(byte[] data) {
this.data = data;
}

/**
* The number of <code>byte</code>s in the list. The range of
* valid child object indices is 0 to <code>length-1</code> inclusive.
*/
public int getLength() {
return data.length;
}
/**
* Checks if the <code>byte</code> <code>item</code> is a
* member of this list.
* @param item <code>byte</code> whose presence in this list
* is to be tested.
* @return True if this list contains the <code>byte</code>
* <code>item</code>.
*/
public boolean contains(byte item) {
for (int i = 0; i < data.length; ++i) {
if (data[i] == item) {
return true;
}
}
return false;
}
/**
* Returns the <code>index</code>th item in the collection. The index
* starts at 0.
* @param index index into the collection.
* @return The <code>byte</code> at the <code>index</code>th
* position in the <code>ByteList</code>.
* @exception XSException
* INDEX_SIZE_ERR: if <code>index</code> is greater than or equal to the
* number of objects in the list.
*/
public byte item(int index)
throws Exception {

if(index < 0 || index > data.length - 1) {
throw new RuntimeException("INDEX SIZE ERR");
}
return data[index];
}

}

</source>



== Java byte: byte is smallest Java integer type.byte is 8 bit signed type ranges from �128 to 127. ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte b1 = 100;
byte b2 = 20;
System.out.println("Value of byte variable b1 is :" + b1);
System.out.println("Value of byte variable b1 is :" + b2);
}
}
/*
Value of byte variable b1 is :100
Value of byte variable b1 is :20
*/

</source>



== Java Byte Example ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte b = 10;
Byte bObj1 = new Byte(b);
Byte bObj2 = new Byte("4");
System.out.println(bObj1);
System.out.println(bObj2);
}
}

</source>



== Max and Min values of datatype char ==



<source lang="java">

public class Main {
public static void main(String[] args) {
System.out.println((int) Character.MIN_VALUE);
System.out.println((int) Character.MAX_VALUE);
}
}
//0
//65535

</source>



== Min and Max values of datatype byte ==



<source lang="java">

public class Main {
public static void main(String[] args) {
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);
}
}
/*
-128
127
*/

</source>



== Min and Max values of datatype int ==



<source lang="java">

public class Main {
public static void main(String[] args) {
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
}
}
/*
-2147483648
2147483647
*/

</source>



== Min and Max values of datatype short ==



<source lang="java">

public class Main {
public static void main(String[] args) {
System.out.println(Short.MIN_VALUE);
System.out.println(Short.MAX_VALUE);
}
}
/*
-32768
32767
*/

</source>



== Minimum and maximum values of a byte ==



<source lang="java">

public class Main {
public static void main(String[] args) {
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);
}
}
/*
-128
127
*/

</source>



== Print the limits of primitive types (e.g. byte, short, int ...) in Java ==



<source lang="java">

public class Main {
public static void main(String args[]) {
System.out.println("Min byte value = " + Byte.MIN_VALUE);
System.out.println("Max byte value = " + Byte.MAX_VALUE);
System.out.println("Min short value = " + Short.MIN_VALUE);
System.out.println("Max short value = " + Short.MAX_VALUE);
System.out.println("Min int value = " + Integer.MIN_VALUE);
System.out.println("Max int value = " + Integer.MAX_VALUE);
System.out.println("Min float value = " + Float.MIN_VALUE);
System.out.println("Max float value = " + Float.MAX_VALUE);
System.out.println("Min double value = " + Double.MIN_VALUE);
System.out.println("Max double value = " + Double.MAX_VALUE);
}
}

</source>



== This shows something interesting about addition of byte variables ==



<source lang="java">

/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
* All rights reserved. Software written by Ian F. Darwin and others.
* $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
* cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
* pioneering role in inventing and promulgating (and standardizing) the Java
* language and environment is gratefully acknowledged.
*
* The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
* inventing predecessor languages C and C++ is also gratefully acknowledged.
*/

/**
* This shows something interesting about addition of "byte" variables
* (which also applies to all integer types).
*/
public class ByteAdd {
public static void main(String[] argv) {
System.out.println("ByteAdd Program");
// bytes are signed integer, so can range from -127 to +127
byte b1 = 10, b2 = 127;
System.out.println("b1 + b2 = " + (b1+b2));
b1 = 127;
System.out.println("b1 + b2 = " + (b1+b2));
}
}

</source>



== To convert a byte to it"s hexadecimal equivalent ==



<source lang="java">

public class Main {
public static void main(String[] argv) {
System.out.println(byteToHex((byte) 123));
}
public static String byteToHex(byte b) {
int i = b & 0xFF;
return Integer.toHexString(i);
}
}
//7b

</source>



== Translates between byte arrays and strings of "0"s and "1"s. ==



<source lang="java">

/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Translates between byte arrays and strings of "0"s and "1"s.
*
* @todo may want to add more bit vector functions like and/or/xor/nand
* @todo also might be good to generate boolean[] from byte[] et. cetera.
*
* @author Apache Software Foundation
* @since 1.3
* @version $Id $
*/
public class BinaryCodec {
/*
* tried to avoid using ArrayUtils to minimize dependencies while using these
* empty arrays - dep is just not worth it.
*/
/** Empty char array. */
private static final char[] EMPTY_CHAR_ARRAY = new char[0];
/** Empty byte array. */
private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
/** Mask for bit 0 of a byte. */
private static final int BIT_0 = 1;
/** Mask for bit 1 of a byte. */
private static final int BIT_1 = 0x02;
/** Mask for bit 2 of a byte. */
private static final int BIT_2 = 0x04;
/** Mask for bit 3 of a byte. */
private static final int BIT_3 = 0x08;
/** Mask for bit 4 of a byte. */
private static final int BIT_4 = 0x10;
/** Mask for bit 5 of a byte. */
private static final int BIT_5 = 0x20;
/** Mask for bit 6 of a byte. */
private static final int BIT_6 = 0x40;
/** Mask for bit 7 of a byte. */
private static final int BIT_7 = 0x80;
private static final int[] BITS = { BIT_0, BIT_1, BIT_2, BIT_3, BIT_4, BIT_5, BIT_6, BIT_7 };
/**
* Converts an array of raw binary data into an array of ascii 0 and 1
* characters.
*
* @param raw
* the raw binary data to convert
* @return 0 and 1 ascii character bytes one for each bit of the argument
* @see org.apache.rumons.codec.BinaryEncoder#encode(byte[])
*/
public byte[] encode(byte[] raw) {
return toAsciiBytes(raw);
}
/**
* Converts an array of raw binary data into an array of ascii 0 and 1 chars.
*
* @param raw
* the raw binary data to convert
* @return 0 and 1 ascii character chars one for each bit of the argument
* @throws EncoderException
* if the argument is not a byte[]
* @see org.apache.rumons.codec.Encoder#encode(java.lang.Object)
*/
public Object encode(Object raw) throws RuntimeException {
if (!(raw instanceof byte[])) {
throw new RuntimeException("argument not a byte array");
}
return toAsciiChars((byte[]) raw);
}
/**
* Decodes a byte array where each byte represents an ascii "0" or "1".
*
* @param ascii
* each byte represents an ascii "0" or "1"
* @return the raw encoded binary where each bit corresponds to a byte in the
* byte array argument
* @throws DecoderException
* if argument is not a byte[], char[] or String
* @see org.apache.rumons.codec.Decoder#decode(java.lang.Object)
*/
public Object decode(Object ascii) throws RuntimeException {
if (ascii == null) {
return EMPTY_BYTE_ARRAY;
}
if (ascii instanceof byte[]) {
return fromAscii((byte[]) ascii);
}
if (ascii instanceof char[]) {
return fromAscii((char[]) ascii);
}
if (ascii instanceof String) {
return fromAscii(((String) ascii).toCharArray());
}
throw new RuntimeException("argument not a byte array");
}
/**
* Decodes a byte array where each byte represents an ascii "0" or "1".
*
* @param ascii
* each byte represents an ascii "0" or "1"
* @return the raw encoded binary where each bit corresponds to a byte in the
* byte array argument
* @see org.apache.rumons.codec.Decoder#decode(Object)
*/
public byte[] decode(byte[] ascii) {
return fromAscii(ascii);
}
/**
* Decodes a String where each char of the String represents an ascii "0" or
* "1".
*
* @param ascii
* String of "0" and "1" characters
* @return the raw encoded binary where each bit corresponds to a byte in the
* byte array argument
* @see org.apache.rumons.codec.Decoder#decode(Object)
*/
public byte[] toByteArray(String ascii) {
if (ascii == null) {
return EMPTY_BYTE_ARRAY;
}
return fromAscii(ascii.toCharArray());
}
// ------------------------------------------------------------------------
//
// static codec operations
//
// ------------------------------------------------------------------------
/**
* Decodes a byte array where each char represents an ascii "0" or "1".
*
* @param ascii
* each char represents an ascii "0" or "1"
* @return the raw encoded binary where each bit corresponds to a char in the
* char array argument
*/
public static byte[] fromAscii(char[] ascii) {
if (ascii == null || ascii.length == 0) {
return EMPTY_BYTE_ARRAY;
}
// get length/8 times bytes with 3 bit shifts to the right of the length
byte[] l_raw = new byte[ascii.length >> 3];
/*
* We decr index jj by 8 as we go along to not recompute indices using
* multiplication every time inside the loop.
*/
for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
for (int bits = 0; bits < BITS.length; ++bits) {
if (ascii[jj - bits] == "1") {
l_raw[ii] |= BITS[bits];
}
}
}
return l_raw;
}
/**
* Decodes a byte array where each byte represents an ascii "0" or "1".
*
* @param ascii
* each byte represents an ascii "0" or "1"
* @return the raw encoded binary where each bit corresponds to a byte in the
* byte array argument
*/
public static byte[] fromAscii(byte[] ascii) {
if (ascii == null || ascii.length == 0) {
return EMPTY_BYTE_ARRAY;
}
// get length/8 times bytes with 3 bit shifts to the right of the length
byte[] l_raw = new byte[ascii.length >> 3];
/*
* We decr index jj by 8 as we go along to not recompute indices using
* multiplication every time inside the loop.
*/
for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
for (int bits = 0; bits < BITS.length; ++bits) {
if (ascii[jj - bits] == "1") {
l_raw[ii] |= BITS[bits];
}
}
}
return l_raw;
}
/**
* Converts an array of raw binary data into an array of ascii 0 and 1
* character bytes - each byte is a truncated char.
*
* @param raw
* the raw binary data to convert
* @return an array of 0 and 1 character bytes for each bit of the argument
* @see org.apache.rumons.codec.BinaryEncoder#encode(byte[])
*/
public static byte[] toAsciiBytes(byte[] raw) {
if (raw == null || raw.length == 0) {
return EMPTY_BYTE_ARRAY;
}
// get 8 times the bytes with 3 bit shifts to the left of the length
byte[] l_ascii = new byte[raw.length << 3];
/*
* We decr index jj by 8 as we go along to not recompute indices using
* multiplication every time inside the loop.
*/
for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
for (int bits = 0; bits < BITS.length; ++bits) {
if ((raw[ii] & BITS[bits]) == 0) {
l_ascii[jj - bits] = "0";
} else {
l_ascii[jj - bits] = "1";
}
}
}
return l_ascii;
}
/**
* Converts an array of raw binary data into an array of ascii 0 and 1
* characters.
*
* @param raw
* the raw binary data to convert
* @return an array of 0 and 1 characters for each bit of the argument
* @see org.apache.rumons.codec.BinaryEncoder#encode(byte[])
*/
public static char[] toAsciiChars(byte[] raw) {
if (raw == null || raw.length == 0) {
return EMPTY_CHAR_ARRAY;
}
// get 8 times the bytes with 3 bit shifts to the left of the length
char[] l_ascii = new char[raw.length << 3];
/*
* We decr index jj by 8 as we go along to not recompute indices using
* multiplication every time inside the loop.
*/
for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
for (int bits = 0; bits < BITS.length; ++bits) {
if ((raw[ii] & BITS[bits]) == 0) {
l_ascii[jj - bits] = "0";
} else {
l_ascii[jj - bits] = "1";
}
}
}
return l_ascii;
}
/**
* Converts an array of raw binary data into a String of ascii 0 and 1
* characters.
*
* @param raw
* the raw binary data to convert
* @return a String of 0 and 1 characters representing the binary data
* @see org.apache.rumons.codec.BinaryEncoder#encode(byte[])
*/
public static String toAsciiString(byte[] raw) {
return new String(toAsciiChars(raw));
}
}

</source>



== Use Byte constructor to convert byte primitive type to Byte object ==



<source lang="java">

public class Main {
public static void main(String[] args) {
byte i = 10;

Byte bObj = new Byte(i);
System.out.println(bObj);
}
}

</source>



== Use toString method of Byte class to convert Byte into String ==



<source lang="java">

public class Main {
public static void main(String[] args) {
Byte bObj = new Byte("10");

String str = bObj.toString();
System.out.println(str);
}
}

</source>



== Wrapping a Primitive Type in a Wrapper Object: boolean, byte, char, short, int, long, float, double ==



<source lang="java">

public class Main {
public static void main(String[] argv) throws Exception {
Boolean refBoolean = new Boolean(true);
boolean bool = refBoolean.booleanValue();

Byte refByte = new Byte((byte) 123);
byte b = refByte.byteValue();

Character refChar = new Character("x");
char c = refChar.charValue();

Short refShort = new Short((short) 123);
short s = refShort.shortValue();

Integer refInt = new Integer(123);
int i = refInt.intValue();

Long refLong = new Long(123L);
long l = refLong.longValue();

Float refFloat = new Float(12.3F);
float f = refFloat.floatValue();

Double refDouble = new Double(12.3D);
double d = refDouble.doubleValue();
}
}

</source>

Java/Data Type/byte - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010

← Предыдущая	Версия 06:20, 1 июня 2010
(нет различий)