java object assignment by value

• United States
• United Kingdom

By Rafael del Nero , Java Developer, JavaWorld |

Tease your mind and test your learning, with these quick introductions to challenging concepts in Java programming.

Does Java pass by reference or pass by value?

You've probably heard that java passes by value, but what matters is how well you understand the concept and the code. find out what happens when you pass an object reference to a method in java..

Object references are passed by value

Are primitive types passed by value, passing immutable object references, passing mutable object references, take the object references challenge, what’s just happened, learn more about java.

Many programming languages allow passing parameters by reference or by value . In Java, we can only pass parameters by value . This imposes some limits and also raises questions. For instance, if the parameter value is changed in the method, what happens to the value following method execution? You may also wonder how Java manages object values in the memory heap. This Java Challenger helps you resolve these and other common questions about object references in Java.

All object references in Java are passed by value. This means that a copy of the value will be passed to a method. But the trick is that passing a copy of the value also changes the real value of the object. To understand why, start with this example:

What do you think the simpson.name will be after the transformIntoHomer method is executed?

In this case, it will be Homer! The reason is that Java object variables are simply references that point to real objects in the memory heap. Therefore, even though Java passes parameters to methods by value, if the variable points to an object reference, the real object will also be changed.

If you’re still not quite clear how this works, take a look at the figure below.

Like object types, primitive types are also passed by value. Can you deduce what will happen to the primitive types in the following code example?

If you determined that the value would change to 30, you are correct. It’s 30 because (again) Java passes object parameters by value. The number 30 is just a copy of the value, not the real value. Primitive types are allocated in the stack memory, so only the local value will be changed. In this case, there is no object reference.

What if we did the same test with an immutable String object?

The JDK contains many immutable classes. Examples include the wrapper types Integer , Double , Float , Long , Boolean , BigDecimal , and of course the very well known String class.

In the next example, notice what happens when we change the value of a String .

What do you think the output will be? If you guessed “” then congratulations! That happens because a String object is immutable, which means that the fields inside the String are final and can’t be changed.

Making the String class immutable gives us better control over one of Java’s most used objects. If the value of a String could be changed, it would create a lot of bugs. Also note that we’re not changing an attribute of the String class; instead, we’re simply assigning a new String value to it. In this case, the “Homer” value will be passed to name in the changeToHomer method. The String “Homer” will be eligible to be garbage collected as soon as the changeToHomer method completes execution. Even though the object can’t be changed, the local variable will be.

Unlike String , most objects in the JDK are mutable, like the StringBuilder class. The example below is similar to the previous one, but features StringBuilder rather than String :

Can you deduce the output for this example? In this case, because we’re working with a mutable object, the output will be “Homer Simpson.” You could expect the same behaviour from any other mutable object in Java.

You’ve already learned that Java variables are passed by value, meaning that a copy of the value is passed. Just remember that the copied value points to a real object in the Java memory heap. Passing by value still changes the value of the real object.

In this Java Challenger we’ll test what you’ve learned about object references. In the code example below, you see the immutable String and the mutable StringBuilder class. Each is being passed as a parameter to a method. Knowing that Java only passes by value, what do you believe will be the output once the main method from this class is executed?

Here are the options, check the end of this article for the answer key.

A : Warrior=null Weapon=null B : Warrior=Dragon Weapon=Dragon C : Warrior=Dragon Knight Weapon=Dragon Sword D : Warrior=Dragon Knight Weapon=Sword

The first parameter in the above example is the warriorProfession variable, which is a mutable object. The second parameter, weapon, is an immutable String :

Now let’s analyze what is happening inside this method. At the first line of this method, we append the Knight value to the warriorProfession variable. Remember that warriorProfession is a mutable object; therefore the real object will be changed, and the value from it will be “Dragon Knight.”

In the second instruction, the immutable local String variable will be changed to “Dragon Sword.” The real object will never be changed, however, since String is immutable and its attributes are final:

Finally, we pass null to the variables here, but not to the objects. The objects will remain the same as long as they are still accessible externally--in this case through the main method. And, although the local variables will be null, nothing will happen to the objects:

From all of this we can conclude that the final values from our mutable StringBuilder and immutable String will be:

