DEV Community: UdayKiran137

Understanding Java Memory Allocation: Stack vs. Heap

UdayKiran137 — Tue, 05 Oct 2021 03:28:12 +0000

Java Stack

A Java stack is a portion of your Computer's memory that stores temporary variables created by all functions you run. It's used to run a thread and can include both short-term values and references to other objects. It employs a LIFO (last in, first out) data structure.

When a method is called, a new block in the stack is created for that method. All local values and pointers to other objects utilized by the process will be stored in the new block. When the procedure is finished, the new block is erased and made available for the following method. The things you'll discover here are solely helpful for that function and won't last beyond it.

This makes keeping track of the stack a breeze, as the most recently reserved block is also the first to be freed. The variables created for the method are saved in memory and can be accessed quickly.

Because all variables created on the stack are wiped forever when a method ends, the memory size of a Java stack is typically significantly smaller than that of a Java heap area.

An example of how to make a stack object is as follows:

void somefunction( )
{
    /* create an object "m" of class Member
    this will be put on the stack since the
    "new" keyword is not used, and we are
    creating the object inside a function
    */

    Member m;

} //the object "m" is destroyed once the function ends

Java Heap

The heap is a location where Java objects are stored. It is formed when the program is executed, and its size may change as the program executes. It's easy for it to fill up, and when it does, garbage collection is started. Objects that are no longer in use are eliminated in order to make room for new ones.

Unlike a Java stack, where memory is allocated when the program is compiled, a Heap allocates Memory while the program is run. When opposed to the direct and fast access of a stack, accessing variables stored here is a little slower.

A global memory pool is analogous to a Heap. If you need the data or variables to live longer than the method or function in question, the heap will be used for Memory Allocation. All of the functionalities are accessible through the items found here.

In addition, there is no set order in which blocks in a heap should be reserved. You can allocate blocks at any time and then release them as needed. As you might expect, keeping track of the sections that are free and can be allocated is much more difficult, but it can be divided into two generations or sub-areas.

The young space (or nursery) and the old space are the two sub-areas. The memory allocation for new objects is usually done in the young space. Garbage collection occurs when the young space is filled. The youthful space is often used by short-term or transient things. When compared to a heap with no divisions, this aid speeds up garbage collection.

An example of how to make an item on the Heap is as follows:

void somefunction( )
{
    /* create an object "m" of class Member
      this will be put on the heap since the 
      "new" keyword is used, and we are 
      creating the object inside a function
    */

    Member* m = new Member( );

    /* the object "m" must be deleted
      otherwise a memory leak occurs
    */

    delete m; 
}

Stack and Heap's Similarities and Dissimilarities

Both of these methods are used by Java to allocate memory, and both are stored in RAM. To make things simpler, heap is utilized for dynamic memory allocation and stack is used for static memory allocation.

Where is it kept? Variables allocated on the stack can be accessed directly from memory, allowing them to run very quickly. Objects on the heap, on the other hand, take longer to access.

When will the allocation take place? When the application is compiled, memory is allocated on the stack. Meanwhile, when the program is started, it starts on the heap.

And, since this is the case, if you wish to use the stack, you'll need to know exactly how much data and memory you'll need before compiling. The stack also has the problem of not being able to manage large blocks of variables that require a lot of memory. You should use heap if you don't know how much data you'll need at runtime or if you require memory for a large amount of data.

In a Nutshell…

Stack:

As methods and functions add and destroy local variables as needed, the stack's size will change.
Without you having to control the memory allocation, memory is allocated and then freed.
The size of a stack is limited, and this varies depending on the operating system.
Variables stored on the stack remain valid for as long as the function that created them is active.

Heap:

Memory is not controlled automatically, and it is not handled as closely by the central processing unit as stack is. When these blocks are no longer required, you must clear the allotted RAM yourself.
Memory leaks are common in heaps, where memory is allocated to useless objects and not available to other processes.
The heap has no size restrictions.
Objects on the heap are much slower to access than those in the stack. It's also slower to write to the heap's memory.

Stack is more convenient and faster to use, but it has a number of drawbacks that you can overlook if you utilize heap.

When do you use "Stack"?

