Metoda collect() din Stream are două forme: <R,A> R collect(collector<? super T,A,R> collector) <R> R collect(supplier<r> supplier, BiConsumer<R,?

Transcription

1 Colectori Prin colectori se pot executa diverse procesări terminale asupra elementelor din obiecte Stream, precum: grupări, sumarizări, selecții, agregări etc. Outputul obișnuit este o colecție rezultată prin selecție sau agregare dar și o valoare rezultată prin sumarizare sau alte tipuri de operațiuni Colectarea se realizează prin invocarea metodelor collect() ale interfeței Stream Un collector este un obiect de tip Collector<T,A,R> public interface Collector<T,A,R> unde: T - este tipul elementelor colectate A - este tipul operațiunii de acumulare aplicate asupra elementelor colectate R - este tipul rezultatului operațiunii de acumulare

2 Metoda collect() din Stream are două forme: <R,A> R collect(collector<? super T,A,R> collector) <R> R collect(supplier<r> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) În componența unui colector este obligatorie prezența a trei elemente: inițializator sau supplier - crează structura asociată colectorului acumulator - actualizează structura asociată colectorului selector sau combiner - efectează operațiuni asupra structurii asociate colectorului în vederea obținerii rezultatului final În mod opțional colectorul poate să aibă un finalizator care este o funcție aplicată asupra rezultatului selecției (combiner) pentru a obține rezultatul final. Dacă nu este furnizat în mod explicit se consideră finalizator funcția identitate cea care nu modifică outputul combinerului. Structura colectorului este reflectată de metodele abstracte ale interfeței Collector

3 Metodele intefeței Collector Supplier<A> supplier(); //Întoarce un obiect Supplier de tip A. Interfața funcțională Supplier are o funcție get() prin care se întoarce un obiect A (tipul Supplier). BiConsumer<A,T> accumulator(); //Întoarce un obiect BiConsumer. Interfața funcțională are o metodă void accept(a t, T u) prin care este implementat "consumul" obiectului de tip T. BinaryOperator<A> combiner(); // Întoarce un obiect BinaryOperator. Înterfața BinaryOperator are metoda funcțională A apply(a t, A u) care întoarce rezultatul aplicării colectorului Function<A,R> finisher(); // Întoarce un finalizator de tip Function al colectorului. Metoda funcțională furnizează rezultatul colectorului: R apply(a t) Set<Collector.Characteristics> characteristics(); //Furnizează caracteristicile colectorului sub formă de Set. Acestea pot fi constante din enumerarea Collector.Characteristics, pecum: CONCURRENT (colectarea in regim concurențial), UNORDERED (in colectare nu contează ordinea) sau IDENTITY_FINISH (funcția de finalizare este ignorată, combiner-ul este cel care furnizează rezultatul colectării).

4 Exemplu creare și utilizare colector personalizat Fie clasele Persoana și Student astfel definite: public class Persoana { private String nume; private long cnp;... } public class Student extends Persoana { private int grupa,anul; private Map<String,Integer> note=new HashMap<>();... } Să se creeze lista cu cnp-urile studenților pornind de la lista de studenți. Va fi invocată metoda collect() din Stream în forma: <R,A> R collect(collector<? super T,A,R> collector); În codul de mai jos lista este un obiect ArrayList<Student> cu lista studenților.

5 List<Long> cnp = lista.stream().map(student::getcnp).collect( new Collector<Long, List<Long>, List<Long>>() { public Supplier<List<Long>> supplier() { Supplier<List<Long>> s = () -> new ArrayList<>(); return s; } public BiConsumer<List<Long>, Long> accumulator() { BiConsumer<List<Long>, Long> bc = (lst, val) -> { lst.add(val); }; return bc; } public BinaryOperator<List<Long>> combiner() { BinaryOperator<List<Long>> bo = (t, u) -> { u.addall(t); return u; }; return bo; } public Function<List<Long>, List<Long>> finisher() { Function<List<Long>,List<Long>> f = (List<Long> t) -> t; return f; } public Set<Collector.Characteristics> characteristics() { Set<Collector.Characteristics> ch = new HashSet<>(); ch.add(characteristics.unordered);ch.add(characteristics.concurrent); return ch; } });

6 Același rezultat se poate obține prin invocarea celei de a doua forme a metodei collect(). Pe exemplul precedent, în codul de mai jos sunt prezentate colectările pentru grupele și anii distincți din care fac parte studenții din listă: List<Integer> ani=lista.stream().map(student::getanul).distinct(). collect( () -> new ArrayList<>(), (t,u) -> {t.add(u);}, (t,u) -> { u.addall(t);}); List<Integer> grupe = lista.stream().map(student::getgrupa).distinct().collect(arraylist::new, ArrayList::add, ArrayList::addAll); Finalizatorul va fi implicit funcția identitate Caracteristicile colectorului vor fi CONCURRENT și UNORDERED În prima variantă metodele funcționale sunt pasate prin funcții lambda În varianta a doua metodele funcționale sunt pasate prin operatorul de referențiere

7 Colectori standard Sunt creați prin metode statice ale clasei utilitare Collectors în contextul efectuării a diverse operațiuni de colectare Colectarea în colecții standard: public static <T> Collector<T,?,List<T>> tolist(); public static <T,C extends Collection<T>> Collector<T,?,C> tocollection(supplier<c> collectionfactory); public static <T> Collector<T,?,Set<T>> toset(); public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> tomap( Function<? super T,? extends K> keymapper, Function<? super T,? extends U> valuemapper) unde keymapper este o funcție care furnizează cheile iar valuemapper o funcție care furnizează valorile. Această formă a metodei tomap presupune inexistența cheilor duplicat. Exemplu. Colectarea numelor studenților din lista de studenți: List<String> nume = lista.stream().map(student::getnume).collect(collectors.tolist());

8 Exemplu. Colectarea numelor studenților după cnp (structură Map): Map<Long,String> nume = lista.stream().collect(collectors.tomap(student::getcnp, Student::getNume)); public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> tomap( Function<? super T,? extends K> keymapper, Function<? super T,? extends U> valuemapper, BinaryOperator<U> mergefunction); mergefunction este o funcție care indică modul de tratare a valorilor avute pentru cheile duplicat Exemplu. Listarea studenților pe grupe: Map<Integer,String> grupe = lista.stream().collect(collectors.tomap( Student::getGrupa, Student::getNume, (nume1,nume2)->nume1+","+nume2)); A treia formă a metodei tomap() include un ultim parametru inițializator (supplier) pentru a inițializa obiectul Map rezultat într-o manieră explicită.

9 Sumarizări public static <T> Collector<T,?,Double> summingdouble(todoublefunction<? super T> mapper); // Sumă de dip double. Idem pentru long și int. public static <T> Collector<T,?,Double> averagingdouble(todoublefunction<? super T> mapper); //Medie de tip double. Idem pentru long și int. public static <T> Collector<T,?,Long> counting(); //Contorizare public static <T> Collector<T,?,Optional<T>> minby(comparator<? super T> comparator); // Minim public static <T> Collector<T,?,Optional<T>> maxby(comparator<? super T> comparator); //Maxim Exemple. Calcul medie generală și media maximă pe lista de studenți double mediagenerala = lista.stream().collect( Collectors.averagingDouble(stud -> stud.calculmedie())); Student studmax = lista.stream().collect(collectors.maxby((stud1,stud2)-> (stud1.calculmedie()>stud2.calculmedie())?1:-1 )).get();

10 Grupări și sumarizări public static <T,K> Collector<T,?,Map<K,List<T>>> groupingby(function<? super T,? extends K> classifier); // Grupare după funcția de clasificare specificată Exemplu. Gruparea studenților după grupa din care fac parte Map<Integer,List<Student>> grupe = lista.stream().collect(collectors.groupingby(student::getgrupa)); public static <T,K,A,D> Collector<T,?,Map<K,D>> groupingby(function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream); //Grupare cu sumarizare conform colectorului downstream Exemplul 1. Contorizarea numărului de studenți pe grupe Map<Integer,Long> grupe = lista.stream().collect(collectors.groupingby( Student::getGrupa,Collectors.counting())); Exemplul 2. Calculul mediei studenților pe grupe Map<Integer,Double> grupe = lista.stream().collect(collectors.groupingby( Student::getGrupa, Collectors.averagingDouble(Student::calculMedie))); unde Student::calculMedie este referențierea la metoda de instanță calculmedie() din clasa Student

11 Partiționarea. Este un caz particular al grupării. Împărțirea se face în două grupe identificate prin cheile true și false public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningby(predicate<? super T> predicate); //Colectare (partiționare) într-o colecție Map cu două chei - true, false - după predicatul specificat Exemplu. Partiționarea listei de studenți în promovați și nepromovați în funcție de note Map<Boolean,List<Student>> promovabilitate = lista.stream().collect(collectors.partitioningby( stud -> stud.getnote().values().stream().allmatch((nota) -> (nota>=5)))); Partiționare cu sumarizare public static <T,D,A> Collector<T,?,Map<Boolean,D>> partitioningby(predicate<? super T> predicate, Collector<? super T,A,D> downstream); // Colectorul downstream este folosit pentru sumarizare Exemplu. Contorizare studenti promovați și nepromovați Map<Boolean,Long> promovabilitate = lista.stream().collect(collectors.partitioningby( stud -> stud.getnote().values().stream().allmatch((nota) -> (nota>=5)), Collectors.counting()));

12 Java Reflection Este o tehnologie care permite obținerea de informații despre clase, interfețe, câmpuri si metode la momentul execuției Este utila in aplicații precum cele care asigura persistenta obiectelor, maparea obiectual-relationala etc. Inspectarea claselor Obtinerea obiectului Class asociat Class myobjectclass = MyObjectClass.class; // se foloseste identificatorul de clasa public static Class<?> forname(string classname) throws ClassNotFoundException; // se folosește numele String al clasei public final Class<?> getclass(); // se folosește referința la obiect

13 Obtinere modificatori int modifiers = aclass.getmodifiers(); // codificarea pentru modificator se face la nivel de bit in intregul returnat Investigare modificator prin metode statice ale clasei Modifier: public static boolean istip(int mod);// in functie de Tip se va testa bitul corespunzator Modifier.isAbstract(int modifiers); Modifier.isFinal(int modifiers); Modifier.isInterface(int modifiers); Modifier.isNative(int modifiers); Modifier.isPrivate(int modifiers); Modifier.isProtected(int modifiers); Modifier.isPublic(int modifiers); Modifier.isStatic(int modifiers); Modifier.isSynchronized(int modifiers); Modifier.isTransient(int modifiers); Modifier.isVolatile(int modifiers); Modifier.toString(int modifiers); // intoarce intr-un String toti modificatorii

14 Obtinere pachet: Package package = aclass.getpackage(); Obtinere superclasa: Class superclass = aclass.getsuperclass(); Obtinere interfete implementate: Class[] interfaces = aclass.getinterfaces(); // întoarce doar interfețele implementate direct

15 Java Reflection - constructori Obtinere constructori: Constructor[] constructors = aclass.getconstructors(); // constructorii publici Constructor[] constructors=aclass.getdeclaredconstructors(); // toți constructorii Constructor constructor = aclass.getconstructor(new Class[]{Tip1.class,..., TipN.class}); // obținerea constructorului cu semnătura specificata Determinare parametrii constructor: Class[] parametertypes = constructor.getparametertypes(); Invocare constructor: public T newinstance(object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException

16 Java Reflection - campuri Obtinere campuri: Field[] fields= aclass.getfields(); // câmpurile publice ale clasei, inclusiv cele moștenite Field[] fields= aclass.getdeclaredfields(); // toate câmpurile, mai puțin cele moștenite public Field getfield(string name) throws NoSuchFieldException, SecurityException; // câmpul public cu numele specificat Caracteristici obținute prin metode al clasei Field: public String getname(); public int getmodifiers(); public Class<?> gettype(); public Type getgenerictype(); // include informații si pentru tipurile parametrizate

17 Java Reflection - campuri Initializare/consultare campuri prin metode Field: public Object get(object objinstance) throws IllegalArgumentException, IllegalAccessException; // întoarce valoarea câmpului pentru instanța objinstance public tip gettip(object objinstance) throws IllegalArgumentException, IllegalAccessException; // idem. Valoarea trebuie sa fie convertibila la tip. Se aplica pentru primitive public void set(object objinstance, Object value) throws IllegalArgumentException, IllegalAccessException public void settip(object objinstance, tip s) throws IllegalArgumentException, IllegalAccessException

18 Java Reflection - metode Obtinere metode: Method[] method = aclass.getmethods(); // Toate metodele publice, inclusiv cele din superclase si/sau superinterfete Method[] method = aclass.getdeclaredmethods(); // Toate metodele clasei curente public Method getmethod(string name, Class<?>... parametertypes) throws NoSuchMethodException, SecurityException; // metoda cu numele si tipurile parametrilor specificați Caracteristici furnizate prin metode ale clasei Method: public Class<?>[] getparametertypes(); public Type[] getgenericparametertypes(); public Class<?>[] getexceptiontypes(); public Class<?> getreturntype();

19 Java Reflection - metode Invocarea metodelor public Object invoke(object objinstance, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException; // Daca metoda este static objinstance poate fi null... Method method1 = myobject.class.getmethod("astaticmethod", String.class); Object returnvalue1 = method.invoke(null, "parameter-value1"); Method method2 = myobject.class.getmethod("aninstancemethod", String.class); Object returnvalue2 = method.invoke(myobject, "parameter-value2");

20 Java API - Introspector Este o clasa utilitara care pune la dispozitie un instrument de inspectare a claselor bean (proprietati, metode, evenimente). public class Introspector extends Object; Informatiile sunt furnizate prin intermediul obiectelor BeanInfo. Obtinere BeanInfo prin metoda statica getbeaninfo a clasei Introspector: public static BeanInfo getbeaninfo(class<?> beanclass) throws IntrospectionException; Investigare continut prin metode ale clasei BeanInfo: PropertyDescriptor[] getpropertydescriptors(); MethodDescriptor[] getmethoddescriptors(); EventSetDescriptor[] geteventsetdescriptors();

21 Clasele Descriptor public class FeatureDescriptor extends Object; // clasa radacina utilizata pentru obtinerea unor informatii commune despre proprietati, metode si evenimente in cadrul unui bean Metode: public String getname(); // numele programmatic al proprietatii public void setname(string name); Descriptor pentru proprietati public class PropertyDescriptor extends FeatureDescriptor; // descrierea proprietatilor Constructori: public PropertyDescriptor(String propertyname, Class<?> beanclass) throws IntrospectionException; // este conditionat de conventia set-get-is public PropertyDescriptor(String propertyname, Class<?> beanclass, String readmethodname, String writemethodname) throws IntrospectionException; // pentru scriere/citire se poate trece null

22 Metode: public Class<?> getpropertytype(); // tipul proprietatii public Method getreadmethod(); // intoarce metoda read public void setreadmethod(method readmethod) throws IntrospectionException; // stabileste metoda read public Method getwritemethod(); // metoda write public void setwritemethod(method writemethod) throws IntrospectionException; Descriptor pentru metode public class MethodDescriptor extends FeatureDescriptor; Metode: public Method getmethod(); public ParameterDescriptor[] getparameterdescriptors();

23 Descriptor pentru evenimente public class EventSetDescriptor extends FeatureDescriptor; Metode: public Class<?> getlistenertype(); public Method getaddlistenermethod(); public Method getremovelistenermethod();

24 Adnotari Adnotarile ofera informatii care nu sunt parte a logicii aplicatiei Au urmatoarele utilizari: Informatii pentru compilare. = "unchecked") Procesari specifice in timpul compilarii si deployment-ului Procesari specifice in executie

25 [(numeproprietate="valoareprorietate")... ] @SuppressWarnings parametrii: public abstract String[] value; "deprecation"})