The only value that changed in the changeWarriorClass method was warriorProfession , because it’s a mutable StringBuilder object. Note that warriorWeapon did not change because it’s an immutable String object.

The correct output from our Challenger code would be:

D : Warrior=Dragon Knight Weapon=Sword.

Video challenge! Debugging object references in Java

Debugging is one of the easiest ways to fully absorb programming concepts while also improving your code. In this video you can follow along while I debug and explain object references in Java.

Common mistakes with object references

• Trying to change an immutable value by reference.
• Trying to change a primitive variable by reference.
• Expecting the real object won't change when you change a mutable object parameter in a method.

What to remember about object references

• Java always passes parameter variables by value.
• Object variables in Java always point to the real object in the memory heap.
• A mutable object’s value can be changed when it is passed to a method.
• An immutable object’s value cannot be changed, even if it is passed a new value.
• “Passing by value” refers to passing a copy of the value.
• “Passing by reference” refers to passing the real reference of the variable in memory.
• Get more quick code tips: Read all of Rafael's articles in the InfoWorld Java Challengers series.
• Check out more videos in Rafael's Java Challengers video playlist .
• Find even more Java Challengers on Rafael's Java Challengers blog and in his book, with more than 70 code challenges .

This story, "Does Java pass by reference or pass by value?" was originally published by JavaWorld .

Next read this:

• Why companies are leaving the cloud
• 5 easy ways to run an LLM locally
• Coding with AI: Tips and best practices from developers
• Meet Zig: The modern alternative to C
• What is generative AI? Artificial intelligence that creates
• The best open source software of 2023
• Programming Languages

Copyright © 2020 IDG Communications, Inc.

Last Minute Java Object Assignment and Object Passing By Value or Reference Explained Tutorial

In Java, we create Classes. We create objects of the Classes. Let us know if it is possible to assign a Java Object  from one variable to another variable by value or reference in this Last Minute Java Tutorial. We also try to know whether it is possible to pass Java Objects to another method by Value or Reference in this tutorial.

You may also read about Introduction to Java Class Structure .

Java Object Assignment by Value or Reference Explained

In Java, objects are always passed by Reference. Reference is nothing but the starting address of a memory location where the actual object lies. You can create any number of references to just One Object. Let us go by an example.

We create a Class "Cloud" with a single Property called "color". It is a String object. We create 3 objects of the Cloud type.

Notice that all three references obj1, obj2 and obj3 are pointing to the same Cloud object. Thus the above example outputs the same color-property value " RED ". Later, we made the references obj2 and obj3 to point to the null location. Still the original object pointed or referenced by obj1 holds the value. So the final PRINT statement outputs "RED" as usual.

Note : Reference is also called a Variable whether Primitive or Object.

This concludes that a Java object assignment happens by Reference . But the actual value of memory location pointed by References are copied by Value only. So we are actually copying memory locations from one Reference variable to another Reference variable by Value . Interviewers ask this famous Java question just to test your knowledge. If someone asks in C language point of view , say that it is by Reference . If they ask in Java point of view , say that it is by Value. 

Java Object Passing by Value or Reference to a Method Explained

You already learnt that Object assignment in Java happens by Reference. Let us try to pass Objects to another method as a parameter or argument. We try to know whether Objects are passed by Value or Reference to another Method using the below example.

In the above example, we have created an object "obj1" of type Tractor. We assigned value of 100 to the property "height". We printed the value before passing the object to another method. Now, we passed the object to another method called "change" from the calling-method " main ". We modified the height property to 200 in the called-method . Now, we tried to print the value of the property in the Calling method. It shows that the Object is modified in the called-method.

Similarly, we can pass Java objects to the Constructor using Pass by Reference or simply Reference . 

This concludes that Java Objects are passed to methods by Reference . Here also, we pass the memory location pointed by one Reference variable to another Reference variable of a Called method as a Value only. So, you are actually passing Values (memory locations represented by integer or long data type). But the actual passed-object can only be referenced by a Reference variable. Interviewers take advantage of this tricky logic to confuse you. If someone asks in C language point of view , say that it is by Reference . If they ask in Java point of view , say that it is by Value .

