assignment array java

• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Assigning arrays in Java.

While creating variables first of all we will declare them, initialize them, assign/re-assign values to them.

Similarly, while creating arrays −

You can declare an array just like a variable −

You can create an array just like an object using the new keyword −

You can initialize the array by assigning values to all the elements one by one using the index −

Assigning values to an array

When we assign primitive values of one type to a variable of other (datatype) implicitly they are converted.

But, when you try to assign a higher datatype to lower, at the time of compilation you will get an error saying “incompatible types: possible lossy conversion”

Therefore while assigning values to the elements of an array you can assign any value which will be cast implicitly.

But, if you try to assign incompatible types (higher types) to a variable a compile-time error will be generated saying “possible lossy conversion”.

 Live Demo

Compile-time error

If you have an array of objects while assigning values to the elements of it, you need to make sure that the objects you assign should be of the same or, a subtype of the class (which is the type of the array).

But to an array of objects if you assign a value which is neither the declared type nor its subtype a compile-time error will be generated.

If you have created an array of objects of an interface type you need to make sure that the values, you assign to the elements of the array are the objects of the class that implements the said interface.

Related Articles

• Assigning values to static final variables in java\n
• Assigning long values carefully in java to avoid overflow\n
• Final Arrays in Java
• String Arrays in Java
• Most Profit Assigning Work in C++
• Assigning function to variable in JavaScript?
• Compare Two Java int Arrays in Java
• How to process Arrays in Java?
• What is length in Java Arrays?
• Sort arrays of objects in Java
• Dump Multi-Dimensional arrays in Java
• Intersection of two arrays in Java
• Merge two sorted arrays in Java
• Streams on Arrays in Java 8
• Merge k sorted arrays in Java

Kickstart Your Career

Get certified by completing the course

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java introduction.

• Java Hello World
• Java JVM, JRE and JDK
• Java Variables and Literals
• Java Data Types
• Java Operators
• Java Input and Output
• Java Expressions & Blocks
• Java Comment

Java Flow Control

• Java if...else
• Java switch Statement
• Java for Loop

Java for-each Loop

• Java while Loop
• Java break Statement
• Java continue Statement

Java Arrays

• Multidimensional Array
• Java Copy Array

Java OOP (I)

• Java Class and Objects
• Java Methods
• Java Method Overloading
• Java Constructor
• Java Strings
• Java Access Modifiers
• Java this keyword
• Java final keyword
• Java Recursion
• Java instanceof Operator

Java OOP (II)

• Java Inheritance
• Java Method Overriding
• Java super Keyword
• Abstract Class & Method
• Java Interfaces
• Java Polymorphism
• Java Encapsulation

Java OOP (III)

• Nested & Inner Class
• Java Static Class
• Java Anonymous Class
• Java Singleton
• Java enum Class
• Java enum Constructor
• Java enum String
• Java Reflection
• Java Exception Handling
• Java Exceptions
• Java try...catch
• Java throw and throws
• Java catch Multiple Exceptions
• Java try-with-resources
• Java Annotations
• Java Annotation Types
• Java Logging
• Java Assertions
• Java Collections Framework
• Java Collection Interface
• Java List Interface
• Java ArrayList
• Java Vector
• Java Queue Interface
• Java PriorityQueue
• Java Deque Interface
• Java LinkedList
• Java ArrayDeque
• Java BlockingQueue Interface
• Java ArrayBlockingQueue
• Java LinkedBlockingQueue
• Java Map Interface
• Java HashMap
• Java LinkedHashMap
• Java WeakHashMap
• Java EnumMap
• Java SortedMap Interface
• Java NavigableMap Interface
• Java TreeMap
• Java ConcurrentMap Interface
• Java ConcurrentHashMap
• Java Set Interface
• Java HashSet
• Java EnumSet
• Java LinkedhashSet
• Java SortedSet Interface
• Java NavigableSet Interface
• Java TreeSet
• Java Algorithms
• Java Iterator
• Java ListIterator
• Java I/O Streams
• Java InputStream
• Java OutputStream
• Java FileInputStream
• Java FileOutputStream
• Java ByteArrayInputStream
• Java ByteArrayOutputStream
• Java ObjectInputStream
• Java ObjectOutputStream
• Java BufferedInputStream
• Java BufferedOutputStream
• Java PrintStream