Only local variables that take up a small amount of memory can be stored on the stack. The best part is that memory management and allocation will not be a problem for you, and access to these objects will be lightning quick. It suffers from size restrictions and the inability to resize variables on the stack.

When do you use "Heap"?

If there are variables that need to be accessed worldwide rather than only by the procedures and functions that produced them, you use the heap to allocate memory. Because it has no memory size restriction, heap is also useful when you need a lot of memory. The variables in the heap can also be resized.

Finally, I'd want to state that

Java allocates memory in two ways: stack and heap. When you have variables that require global access, heap is the way to go, whereas stack is the way to go for local variables that just require a limited amount of memory. When it comes to writing better Java applications, knowing when and how to use a stack and a heap is crucial.

When dealing with memory leaks, it's also beneficial to understand how memory allocation works.

Top 5 Operations for Python Lists

UdayKiran137 — Sun, 02 May 2021 10:11:17 +0000

A list is an ordered collection of Python objects. As a mutable data type, lists are often used to store data that are subject to change at the runtime. Another advantageous feature of lists is that the allowance of having duplicate elements.
Because of these features, lists are probably the most used data structure in any Python project. In this article, I will share the top 5 operations for the use of Python lists with you.

1. Construction
The first apparent operation is how we create lists.

I) The easiest way will be just listing composing elements inside a pair of square brackets. We use commas to separate these items. Optionally, we can use this declaration with the * operator if we want to repeat a particular list for specific times.

Code
>>> # Create an empty list
>>> empty_list = []
>>> # A list of numbers
>>> numbers = [1, 2, 3, 4, 5]
>>> # Use * operator
>>> triples = [1, 2, 3] * 3
>>> triples
[1, 2, 3, 1, 2, 3, 1, 2, 3]

II) We can also create lists by slicing existing lists. Some examples are shown below. One quick note, these slicing operations return lists as their return values, but just to make code snippets of the present article look clear, I don’t typically assign these lists to variables such that the Python interpreter will print them automatically.

Code
>>> # Suppose we have the following list to begin with
>>> list0 = [0, 2, 4, 6, 8, 10, 12, 14]
>>> # Create a list of the same elements
>>> list0[:] # This is equivalent to list0.copy()
[0, 2, 4, 6, 8, 10, 12, 14]
>>> # Specify the start, end, and step 
>>> list0[1:8:2]
[2, 6, 10, 14]
>>> # Create a list of the reverse order
>>> list0[::-1]
[14, 12, 10, 8, 6, 4, 2, 0]

III) More generally, we can use the list() function that creates lists from any iterable, such as tuples and dictionaries. When nothing is set, the list() function will create an empty list.

Code
>>> # from range
>>> list(range(4))
[0, 1, 2, 3]
>>> # from tuple
>>> list((5, 4, 3))
[5, 4, 3]
>>> # from dictionary
>>> list({'zero': 0, 'one': 1, 'two': 2})
['zero', 'one', 'two']
>>> # from map object
>>> list(map(len, ['one', 'hello', 'world!']))
[3, 5, 6]

IV) Another convenient way is to use the list comprehension. The general format is [expression for ele in iterable if condition].

Code
>>> # Create a list of squares
>>> [x*x for x in range(5)]
[0, 1, 4, 9, 16]
>>> # Create a list of even numbers
>>> [x for x in range(10) if x%2 == 0]
[0, 2, 4, 6, 8]

2. Access Elements
When we work with lists, we need to access individual elements or elements within a range.

I) We can access individual elements using indexing. Typically, we use zero-based indexing that counts from the left. Alternatively, we can use reverse indexing, which counts from the right and begins with -1.

Code
>>> numbers = [1, 4, 5, 7, 9, 13]
>>> # Forward Indexing
>>> numbers[2]
5
>>> # Reverse Indexing
>>> numbers[-1]
13

II) We can access individual and a range of elements by unpacking. It’s pretty much like unpacking a tuple (i.e., a, b = (‘code’, 404)), and we can use * and _ to have a more powerful unpacking

Code
>>> pets = ['Dog', 'Cat', 'Turtle', 'Snake', 'Hamster']
>>> # when we're only interested in the first and last element
>>> a, *_, b = pets
>>> # elements as a list and two last elements
>>> *c, d, e = pets
>>> print(f'a: {a}, b: {b}, c: {c}, d: {d}, e: {e}')
a: Dog, b: Hamster, c: ['Dog', 'Cat', 'Turtle'], d: Snake, e: Hamster