Let us know more about Java Classes with different Constructors and Methods in coming chapters.

Share this Last Minute Java  Tutorial explaining Java Object Assignment using Reference and Java Object Passing with Pass by Reference with your friends and colleagues to encourage authors.

Java Class Structure Tutorial

Java Method Signature Rules Tutorial

• Manage Email Subscriptions
• How to Post to DZone
• Article Submission Guidelines
• Manage My Drafts

Cloud Native : How are orgs leveraging a cloud-centric state of development that allow their applications to remain resilient and scalable?

Data Engineering: Work with DBs? Build data pipelines? Or maybe you're exploring AI-driven data capabilities? We want to hear your insights.

Launch your software development career: Dive head first into the SDLC and learn how to build high-quality software and teams.

AI Automation Essentials . Check out this Refcard for all things AI automation, including model training, data security, and more.

• Singleton: 6 Ways To Write and Use in Java Programming
• Creating a Deep vs. Shallow Copy of an Object in Java
• Java String: A Complete Guide With Examples
• Java: A Time-Tested Programming Language Still Going Strong
• Cypress With Cucumber for Seamless End-To-End Testing
• Cost Optimization Strategies for High-Volume Data Platforms
• Middleware in Autonomous Vehicles
• Application Task Driven: LLM Evaluation Metrics in Detail

Passing by Value vs. Passing by Reference in Java

While many languages put information passing into the hands of developers, all data is passed by value in java. see how to turn that restriction to your advantage..

Join the DZone community and get the full member experience.

Understanding the technique used to pass information between variables and into methods can be a difficult task for a Java developer, especially those accustomed to a much more verbose programming language, such as C or C++. In these expressive languages, the developer is solely responsible for determining the technique used to pass information between different parts of the system. For example, C++ allows a developer to explicitly pass a piece of data either by value, by reference, or by pointer. The compiler simply ensures that the selected technique is properly implemented and that no invalid operation is performed.

In the case of Java, these low-level details are abstracted, which both reduces the onus on the developer to select a proper means of passing data and increases the security of the language (by inhibiting the manipulation of pointers and directly addressing memory). In addition, though, this level of abstraction hides the details of the technique performed, which can obfuscate a developer's understanding of how data is passed in a program. In this article, we will examine the various techniques used to pass data and deep-dive into the technique that the Java Virtual Machine (JVM) and the Java Programming Language use to pass data, as well as explore some examples that demonstrate in practical terms what these techniques mean for a developer.

Terminology

In general, there are two main techniques for passing data in a programming language: (1) passing by value and (2) passing by reference. While some languages consider passing by reference and passing by pointer two different techniques, in theory, one technique can be thought of as a specialization of the other, where a reference is simply an alias to an object, whose implementation is a pointer.

Passing by Value

The first technique, passing by value, is defined as follows:

Passing by value constitutes copying of data, where changes to the copied value are not reflected in the original value

For example, if we call a method that accepts a single integer argument and the method makes an assignment to this argument, the assignment is not preserved once the method returns. While one might expect that the assignment is preserved after the method returns, the assignment is lost because the value placed on the call stack was a copy of the value passed into the method, as illustrated in the snippet below:

If we execute this code, we obtain the following output:

We see that the change made to the argument passed into the process function was not preserved after we exited the scope of the function. This loss of data was due to the fact that a copy of the value held by the someValue variable was placed on the call stack prior to the execution of the process function. Once the process function exited, this copy was popped from the call stack and the changes made to it were lost, as illustrated in the figure below:

Additionally, the action of popping the call stack at the completion of the process method is illustrated in the figure below. Note that the value copied as the argument to the process method is lost (reclaimed) once the call stack is popped, and therefore, all changes made to that value are in turn lost during the reclamation step.

Passing by Reference

The alternative to passing by value is passing by reference, which is defined as follows:

Passing by reference consitutes the aliasing of data, where changes to the aliased value are reflected in the original value

Unlike passing by value, passing by reference ensures that a change made to a value in a different scope is preserved when that scope is exited. For example, if we pass a single argument into a method by reference, and the method makes an assignment to that value within its body, the assignment is preserved when the method exits. This can be demonstrated using the following snippet of C++ code:

