I Java är ' Konsument ”-gränssnittet representerar en operation som tar emot en enda ingång och utför någon åtgärd på den utan att returnera ett resultat. Det erbjuder också ett flexibelt sätt att definiera anpassade operationer som kan användas i funktionell programmering som lambda-uttryck. Den här bloggen illustrerar implementeringen av ett konsumentgränssnitt i Java.
Hur man använder konsumentgränssnitt i Java?
den ' Konsument ”-gränssnittet erbjuder inkapsling eller beteende som kan skickas runt och exekveras på olika platser i programmet. Det främjar återanvändbart beteende som kan appliceras på olika ingångar utan att duplicera kod. Konsumentgränssnittet består av två metoder, nämligen ' och då() ' och ' acceptera() ”.
Besök exemplen nedan för att förstå båda funktionerna tillsammans med codec-exempel:
Exempel 1: Användning av metoden 'andThen()'.
Utvecklaren kan kedja flera ' Konsument ' operationer helt och hållet genom att använda ' och då() 'metoden. Det returnerar en ny ' Konsument ' som utför operationen av nuvarande ' Konsument ' exempel. Efter det, uppfyller operationerna för den kommande/efter ' Konsument ' exempel. Det är standardmetoden som används allmänt för processen med ' Sammansättning ”.
Syntaxen för ' och då() ”-metoden infogas nedan:
och då ( Konsument < ? super T > efter )
den ' och då() ”metoden kombinerar den nuvarande konsumenten” super ' med en annan konsument ' efter ”. Och den utför den aktuella konsumentens operation först, följt av driften av den tillhandahållna konsumenten.
Låt oss gå igenom ett program för en bättre förståelse:
importera java.util.ArrayList;importera java.util.LinkedList;
importera java.util.List;
importera java.util.function.Consumer;
allmän klass Rot {
offentliga statiska tomrum huvud ( String args [ ] )
{
// skapande av huvudmetod
Konsument < Lista < Heltal > > multiplicera = dataEle - >
{
för ( int j = 0 ; j < dataEle.size ( ) ; j++ ) {
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
}
} ;
// Konsument för att visa en lista med heltal
Konsument < Lista < Heltal > >
utskrifter = dataEle - > dataEle.stream ( ) .för varje ( k - > System.ut.utskrift ( k + ' ' ) ) ;
Lista < Heltal > dataEle = ny ArrayList < Heltal > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
multiplicera.och sedan ( grafik ) .acceptera ( dataEle ) ;
}
}
Förklaring av ovanstående kod:
- Först, ' Konsument ”, “ Länkad lista ” och relaterade verktyg importeras till Java-filen. Efter det, huvudklassen med namnet ' Rot ' är skapad.
- Skapa sedan ett 'Konsument'-gränssnitt av typen Lista med namnet ' multiplicera ' och sätt den lika med ' ArrayList ” som kommer att skapas nedan.
- Den använder en ' för ' loop som itererar till längden av ' ArrayList ' som heter ' dataEle ', och multiplicerar varje dataelement i ' dataEle ' med ' 5 ”.
- Efter det, en andra ' Konsument ”-gränssnitt skapas som skriver ut varje element på konsolen som hämtas efter multiplikationsprocessen från en ström.
- Skapa och lägg till dummy-dataelement i ' dataEle ” ArrayList.
- I slutändan, ' och då() metoden kallas med acceptera() ' metod som accepterar ' dataEle ' ArrayList och returnerar resultatet av ' multiplicera ' i turordning.
Efter slutet av utförandefasen:
Ögonblicksbilden visar att multiplikationsuppgiften har slutförts genom att använda ' och då() ' metoden för ' Konsument ' gränssnitt.
Exempel 2: Användning av metoden 'accept()'.
den ' acceptera() ”-metoden är en funktionell metod för ” Konsument ' gränssnitt. Den accepterar ett enda argument av typen ' T ” och utför de specificerade/behövliga operationerna på den. Värdet av ' Null ' får inte tillhandahållas den eftersom den inte accepterar ' Null ”-värden och genererar ett undantag.
Dess syntax anges nedan:
ogiltig acceptera ( < stark > T stark > t )
I ovanstående syntax, ' t ” är det enda argumentet för vissa operationer.
Låt oss besöka nedanstående kodblock för en bättre förståelse:
importera java.util.ArrayList;importera java.util.LinkedList;
importera java.util.List;
importera java.util.function.Consumer;
// importera verktyg i Java fil
allmän klass Rot {
offentliga statiska tomrum huvud ( String args [ ] ) // skapande av huvudmetod
{
Konsument < Heltal > disp = k - > System.out.println ( k ) ;
disp.acceptera ( 255 ) ;
Konsument < Lista < Heltal > > multiplicera = dataEle - >
{
för ( int k = 0 ; k < dataEle.size ( ) ; k++ )
dataEle.set ( k, 5 * dataEle.get ( k ) ) ;
} ;
Konsument < Lista < Heltal > >
utskrifter = dataEle - > dataEle.stream ( ) .för varje ( j - > System.ut.utskrift ( j+ '
' ) ) ;
Lista < Heltal > dataEle = ny ArrayList < Heltal > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// Implementera modifiera med acceptera ( )
multiplicera.acceptera ( dataEle ) ;
// Implementera dispList med accept ( )
utskrifter.acceptera ( dataEle ) ;
}
}
Förklaring av ovanstående kod:
- Först, ' Konsument ' gränssnitt med namnet ' disp ” skapas som visar tillhandahållna parametrar på konsolen, utan att utföra någon åtgärd.
- Nu den ' acceptera() metoden kallas av ' disp ' Konsument och värdet av ' 255 ” överförs till denna metod.
- Nästa, en annan ' Konsument '-gränssnitt skapas som använder ' för ” loop för att tillämpa multiplikation på varje kvarvarande element i ArrayList som heter ” dataEle ”.
- Efter det skapar du en till ' Konsument ' gränssnitt för att visa ' dataEle ” element resulterar efter att multiplikationen som kommer från strömmen tillämpats.
- Initiera sedan ArrayList ' dataEle ' med dummy-dataelement och använd ' acceptera() '-metoden med ' multiplicera ' gränssnitt.
- I slutändan ringer du ' acceptera() ' metoden med ' grafik ”-gränssnittet för att visa resultatet efter att ha tillämpat multiplikation på konsolloggen.
Efter slutet av utförandet:
Ovanstående ögonblicksbild visar att flera konsumentgränssnitt har anropats ett i taget med hjälp av ' acceptera() 'metoden.
Exempel 3: Hanteringsundantag för efterfunktion
Undantaget uppstår när ' efter ' funktionen för ' och då() ”-metoden innehåller en ” acceptera() 'metoden. Detta gör ett gränssnitt som innehåller data som ska behandlas av gränssnitt som använder konsumentgränssnittsmetoder som visas nedan:
importera java.util.ArrayList;importera java.util.LinkedList;
importera java.util.List;
importera java.util.function.Consumer;
allmän klass Rot {
offentliga statiska tomrum huvud ( String args [ ] )
{
Konsument < Lista < Heltal > > multiplicera = dataEle - >
{
för ( int j = 0 ; j < = dataEle.storlek ( ) ; j++ )
dataEle.set ( j, 5 * dataEle.get ( j ) ) ;
} ;
// Konsument för att visa en lista med heltal
Konsument < Lista < Heltal > >
skriva ut = dataEle - > dataEle.stream ( ) .för varje ( jag - > System.ut.utskrift ( i + ' ' ) ) ;
Lista < Heltal > dataEle = ny ArrayList < Heltal > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
Prova {
print.andSedan ( multiplicera ) .acceptera ( dataEle ) ;
}
fånga ( Undantag e ) {
System.out.println ( 'Undantag:' + och ) ;
}
}
}
Förklaring av ovanstående kodblock:
- Först, ' Konsument ' gränssnitt skapas som helt enkelt flera ' 5 ” heltal med dataelementen som finns i den tillhandahållna ArrayList.
- Nästa, den andra ' Konsument ”-gränssnitt skapas för att visa varje dataelement i ArrayList som tas emot av strömmen.
- Därefter skapas ArrayList och initieras med dummy-heltalstypvärden.
- Sedan ' Prova '-blocket används där ' och då() metoden kallas av ' skriva ut ' gränssnitt.
- Det orsakar ' IndexOutOfBoundsException ' eftersom den ' för ” loop iterationsgränsen har överskridits, vilket löses av ” fånga ” block.
Efter slutet av utförandefasen:
Ögonblicksbilden visar att IndexOutOfBoundsException har genererats av kompilatorn.
Slutsats
den ' Konsument ”-gränssnittet ger ett sätt att definiera återanvändbart beteende och utföra åtgärder på indata utan att returnera ett resultat. Den består av ' acceptera() ' och ' och då() ' metoder. Det används ofta för databearbetningsuppgifter, där användare behöver utföra en åtgärd på varje element i en samling eller ström. Det handlar om användningen och implementeringen av konsumentgränssnittet i Java.