26 Adnotari standard applicate altor - arata la ce moment este tratata adnotarea parametrii: public abstract RetentionPolicy value; // Unde RetentionPolicy sunt: RetentionPolicy.SOURCE Se adreseaza codului sursa fiind ignorata de compilator RetentionPolicy.CLASS Se adreseaza compilatorului si este tratata la momentul compilarii (optiune default) RetentionPolicy.RUNTIME Se adreseaza JVM si este tratata la momentul - arata carei entitati i se adreseaza adnotarea parametrii: public abstract ElementType[] value; // ElementType este o enumerare valori posibile:

27 ElementType.ANNOTATION_TYPE - se adreseaza altei adnotari ElementType.CONSTRUCTOR - constructorului ElementType.FIELD - campului ElementType.LOCAL_VARIABLE - variabilei locale ElementType.METHOD - metodei ElementType.PACKAGE - pachetului ElementType.PARAMETER- parametrilor unei metode ElementType.TYPE - oricarui element dintr-o - Indica faptul ca o adnotare este automat mostenita.

28 Crearea adnotarilor proprii Sunt create dupa reguli asemanatoare claselor si interfetelor, in fisiere sursa cu numele adnotarii Sintaxa: [numeadnotare] { [tip nume() default valoare;]... }

29 Accesul la adnotari in timpul executiei Accesul la adnotari in timpul executiei este realizat prin implementarea interfetei AnnotatedElement Metode ale interfetei AnnotatedElement: public Annotation[] getannotations(); // intoarce toate adnotarile prezente la elementul curent public Annotation[] getdeclaredannotations(); // întoarce doar adnotarile prezente direct la elementul current public <A extends Annotation> A getannotation(class<a> annotationclass); //intoarece adnotarea specificata daca aceasta este prezenta public <A extends Annotation> A getdeclaredannotation(class<a> annotationclass); // Idem dar pentru adnotare direct prezenta O adnotare este direct prezenta la un element daca elementul contine acea adnotare. O adnotare este prezenta la un element daca este direct prezenta sau daca este direct prezenta la o superclasa si este de tip inheritable. Clase care implementeaza AnnotatedElement: Class, Constructor, Executable, Field, Method, Package, Parameter