If we run this code, we obtain the following output:

In this example, we can see that when we exit the function, the assignment we made to our argument that was passed by reference was preserved outside of the scope of the function. In the case of C++, we can see that under-the-hood, the compiler has passed a pointer into the function that points to the someValue variable. Thus, when this pointer is dereferenced (as happens during reassignment), we are making a change to the exact location in memory that stores the someValue variable. This principle is demonstrated in the illustrations below:

Passing Data in Java

Unlike in C++, Java does not have a means of explicitly differentiating between pass by reference and pass by value. Instead, the Java Language Specification ( Section 4.3 ) declares that the passing of all data, both object and primitive data, is defined by the following rule:

All data is passed by value

Although this rule may be simple on the surface, it requires some further explanation. In the case of primitive values, the value is simply the actual data associated with the primitive (.e.g 1 , 20.7 , true , etc.) and the value of the data is copied each time it is passed. For example, if we define an expression such as int x = 7 , the variable x holds the literal value of 7 . In the case of objects in Java, a more expanded rule is used:

The value associated with an object is actually a pointer, called a reference, to the object in memory

For example, if we define an expression such as Foo foo = new Foo() , the variable foo does not hold the Foo object created, but rather, a pointer value to the created Foo object. The value of this pointer to the object (what the Java specification calls an object reference , or simply reference) is copied each time it is passed. According to the Objects section (Section 4.3.1) of the Java Language Specification, only the following can be performed on an object reference:

• Field access, using either a qualified name or a field access expression
• Method invocation
• The cast operator
• The string concatenation operator  + , which, when given a  String operand and a reference, will convert the reference to a  String by invoking the  toString method of the referenced object (using  "null" if either the reference or the result of  toString is a null reference), and then will produce a newly created  String that is the concatenation of the two strings
• The instanceof operator
• The reference equality operators == and !=
• The conditional operator  ? :

In practice, this means that we can change the fields of the object passed into a method and invoke its methods, but we cannot change the object that the reference points to. Since the pointer is passed into the method by value, the original pointer is copied to the call stack when the method is invoked. When the method scope is exited, the copied pointer is lost, thus losing the change to the pointer value.

Although the pointer is lost, the changes to the fields are preserved because we are dereferencing the pointer to access the pointed-to object: The pointer passed into the method and the pointer copied to the call stack are identical (although independent) and thus point to the same object. Thus, when the pointer is dereferenced, the same object at the same location in memory is accessed. Therefore, when we make a change to the dereferenced object, we are changing a shared object. This concept is illustrated in the figure below:

This should not be confused with passing by reference: If the pointer were passed by reference, the variable foo would be an alias to someFoo and changing the object that foo points to would also change the object that someFoo points to. In this case, though, a copied pointer is passed into the function, and thus, the change to the pointer value is lost once the call stack it popped.

While it is crucial to understand the concepts behind passing data in a programming language (Java in particular), many times it is difficult to solidify these theoretical ideas without concrete examples. In this section, we will cover four primary examples:

• Assigning primitive values to a variable
• Passing primitive values to a method
• Assigning object values to a variable
• Passing object values to a method

For each of these examples, we will explore a snippet of code accompanied by print statements that show the value of the primitive or object at each major step in the assignment or the argument-passing process.

Primitive Type Example

Since Java primitives are not objects, primitives and objects are treated as two separate cases with respect to data binding (assignment) and argument-passing. In this section, we will focus on binding primitive data to a variable and passing primitive data to a simple method.

Assigning Values to Variable

If we assign an existing primitive value, such as someValue , to a new variable, anotherValue , the primitive value is copied to the new variable. Since the value is copied, the two variables are not aliases of one another, and therefore, when the original variable, someValue , is changed, the change is not reflected in anotherValue :

If we execute this snippet, we receive the following output:

Passing Values to Method

Similar to making primitive assignments, the arguments for a method are bound by value, and thus, if a change is made to the argument within the scope of the method, the changes are not preserved when the method scope is exited:

If we run this code, we see that the original value of 7 is preserved when the scope of the process method is exited, even though that argument was assigned a value of 50 within the method scope:

Object Type Example

