Java-Programm zum Mischen von Vektorelementen

Shuffle() ist eine Sammlungsklassenmethode in Java, die auf zufällige Weise basierend auf der Permutationslogik einer bestimmten Gruppe von Listenelementen arbeitet. Tree gibt zwei verschiedene Arten von Methoden in shuffle class(), abhängig von bestimmten Parametern.

• Java Collection Shuffle(list)-Methode.

• Java Collections Shuffle-Methode (Liste, Zufall). Bei dieser Methode können wir die Zeichen zufällig anordnen, um einige Zufallswerte zu erzeugen. Dann wenden wir die Suffle-Methode darauf an.

Um Vektor-Shuffling durchzuführen, können wir den Fisher-Yates-Shuffling-Algorithmus verwenden. Bei diesem Ansatz können wir den Vektor linear scannen und jedes Element durch ein zufälliges Element austauschen.

Im heutigen Artikel erfahren wir, wie man Vektorelemente mithilfe der Java-Umgebung mischt.

Schreiben Sie ein Java-Programm, um den Algorithmus von Vektorelementen zu verschlüsseln

Dies ist ein möglicher Algorithmus im Java-Code, wie wir die Elemente eines Vektors, der Strings enthält, mischen können.

• Schritt 1 – Los geht’s.

• Schritt 2 – Deklarieren Sie das Shuffle-Paket, das in der Java-Umgebung vorhanden ist.

• Schritt 3 – Deklarieren Sie eine Funktion zum Mischen von Karten.

• Schritt 4 – Wenn die Operation darin besteht, einen zufälligen Vektor zu mischen, deklarieren Sie ihn.

• Schritt 5 – Deklarieren Sie eine öffentliche Klasse.

• Schritt 6 – Holen Sie sich einen Eingabe-Array-Vektor.

• Schritt 7 – Geben Sie die Länge des Arrays an.

• Schritt 8 – Wenn die Deklaration zufällig ist, deklarieren Sie sie.

• Schritt 9 – Fahren Sie mit dem nächsten Schritt fort.

• Schritt 10 – Verwenden Sie eine for-Schleife, um die Methode auszuführen.

• Schritt 11 – Iterieren Sie den Wert.

• Schritt 12 – Verringern Sie den Wert bei Bedarf.

• Schritt 13 – Positionen tauschen und ändern.

• Schritt 14 – Assistenzkurs besuchen

• Schritt 15 – Deklarieren Sie den Änderungswert als gleich der Hilfsklasse.

• Schritt 16 – Parameterzeichenfolge eingeben.

• Schritt 17 – Geben Sie die int-Zeichenfolge ein.

• Schritt 18 – Deklarieren Sie das Subarray.

• Schritt 19 – Ausdruck anfordern.

• Schritt 20 – Kündigung.

Syntax zum Schreiben eines Java-Programms zum Mischen von Vektorelementen

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

Hier haben wir die mögliche Syntax im Zusammenhang mit der Shuffle-Methode erwähnt. Sie sehen, dass der doppelte Shuffling-Prozess auch für Vektorelemente funktioniert. Mit diesen möglichen Syntaxen versuchen wir später, Java-Code zu erstellen, um Vektorelemente in einer bestimmten Zeichenfolge zu mischen.

So erstellen Sie ein Java-Programm zum Verschlüsseln von Vektorelementen

• Methode 1 – Java-Programm zum Mischen von Vektorelementen

• Methode 2 − Fisher-Yates-Shuffling-Algorithmus

Java-Programm zum Verschlüsseln von Vektorelementen

Hier fügen wir Java-Build-Code hinzu, der es uns ermöglicht, einige Vektorelemente auf einfache und zufällige Weise zu mischen.

Die chinesische Übersetzung von

Beispiel 1

lautet:

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

Ausgabe

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

Beispiel 2

wird übersetzt als:

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

Ausgabe

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

Die chinesische Übersetzung von

Beispiel 3

lautet:

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

Ausgabe

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]

Die chinesische Übersetzung von

Beispiel 4

lautet:

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

Ausgabe

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]

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

Ausgabe

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

Der Fisher-Yates-Mischalgorithmus mischt Vektorelemente

Der Shuffle-Algorithmus von Fisher Yates ist eine hypothetische Prozessausführungsmethode in Java mit einer laufenden Komplexität von O(n). Die Funktion rand() generiert eine Zufallszahl in O(1)-Zeit.

Beispiel 6

wird übersetzt als:

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

Ausgabe

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

Fazit

Aus dem heutigen Artikel haben wir einige mögliche Shuffle-Methoden von Java-Code durch Syntax und Algorithmen kennengelernt. Hoffentlich hat Ihnen dieser Artikel dabei geholfen, die Funktionsweise der verschiedenen hier erwähnten Vektor-Shuffling-Methoden zu verstehen.

Das obige ist der detaillierte Inhalt vonJava-Programm zum Mischen von Vektorelementen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!