30 Java Beans JB tehnologie utilizată pentru construirea de componente reutilizabile, autonome, independente de platformă şi asamblabile Caracteristici Persistenţa. Prin mecanismul de serializare se asigură salvarea stării unui obiect bean şi restaurarea sa Comunicarea prin evenimente. Se utilizează mecanismul sursă-ascultător pentru a comunica intre două obiecte bean Reflexia (introspecţia). Se utilizează mecanismul Java-Reflection pentru a afla informaţii despre obiecte la momentul execuţiei Reguli de denominare Constructor public fără parametrii Definire de proprietăţi Metode publice normalizate de acces utilizând prefixe: set, get, is

31 Proprietăţi Sunt date (primitive sau obiecte) care dau starea unui obiect bean. Tipuri de proprietăţi: Proprietăţi simple Proprietăţi indexate Proprietăţi legate Proprietăţi cu constrângeri Proprietățile simple sunt atribute care au asociate metode set, get, is. private <tip> <nume>;... public void set<nume>(<tip> val); public <tip> get<nume>(); Metodele set nu sunt obligatorii. Pentru atributele boolean accesul se face si prin: public boolean is<nume>();

32 Proprietatile indexate corespund atributelor de tip masiv: private <tip>[] nume;... public <tip>[] get<nume>(); public void set<nume>(<tip>[] val); public <tip> get<nume>(int index); public void set<nume>(int index, <tip> val); Proprietatile legate sunt proprietati care genereaza un eveniment la schimbarea valorilor lor. Aceste evenimente pot fi interceptate de obiecte din clase speciale - ascultatori. Implementare eveniment: public class PropertyChangeEvent extends EventObject; Constructor: public PropertyChangeEvent(Object source, String propertyname, Object oldvalue, Object newvalue); // source - obiectul care contine proprietatea pentru care se face notificarea (ii se schimba valoarea), propertyname - numele proprietatii, oldvalue, newvalue - valoriile veche si noua

