Meniu

Tutorial Java Stack: Implementarea clasei Stack cu exemple

  • Principal
  • Alte
  • Tutorial Java Stack: Implementarea clasei Stack cu exemple

java stack tutorial stack class implementation with examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică ce este Stack în Java, Java Stack Class, Stack API Methods, Stack Implementation using Array & Linked List cu ajutorul unor exemple:

O stivă este o structură de date ordonată aparținând Java Collection Framework. În această colecție, elementele sunt adăugate și eliminate dintr-un singur capăt. Sfârșitul la care sunt adăugate și eliminate elementele se numește „Top of the Stack”.

Deoarece adăugarea și ștergerea se fac doar la un capăt, primul element adăugat la stivă se întâmplă să fie ultimul element eliminat din stivă. Astfel stiva se numește structură de date LIFO (Last-in, First-out).

=> Consultați aici Ghidul pentru începători Java

Stack Collection în Java

Ce veți învăța:

c ++ converti char în șir

Colecția Java Stack

O reprezentare picturală a stivei este dată mai jos.

reprezentarea pictorială a stivei

Așa cum se arată în secvența de reprezentare de mai sus, inițial stiva este goală și partea de sus a stivei este setată la -1. Apoi inițiam o operație de „împingere” care este utilizată pentru a adăuga un element la stivă.

Deci, în a doua reprezentare, împingem elementul 10. În acest moment, partea de sus este incrementată. Împingem din nou elementul 20 în stivă, crescând astfel partea superioară.

În ultima reprezentare, inițiam o operație „pop”. Această operație este utilizată pentru a elimina un element din stivă. Un element indicat în prezent spre „Sus” este eliminat prin operația pop.

O structură de date stivă acceptă următoarele operații:

  • Apăsați: Adaugă un element la stivă. Ca rezultat, valoarea de sus este incrementată.
  • Pop: Un element este eliminat din stivă. După operația pop, valoarea topului este scăzută.
  • Arunca o privire: Această operație este utilizată pentru a căuta sau a căuta un element. Valoarea de sus nu este modificată.

Partea superioară a stivei care este utilizată ca final pentru a adăuga / elimina elemente din stivă poate avea, de asemenea, diferite valori la un moment dat. Dacă dimensiunea stivei este N, atunci partea de sus a stivei va avea următoarele valori în condiții diferite, în funcție de starea în care se află stiva.

Starea stiveiValoare maximă
Stiva gol-1
Un element din stivă0
Stiva plinN-1
Overflow (elemente> N)N

Stack Class În Java

Java Collection Framework oferă o clasă numită „Stack”. Această clasă Stack extinde clasa Vector și implementează funcționalitatea structurii de date Stack.

Diagrama de mai jos prezintă ierarhia clasei Stack.

Ierarhia clasei stivei în Java

Așa cum se arată în diagrama de mai sus, clasa Stack moștenește clasa Vector care la rândul său implementează interfața List Interface of Collection.

Clasa Stack face parte din pachetul java.util. Pentru a include clasa Stack în program, putem folosi declarația de import după cum urmează.

import java.util.*;

sau

import java.util.Stack;

Creați o stivă în Java

După ce importăm clasa Stack, putem crea un obiect Stack așa cum se arată mai jos:

Stack mystack = new Stack();

De asemenea, putem crea un tip generic de obiect de clasă Stack după cum urmează:

Stack myStack = new Stack;

Aici data_type poate fi orice tip de date valid în Java.

De exemplu ,putem crea următoarele obiecte din clasa Stack.

Stack stack_obj = new Stack(); Stack str_stack = new Stack();

Metode API Stack în Java

Clasa Stack oferă metode pentru a adăuga, elimina și căuta date în Stack. De asemenea, oferă o metodă pentru a verifica dacă stiva este goală. Vom discuta despre aceste metode în secțiunea de mai jos.

Operațiunea de împingere a stivei

