Primitive v/s Non-primitive data type

Hi,
I am new to java. What is the difference between primitive and non-primitive data type?

hi Anand,
there are hundred thousands of object in the Data Dictionary, so 15 won't harm much On the other hand, if you build up an ALV list based on this table, than it is good that you have these texts there with translations, etc.
hope this helps
ec

Similar Messages

Transfer an internal table with non char data type to an application server

Here is a part of my code. lv_string variable was type string initially but i got an error Not mutually convertible in a Unicode Program. I changed it to type ty_afko. Now the program works but the data it puts out has just a bunch of #####. I cannot make all value in the internal table type char because then my select statement is giving errors.. Please help...
Type: BEGIN OF ty_afko,
 rsnum LIKE afko-rsnum, " Number of reservation
 aprio LIKE afko-aprio, " Order Priority
 maufnr LIKE afko-maufnr, " Number of superior order
 lead_aufnr LIKE afko-lead_aufnr, " Leading order in current processing
 END OF ty_afko.
data: gt_afko TYPE STANDARD TABLE OF ty_afko INITIAL SIZE 0,
 wa_afko TYPE ty_afko,
select rsnum aprio maufnr lead_aufnr
from afko into table gt_afko.
IF gv_error = 'X'.
EXIT.
ELSE.
DATA: Lv_string type ty_afko.
loop at gt_afko into wa_afko.
 clear lv_string.
 move wa_afko to lv_string.
 perform f_transfer_dataset using gc_f_afko lv_string changing gv_error.
endloop.
endif.
FORM f_transfer_dataset USING p_file
 p_data
 CHANGING p_error TYPE c.
Data: lv_file(25) type c.
CONCATENATE gc_path p_file INTO lv_file.
TRANSFER p_data TO lv_file.
ENDFORM. "F_TRANSFER_DATASET

The key is to create another empty structure with fields of type c.
TYPES: BEGIN OF ty_resb,
 bdter TYPE RESB-BDTER, " This field is type d
 bdmng type resb-bdmng, " This field is type p with 3 decimals - total 14
 END OF ty_resb,
 BEGIN OF ty_resbstr, " This structure is the same as above but the field types will be char.
 bdter(10),
 bdmng(14),
 END OF ty_resbstr.
DATA: gt_resb TYPE STANDARD TABLE OF ty_resb,
 wa_resb TYPE ty_resb,
 structure type ty_resbstr. " Empty fields with the same structure as the work area.
SELECT bdter bdmng FROM resb INTO corresponding fields of TABLE gt_resb.
 open dataset pfile for output in text mode encoding default.
 loop at gt_resb into wa_resb.
 clear gv_string.
 move-corresponding wa_resb to gv_string.
 perform f_transfer_dataset using gc_f_resb gv_string.
 endloop.
 FORM f_transfer_dataset USING p_file p_data.
 TRANSFER p_data TO lv_file.
 ENDFORM.

@protocol doesn't seem to work with non-primitive arguments

Any idea why this works.
CustomProtocol1.h
@protocol CustomProtocol1
- (void) start:(int) offset;
@end
But this doesn't:
CustomProtocol2.h
@protocol CustomProtocol2
- (void) start:(CustomClass*) custom;
@end
The only difference is that CustomProtocol1 uses a non-primitve argument. Here is the error I get for CustomProtocol2: "Syntax error before 'CustomClass'. Method definition not in @implementation context"
It seems CustomProtocol2 has problems finding the CustomClass.h but if I add #import "CustomClass.h" into CustomProtocol2.h I get this error: "Cannot find protocol declaration for 'CustomProtocol2'"
So far, I can only conclude that Objective-C @protocol does not work with non-primitives.
Any help would be MUCH appreciated.
Anthony

The compiler doesn't know what CustomClass is. You have to tell it. However, it is a pointer and, hence, actually is a "primitive" (AKA POD - plain 'ole data) type. So, you need to forward declare CustomClass like so:
@class CustomClass;
@protocol CustomProtocol2
- (void) start:(CustomClass*) custom;
@end