33 Metode ale clasei: public Object getoldvalue(); public Object getnewvalue(); public String getpropertyname(); Sursa evenimentelor PropertyChangeEvent o constituie obiectele care contin proprietatile legate. Un astfel de obiect trebuie sa aiba metode care sa permita inregistrarea/stergerea de ascultatori pentru evenimentele PropertyChangeEvent generate. Crearea ascultatorilor se face prin interfata : public interface PropertyChangeListener extends EventListener; Metoda abstracta: void propertychange(propertychangeevent evt) ; // Metoda prin care se implementeaza actiunea executata la interceptarea evenimentului evt (schimbarea valorii proprietatii)

34 Mecanismul de notificare In plus fata de simpla inregistrare a ascultatorilor, un obiect cu proprietati legate trebuie sa furnizeze un mecanism pentru crearea efectiva a ascultatorilor si notificarea lor la crearea de evenimente. Notificarea consta in generarea unui obiect-eveniment de tip PropertyChangeEvent, care va fi tratat de ascultator prin metoda propertychange. Acest mecanism este implementat de clasa: public class PropertyChangeSupport extends Object implements Serializable; Constructor: public PropertyChangeSupport(Object sourcebean); // se specifica beanul asociat - cel pentru care se efectueaza suportul Metode de notificare: public void firepropertychange(string propertyname, Object oldvalue, Object newvalue); //raporteaza schimbarea unei proprietati public void fireindexedpropertychange(string propertyname, int index, Object oldvalue, Object newvalue); //idem pentru o proprietate indexata