While all values, both primitive and object, are passed by value in Java, there are some nuances in passing objects by value that are made explicit when seen in an example. Just as with primitive types, we will explore both assignment and argument binding the following examples.

The variable binding semantics of for objects and primitives are nearly identical, but instead of binding a copy of the primitive value, we bind a copy of the object address. We can see this in action in the following snippet:

In this example, we expect that assigning a new Ball object to someBall (after assigning someBall to anotherBall ) does not change the value of anotherBall , since anotherBall holds a copy of the address for the original someBall . When the address stored at someBall changes, no change is made to anotherBall because the copied value in anotherBall is completely independent of the address value stored in someBall . If we execute this code, we see our expected results (note that the address of each Ball object will vary between executions, but the address in line 1 and line 3 should be identical, regardless of the specific address value):

Passing Values to Methods

The last case we must cover is that of passing an object into a method. In this case, we see that we are able to change the fields associated with the passed in object, but if we try to reassign a value to the argument itself, this reassignment is lost when the method scope is exited.

If we execute this code, we see the following output:

Although there is a large volume of output, if we take each line one at a time, we see that when we make a change to the fields of a Vehicle object passed into a method, the field changes are preserved, but when we try to reassign a new Vehicle object to the argument, the change is not preserved once we leave the scope of the method.

In the former case, the address of the Vehicle created outside the method is copied to the argument of the method, and thus both point to the same Vehicle object. If this pointer is dereferenced (which occurs when the fields of the object are accessed or changed), the same object is changed. In the latter case, when we try to reassign the argument with a new address, the change is lost because the argument is only a copy of the address of the original object, and thus, once the method scope is exited, the copy is lost.

A secondary principle can be formed from this mechanism in Java: Do not reassign arguments passed into a method (codified by Martin Fowler in the refactoring Remove Assignments to Parameters ). To ensure that no such reassignment of method arguments is made, the arguments can be marked as final in the method signature. Note that a new local variable can be used instead of the arguments if reassigned is required:

Although fundamental principles such as data binding schemes and data passing schemes can seem abstract in the realm of daily programming, these concepts are essential in avoiding subtle mistakes. Unlike other programming languages (such as C++), Java simplifies its data binding and passing scheme into a single rule: Data is always passed by value. Although this rule can be a harsh restriction, its simplicity, and understanding how to apply this simplicity, can be a major asset when accomplishing a slew of daily tasks.

Opinions expressed by DZone contributors are their own.

Partner Resources

• About DZone
• Send feedback
• Community research
• Advertise with DZone

CONTRIBUTE ON DZONE

• Become a Contributor
• Core Program
• Visit the Writers' Zone
• Terms of Service
• Privacy Policy
• 3343 Perimeter Hill Drive
• Nashville, TN 37211
• [email protected]

Let's be friends:

• Prev Class
• Next Class
• No Frames
• All Classes
• Summary: 
• Nested | 
• Field | 
• Constr  | 
• Detail: 

Class Object

• java.lang.Object
• public class Object Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class. Since: JDK1.0 See Also: Class

Constructor Summary

Method summary, constructor detail, method detail.

The actual result type is Class<? extends |X|> where |X| is the erasure of the static type of the expression on which getClass is called. For example, no cast is required in this code fragment:

Number n = 0; Class<? extends Number> c = n.getClass();

x.clone() != x

x.clone().getClass() == x.getClass()

x.clone().equals(x)

getClass().getName() + '@' + Integer.toHexString(hashCode())

1000000*timeout+nanos

Submit a bug or feature For further API reference and developer documentation, see Java SE Documentation . That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples. Copyright © 1993, 2024, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms . Also see the documentation redistribution policy .

Scripting on this page tracks web page traffic, but does not change the content in any way.

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

onlineexamguide

• Electrical Engineering
• Mechanical Engineering
• Automobile Engineering
• Civil Engineering
• Computer Science Engineering
• Chemical Engineering
• Aptitude Tricks
• Computer Knowledge
• Logical Reasoning Tricks
• Ghatna Chakra
• Instructor Registration
• Student Registration

Object in java Assignment and Object Passing By Value or Reference

Table of Contents

