Programme Java pour renvoyer des éléments à des positions impaires dans une liste

Quel est l'endroit bizarre sur la liste ?

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.

Qu'est-ce qu'un tableau et ses éléments ?

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.

Algorithme pour trouver des éléments dans des 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

Exemple

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]);
      }
   }
}

Sortie

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.

Trouver des éléments impairs en itérant avec la valeur 1

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.

Exemple

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;
      }
   }
}

Sortie

Elements present at odd position are: 200 400 600

Incrémentez de la position 2 pour obtenir des positions impaires

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

Exemple

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) + " ");
      }
   }
}

Sortie

Elements at odd positions in that array are: 2000 4000 6000

Trouver des éléments étranges via la maintenance du pointeur de drapeau

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 整除的元素

要检查奇数位置的元素，我们可以使用是否被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!