Not Able to Load the data type "Non Currency"in Planning accounts dimension

Dear All,
We are building Meta data in planning using HAL 9.2 ...while construction of accounts we were able to assign "Currency" Data Type ,but were unable to add the "Non Currency" data types to account members.
We have mentioned "Non Currency" in the the Data Type Field.
Thanks in Advance.

Hi Guys my issue is resolved..... just wanted to let you know that you will need to write "Non-Currency" in the field name in the csv for marking accounts as Non currency data type.

Unicode and non-unicode string data types Issue with 2008 SSIS Package

Hi All,
I am converting a 2005 SSIS Package to 2008. I have a task which has SQL Server as the source and Oracle as the destination. I copy the data from a SQL server view with a field nvarchar(10) to a field of a oracle table varchar(10). The package executes fine
on my local when i use the data transformation task to convert to DT_STR. But when I deploy the dtsx file on the server and try to run from an SQL Job Agent it gives me the unicode and non-unicode string data types error for the field. I have checked the registry
settings and its the same in my local and the server. Tried both the data conversion task and Derived Column task but with no luck. Pls suggest me what changes are required in my package to run it from the SQL Agent Job.
Thanks.

What is Unicode and non Unicode data formats
Unicode :
A Unicode character takes more bytes to store the data in the database. As we all know, many global industries wants to increase their business worldwide and grow at the same time, they would want to widen their business by providing
services to the customers worldwide by supporting different languages like Chinese, Japanese, Korean and Arabic. Many websites these days are supporting international languages to do their business and to attract more and more customers and that makes life
easier for both the parties.
To store the customer data into the database the database must support a mechanism to store the international characters, storing these characters is not easy, and many database vendors have to revised their strategies and come
up with new mechanisms to support or to store these international characters in the database. Some of the big vendors like Oracle, Microsoft, IBM and other database vendors started providing the international character support so that the data can be stored
and retrieved accordingly to avoid any hiccups while doing business with the international customers.
The difference in storing character data between Unicode and non-Unicode depends on whether non-Unicode data is stored by using double-byte character sets. All non-East Asian languages and the Thai language store non-Unicode characters
in single bytes. Therefore, storing these languages as Unicode uses two times the space that is used specifying a non-Unicode code page. On the other hand, the non-Unicode code pages of many other Asian languages specify character storage in double-byte character
sets (DBCS). Therefore, for these languages, there is almost no difference in storage between non-Unicode and Unicode.
Encoding Formats:
Some of the common encoding formats for Unicode are UCS-2, UTF-8, UTF-16, UTF-32 have been made available by database vendors to their customers. For SQL Server 7.0 and higher versions Microsoft uses the encoding format UCS-2 to store the UTF-8 data. Under
this mechanism, all Unicode characters are stored by using 2 bytes.
Unicode data can be encoded in many different ways. UCS-2 and UTF-8 are two common ways to store bit patterns that represent Unicode characters. Microsoft Windows NT, SQL Server, Java, COM, and the SQL Server ODBC driver and OLEDB
provider all internally represent Unicode data as UCS-2.
The options for using SQL Server 7.0 or SQL Server 2000 as a backend server for an application that sends and receives Unicode data that is encoded as UTF-8 include:
For example, if your business is using a website supporting ASP pages, then this is what happens:
If your application uses Active Server Pages (ASP) and you are using Internet Information Server (IIS) 5.0 and Microsoft Windows 2000, you can add "<% Session.Codepage=65001 %>" to your server-side ASP script.
This instructs IIS to convert all dynamically generated strings (example: Response.Write) from UCS-2 to UTF-8 automatically before sending them to the client.
If you do not want to enable sessions, you can alternatively use the server-side directive "<%@ CodePage=65001 %>".
Any UTF-8 data sent from the client to the server via GET or POST is also converted to UCS-2 automatically. The Session.Codepage property is the recommended method to handle UTF-8 data within a web application. This Codepage
setting is not available on IIS 4.0 and Windows NT 4.0.
Sorting and other operations :
The effect of Unicode data on performance is complicated by a variety of factors that include the following:
1. The difference between Unicode sorting rules and non-Unicode sorting rules
2. The difference between sorting double-byte and single-byte characters
3. Code page conversion between client and server
Performing operations like >, <, ORDER BY are resource intensive and will be difficult to get correct results if the codepage conversion between client and server is not available.
Sorting lots of Unicode data can be slower than non-Unicode data, because the data is stored in double bytes. On the other hand, sorting Asian characters in Unicode is faster than sorting Asian DBCS data in a specific code page,
because DBCS data is actually a mixture of single-byte and double-byte widths, while Unicode characters are fixed-width.
Non-Unicode :
Non Unicode is exactly opposite to Unicode. Using non Unicode it is easy to store languages like ‘English’ but not other Asian languages that need more bits to store correctly otherwise truncation will occur.
Now, let’s see some of the advantages of not storing the data in Unicode format:
1. It takes less space to store the data in the database hence we will save lot of hard disk space.
2. Moving of database files from one server to other takes less time.
3. Backup and restore of the database makes huge impact and it is good for DBA’s that it takes less time
Non-Unicode vs. Unicode Data Types: Comparison Chart
The primary difference between unicode and non-Unicode data types is the ability of Unicode to easily handle the storage of foreign language characters which also requires more storage space.
Non-Unicode
Unicode
(char, varchar, text)
(nchar, nvarchar, ntext)
Stores data in fixed or variable length
Same as non-Unicode
char: data is padded with blanks to fill the field size. For example, if a char(10) field contains 5 characters the system will pad it with 5 blanks
nchar: same as char
varchar: stores actual value and does not pad with blanks
nvarchar: same as varchar
requires 1 byte of storage
requires 2 bytes of storage
char and varchar: can store up to 8000 characters
nchar and nvarchar: can store up to 4000 characters
Best suited for US English: "One problem with data types that use 1 byte to encode each character is that the data type can only represent 256 different characters. This forces multiple
encoding specifications (or code pages) for different alphabets such as European alphabets, which are relatively small. It is also impossible to handle systems such as the Japanese Kanji or Korean Hangul alphabets that have thousands of characters."1
Best suited for systems that need to support at least one foreign language: "The Unicode specification defines a single encoding scheme for most characters widely used in businesses around the world.
All computers consistently translate the bit patterns in Unicode data into characters using the single Unicode specification. This ensures that the same bit pattern is always converted to the same character on all computers. Data can be freely transferred
from one database or computer to another without concern that the receiving system will translate the bit patterns into characters incorrectly.
https://irfansworld.wordpress.com/2011/01/25/what-is-unicode-and-non-unicode-data-formats/
Thanks Shiven:) If Answer is Helpful, Please Vote

