Dans un environnement Java, l'impression des valeurs de retour à des positions impaires d'éléments peut être effectuée via des instructions de flux de contrôle dans une liste de tableaux. Les instructions de flux de contrôle en Java vérifient les positions impaires en fonction de la taille du pas. Une boucle est une méthode de flux de contrôle de vérification des conditions qui permet d'évaluer si une condition spécifique est vraie ou fausse. Dans ce cas, les « positions impaires » apparaissent toujours comme premier, troisième, cinquième dans une liste de tableaux particulière. En utilisant cette syntaxe, le code de build vérifie cette condition.
Dans un premier temps, la valeur temporaire est initialisée à 0 afin qu'elle puisse être vérifiée directement dans la liste. Triez ensuite l'index des données par nombre pair ou impair. Lorsqu'une chaîne est le chemin principal, il est plus facile de retrouver l'élément de la liste renvoyée correspondante.
Dans cet article, nous apprendrons et étudierons comment écrire du code Java et implémenter des méthodes possibles pour renvoyer des éléments qui apparaissent dans des positions impaires dans une liste de données spécifique.
Les tableaux sont des types similaires d'éléments de données qui existent dans une liste spécifique. Dans un tableau, les utilisateurs peuvent accéder aux éléments à l'aide de numéros d'index. Le processus de recherche est très simple et peut être utilisé efficacement.
Supposons que voici un tableau {2,12,23,7,6,15} et que nous devons trouver les éléments de position impaire qui apparaissent dans ce tableau particulier. Ici, nous pouvons voir que le résultat sera 2,23,6 apparaissant dans la liste.
Un tableau est une collection d'ensembles de données similaires d'éléments du même type. Ce sont toutes des données continues de taille fixe.
Les éléments apparaissant ici sont représentés par N et finissent par N-1 après application de l'itération.
En Java, il existe de nombreuses façons de trouver la position d'un élément dans un tableau spécifique
Pour la méthode
Méthode API Stream
For est une manière ancienne et classique de parcourir un tableau, puis d'imprimer et d'écrire, mais pour l'API de streaming, il suffit d'utiliser "Arrays.AsList() .stream().forEach(s.o::p)" éléments de résultat pour ces positions impaires.
Il s'agit d'un algorithme général pour trouver des éléments de position impaire en Java -
Étape 1 - Commencer
Étape 2 - Initialiser le tableau spécifique qui existe sur les nombres impairs
Étape 3 - Répétez les étapes pour imprimer (Étape 5)
Étape 4 - Imprimer le tableau
Étape 5 - Imprimer
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
Il s'agit d'un exemple simple et général de recherche d'éléments dans des positions impaires à l'aide de Java. Il existe désormais plusieurs façons de renvoyer des éléments de tableau à des positions impaires dans une liste de données spécifique. Creusons un peu plus profondément.
La méthode suivante peut trouver les éléments à des positions impaires dans la liste -
Méthode 1 - Trouver des éléments impairs de valeur 1 par itération
Méthode 2 - Recevez des positions impaires par incrément de position 2.
Méthode 3 - Trouvez des éléments impairs via la maintenance du pointeur de drapeau.
Méthode 4 : - En recherchant les éléments impairs divisibles par 2.
Le processus d'obtention d'éléments impairs avec une valeur d'itération de 1 : Iterator est un fichier objet qui peut être utilisé pour connecter des boucles. Pour utiliser des itérateurs en Java, il existe un package appelé java.util.
Les valeurs temporaires sont initialisées à 0.
Parcours d'applications.
Chaque itération vérifiera la valeur temporaire, si la valeur est 0 alors vous serez renvoyé, sinon continuez simplement le processus.
La valeur temporaire augmente de 1 après chaque traitement.
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
Parcourez les éléments du tableau et ajoutez 1 lorsque la position de l'élément est un nombre impair.
Étapes à suivre par incréments de 2 -
Parcourez la liste en commençant par la première position.
Appliquez un processus incrémental de 2 à chaque opération.
Terminez le processus une fois l'itération terminée.
Première itération - 1+2=3
Deuxième itération - 2+3=5
Troisième itération - 5+2=7
Continuer le processus
Retour
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
Dans un tableau trié contenant des entiers positifs, la valeur du premier élément doit être la valeur maximale, la valeur du deuxième élément doit être la valeur minimale et ainsi de suite. Durant ce processus, le pointeur sera initialisé à 1 pour démarrer l'itération.
Les étapes pour obtenir les éléments impairs avec la valeur d'itération 1 sont -
Démarrer
Le pointeur est initialisé à 1
Commencer à itérer
Si le drapeau est 1, imprimez les données
Changer le drapeau en 0
Sinon, si le drapeau lance 0, changez-le en 1
Fin
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 程序来返回列表中奇数位置的元素。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