Operația de împingere este utilizată pentru a împinge sau adăuga elemente în stivă. Odată ce am creat o instanță de stivă, putem utiliza operația de împingere pentru a adăuga elementele tipului de obiect de stivă la stivă.

Următoarea bucată de cod este utilizată pentru inițializarea unei stive întregi cu valorile.

Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20);

Stiva inițială obținută ca rezultat al execuției de cod de mai sus este prezentată mai jos:

stiva inițială

Dacă efectuăm o altă operațiune push () așa cum se arată mai jos,

push(25);

Stiva rezultată va fi:

Stiva rezultată

Operațiunea Stack Pop

Putem elimina elementul din stivă folosind operația „pop”. Elementul indicat de partea de sus în prezent este scos din stivă.

Următoarea bucată de cod realizează acest lucru.

Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop();

Variabila val va conține valoarea 200 deoarece a fost ultimul element împins în stivă.

Reprezentarea stivei pentru operația push și pop este după cum urmează:

operațiunea push și pop

Operațiunea Stack Peek

Operația de vizualizare returnează partea de sus a stivei fără a elimina elementul. În exemplul stivei de mai sus, „intStack.peek ()” va returna 200.

Stiva este operațiunea goală

Operațiunea isEmpty () a clasei Stack verifică dacă obiectul stivei este gol. Revine adevărat dacă Stack nu are elemente în el, altfel returnează false.

Operațiunea de căutare stivă

Putem căuta un element din stivă folosind operația search (). Operațiunea search () returnează indexul elementului căutat. Acest indice este numărat din partea de sus a stivei.

Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.

Dimensiunea stivei

Dimensiunea obiectului Stack este dată de java.util.Stack.size () metodă. Returnează numărul total de elemente din stivă.

Următorul exemplu imprimă dimensiunea stivei.

Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3

Elemente tipărire / Iterare stivă

Putem declara un iterator pentru Stack și apoi traversăm întreaga Stack folosind acest iterator. Astfel putem vizita și imprima fiecare element de stivă unul câte unul.

Următorul program arată modul de a itera Stack folosind un iterator.

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements:'); //get an iterator for the stack Iterator iterator = stack.iterator(); //traverse the stack using iterator in a loop and print each element while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } }

Ieșire:

Elementele stivei:
PUNE MUMBAI NASHIK

Ieșire stivă

Stivați folosind Java 8

De asemenea, putem imprima sau parcurge elementele stivei folosind caracteristici Java 8, cum ar fi API-urile Stream, forEach și forEachRemaining.

Următorul program demonstrează utilizarea construcțiilor Java 8 pentru a traversa stiva.

import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements using Java 8 forEach:'); //get a stream for the stack Stream stream = stack.stream(); //traverse though each stream object using forEach construct of Java 8 stream.forEach((element) -> { System.out.print(element + ' '); // print element }); System.out.println(' Stack elements using Java 8 forEachRemaining:'); //define an iterator for the stack Iterator stackIterator = stack.iterator(); //use forEachRemaining construct to print each stack element stackIterator.forEachRemaining(val -> { System.out.print(val + ' '); }); } }

Ieșire:

Stivați elemente folosind Java 8 pentru fiecare:
PUNE MUMBAI NASHIK
Stivați elemente folosind Java 8 forEachRemaining:
PUNE MUMBAI NASHIK

ieșire - Stivați folosind Java 8

Implementarea stivei în Java

Următorul program implementează stiva detaliată care demonstrează diferitele operațiuni ale stivei.