Study and learn Interview MCQ Questions and Answers on object in java . Attend job interviews easily with these Multiple Choice Questions.

Object in java

Objects are always passed by Reference. Reference is nothing but the starting address of a memory location where the actual object lies. You can create any number of references to just One Object. Let us go by an example .

We create a Class “Cloud” with a single Property called “color”. It is a String object . We create 3 objects of the Cloud type.

Notice that all three references obj1, obj2 and obj3 are pointing to the same Cloud object. Thus the above example outputs the same color-property value “ RED “. Later, we made the references obj2 and obj3 to point to the null location. Still the original object pointed or referenced by obj1 holds the value. So the final PRINT statement outputs “RED” as usual.

Note : Reference is also called a Variable whether Pri-mitive or Object.

This concludes that a Java object assignment happens by Reference . But the actual value of memory location pointed by References are copied by Value only. So we are actually copying memory locations from one Reference variable to another Reference variable by Value . Interviewers ask this famous Java question just to test your knowledge. If someone asks in C language point of view , say that it is by Reference . If they ask in Java point of view , say that it is by Value. 

object in java Passing by Value or Reference to a Method Explained

You already learnt that Object assignment in Java happens by Reference. Let us try to pass Objects to another method as a parameter or argument.

In the above example, we have created an object “obj1” of type Tractor. We assigned value of 100 to the property “height”. We printed the value before passing the object to another method. Now, we passed the object to another method called “change” from the calling-method “ main “. We modified the height property to 200 in the called-method . Now, we tried to print the value of the property in the Calling method.

Similarly, we can pass Java objects to the Constructor using Pass by Reference or simply Reference . 

Here also, we pass the memory location pointed by one Reference variable to another Reference variable of a Called method as a Value only. So, you are actually passing Values (memory locations represented by integer or long data type). Interviewers take advantage of this tricky logic to confuse you. If someone asks in C language point of view , say that it is by Reference . If they ask in Java point of view , say that it is by Value .

[WpProQuiz 157]

Object in java mcq, 1) what is the output of the below java program with two classes.

A) Hello Boss.!

B) No Output

C) Compiler error

D) None of the above

Answer [=] C

Explanation:

There can not be more than one public class declared inside a single java file.

2) What is the output of the below Java program?

The class name and the java file name should be the same. So, change either file name or class name to match.

3) State TRUE or FALSE. A Java class provides encapsulation.

Answer [=] A

4) What is the output of the below java class?

D) Compiler error

There can be any number of classes in a single .java file.

5) The value of one Pri-mitive variable is assigned to another Pri-mitive variable by ___ in Java.

A) Pass by value

B) Pass by reference

6) A Pri-mitive variable is passed from one method to another method by ___ in Java.

7) an object or pri-mitive value that is passed from one method to another method is called ___ in java. (argument / parameter).

A) Argument

B) Parameter

Answer [=] B

8) An object or a Pri-mitive value that is received in a method from another method is called ___ in Java. (Argument / Parameter)

9) what is the output of the below java program that passes an object to another method, 10) what is the output of the below java program that passes pri-mitive values.

The Pri-mitive values are passed by value only. So, changes in the method modify does not change the original value.

11) Java object assignment happens by ___.

A) Pass by Value

B) Pass by Reference

Yes. That is the reason why you can change the values of variables of the object using another reference.

12) Java object passing from one method to another method happens by ___.

References point to the original objects. So they can change the state of the objects.

13) In Java Pass by reference ___ is passed even if you are passing a reference to an object.

A) Address value

B) Variable value

C) Hash code

Yes. The address is passed automatically by Java. So, Java pundits argue that it is passing a value (Address).

14) A Java reference is comparable to ___ in C language.

B) Structure

15) ___ is the superclass to all Java classes either user-defined or built-in.

C) Superclass

Yes. java.lang.Object is the superclass to all Java classes.

16) State TRUE of FALSE. Java objects have built-in methods to handle threads.

Yes. The methods are wait(), notify() and notifyAll().

17) State TRUE or FALSE. Java Object’s hashcode() method is mainly used with Collection objects.

Java collection classes use the hashcode() method to determine the equality of two objects.

18) What is the output of the below Java program using toString() method?