Amount field data type?

I have rows coming in with three column values I need on the export, I don't want to change the export process that is in place ...and I can't change the import formats...
I would like to concatenate them and put them in the "Amount" field...can this be done?
Suggestions?
Jz

You won't be able to do it in the Amount field because without using some sort of seperator i can't see how you will parse the values out later and this will give you issues at import with non numeric data type exceptions. Also if you can't change import formats you are extremely limited as this is where any sort of data manipulation is traditionally done.
Edited by: SH on May 13, 2011 8:39 PM

JAX-RPC and non-primitive data types

Hello all!
I am using JWSDP v1.3 and i have a problem using non-primitive data types as return types for my operations.
Consider the helloservice example of the JWSDP1.3 tutorial. Now suppose that instead of having the simple operation sayHello() that returns a String, we execute a query on a database, get some ResultSetMetaData and we want these Metadata to be the return type of our operation. I.e. have the operation
public ResultSetMetaData sayHello()
instead of the
public String sayHello()
of the tutorial.
When trying to build the service i get the following error which is normal, because ResultSetMetaData is not a supported JAX-RPC type.
run-wscompile: [echo] Running wscompile: [echo] C:\jwsdp\apache-ant\../jaxrpc/bin/wscompile.bat -define -d build - nd build -classpath build config-interface.xml -model build/model. gz [exec] error: invalid type for JAX-RPC structure: java.sql.ResultSetMetaData [exec] Result: 1
Is there any way to define an operation like this? Can i specify somehow ResultSetMetaData as a supported-type?
I hope someone can give me some advice on it, because i have lost one evening trying to figure it out myself :)
Regards,
Kostas