35 Metode de inregistrare/stergere a ascultatorilor de catre suport (metode ale clasei PrpertyChangeSuport): public void addpropertychangelistener(propertychangelistener listener); // Adaugare ascultator pentru modificarea proprietatilor public void removepropertychangelistener(propertychangelistener listener); // Stergere ascultator

36 Proprietati cu constrangeri Prin mecanismul de constrangere, modificarea valorilor unor proprietati poate fi impiedicata de terte obiecte, printr-un fel de "veto". Din punct de vedere tehnic, mecanismul este asemanator celui de notificare: - sunt inregistrati ascultatori de veto; - se face notificare de veto si se arunca o exceptie de tip PropertyVetoException; - suportul este asigurat de clasa: public class VetoableChangeSupport extends Object implements Serializable; Constructor public VetoableChangeSupport(Object sourcebean); // sourcebean este obiectul care contine proprietatea

37 Metode de inregistrare a ascultatorilor (ale clasei VetoableChangeSupport): public void addvetoablechangelistener(vetoablechangelistener listener); public void removevetoablechangelistener(vetoablechangelistener listener); Metoda de notificare veto: public void firevetoablechange(string propertyname, Object oldvalue, Object newvalue) throws PropertyVetoException; Crearea ascultătorilor se face prin implementarea interfeței: public interface VetoableChangeListener extends EventListener; Metodă abstractă; void vetoablechange(propertychangeevent evt) throws PropertyVetoException;

38 Excepțiile aruncate la notificare sunt din clasa: public class PropertyVetoException extends Exception; Constructor: public PropertyVetoException(String mess, PropertyChangeEvent evt);

39 Documentarea aplicațiilor - Javadoc Crearea unei documentații pe baza comentariior inserate în codul sursă Comentariile sunt inserate în manieră standardizată Are avantajul de a păstra în același loc documentația și codul Pot fi documentate pachete, clase, constructori, câmpuri, și metode

40 Definire documentație Comentariile de bază sunt inserate în structura /** */ respectând câteva reguli: blocul de comentarii începe cu /** și se termină cu */ ; liniile din comentarii încep cu *; caracterele blank (spațiu, tab, \n) de la începutul liniilor sunt ignorate in comentarii pot fi inserate tag-uri HTML Taguri pentru attribute speciale asociate name - este asociat claselor sau major.minor.patch - asociat claselor și name description - asociat description - asociat Throwable description - asociat explanation - asociat package.class#member label - asociat tuturor nivelurilor