A) Printing Object=

B) Printing Object=null

C) Printing Object=College Object

print() and println() methods call toString() method of objects automatically.

19) What is the output of the below Java program?

B) Runs= 250

C) Runs= 300

The reference C2 also points to the same object pointed by reference C1.

20) What is the output of the below Java program?

A) Posts=25

C) Posts=null

D) Runtime exception occurs

Even if one REFERENCE to the same object is alive, it can be used to access the object. So, wp2 still works even if wp1 is set to null.

Write a comment Cancel reply

You must be logged in to post a comment.

onlineexamguide.com is the ultimate guide that will keep you updated about almost every Exam & Interviews . We aim to provide our readers with an informative details that have been occurring in Examination . Here at onlineexamguide.com , we focus on delivering our readers with the latest exam Pattern Mock test

We Provide Free online test to practice for Competitive exams , Online Exam, Entrance and Interview. Learn and Practice online test for Free and Prepare for your exam online with us

Quick links

• Privacy Policy
• Java Programming
• C programming
• C++ programming

Free Online Mock Test

• UPTET PRIMARY Online Test Series
• Super TET Mock Test in Hindi 2023
• CTET Mock Test 2022 Paper 1
• SSC CHSL Online Mock Test
• SSC MTS Mock Test 2023
• SSC CGL Mock Test
• SSC GD Mock Test
• ccc online test

Learn and Earn

Register as Instructor - Create  and sell online courses and coaching services with the best online platform onlineexamguide.com . Build  a  course ,  build  a brand,  earn money

For any queries

Email us on - [email protected]

We will response fast as much as we can

Insert/edit link.

Enter the destination URL

Or link to existing content

Improving OpenJDK Scalar Replacement – Part 1/3

Cesar Soares

May 28th, 2024 0 2

Scalar replacement (SR) is a powerful optimization technique in OpenJDK that aims to enhance the performance of Java applications by breaking down complex objects into simpler, more manageable scalar variables. In this three-part blog series, we will delve into the intricacies of scalar replacement and the enhancements we’ve contributed to the OpenJDK implementation of it. The first post will provide an overview of scalar replacement, explaining its purpose and fundamental mechanisms. The second post will detail the specific improvements we have made. Finally, the third post will present the results of these improvements. Let’s jump right into it – and don’t forget to add comments!

Introduction  

The OpenJDK JVM has two Just-In-Time compilers, C1 and C2. C2 is a compiler that applies many optimizations to produce a very efficient compiled version of the program. This blog post series presents an improvement that we contributed to C2 scalar replacement optimization. But before we delve into the details of our contributions, we are going to discuss about three optimizations implemented in C2: escape analysis , method inlining, and scalar replacement .  

Escape analysis (EA) analyzes the code being compiled and decides for each object allocation whether that object might be used outside the current method or thread.

Method Inlining (MI) is, in very general terms, an optimization that replaces method calls with a copy of the body of the method being called.    

Scalar replacement (SR) is an optimization which tries to remove object allocations that it considers unnecessary, and it uses information provided by EA and changes made by MI to achieve that. SR removes object allocations by transforming the code to store object’s fields in local variables and using MI to remove the need to invoke methods on objects.  

The main benefit of SR may be that it decreases memory allocation rate and pressure on the Garbage Collector (GC). However, there are more benefits. By removing allocations, the method’s code becomes simpler, which may reveal more optimizations. So, in general, doing scalar replacement is a Good Thing TM .

A Simple Example  

We are going to use the Message class shown in Listing 1 as the running example in this article. The important things to note in this class are the Checksum method and the content field. The Checksum method iterates on the characters of the content field and accumulates their integer value, returning that as the checksum of the message list.    

Listing 1: The Message class.  

Listing 2 shows the CompositeChecksum method. This method iterates on a list of messages and for each message it calls the Checksum method on it. The method accumulates the checksum of all messages and returns it as the composite checksum of the list. This may not be an example of a piece of code written very carefully, but is the kind of code that is often processed by compilers, especially after many transformations have been applied to the code.  

Listing 2: The CompositeChecksum method.  