Courtesy links to crossposts so people don't waste their time answering a question which has already been answered
http://forum.java.sun.com/thread.jsp?thread=482875&forum=59&message=2253704
http://forum.java.sun.com/thread.jsp?thread=482873&forum=331&message=2253699

Conversion error with non-primitive types

I'm wondering if anyone else is seeing this problem or has a potential solution.
The problem, in a nutshell:
I have beans that use non-primitive types (Float instead of float) in the getters and setters. However I keep getting conversion error problems. If I switch to primitive types, I don't get conversion errors. The built-in FloatConverter says (in the documentation at least) that it supports both primitives and boxed types. This was all working in EA4, though. I am discovering this problem as I migrate from EA4 to 1.0.
The code is pretty straightforward:
public class Bean implements Serializable {
public float getProp() {...}
public void setProp(float) {...}
public Float getPropOld() {...}
public void setPropOld(Float) {...}

<h:inputText id="floatinput" value="#{BeanInstance.prop}"/>

<h:inputText id="floatinputold" value="#{BeanInstance.propOld}"/>
Any ideas? I have tried explicitly calling the FloatConverter but that gave the same problems.

Okay, I figured out my problem.
The JSF spec implies that f:convertNumber may be used inside an h:inputText tag. The early versions of Core JSF go further and show f:convertNumber being used inside an h:inputText tag in one of the examples. (Chapter 7, conversions).
However, this has been the source of my problem. When using f:convertNumber, the converter would automatically determine the data type without regard to the data type in the backing bean. Hence, it would try to pass Longs or Doubles to the bean instead of Floats.
I believe this may be an issue in the 1.0 FR release.

Runtime conversion of a string value to a primitive data type in java

can anyone of you give me an idea to convert a string value to a primitive data type during run time...i have the value and the type to which it has to be converted as String values...do you have any idea ,...pls share

String recvalvalue = inputval;
                String recvartype = inputtype;
               if (recvartype.equals("int")){
               value0 = Integer.parseInt(recvalvalue);
         else
         if (recvartype.equals("double")){
                value1 = Double.parseDouble(recvalvalue);
         else
         if(recvartype.equals("float")){
          value2 = Float.parseFloat(recvalvalue);
         else
         if(recvartype.equals("Boolean")){
          value3 = Boolean.parseBoolean(recvalvalue);
         else
         if(recvartype.equals("char")){
           value4 = (char)recvalvalue.charAt(0);
        else
        if(recvartype.equals("String")){
          value5 = recvalvalue;
         else
         if(recvartype.equals("byte")){
           value6 = Byte.parseByte(recvalvalue);
              //listA.add(6, value6);
              //     listA.g = value6;
         else
          if(recvartype.equals("long")){
           value7 = Long.parseLong(recvalvalue);
         else
          if(recvartype.equals("short")){
          value8 = Short.parseShort(recvalvalue);
         } yes i can do this but the resultant value has to be assigned to a variable of a specific type which is here recvartype .....it has to be done dynamically automatically..if we know what type of data is that we can convert and assign to the type but we donot know when we run the program as the program will be supllied by someone and has to be executed

Creation of new primitive data types

Is it possible to create primitive data types? Or perhaps there's another solution...
I have a need to work with signed integers represented by more than 128 bits, and would prefer to define such variables as primitive types and be able to use them as such. I have no problem creating "toString()" and friends for convert binary to decimal.
Thanks in advance.
Randolf Richardson - [email protected]
Inter-Corporate Computer & Network Services, Inc.
Vancouver, British Columbia, Canada
http://www.8x.ca/

What about using "BigIntegers"?
http://java.sun.com/j2se/1.4.2/docs/api/java/math/BigInteger.html

Should Java introduce new primitive data types??

In Java SE 5.0, many character- related methods (especially in the class Character) handle code points by using int type, i.e. return (code point) type is int, or receive (code point) int as parameter. This leads several problems. First, the variable used for storing returned result should be carefully stated, otherwise confusion may arise. Second, the parameters of method should be carefully ordered, otherwise conflict of method signature may meet.
By those reasons, I suggest that Java should introduce new primitive data types for handling characters, they are:
1. wchar
this type states the variable stores 32-bit UNSIGNED integer, and it could be used to store either the code point, or the UTF-16 code of a character.
2. ascii
this type states the variable stores 8-bit UNSIGNED integer, and it could be used to store the code point of a elemental (ascii) character.

short char, no. Nononono.
No.
wchar, I think I'd pref to see Java version 2 come
out, and that be wchar by default, but that is not
going to happen.
I don't see a great need for it at this time.http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4504839
Though I do not think that Java developer would like to change too much program code for using proposed (unsigned) primitive data types, I still believe that Java developer will eventually introduce these types, because it is not efficient to pretend signed integer to unsigned integer, and the success of a programming language is determined by how it can meet the programmers' need.

Primitive data types as a sequence of bytes

Does anyone have any experience of converting between primitive data types and sequences (i.e. arrays) of bytes? In particular I want to transmit primitive data types over a socket connection by writing a sequence of bytes.
Thanks in advance.

Yes. My personal favourite class for this is java.nio.ByteBuffer though you can also do it with java.io.DataInputStream/DataOutputStream and that might work better with sockets. ByteBuffer is particularly useful with pre-specified formats since you can specify big/little endian storage.

Setting precision to primitive data types

How can I set precisions to the primitive data types, viz, double and float??
I'm writing a program in which I've declared a double variable as follows :
double d=12.00
System.out.println(d);
The output is 12.0 but I want it to be 12.00
How can it be done??

You have to use a BigDecimal:
        BigDecimal bd = new BigDecimal(12);
        bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
        System.out.println(bd);

JAVA primitive data types - Signed/ unsigned etc.

1. Are the following data types signed or unsigned in JAVA?
byte, short, int, long, float, double
2. I have tried using "Integer" in place of "int" and the program runs perfectly. Why is this so when "Integer" is not a reserved word in JAVA?
Thanks.

And to answer your first question, byte, short, int, long, float and double are all signed.
As a part of the core of the language, Sun developed a series of 'collections' classes; Vector, ArrayList, etc. All of these classes, in the days before generics, were able to store instances of the Object class or anything that derived from it. Therefore, to store an int, a float or a double value into one of these collections classes, it was necessary to wrap it up in an instance of one of those classes that derived from Number. These are the wrapper classes that the previous poster alluded to. Typically, the wrapper class has a similar name to the primitive data type but with a capital latter; int - Integer, double - Double, etc.

Transferring primitive data types via UDP other than a String

Hi ALL,
I am new to Socket programming in UDP.
I need to implement a FTP client-server application.
Now the packet that I need to transfer using UDP as a DatagramPacket consists of multiple primitive data types, (3short types and 1 byte array of size 265.)
How do I do that?
All the samples and examples I managed to find on the Internet illustrated the problem of transferring a String type converted to getBytes and the byteArray is transferred.
However, in my case i need to pass this structure..(3fields) to the other side. If I convert the 4 fields to a single concatenated string there's this problem of finding out where each of the four fields begin and where do they end.
Please suggest and help...
thanks..
: )

Just create a class that represents your structure and convert-it to a byte array that can be sended over a DatagramSocket.
Try this sample code :
import java.io.*;
import java.net.*;
public class DP
 /** Creates a new instance of DP */
 public DP ()
 * @param args the command line arguments
 public static void main (String[] args)
 try
 System.out.println ("Starting server ...");
 DatagramServerThread server = new DatagramServerThread ("Datagram server");
 server.start ();
 System.out.println ("Creating your object ...");
 ByteArrayOutputStream baos = new ByteArrayOutputStream (); // Creating byte array output stream ..
 ObjectOutputStream oos = new ObjectOutputStream (baos);// Creating a object output stream that writes to byte array output stream..
 YourStructure newObject = new YourStructure (); // creating your data structure..
 newObject.setShortField1 ((short)12);// setting values ...
 newObject.setShortField2 ((short)45);
 newObject.setShortField3 ((short)4);
 newObject.setArray (new byte [256]);
 oos.writeObject (newObject); // write your structure to object output stream...
 byte data_to_be_sent[] = baos.toByteArray (); // retrieving equivalent byte array...
 // send data...
 DatagramSocket s = new DatagramSocket ();
 System.out.println ("Sending ...");
 DatagramPacket packet = new DatagramPacket (data_to_be_sent, data_to_be_sent.length);
 packet.setAddress (InetAddress.getByName ("localhost"));
 packet.setPort (8888);
 s.send (packet);
 catch (Exception e)
 e.printStackTrace ();
class YourStructure implements Serializable
 * Holds value of property shortField1.
 private short shortField1;
 * Holds value of property shortField2.
 private short shortField2;
 * Holds value of property shortField3.
 private short shortField3;
 * Holds value of property array.
 private byte[] array;
 * Getter for property shortField1.
 * @return Value of property shortField1.
 public short getShortField1 ()
 return this.shortField1;
 * Setter for property shortField1.
 * @param shortField1 New value of property shortField1.
 public void setShortField1 (short shortField1)
 this.shortField1 = shortField1;
 * Getter for property shortField2.
 * @return Value of property shortField2.
 public short getShortField2 ()
 return this.shortField2;
 * Setter for property shortField2.
 * @param shortField2 New value of property shortField2.
 public void setShortField2 (short shortField2)
 this.shortField2 = shortField2;
 * Getter for property shortField3.
 * @return Value of property shortField3.
 public short getShortField3 ()
 return this.shortField3;
 * Setter for property shortField3.
 * @param shortField3 New value of property shortField3.
 public void setShortField3 (short shortField3)
 this.shortField3 = shortField3;
 * Getter for property array.
 * @return Value of property array.
 public byte[] getArray ()
 return this.array;
 * Setter for property array.
 * @param array New value of property array.
 public void setArray (byte[] array)
 this.array = array;
 public String toString ()
 StringBuffer buffer = new StringBuffer ();
 buffer.append ("Short field 1 is ");
 buffer.append(this.getShortField1 ());
 buffer.append ("\nShort field 2 is ");
 buffer.append (this.getShortField2 ());
 buffer.append ("\nShort field 3 is ");
 buffer.append (this.getShortField3 ());
 buffer.append ("\nYour array field is ");
 for (int index = 0; index < this.getArray ().length; index++)
 buffer.append ("Index [" + index + "] = " + this.getArray () [index] + "\n");
 return buffer.toString ();
class DatagramServerThread extends Thread
 protected DatagramSocket socket = null;
 public DatagramServerThread (String name) throws IOException
 super (name);
 socket = new DatagramSocket (8888);
 public void run ()
 try
 byte buffer [] = new byte [socket.getReceiveBufferSize ()];
 DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
 System.out.println ("Server is ready. Waiting for packet ...");
 socket.receive(packet); // waiting for packet ...
 System.out.println ("Packet received! : ");
 byte received_data[] = packet.getData ();
 ByteArrayInputStream bais = new ByteArrayInputStream (received_data); // Creating byte array input stream ..
 ObjectInputStream ois = new ObjectInputStream (bais); // Creting Object input stream
 Object readed_object = ois.readObject ();
 YourStructure your_original_object = (YourStructure)readed_object;
 System.out.println (your_original_object.toString ());
 System.out.println ("Exiting server thread. Bye");
 socket.close ();
 catch (Exception e)
 System.err.println ("Server error");
 e.printStackTrace ();
}

Primitive v/s Non-primitive data type

Similar Messages

Maybe you are looking for