import java.util.Stack; public class Main { public static void main(String a()){ //declare a stack object Stack stack = new Stack(); //print initial stack System.out.println('Initial stack : ' + stack); //isEmpty () System.out.println('Is stack Empty? : ' + stack.isEmpty()); //push () operation stack.push(10); stack.push(20); stack.push(30); stack.push(40); //print non-empty stack System.out.println('Stack after push operation: ' + stack); //pop () operation System.out.println('Element popped out:' + stack.pop()); System.out.println('Stack after Pop Operation : ' + stack); //search () operation System.out.println('Element 10 found at position: ' + stack.search(10)); System.out.println('Is Stack empty? : ' + stack.isEmpty()); } }

Ieșire:

Stiva inițială: ()
Stiva este goală? : Adevărat
Stivă după operația de împingere: (10, 20, 30, 40)
Elementul a ieșit: 40
Stivă după operația Pop: (10, 20, 30)
Elementul 10 găsit la poziția: 3
Stack este gol? : fals

ieșire - Implementarea stivei

cum se execută fișiere jar pe Windows 10

Stack To Array în Java

Structura de date a stivei poate fi convertită într-o matrice utilizând metoda „toArray ()” din clasa Stack.

Următorul program demonstrează această conversie.

import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); //print the stack System.out.println('The Stack contents: ' + stack); // Create the array and use toArray() method to convert stack to array Object() strArray = stack.toArray(); //print the array System.out.println('The Array contents:'); for (int j = 0; j

Ieșire:

Conținutul stivei: (PUNE, MUMBAI, NASHIK)
Conținutul matricei:
PUNE MUMBAI NASHIK

ieșire - STACK TO ARRAY ÎN JAVA

Implementarea stivei în Java utilizând Array

Stiva poate fi implementată folosind un Array. Toate operațiunile de stivă sunt efectuate folosind o matrice.

Programul de mai jos demonstrează implementarea Stack folosind o matrice.

import java.util.*; //Stack class class Stack { int top; //define top of stack int maxsize = 5; //max size of the stack int() stack_arry = new int(maxsize); //define array that will hold stack elements Stack(){ //stack constructor; initially top = -1 top = -1; } boolean isEmpty(){ //isEmpty () method return (top <0); } boolean push (int val){ //push () method if(top == maxsize-1) { System.out.println('Stack Overflow !!'); return false; } else { top++; stack_arry(top)=val; return true; } } boolean pop () { //pop () method if (top == -1) { System.out.println('Stack Underflow !!'); return false; } else { System.out.println(' Item popped: ' + stack_arry(top--)); return true; } } void display () { //print the stack elements System.out.println('Printing stack elements .....'); for(int i = top; i>=0;i--) { System.out.print(stack_arry(i) + ' '); } } } public class Main { public static void main(String() args) { //define a stack object Stack stck = new Stack(); System.out.println('Initial Stack Empty : ' + stck.isEmpty()); //push elements stck.push(10); stck.push(20); stck.push(30); stck.push(40); System.out.println('After Push Operation...'); //print the elements stck.display(); //pop two elements from stack stck.pop(); stck.pop(); System.out.println('After Pop Operation...'); //print the stack again stck.display(); } }

Ieșire:

Stiva inițială goală: adevărat
După operația Push ...
Tipărirea elementelor stivei ... ..
40 30 20 10
Elementul a apărut: 40

Elementul a apărut: 30
După operația Pop ...
Tipărirea elementelor stivei ... ..
20 10

cea mai bună aplicație pentru a programa postări pe Instagram

ieșire - Implementarea stivei în java folosind matrice

Implementarea stivei utilizând lista conectată

Stiva poate fi, de asemenea, implementată utilizând o listă legată la fel cum am făcut-o folosind matrici. Un avantaj al utilizării unei liste legate pentru implementarea stivei este că poate crește sau micșora dinamic. Nu trebuie să avem o restricție de dimensiune maximă ca în matrice.

Următorul program implementează o listă legată pentru a efectua operațiuni de stivă.

import static java.lang.System.exit; // Stack class using LinkedList class Stack_Linkedlist { // Define Node of LinkedList private class Node { int data; // node data Node nlink; // Node link } // top of the stack Node top; // stack class Constructor Stack_Linkedlist() { this.top = null; } // push () operation public void push(int val) { // create a new node Node temp = new Node(); // checks if the stack is full if (temp == null) { System.out.print(' Stack Overflow'); return; } // assign val to node temp.data = val; // set top of the stack to node link temp.nlink = top; // update top top = temp; } // isEmpty () operation public boolean isEmpty() { return top == null; } // peek () operation public int peek() { // check if the stack is empty if (!isEmpty()) { return top.data; } else { System.out.println('Stack is empty!'); return -1; } } // pop () operation public void pop() { // check if stack is out of elements if (top == null) { System.out.print(' Stack Underflow!!'); return; } // set top to point to next node top = (top).nlink; } //print stack contents public void display() { // check for stack underflow if (top == null) { System.out.printf(' Stack Underflow!!'); exit(1); } else { Node temp = top; System.out.println('Stack elements:'); while (temp != null) { // print node data System.out.print(temp.data + '->'); // assign temp link to temp temp = temp.nlink; } } } } public class Main { public static void main(String() args) { // Create a stack class object Stack_Linkedlist stack_obj = new Stack_Linkedlist(); // push values into the stack stack_obj.push(9); stack_obj.push(7); stack_obj.push(5); stack_obj.push(3); stack_obj.push(1); // print Stack elements stack_obj.display(); // print current stack top System.out.println(' Stack top : ' + stack_obj.peek()); // Pop elements twice System.out.println('Pop two elements'); stack_obj.pop(); stack_obj.pop(); // print Stack elements stack_obj.display(); // print new stack top System.out.println(' New Stack top:' + stack_obj.peek()); } }

Ieșire:

Elementele stivei:
1-> 3-> 5-> 7-> 9->

Stiva de sus: 1
Pop două elemente
Elementele stivei:
5-> 7-> 9->

Top Stack nou: 5

ieșire - Implementarea stivei utilizând o listă legată

întrebări frecvente

Q # 1) Ce sunt stivele în Java?

Răspuns: O stivă este o structură de date LIFO (Last in, First out) pentru stocarea elementelor. Elementele stivei sunt adăugate sau eliminate din stivă de la un capăt numit Partea de sus a stivei.

Adăugarea unui element la stivă se face folosind operația Push. Ștergerea elementelor se face folosind operația pop. În Java, un stack este implementat folosind clasa Stack.

Q # 2) Stack este o colecție în Java?

Răspuns: Da. Stiva este o colecție veche în Java care este disponibilă de la API-ul de colecție în Java 1.0 și mai departe. Stack moștenește clasa Vector a interfeței List.

Î # 3) Stiva este o interfață?

Răspuns: Stiva de interfețe este o interfață care descrie structura de ultim intrare, prima ieșire și este utilizată pentru stocarea stării problemelor recursive.

Î # 4) Pentru ce se utilizează stivele?

Răspuns: Următoarele sunt principalele aplicații ale stivei:

  • Evaluarea expresiei și conversii: Stack este utilizat pentru conversia expresiilor în postfix, infix și prefix. De asemenea, este folosit pentru a evalua aceste expresii.
  • Stiva este, de asemenea, utilizată pentru analizarea arborilor de sintaxă.
  • Stiva este utilizată pentru a verifica parantezele într-o expresie.
  • Stiva este utilizată pentru rezolvarea problemelor de backtracking.
  • Apelurile funcționale sunt evaluate folosind stive.

Q # 5) Care sunt avantajele stivei?

Răspuns: Variabilele stocate în stivă sunt distruse automat la returnare. Stivele sunt o alegere mai bună atunci când memoria este alocată și alocată. Stivele curăță, de asemenea, memoria. În afară de aceasta, stivele pot fi utilizate în mod eficient pentru a evalua expresiile și a analiza expresiile.

Concluzie

Aceasta completează tutorialul nostru despre stive în Java. Clasa Stack face parte din API-ul colecției și acceptă operații push, pop, peek și search. Elementele sunt adăugate sau eliminate în / din stivă doar la un capăt. Acest capăt se numește partea de sus a stivei.

În acest tutorial, am văzut toate metodele acceptate de clasa stack. De asemenea, am implementat stiva folosind tablouri și liste legate.

Vom continua cu alte clase de colectare în tutorialele noastre ulterioare.

=> Citiți seria Easy Training Java

Lectură recomandată

^