#Strings in Java

Thilak — Thu, 25 Nov 2021 15:34:57 +0000

Strings

Strings in Java are Objects that are backed internally by a char array. Since arrays are immutable(cannot grow), Strings are immutable as well. Whenever a change to a String is made, an entirely new String is created.

Syntax:

String str = "abcd";

Memory allotment of String

Whenever a String Object is created as a literal, the object will be created in String constant pool. This allows JVM to optimize the initialization of String literal.
The string can also be declared using new operator i.e. dynamically allocated. In case of String are dynamically allocated they are assigned a new memory location in heap. This string will not be added to String constant pool.

Example:

String str = new String("abcd");

An example that shows how to declare String

import java.io.;
import java.lang.;

class Test {
public static void main(String[] args)
{
// Declare String without using new operator
String s = "GeeksforGeeks";

    // Prints the String.
    System.out.println("String s = " + s);

    // Declare String using new operator
    String s1 = new String("GeeksforGeeks");

    // Prints the String.
    System.out.println("String s1 = " + s1);
}

}
Output:

String s = GeeksforGeeks
String s1 = GeeksforGeeks

pointers

Thilak — Tue, 11 May 2021 08:32:55 +0000

pointers:

A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before using it to store any variable address. The general form of a pointer variable declaration is −

syntax:

type *var-name;

example:
include

int main () {

int var = 20;
int ip;

ip = &var;

printf("Address of var variable: %x\n", &var );

/* address stored in pointer variable */
printf("Address stored in ip variable: %x\n", ip );

/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );

return 0;
}

Types of Pointers

There are different types of pointers which are as follows −

Null pointer

Void pointer

Wild pointer

1.Null Pointer:

You create a null pointer by assigning the null value at the time of pointer declaration.

This method is useful when you do not assign any address to the pointer. A null pointer always contains value 0.

syntax:

Begin.
Declare a pointer p of the integer datatype.
Initialize *p= NULL.
Print “The value of pointer is”.
Print the value of the pointer p.
End.

example:
include
int main() {
int *p= NULL;//initialize the pointer as null.
printf("The value of pointer is %u",p);
return 0;
}

2.Void Pointer:

It is a pointer that has no associated data type with it. A void pointer can hold addresses of any type and can be typecast to any type.

It is also called a generic pointer and does not have any standard data type.

It is created by using the keyword void.

syntax:
Begin
Declare a of the integer datatype.
Initialize a = 7.
Declare b of the float datatype.
Initialize b = 7.6.
Declare a pointer p as void.
Initialize p pointer to a.
Print “Integer variable is”.
Print the value of a using pointer p.
Initialize p pointer to b.
Print “Float variable is”.
Print the value of b using pointer p
End.

example:
include
int main() {
int a = 7;
float b = 7.6;
void *p;
p = &a;
printf("Integer variable is = %d", ( (int) p) );
p = &b;
printf("\nFloat variable is = %f", ( (float) p) );
return 0;
}

3.Wild Pointer:

Wild pointers are also called uninitialized pointers. Because they point to some arbitrary memory location and may cause a program to crash or behave badly.

syntax:
include
int main(){
int *p; //wild pointer
printf("\n%d",*p);
return 0;
}

example:
include
int main(){
int *p; //wild pointer
printf("\n%d",*p);
return 0;
}

DEV Community: Thilak