Java Reader/Writer

• Java Reader
• Java Writer
• Java InputStreamReader
• Java OutputStreamWriter
• Java FileReader
• Java FileWriter
• Java BufferedReader
• Java BufferedWriter
• Java StringReader
• Java StringWriter
• Java PrintWriter

Additional Topics

• Java Scanner Class
• Java Type Casting
• Java autoboxing and unboxing
• Java Lambda Expression
• Java Generics
• Java File Class
• Java Wrapper Class
• Java Command Line Arguments

Java Tutorials

Java Multidimensional Arrays

Java Copy Arrays

Java Math max()

• Java Math min()
• Java ArrayList trimToSize()

An array is a collection of similar types of data.

For example, if we want to store the names of 100 people then we can create an array of the string type that can store 100 names.

Here, the above array cannot store more than 100 names. The number of values in a Java array is always fixed.

• How to declare an array in Java?

In Java, here is how we can declare an array.

• dataType - it can be primitive data types like int , char , double , byte , etc. or Java objects
• arrayName - it is an identifier

For example,

Here, data is an array that can hold values of type double .

But, how many elements can array this hold?

Good question! To define the number of elements that an array can hold, we have to allocate memory for the array in Java. For example,

Here, the array can store 10 elements. We can also say that the size or length of the array is 10.

In Java, we can declare and allocate the memory of an array in one single statement. For example,

• How to Initialize Arrays in Java?

In Java, we can initialize arrays during declaration. For example,

Here, we have created an array named age and initialized it with the values inside the curly brackets.

Note that we have not provided the size of the array. In this case, the Java compiler automatically specifies the size by counting the number of elements in the array (i.e. 5).

In the Java array, each memory location is associated with a number. The number is known as an array index. We can also initialize arrays in Java, using the index number. For example,

• Array indices always start from 0. That is, the first element of an array is at index 0.
• If the size of an array is n , then the last element of the array will be at index n-1 .
• How to Access Elements of an Array in Java?

We can access the element of an array using the index number. Here is the syntax for accessing elements of an array,

Let's see an example of accessing array elements using index numbers.

Example: Access Array Elements

In the above example, notice that we are using the index number to access each element of the array.

We can use loops to access all the elements of the array at once.

• Looping Through Array Elements

In Java, we can also loop through each element of the array. For example,

Example: Using For Loop

In the above example, we are using the for Loop in Java to iterate through each element of the array. Notice the expression inside the loop,

Here, we are using the length property of the array to get the size of the array.

We can also use the for-each loop to iterate through the elements of an array. For example,

Example: Using the for-each Loop

• Example: Compute Sum and Average of Array Elements

In the above example, we have created an array of named numbers . We have used the for...each loop to access each element of the array.

Inside the loop, we are calculating the sum of each element. Notice the line,

Here, we are using the length attribute of the array to calculate the size of the array. We then calculate the average using:

As you can see, we are converting the int value into double . This is called type casting in Java. To learn more about typecasting, visit Java Type Casting .

• Multidimensional Arrays

Arrays we have mentioned till now are called one-dimensional arrays. However, we can declare multidimensional arrays in Java.

A multidimensional array is an array of arrays. That is, each element of a multidimensional array is an array itself. For example,

Here, we have created a multidimensional array named matrix. It is a 2-dimensional array. To learn more, visit the Java multidimensional array .

• Java Program to Print an Array
• Java Program to Concatenate two Arrays
• Java ArrayList to Array and Array to ArrayList
• Java Dynamic Array

Table of Contents

• Introduction

Sorry about that.

Related Tutorials

Java Tutorial

Java Library

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed. You have seen an example of arrays already, in the main method of the "Hello World!" application. This section discusses arrays in greater detail.

An array of 10 elements.

Each item in an array is called an element , and each element is accessed by its numerical index . As shown in the preceding illustration, numbering begins with 0. The 9th element, for example, would therefore be accessed at index 8.

