Programme Java pour mélanger les éléments vectoriels

Shuffle() est une méthode de classe de collection en Java qui fonctionne de manière aléatoire basée sur la logique de permutation d'un groupe spécifique d'éléments de liste. Tree existe deux types différents de méthodes dans shuffle class(), en fonction de paramètres spécifiques.

• Méthode de mélange (liste) de collection Java.

• Méthode de mélange (liste, aléatoire) des collections Java. Dans cette méthode, nous pouvons disposer les caractères de manière aléatoire pour générer des valeurs aléatoires. Nous lui appliquerons ensuite la méthode suffle.

Pour effectuer un brassage de vecteurs, nous pouvons utiliser l'algorithme de brassage de Fisher-Yates. Dans cette approche, nous pouvons scanner linéairement le vecteur et échanger chaque élément avec un élément aléatoire.

Dans l'article d'aujourd'hui, nous allons apprendre à mélanger des éléments vectoriels à l'aide de l'environnement Java.

Écrire un programme Java pour brouiller l'algorithme des éléments vectoriels

Il s'agit d'un algorithme possible dans le code Java, permettant de mélanger les éléments d'un vecteur contenant des chaînes.

• Étape 1 – Commencer.

• Étape 2 - Déclarez le package shuffle qui existe dans l'environnement Java.

• Étape 3 - Déclarez une fonction pour mélanger les cartes.

• Étape 4 - Si l'opération consiste à mélanger un vecteur aléatoire, déclarez-le.

• Étape 5 - Déclarez une classe publique.

• Étape 6 - Obtenez un vecteur de tableau d'entrée.

• Étape 7 - Mentionnez la longueur du tableau.

• Étape 8 - Si la déclaration est aléatoire, déclarez-la.

• Étape 9 - Passez à l'étape suivante.

• Étape 10 - Utilisez une boucle for pour exécuter la méthode.

• Étape 11 - Parcourez la valeur.

• Étape 12 - Diminuez la valeur si nécessaire.

• Étape 13 - Échangez et changez de position.

• Étape 14 - Assister au cours d'assistance

• Étape 15 - Déclarez la valeur de changement comme égale à la classe d'assistance.

• Étape 16 - Entrez la chaîne de paramètres.

• Étape 17 - Entrez la chaîne int.

• Étape 18 - Déclarez le sous-tableau.

• Étape 19 - Demandez une impression.

• Étape 20 - Résiliation.

Syntaxe pour écrire un programme Java pour mélanger des éléments vectoriels

General Syntax:
public static void shuffle(List<?> list)  
public static void shuffle(List<?> list, Random random)  

Possible Code Syntax:

public class Main {
   public static void main(String[] args) {
      Vector<String> v = new Vector<String>();

      v.add("16");
      v.add("07");
      v.add("10");
      v.add("2001");
      v.add("1997");
      System.out.println(v);
      Collections.shuffle(v);
      System.out.println(v);
   }
}

Double Shuffle:

import java.util.*;  
public class CollectionsShuffleTutorialspoint {  
   public static void main(String[] args) {  
      List<String> list = Arrays.asList("X", "Y", "R", "A");  
      System.out.println("List Before Shuffle Here ----> : "+list);  
      Collections.shuffle(list);  
      System.out.println("List After Shuffle Is Here ----> : "+list);  
   }  
}  

Nous avons mentionné ici la syntaxe possible liée à la méthode shuffle. Vous pouvez voir que le processus de double brassage fonctionne également pour les éléments vectoriels. Avec ces syntaxes possibles, nous essayons ensuite de créer du code Java pour mélanger les éléments vectoriels dans une chaîne spécifique.

Comment créer un programme Java pour brouiller les éléments vectoriels

• Méthode 1 - Programme Java pour mélanger les éléments vectoriels

• Méthode 2−Algorithme de brassage Fisher-Yates

Programme Java pour brouiller les éléments vectoriels

Nous incluons ici du code de construction Java qui nous permet de mélanger certains éléments vectoriels de manière simple et aléatoire.

La traduction chinoise de

Exemple 1

est :

Exemple 1

import java.util.Collections;
import java.util.Vector;
public class VectorShuffleElements {
   public static void main(String[] args) { 
      Vector<Integer> vNumbers = new Vector<Integer>();
      vNumbers.add(16);
      vNumbers.add(07);
      vNumbers.add(2001);
      vNumbers.add(1997);
      vNumbers.add(10);
      Collections.shuffle(vNumbers);
      System.out.println("Vector contains are present in the list:----> " + vNumbers);
   }
}

Sortie

Vector contains are present in the list:----> [16, 2001, 7, 10, 1997]

Exemple 2

se traduit par :

Exemple 2