III) We can access multiple elements using slicing. It’s discussed in the above section when we use slicing to create new lists

Code
>>> numbers = list(range(20))
>>> # Get even numbers
>>> numbers[::2]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> # Get odd numbers
>>> numbers[1::2]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> # Get some numbers in the middle
>>> numbers[5:9]
[5, 6, 7, 8]

IV) We can access a random element in the list. It can be done using random.choice() function. Please note that this function is available in the random module.

Code
>>> import random
>>> lottery_tickets = ['A0049', 'A0050', 'A0051', 'A0052', 'A0053']
>>> # draw the winning ticket
>>> random.choice(lottery_tickets)
'A0050'

V) We can find the index of a particular object. To do that, we can use the index() method. Please note that we’ll encounter an error if the object isn’t on the list.

Code
>>> students = ['John', 'Mike', 'Jennifer', 'Joe']
>>> # when an object exist
>>> students.index('Mike')
1
>>> # when an object doesn't exist
>>> students.index('Mary')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'Mary' is not in list

3. Conditionals
Certain operations rely on whether a particular condition is met or not. There are multiple possible conditions that pertain to lists in Python.

I) We can check if a list is empty. When a list isn’t empty, it is evaluated as True. When it’s empty, using the not keyword will make the evaluation True. In other words, an empty list is evaluated as False.

Code
>>> some_list = [1, 2]
>>> empty_list = []
>>> if some_list:
...     print('This is not an empty list')
... 
This is not an empty list
>>> if not empty_list:
...     print('This is to negate an empty list')
... 
This is to negate an empty list

II) We can check if an element is in the list. To do that, we can use the item in the list expression. To negate it, we can use not in.

Code
>>> activities = ['soccer', 'tennis', 'swim', 'karate']
>>> # check if something is in the list
>>> 'tennis' in activities
True
>>> # check if something is not in the list
>>> 'swim' not in activities
False

III) We can check if the list contains all the elements of another list. We can take advantage of some built-in functionalities of the set datatype.

Code
>>> larger_list = [7, 8, 9, 17, 18, 19]
>>> smaller_list = [8, 9, 18, 19]
>>> # use the issuperset function
>>> set(larger_list).issuperset(set(smaller_list))
True
>>> # use the issubset function
>>> set(smaller_list).issubset(set(larger_list))
True

IV) We can check if the list contains any elements of another list. Similarly, as above, the set data type has built-in functionalities for this operation.

Code
>>> large_list = [7, 8, 9, 17, 18, 19]
>>> small_list0 = [9, 28, 29]
>>> small_list1 = [28, 29]
>>> # use the intersection function
>>> bool(set(large_list).intersection(set(small_list0)))
True
>>> bool(set(large_list).intersection(set(small_list1)))
False

4. Modify Elements
One major feature of lists is their mutability, which means we can modify their elements, such as adding and removing items.

I) We can append an element at the end or insert one at a particular index using the append() and insert() methods, respectively

Code
>>> existing_numbers = [2, 4, 6, 8]
>>> # append an element at the end
>>> existing_numbers.append(10)
>>> existing_numbers
[2, 4, 6, 8, 10]
>>> # insert an element at an index
>>> existing_numbers.insert(0, 0)
>>> existing_numbers
[0, 2, 4, 6, 8, 10]

II) We can extend the list by appending multiple elements using the extend() method, which takes in an iterable.

Code
>>> numbers_to_extend = [1, 3, 5]
>>> # extend the list with another list
>>> numbers_to_extend.extend([7, 9])
>>> numbers_to_extend
[1, 3, 5, 7, 9]
>>> # extend the list with a tuple
>>> numbers_to_extend.extend((11, 13))
>>> numbers_to_extend
[1, 3, 5, 7, 9, 11, 13]

III) We can replace certain elements directly. It can be achieved by assignment to the element at an index or elements within a range.