The following program, ArrayDemo , creates an array of integers, puts some values in the array, and prints each value to standard output.

The output from this program is:

In a real-world programming situation, you would probably use one of the supported looping constructs to iterate through each element of the array, rather than write each line individually as in the preceding example. However, the example clearly illustrates the array syntax. You will learn about the various looping constructs ( for , while , and do-while ) in the Control Flow section.

Declaring a Variable to Refer to an Array

The preceding program declares an array (named anArray ) with the following line of code:

Like declarations for variables of other types, an array declaration has two components: the array's type and the array's name. An array's type is written as type [] , where type is the data type of the contained elements; the brackets are special symbols indicating that this variable holds an array. The size of the array is not part of its type (which is why the brackets are empty). An array's name can be anything you want, provided that it follows the rules and conventions as previously discussed in the naming section. As with variables of other types, the declaration does not actually create an array; it simply tells the compiler that this variable will hold an array of the specified type.

Similarly, you can declare arrays of other types:

You can also place the brackets after the array's name:

However, convention discourages this form; the brackets identify the array type and should appear with the type designation.

Creating, Initializing, and Accessing an Array

One way to create an array is with the new operator. The next statement in the ArrayDemo program allocates an array with enough memory for 10 integer elements and assigns the array to the anArray variable.

If this statement is missing, then the compiler prints an error like the following, and compilation fails:

The next few lines assign values to each element of the array:

Each array element is accessed by its numerical index:

Alternatively, you can use the shortcut syntax to create and initialize an array:

Here the length of the array is determined by the number of values provided between braces and separated by commas.

You can also declare an array of arrays (also known as a multidimensional array) by using two or more sets of brackets, such as String[][] names . Each element, therefore, must be accessed by a corresponding number of index values.

In the Java programming language, a multidimensional array is an array whose components are themselves arrays. This is unlike arrays in C or Fortran. A consequence of this is that the rows are allowed to vary in length, as shown in the following MultiDimArrayDemo program:

Finally, you can use the built-in length property to determine the size of any array. The following code prints the array's size to standard output:

Copying Arrays

The System class has an arraycopy method that you can use to efficiently copy data from one array into another:

The two Object arguments specify the array to copy from and the array to copy to . The three int arguments specify the starting position in the source array, the starting position in the destination array, and the number of array elements to copy.

The following program, ArrayCopyDemo , declares an array of String elements. It uses the System.arraycopy method to copy a subsequence of array components into a second array:

Array Manipulations

Arrays are a powerful and useful concept used in programming. Java SE provides methods to perform some of the most common manipulations related to arrays. For instance, the ArrayCopyDemo example uses the arraycopy method of the System class instead of manually iterating through the elements of the source array and placing each one into the destination array. This is performed behind the scenes, enabling the developer to use just one line of code to call the method.

For your convenience, Java SE provides several methods for performing array manipulations (common tasks, such as copying, sorting and searching arrays) in the java.util.Arrays class. For instance, the previous example can be modified to use the copyOfRange method of the java.util.Arrays class, as you can see in the ArrayCopyOfDemo example. The difference is that using the copyOfRange method does not require you to create the destination array before calling the method, because the destination array is returned by the method:

As you can see, the output from this program is the same, although it requires fewer lines of code. Note that the second parameter of the copyOfRange method is the initial index of the range to be copied, inclusively, while the third parameter is the final index of the range to be copied, exclusively . In this example, the range to be copied does not include the array element at index 9 (which contains the string Lungo ).

Some other useful operations provided by methods in the java.util.Arrays class are:

Searching an array for a specific value to get the index at which it is placed (the binarySearch method).

Comparing two arrays to determine if they are equal or not (the equals method).

Filling an array to place a specific value at each index (the fill method).

Sorting an array into ascending order. This can be done either sequentially, using the sort method, or concurrently, using the parallelSort method introduced in Java SE 8. Parallel sorting of large arrays on multiprocessor systems is faster than sequential array sorting.

Creating a stream that uses an array as its source (the stream method). For example, the following statement prints the contents of the copyTo array in the same way as in the previous example:

See Aggregate Operations for more information about streams.

