In the Java environment, printing return values at odd positions of elements can be performed through control flow statements in the array list. Control flow statements in Java check odd positions based on step size. A loop is a condition-checking control flow method that helps evaluate whether a specific condition is true or false. For this case, "odd positions" always appear as first, third, fifth in a particular array list. By using this syntax, the build code checks for this condition.
In the first step, the temporary value is initialized to 0 so that it can be checked directly in the list. Next sort the data index by even or odd number. When a string is the main path, it is easier to find the element of the corresponding returned list.
In this article, we will learn and study how to write Java code and implement possible methods to return elements that appear in odd positions in a specific data list.
Arrays are similar types of data elements that exist in a specific list. In an array, users can access elements using index numbers. The search process is very simple and can be used effectively.
Suppose, here is an array {2,12,23,7,6,15}, and we need to find the odd position elements that appear in this specific array. Here we can see that the result will be 2,23,6 appearing in the list.
An array is a collection of similar data sets with elements of the same type. They are all continuous fixed-size data.
The elements appearing here are represented by N and end with N-1 after applying iteration.
In java, there are many ways to find the position of an element from a specific array
For method
Stream API method
For is an old and classic way to iterate over an array and then print and write, but for streaming API use "Arrays.AsList() .stream().forEach(s.o::p) ” is enough to get detailed result elements for these odd positions.
This is a general algorithm for finding elements at odd positions in Java -
Step 1 - Get Started
Step 2 - Initialize the specific array that exists on odd
Step 3 - Repeat steps to print (Step 5)
Step 4 - Print Array
Step 5 - Print
public class OddPosition {
public static void main(String[] args) {
int [] arr = new int [] {11, 12, 13, 14, 15};
System.out.println("Odd position elements present in the array: ");
for (int i = 0; i < arr.length; i = i+2) {
System.out.println(arr[i]);
}
}
}
Odd position elements present in the array: 11 13 15
This is a simple and general example of finding elements at odd positions using java. There are now several ways to return array elements at odd positions in a specific data list. Let’s dig a little deeper.
The following method can find the elements at odd positions in the list -
Method 1 - Find odd elements with value 1 by iterating
Method 2 - Receive odd positions by position increment 2.
Method 3 - Find odd elements through flag pointer maintenance.
Method 4: - By looking for odd elements that are divisible by 2.
The process of obtaining odd elements with an iteration value of 1: Iterator is an object file that can be used to connect loops. To use iterators in java there is a package called java.util.
Temporary value is initialized to 0.
Apply traversal.
Each iteration will check the temporary value, if the value is 0 then you will get returned, otherwise just continue the process.
The temporary value is increased by 1 after each processing.
import java.io.*;
import java.util.*;
public class TP {
public static void main(String[] args){
List<Integer> tp_list1 = new ArrayList<Integer>();
tp_list1.add(100);
tp_list1.add(200);
tp_list1.add(300);
tp_list1.add(400);
tp_list1.add(500);
tp_list1.add(600);
int temp_val = 0;
System.out.print("Elements present at odd position are : ");
for (Integer numbers : tp_list1) {
if (temp_val % 2 != 0) {
System.out.print(numbers + " ");
}
temp_val += 1;
}
}
}
Elements present at odd position are: 200 400 600
Traverse the array elements and add 1 when the element position is an odd number.
Steps to follow in increments of 2 -
Traverse the list starting from the first position.
Apply an incremental process of 2 to each operation.
End the process after the iteration is completed.
First iteration - 1 2=3
Second iteration - 2 3=5
Third iteration - 5 2=7
Continue the process
return
import java.io.*;
import java.util.*;
public class TP {
public static void main(String[] args){
List<Integer> tp_list2 = new ArrayList<>();
tp_list2.add(1000);
tp_list2.add(2000);
tp_list2.add(3000);
tp_list2.add(4000);
tp_list2.add(5000);
tp_list2.add(6000);
System.out.print(
"Elements at odd positions in that array are : ");
for (int i = 1; i < 6; i = i + 2) {
System.out.print(tp_list2.get(i) + " ");
}
}
}
Elements at odd positions in that array are: 2000 4000 6000
In a sorted array containing positive integers, the value of the first element should be the maximum value, the value of the second element should be the minimum value, and so on. During this process, the pointer will be initialized to 1 to start the iteration.
The steps to get the odd elements with an iteration value of 1 are -
start
The pointer is initialized to 1
Start iteration
If the flag is 1, print the data
Change flag to 0
Otherwise, if the flag throws 0, change it to 1
Finish
import java.util.*;
public class PrintOddElementsInArray {
public static void main(String[] args){
int inputArray[] = new int[] { 1000, -5000, 4500, -2000,
10000, -2130, 7500 };
System.out.println("Existing array elements.");
for (int i = 0; i < inputArray.length; i++) {
System.out.println(inputArray[i]);
}
System.out.println(
"Array elements at odd position.");
int flag = 1;
for (int i = 0; i < inputArray.length; i++) {
if (flag == 1) {
System.out.print(inputArray[i] + " ");
flag = 0;
}
else
flag = 1;
}
}
}
Existing array elements .. 1000 -5000 4500 -2000 10000 -2130 7500 Array elements at odd position.1000 4500 10000 7500
要检查奇数位置的元素，我们可以使用是否被2整除的方法。
import java.util.*;
public class PrintOddElementsInArray {
public static void main(String[] args){
int inputArray[] = new int[] { 1000, -5000, 4500, -2000, 10000, -2130, 7500 };
System.out.println("Existing array elements ..");
for (int i = 0; i < inputArray.length; i++) {
System.out.println(inputArray[i]);
}
System.out.println(
"Array elements at odd position.");
for (int i = 0; i < inputArray.length; i++) {
if (i % 2 == 0) {
System.out.println(inputArray[i]);
}
}
}
}
Existing array elements. 1000 -5000 4500 -2000 10000 -2130 7500 Array elements at odd position. 1000 4500 10000 7500
要查找出现在奇数位置的元素，应用排序方法或应用可被 2 整除的方法会更方便。它评估特定条件的过程是真还是假。
在本文中，我们学习了如何使用这些算法和示例编写 Java 程序来返回列表中奇数位置的元素。
The above is the detailed content of Java program to return elements at odd positions in a list. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