Code
>>> numbers_to_replace = [1, 2, 3, 5]
>>> # replace an element
>>> numbers_to_replace[3] = 4
>>> numbers_to_replace
[1, 2, 3, 4]
>>> # replace a range of elements
>>> numbers_to_replace[1:3] = [0, 0]
>>> numbers_to_replace
[1, 0, 0, 4]

IV) We can remove an element using the remove(), pop(), and del methods. The remove() method removes the matching element at its first occurrence, the pop() method removes the element at the optionally specified index, and the default index is -1 (i.e., the last one), and the del statement removes an element with its index specified. Another thing to note is that the pop() method returns the value, while the other two return None.

Code
>>> numbers_to_remove = [1, 2, 3, 4, 5, 6]
>>> # using the remove()
>>> numbers_to_remove.remove(3)
>>> numbers_to_remove
[1, 2, 4, 5, 6]
>>> # using the pop()
>>> numbers_to_remove.pop(1)
2
>>> numbers_to_remove
[1, 4, 5, 6]
>>> # using the del statement
>>> del numbers_to_remove[-1]
>>> numbers_to_remove
[1, 4, 5]

V) We can remove multiple elements using the clear() and del methods. The clear() method removes all the elements of the list, and the del statement removes multiple elements with the range specified. Another handy way to remove all elements in the list is to assign the variable with an empty list.

Code
>>> # using clear
>>> numbers_to_clear = [3, 7, 8, 9, 10]
>>> numbers_to_clear.clear()
>>> numbers_to_clear
[]
>>> # using del
>>> numbers_to_del = [3, 7, 8, 9, 10]
>>> del numbers_to_del[2:]
>>> numbers_to_del
[3, 7]
>>> # using the re-assignment; note that this doesn't actually clear the old list
>>> numbers_to_reassign = [3, 4, 5]
>>> numbers_to_reassign = []
>>> numbers_to_reassign
[]

VI) We can change the order of the list. Some common ways include sorting the list, reversing the list, and shuffling the list.

Code
>>> numbers_to_order = [7, 9, -11, 4, 0, -13]
>>> # sort the list
>>> numbers_to_order.sort()
>>> numbers_to_order
[-13, -11, 0, 4, 7, 9]
>>> numbers_to_order.sort(key=lambda x: abs(x))
>>> numbers_to_order
[0, 4, 7, 9, -11, -13]
>>> # shuffle the list
>>> import random
>>> random.shuffle(numbers_to_order)
>>> numbers_to_order
[0, 9, -11, -13, 4, 7]
>>> # reverse the list
>>> numbers_to_order[::-1]
[7, 4, -13, -11, 9, 0]

5. Iteration
It’s a prevalent task that we need to perform certain operations by going through the list’s elements, which is termed iteration.

I) We can iterate a list directly. Lists are iterables in Python, and thus we can iterate a list in a for loop directly.

Code
>>> pets = ['Dog', 'Cat', 'Bird']
>>> for pet in pets:
...     print(pet)
... 
Dog
Cat
Bird

II) We can iterate a list using the enumerate() function. This function allows us to track the count of the iteration. Optionally, we can set the start argument to specify the start number for the counting.

Code
>>> activities = ['soccer', 'karate', 'basketball']
>>> for i, activity in enumerate(activities, start=1):
...     print(f'Day {i}: {activity}')
... 
Day 1: soccer
Day 2: karate
Day 3: basketball

III) We can iterate a list using the reversed() function. This function allows us to iterate the list using the reverse order.

Code
>>> arrivals = ['John', 'Mike', 'Jennifer']
>>> for student in reversed(arrivals):
...     print(student)
... 
Jennifer
Mike
John

Conclusions for the 5 topics
This article summarizes the most common operations for Python lists. Here are some quick takeaways so that you can understand the topic in these 5 sentences
Hope you like it

1) We can construct lists by listing the items, using the list() function, and working with existing ones.
2) We can access individual and multiple items using indexing and ranges.
3) We can check whether the list has a particular item and its emptiness and relationship with other lists.
4) We can append, insert, and remove one or more elements. Besides, we can change the order of lists.
5) We can iterate lists using themselves and in combination with the enumerate() and reversed() functions.

Stack

UdayKiran137 — Tue, 01 Dec 2020 10:12:26 +0000