Converting an array to a string. The toString method converts each element of the array to a string, separates them with commas, then surrounds them with brackets. For example, the following statement converts the copyTo array to a string and prints it:

This statement prints the following:

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

How to Declare and Initialize an Array in Java

• Introduction

In this tutorial, we'll take a look at how to declare and initialize arrays in Java .

We declare an array in Java as we do other variables, by providing a type and name:

To initialize or instantiate an array as we declare it, meaning we assign values as when we create the array, we can use the following shorthand syntax:

Or, you could generate a stream of values and assign it back to the array:

To understand how this works, read more to learn the ins and outs of array declaration and instantiation!

• Array Declaration in Java
• Array Initialization in Java
• IntStream.range()
• IntStream.rangeClosed()
• IntStream.of()
• Java Array Loop Initialization

The declaration of an array object in Java follows the same logic as declaring a Java variable. We identify the data type of the array elements, and the name of the variable, while adding rectangular brackets [] to denote its an array.

Here are two valid ways to declare an array:

The second option is oftentimes preferred, as it more clearly denotes of which type intArray is.

Note that we've only created an array reference. No memory has been allocated to the array as the size is unknown, and we can't do much with it.

To use the array, we can initialize it with the new keyword, followed by the data type of our array, and rectangular brackets containing its size:

This allocates the memory for an array of size 10 . This size is immutable.

Java populates our array with default values depending on the element type - 0 for integers, false for booleans, null for objects, etc. Let's see more of how we can instantiate an array with values we want.

The slow way to initialize your array with non-default values is to assign values one by one:

In this case, you declared an integer array object containing 10 elements, so you can initialize each element using its index value.

The most common and convenient strategy is to declare and initialize the array simultaneously with curly brackets {} containing the elements of our array.

The following code initializes an integer array with three elements - 13, 14, and 15:

Keep in mind that the size of your array object will be the number of elements you specify inside the curly brackets. Therefore, that array object is of size three.

This method work for objects as well. If we wanted to initialize an array of three Strings, we would do it like this:

Java allows us to initialize the array using the new keyword as well:

It works the same way.

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Note : If you're creating a method that returns an initialized array, you will have to use the new keyword with the curly braces. When returning an array in a method, curly braces alone won't work:

If you're declaring and initializing an array of integers, you may opt to use the IntStream Java interface:

The above code creates an array of ten integers, containing the numbers 1 to 10:

The IntStream interface has a range() method that takes the beginning and the end of our sequence as parameters. Keep in mind that the second parameter is not included, while the first is.

We then use the method toArray() method to convert it to an array.

Note: IntStream is just one of few classes that can be used to create ranges. You can also use a DoubleStream or LongStream in any of these examples instead.

If you'd like to override that characteristic, and include the last element as well, you can use IntStream.rangeClosed() instead:

This produces an array of ten integers, from 1 to 10:

The IntStream.of() method functions very similarly to declaring an array with some set number of values, such as:

Here, we specify the elements in the of() call:

This produces an array with the order of elements preserved:

Or, you could even call the sorted() method on this, to sort the array as it's being initialized:

Which results in an array with this order of elements:

One of the most powerful techniques that you can use to initialize your array involves using a for loop to initialize it with some values.

Let's use a loop to initialize an integer array with values 0 to 9:

This is identical to any of the following, shorter options:

A loop is more ideal than the other methods when you have more complex logic to determine the value of the array element.

For example, with a for loop we can do things like making elements at even indices twice as large:

In this article, we discovered the different ways and methods you can follow to declare and initialize an array in Java. We've used curly braces {} , the new keyword and for loops to initialize arrays in Java, so that you have many options for different situations!

We've also covered a few ways to use the IntStream class to populate arrays with ranges of elements.

You might also like...

• Java: Finding Duplicate Elements in a Stream
• Spring Boot with Redis: HashOperations CRUD Functionality
• Spring Cloud: Hystrix
• Java Regular Expressions - How to Validate Emails

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

I am a very curious individual. Learning is my drive in life and technology is the language I speak. I enjoy the beauty of computer science and the art of programming.

In this article

Make clarity from data - quickly learn data visualization with python.