Listing 3 highlights what is going to happen when MI is performed on this method with respect to the Message class constructor and Checksum method. Note that the constructor of the Message object is going to be copied in the place where the constructor was previously being called and the call to the Checksum method is going to be replaced by the code of the Checksum method itself. Of course, after the code is copied, it is adjusted to still work correctly in the target location.  

Listing 3: The CompositeChecksum method during inlining optimization.  

Listing 4 shows the code after MI has been executed. Note that the object allocation is still happening. The body of the Message and Checksum methods were copied inside the loop, but they still operate on an object, in this case the one pointed to by m_ptr – previously these methods used an object pointed to by this . The chks variable that was local to the Checksum method now is another variable local to the CompositeChecksum loop.  

Listing 4: The CompositeChecksum method after inlining optimization.  

Note that there is still room for improving the code of the CompositeChecksum method. After performing some more analysis C2 will find that some of the assignments in the code do not really need to be performed. For instance, the assignment of the msg variable to the content variable can be eliminated and we can just iterate on msg itself, instead of content . The same logic applies to the chks variable: instead of doing the computation on the chks variable and then later assigning it to cs and then accumulating into checksum we can just do the computation directly in the checksum variable. Listing 5 shows the code after these optimizations.   

Listing 5: The CompositeChecksum method after additional optimizations.  

After still some more analysis C2 will note that there are only writes to the object pointed to by m_ptr and no code is reading from it. That observation, together with some other info about the object class, means that this object allocation is not necessary and therefore it can be removed! Listing 6 shows the code after the object allocation is removed.  

Listing 6: The CompositeChecksum method after Message allocation is removed.    

The object allocation removal was only possible because at some point there was no code reading from that object. Scalar replacement is one of the optimizations that replaces loads from objects’ fields with a direct use of the statement (or value) that was last written in the objects’ fields. There are other optimizations that achieve the same effect but usually they work on simple pieces of code, like this example method. Scalar replacement, however, can “look” more thoroughly in the method and find points where these object fields’ writes can be simplified.  

In conclusion, scalar replacement serves as a critical optimization technique within OpenJDK, transforming complex object instances into simpler scalar variables to enhance runtime performance. By eliminating the need for heap allocation and reducing memory overhead, scalar replacement significantly improves execution speed and resource efficiency. Understanding the fundamental mechanisms behind scalar replacement sets the stage for the second part of this series where we describe the improvements we contributed to OpenJDK’s scalar replacement implementation.

Leave a comment Cancel reply

Log in to start the discussion.

Insert/edit link

Enter the destination URL

Or link to existing content

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot

Array Variable Assignment in Java

• Variable Arguments (Varargs) in Java
• Default Array Values in Java
• How to Implement a Resizable Array in Java?
• Reflection Array Class in Java
• Array get() Method in Java
• Array getInt() Method in Java
• Iterating over Arrays in Java
• Array vs ArrayList in Java
• Arrays class in Java
• Implementing Associate Array in Java
• Iterating over ArrayLists in Java
• String Arrays in Java
• Array Literals in Java
• Rules For Variable Declaration in Java
• Convert HashSet to array in Java
• Arrays.sort() in Java with examples
• Array getFloat() Method in Java
• Array of ArrayList in Java
• Convert List to Array in Java

An array is a collection of similar types of data in a contiguous location in memory. After Declaring an array we create and assign it a value or variable. During the assignment variable of the array things, we have to remember and have to check the below condition.

1. Element Level Promotion

Element-level promotions are not applicable at the array level. Like a character can be promoted to integer but a character array type cannot be promoted to int type array.

2. For Object Type Array

In the case of object-type arrays, child-type array variables can be assigned to parent-type array variables. That means after creating a parent-type array object we can assign a child array in this parent array.

When we assign one array to another array internally, the internal element or value won’t be copied, only the reference variable will be assigned hence sizes are not important but the type must be matched.

3. Dimension Matching

When we assign one array to another array in java, the dimension must be matched which means if one array is in a single dimension then another array must be in a single dimension. Samely if one array is in two dimensions another array must be in two dimensions. So, when we perform array assignment size is not important but dimension and type must be matched.

Please Login to comment...

Similar reads, improve your coding skills with practice.

What kind of Experience do you want to share?