import java.util.Vector;
import java.util.Collections;
public class Tutorialspoint {
	public static void main(String[] args){
      Vector<String> vec07 = new Vector<String>();
      vec07.add("10");
      vec07.add("16");
      vec07.add("7");
      vec07.add("2001");
      vec07.add("1997");
      System.out.println("Original Vector is here ----> : " + vec07);	
      Collections.shuffle(vec07);
      System.out.println("After shuffling we get the set here ---->: " + vec07);
	}
}

Sortie

Original Vector is here ----> : [10, 16, 7, 2001, 1997]
After shuffling we get the set here ---->: [1997, 10, 7, 16, 2001]

La traduction chinoise de

Exemple 3

est :

Exemple 3

import java.util.*;
import java.util.Vector;
import java.util.Collections;
public class ARBRDD {
	public static void main(String[] args){
      Vector<String> vec = new Vector<String>();
      vec.add("13109");
      vec.add("KOAA-DHAKA Maitree Express");
      vec.add("International Railway Connectivity");
      vec.add("India");
      vec.add("Bangladesh");
      System.out.println("Original Vector is here ----> : " + vec);
      Collections.shuffle(vec, new Random());
      System.out.println("\nShuffled Vector with Random() is here ----> : \n" + vec);
      Collections.shuffle(vec, new Random(3));
      System.out.println("\nShuffled Vector with Random(3) is here ---->: \n" + vec);
      Collections.shuffle(vec, new Random(5));
      System.out.println("\nShuffled Vector with Random(5) is here ----> : \n" + vec);
	}
}

Sortie

Original Vector is here ----> : [13109, KOAA-DHAKA Maitree Express, International Railway Connectivity, India, Bangladesh]

Shuffled Vector with Random() is here ----> : 
[KOAA-DHAKA Maitree Express, 13109, International Railway Connectivity, India, Bangladesh]

Shuffled Vector with Random(3) is here ---->: 
[India, 13109, KOAA-DHAKA Maitree Express, International Railway Connectivity, Bangladesh]

Shuffled Vector with Random(5) is here ----> : 
[International Railway Connectivity, 13109, Bangladesh, India, KOAA-DHAKA Maitree Express]

La traduction chinoise de

Exemple 4

est :

Exemple 4

import java.util.Arrays; 
import java.util.Collections; 
import java.util.List; 
import java.util.Random; 
public class RandomizeList { 
   public static void main(String args[]) { 
      List<Integer> numbers = Arrays.asList(16, 7, 10, 2001, 1997, 10, 2022); System.out.println("Particular List Before Shuffling Present Here ---->: " + numbers);
      Collections.shuffle(numbers); 
      System.out.println("The Particular List after shuffling Done --->: " + numbers); 
      Collections.shuffle(numbers, new Random(System.nanoTime())); 
       System.out.println("Particular List After Shuffling Again Done ---->: " + numbers); 
   }
}

Sortie

Particular List Before Shuffling Present Here ---->: [16, 7, 10, 2001, 1997, 10, 2022]
The Particular List after shuffling Done --->: [1997, 2001, 10, 2022, 7, 10, 16]
Particular List After Shuffling Again Done ---->: [1997, 2022, 10, 10, 16, 7, 2001]

Exemple 5

import java.util.*;  
public class Greetingsshufflelist {  
   public static void main(String[] args) {          
      List<String> list = Arrays.asList("Hi!", "Hello!", "Hallo!", "Bonjour!");  
      System.out.println(list);  
      Collections.shuffle(list, new Random(7));  
      System.out.println(list);         
   }  
}

Sortie

[Hi!, Hello!, Hallo!, Bonjour!]
[Hi!, Hello!, Bonjour!, Hallo!]

L'algorithme de brassage Fisher-Yates mélange les éléments vectoriels

L'algorithme shuffle de Fisher Yates est une méthode d'exécution de processus hypothétique en Java avec une complexité d'exécution de O(n). La fonction rand() génère un nombre aléatoire en un temps O(1).

Exemple 6

se traduit par :

Exemple 6

import java.util.Random;
import java.util.Arrays;
public class ShuffleRand{
	static void randomize( int arr[], int n){
      Random r = new Random();
      for (int i = n-1; i > 0; i--) {
      	int j = r.nextInt(i+1);
      	int temp = arr[i];
      	arr[i] = arr[j];
      	arr[j] = temp;
      }
      System.out.println(Arrays.toString(arr));
	}
	public static void main(String[] args){
      
      int[] arr = {16, 7, 10, 2022, 1997, 2001, 25, 11};
      int n = arr.length;
      randomize (arr, n);
	}
}

Sortie

[1997, 2022, 2001, 25, 11, 16, 7, 10]

Conclusion

Dans l'article d'aujourd'hui, nous avons découvert certaines méthodes possibles de lecture aléatoire du code Java via la syntaxe et les algorithmes. J'espère que cet article vous a aidé à comprendre comment fonctionnent les différentes méthodes de brassage de vecteurs mentionnées ici.

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!