Learn the landscape of Data Visualization tools in Python - work with Seaborn , Plotly , and Bokeh , and excel in Matplotlib !

From simple plot types to ridge plots, surface plots and spectrograms - understand your data and learn to draw conclusions from it.

© 2013- 2024 Stack Abuse. All rights reserved.

1.4   Arrays

Arrays in java..

double[] a; // declare the array a = new double[n]; // create the array for (int i = 0; i

Typical array-processing code.

double sum = 0.0; for (int i = 0; i

Programming with arrays.

double[] a = new double[n];

String[] SUITS = { "Clubs", "Diamonds", "Hearts", "Spades" }; String[] RANKS = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace" };

int i = (int) (Math.random() * RANKS.length); int j = (int) (Math.random() * SUITS.length); System.out.println(RANKS[i] + " of " + SUITS[j]);

String[] deck = new String[RANKS.length * SUITS.length]; for (int i = 0; i

Shuffling and sampling.

String temp = deck[i]; deck[i] = deck[j]; deck[j] = temp;

int n = deck.length; for (int i = 0; i

Precomputed values.

double[] harmonic = new double[n]; for (int i = 1; i

Simplifying repetitive code.

if (m == 1) System.out.println("Jan"); else if (m == 2) System.out.println("Feb"); else if (m == 3) System.out.println("Mar"); else if (m == 4) System.out.println("Apr"); else if (m == 5) System.out.println("May"); else if (m == 6) System.out.println("Jun"); else if (m == 7) System.out.println("Jul"); else if (m == 8) System.out.println("Aug"); else if (m == 9) System.out.println("Sep"); else if (m == 10) System.out.println("Oct"); else if (m == 11) System.out.println("Nov"); else if (m == 12) System.out.println("Dec");

String[] MONTHS = { "", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; ... System.out.println(MONTHS[m]);

Coupon collector.

Sieve of eratosthenes., two-dimensional arrays..

double[][] a = new double[m][n];

double[][] a; a = new double[m][n]; for (int i = 0; i

double[][] a = { { 99.0, 85.0, 98.0, 0.0 }, { 98.0, 57.0, 79.0, 0.0 }, { 92.0, 77.0, 74.0, 0.0 }, { 94.0, 62.0, 81.0, 0.0 }, { 99.0, 94.0, 92.0, 0.0 }, { 80.0, 76.5, 67.0, 0.0 }, { 76.0, 58.5, 90.5, 0.0 }, { 92.0, 66.0, 91.0, 0.0 }, { 97.0, 70.5, 66.5, 0.0 }, { 89.0, 89.5, 81.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 } };

for (int i = 0; i

double[][][] a = new double[n][n][n];

Matrix operations.

double[][] c = new double[n][n]; for (int i = 0; i

Self-avoiding walk.

int n = 1000; int[] a = new int[n*n*n*n];

int n = a.length; for (int i = 0; i

int[] a; for (int i = 0; i

int [] a = new int[10]; for (int i = 0; i

int n = 10; int[] a = new int[n]; a[0] = 0; a[1] = 1; for (int i = 2; i

int[] a = { 1, 2, 3 }; int[] b = { 1, 2, 3 }; System.out.println(a == b);

99 98 92 94 99 90 76 92 97 89 85 57 77 32 34 46 59 66 71 29 98 78 76 11 22 54 88 89 24 38

double[] weights = { 0.25, 0.25, 0.50 };

double[] dist = new double[13]; for (int i = 1; i

* * . . . * * 1 0 0 . . . . . 3 3 2 0 0 . * . . . 1 * 1 0 0

Pascal's triangle Binomial distribution -------------------------------------------- 1 1 1 1 1/2 1/2 1 2 1 1/4 1/2 1/4 1 3 3 1 1/8 3/8 3/8 1/8 1 4 6 4 1 1/16 1/4 3/8 1/4 1/16

4 1 3 0 2 * * * Q * * Q * * * * * * * Q * * Q * * Q * * * *

* * * Q * * Q * * * * * * * Q * * Q * * Q * * * *

weight class from to ------------------------------------ Fly Weight 0 112 Super Fly Weight 112 115 Bantam Weight", 115 118 Super Bantam Weight 118 122 Feather Weight 122 126 Super Feather Weight 126 130 Light Weight 130 135 Super Light Weight 135 140 Welter Weight 140 147 Super Welter Weight 147 154 Middle Weight 154 160 Super Middle Weight 160 167 Light Heavy Weight 167 174 Super Light Heavy Weight 174 183 Cruiser Weight 183 189 Super Cruiser Weight 189 198 Heavy Weight 198 209 Super Heavy Weight 209

4 9 2 11 18 25 2 9 3 5 7 10 12 19 21 3 8 1 6 4 6 13 20 22 23 5 7 14 16 17 24 1 8 15

% java Banner "Kevin" # # ###### # # # # # # # # # # # ## # #### ##### # # # # # # # # # # # # # # # # # # # # # # ## # # ###### ## # # #

int footrule = 0; for (int i = 0; i

VALUE ENCODING 0 ||╷╷╷ 1 ╷╷╷|| 2 ╷╷|╷| 3 ╷╷||╷ 4 ╷|╷╷| 5 ╷|╷|╷ 6 ╷||╷╷ 7 |╷╷╷| 8 |╷╷|╷ 9 |╷|╷╷

***** ***** ***** ** ** ** ***** ** ** ***** ** ** ***** ** ***** ** ** ***** ** ** ***** ***** ***** ** ** ** ***** ** ** ** ***** *****

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10

5 3 4 | 6 7 8 | 9 1 2 6 7 2 | 1 9 5 | 3 4 8 1 9 8 | 3 4 2 | 5 6 7 -------+-------+------ 8 5 9 | 7 6 1 | 4 2 3 4 2 6 | 8 5 3 | 7 9 1 7 1 3 | 9 2 4 | 8 5 6 -------+-------+------ 9 6 1 | 5 3 7 | 2 8 4 2 8 7 | 4 1 9 | 6 3 5 3 4 5 | 2 8 6 | 1 7 9

448 768 704 640 1280 1408 1600 1600 (original) 608 672 1344 1600 -160 32 -64 0 (step 1) 640 1472 -32 -128 -160 32 -64 0 (step 2) 1056 -416 -32 -128 -160 32 -64 0 (step 3)

int[] a = new int[-17];

Java Array assignment

In this tutorial on Java Arrays, we will see to how to assign an array – both Primitive Array assignment and Reference Array assignment.

Java Primitive Array Assignment

If an array is declared as int (int[]) then you can assign another int array of any size but cannot assign anything that is not an int array including primitive int variable. Following is an example of int[] array assignment.

Java Reference Array Assignment

If an array is declared as a reference type then you can assign any other array reference which is a subtype of the declared reference type, i.e.) it should pass the “IS-A relationship”. Following is an example of reference array assignment.

Similarly, if an array is declared as interface type then it can reference an array of any type that implements that interface.

Leave a Comment Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed .

• Visitor Master
• Garage Master
• Builder Master
• Call Service Management
• Mobile Solutions
• Cloud Deployment Services
• Web Solutions
• Business Technology Consulting
• Graphic Designs
• Search Engine Optimization
• Social Media Marketing
• Software Training

• 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
• CompileTime Vs RunTime Resolution of Strings
• String Class stripTrailing() Method in Java with Examples
• Java String Literals as Constants or Singletons
• Java String Class indent() Method With Examples
• Java String startsWith() and endsWith() Methods With Examples
• Java String contentEquals() Method with Examples
• Java String hashCode() Method with Examples
• Difference between concat() and + operator in Java
• Java String codePoint() Method with Examples
• String Class stripLeading() Method in Java With Examples
• Java Program to Replace All Line Breaks from Strings
• Escaping XML Special Characters in Java String
• How to Split a String into Equal Length Substrings in Java?
• String equals() Method in Java
• Law of Demeter in Java - Principle of Least Knowledge
• How to Set Classpath in Java?
• C++ vs Java vs Python
• Hibernate - Map Mapping
• Spring - Constructor Injection with Non-String Collection

String Arrays in Java

In programming, an array is a collection of the homogeneous types of data stored in a consecutive memory location and each data can be accessed using its index. 

In the Java programming language, we have a String data type. The string is nothing but an object representing a sequence of char values. Strings are immutable in java. Immutable means strings cannot be modified in java.

When we create an array of type String in Java, it is called String Array in Java.

To use a String array, first, we need to declare and initialize it. There is more than one way available to do so.

Declaration:

The String array can be declared in the program without size or with size. Below is the code for the same –  

In the above code, we have declared one String array (myString0) without the size and another one(myString1) with a size of 4. We can use both of these ways for the declaration of our String array in java.

Initialization:

In the first method , we are declaring the values at the same line. A second method is a short form of the first method and in the last method first, we are creating the String array with size after that we are storing data into it.

To iterate through a String array we can use a looping statement.

Time Complexity: O(N), where N is length of array. Auxiliary Space: O(1)

So generally we are having three ways to iterate over a string array.  The first method is to use a for-each loop. The second method is using a simple for loop and the third method is to use a while loop. You can read more about iterating over array from Iterating over Arrays in Java

To find an element from the String Array we can use a simple linear search algorithm. Here is the implementation for the same –

In the above code, we have a String array that contains three elements Apple, Banana & Orange. Now we are searching for the Banana. Banana is present at index location 1 and that is our output.

Sorting of String array means to sort the elements in ascending or descending lexicographic order.

We can use the built-in sort() method to do so and we can also write our own sorting algorithm from scratch but for the simplicity of this article, we are using the built-in method.

Here our String array is in unsorted order, so after the sort operation the array is sorted in the same fashion we used to see on a dictionary or we can say in lexicographic order.

String array to String:

To convert from String array to String, we can use a toString() method.

Here the String array is converted into a string and it is stored into a string type variable but one thing to note here is that comma(,) and brackets are also present in the string. To create a string from a string array without them, we can use the below code snippet.

In the above code, we are having an object of the StringBuilder class. We are appending that for every element of the string array (myarr). After that, we are storing the content of the StringBuilder object as a string using the toString() method.

Please Login to comment...

Similar reads.

• Java-Strings
• CBSE Exam Format Changed for Class 11-12: Focus On Concept Application Questions
• 10 Best Waze Alternatives in 2024 (Free)
• 10 Best Squarespace Alternatives in 2024 (Free)
• Top 10 Owler Alternatives & Competitors in 2024
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Java Tutorial

Java methods, java classes, java file handling, java how to, java reference, java examples, java arraylist.

The ArrayList class is a resizable array , which can be found in the java.util package.

The difference between a built-in array and an ArrayList in Java, is that the size of an array cannot be modified (if you want to add or remove elements to/from an array, you have to create a new one). While elements can be added and removed from an ArrayList whenever you want. The syntax is also slightly different:

Create an ArrayList object called cars that will store strings:

If you don't know what a package is, read our Java Packages Tutorial .

The ArrayList class has many useful methods. For example, to add elements to the ArrayList , use the add() method:

Try it Yourself »

Access an Item

To access an element in the ArrayList , use the get() method and refer to the index number:

Remember: Array indexes start with 0: [0] is the first element. [1] is the second element, etc.

Advertisement

Change an Item

To modify an element, use the set() method and refer to the index number:

Remove an Item

To remove an element, use the remove() method and refer to the index number:

To remove all the elements in the ArrayList , use the clear() method:

ArrayList Size

To find out how many elements an ArrayList have, use the size method:

Loop Through an ArrayList

Loop through the elements of an ArrayList with a for loop, and use the size() method to specify how many times the loop should run:

You can also loop through an ArrayList with the for-each loop:

Other Types

Elements in an ArrayList are actually objects. In the examples above, we created elements (objects) of type "String". Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class : Integer . For other primitive types, use: Boolean for boolean, Character for char, Double for double, etc:

Create an ArrayList to store numbers (add elements of type Integer ):

Sort an ArrayList

Another useful class in the java.util package is the Collections class, which include the sort() method for sorting lists alphabetically or numerically:

Sort an ArrayList of Strings:

Sort an ArrayList of Integers:

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.