The stack may be a linear arrangement that follows a specific order during which the operations are performed. The order of stack could also be LIFO (Last in First Out) or FILO (First In Last Out).
A stack is generally an Abstract Data Type (ADT). This ADT is generally used in most programming languages it's an easy arrangement that permits adding and removing elements during a particular order. whenever a component is added, it goes on the highest of the stack, and therefore the only element which will be removed is that the element that's at the highest of the stack, a bit like a pile of objects.

This is named the stack because this behaves like a real-world stack application the stack ADT will allow all the data operations at one end only at any time, we can use the top element of a stack

Generally, a stack is an abstract data type that is a set of elements, with two main principal operations:
1) Push (a)
2) Pop ()

Push: which adds a component to the gathering, and

Pop: which removes the foremost recently added element that wasn't yet removed.

Not only push and pop but there are also other operations in a stack. They are :
1) IsEmpty ()
2) is full ()
3) Peek ()
4) Top ()
5) Search ()

Now let us see the time complexity of all the operations in the stack:
1) push (a) – 0(1)
2) pop () – 0()1
3) IsEmpty () – 0(1)
4) ISFull () – 0(1)
5) peek () – 0(1)
6) top () – 0(1)
7) search () – 0(n)

We can generally write stacks in any of the major programming languages but I'm now writing stacks in ”python”
Ok, let's see how we can implement stacks in python. Generally in Python stack can be implemented in 3 ways. they're implementation method using List
Python’s built-in arrangement list is often used as a stack. Instead of push(), append() is employed to feature elements to the highest of the stack while pop() removes the element in LIFO order.
Unfortunately, the list has a few shortcomings. The biggest issue is that it can run into speed issues because it grows. The items in the list are stored next to every other in memory, if the stack grows bigger than the block of memory that currently hold it, then Python needs to do some memory allocations. This can cause some append() calls taking for much longer than other ones.

Features of stacks:

•They are Dynamic data structures
•They Do not have a fixed size and also
•They Do not consume a fixed amount of memory

Uses of Stacks:

Basically, there are some particular uses of stacks in data structures. They are

1)Expression Handling

1.Infix to suffix or Infix to Prefix Conversion −

The stack is accustomed convert some infix expression into its suffix equivalent, or prefix equivalent. These suffixes or prefix notations are employed in computers to specific some expressions. These expressions aren't most acquainted with the infix expression, however, they need some nice blessings additionally. we tend to don't got to maintain operator ordering and parenthesis.

2.Postfix or Prefix analysis analysis

After changing into a prefix or ending notations, we've got to gauge the expression to urge the result. For that purpose, conjointly we want the assistance of stack organization.

2) Backtracking Procedure −

Backtracking is one in every of the formula coming up with technique. For that purpose, we tend to dive away, if that method isn't economical, we tend to return to the previous state and go in another way. to induce back from the current state, we'd like to store the previous state. For that purpose, we'd like a stack. Some samples of backtracking are finding the answer for Knight Tour downside or N-Queen downside etc.

3) Another nice use of stack is throughout the call and come back method. after we decided a operate from one alternative operate, that call statement might not be the primary statement. when career the operate, we tend to even have to come back from the operating space to the place, wherever we've left our management. thus we would like to resume our task, not restart. For that reason, we have a tendency to store the address of the program counter into the stack, then head to the operating body to execute it. when completion of the execution, it pops out the address from the stack and assign it to the program counter to resume the task once more.

4) Syntax Parsing-
Many compilers use a stack for parsing the syntax of expressions, program blocks, etc. before translating into low-level code.

5) Parenthesis Checking -
The stack is used to check the proper opening and closing of the parenthesis.

6) String Reversal
The stack is used to reverse a string. We push the characters of the string one by one into the stack and then pop character from the stack.

Not only these but there are many uses of stacks like Function call, Memory Management, etc, etc



# initial empty stack  
my_stack = []  
# append() function to push   
# element in the my_stack   
my_stack.append('k')  
my_stack.append('p')  
my_stack.append('s')  
print(my_stack)  
#pop() function to pop   
# element from my_stack in    
# LIFO order   
print('\nElements poped from my_stack:')  
print(my_stack.pop())  
print(my_stack.pop())  
print(my_stack.pop())     
print('\nmy_stack after elements are poped:')  
print(my_stack)