Serializarea. Transformarea datelor în secvenţe de octeţi astfel încât să poată fi transmise pe un flux de ieşire. Deserializare - procesul invers

Transcription

1 Serializarea Transformarea datelor în secvenţe de octeţi astfel încât să poată fi transmise pe un flux de ieşire Deserializare - procesul invers

2 Scopul serializării transmiterea datelor la distanţă. RMI conservarea datelor în afara timpului de execuţie. Persistenţa obiectelor asigurarea portabilităţii datelor sub diverse SO implementarea tehnologiei bazate pe componente reutilizabile - Beans

3 Mecanisme de serializare Mecanismul implicit de serializare este realizat prin implementarea formala a interfetei Serializable Serializarea voluntara se realizeaza in doua moduri: prin redefinirea metodelor readobject si writeobject. Semnătura exactă a metodelor este: private void readobject(java.io.objectinputstream stream) throws IOException, ClassNotFoundException; private void writeobject(java.io.objectoutputstream stream) throws IOException prin implementarea interfetei Externalizable

4 Clase si interfete utilizate la serializarea implicita Interfata Serializable. Este o interfata de marcaj, fara metode abstracte, care marcheaza clasele serializabile prin mecanismul implicit Interfata ObjectOutput extinde cadrul creat de DataOutput la scrierea de obiecte public interface ObjectOutput extends DataOutput; Metoda declarata pentru scriere: void writeobject(object obj) throws IOException; //Metoda este implementata de clasa ObjectOutputStream

5 Clasa ObjectOutputStream. Este clasa care realizeaza implementarea efectiva a mecanismului de serializare Declaratia de clasa: public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants; // in interfata ObjectStreamConstants sunt declarate constante utilizate in mecanismul de serializare Constructor: public ObjectOutputStream(OutputStream out) throws IOException; // out este un flux de scriere la nivel de octet Metode public final void writeobject(object obj) throws IOException; // Implementeaza mecanismul de serializare. Sunt exceptate de la serializare campurile transient. In mecanismul de serializare implicita sunt scrise clasa obiectului, semnatura de clasa si valorile tuturor campurilor netransiente si nestatice. Referintele la alte obiecte declanseaza si serializarea acestora.

6 Clase si interfete utilizate la deserializarea implicita Interfata ObjectInput, extinde functionalitatile din DataInput la citirea de obiecte. public interface ObjectInput extends DataInput; Metoda de citire declarata: Object readobject() throws ClassNotFoundException, IOException; Clasa ObjectInputStream citeste obiecte serializate prin ObjectOutputStream public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants; Constructor public ObjectInputStream(InputStream in) throws IOException ; // in este flux de citire la nivel de octet Metoda pentru deserializare: public final Object readobject() throws IOException, ClassNotFoundException; //sunt deserializate obiectele serializate prin writeobject

7 Serializarea voluntara prin implementarea interfetei Externalizable Este o metoda utilizata pentru a personaliza procesul de serializare. Folosirea interfeței impune existența unui constructor fără parametrii pentru clasele obiectelor serializate. Declarația de clasă: public interface Externalizable extends Serializable; Metode de implementat pentru citire si scriere: public void writeexternal(objectoutput out) throws IOException; public void readexternal(objectinput in) throws IOException, ClassNotFoundException; // in si out sunt fluxuri de citire si scriere la nivel de obiect

8 Controlul versionării Un obiect serializat intr-o anumită versiune de clasă trebuie deserializat în aceeași versiune Controlul versiunii se face printr-un câmp static: public static final long serialversionuid = valoare; Dacă nu este declarat explicit, acest câmp este adăugat automat de JVM La momentul deserializării se compară valorile acestui camp și este aruncată o excepție de tipul InvalidClassException dacă acestea sunt diferite

9 Generics

10 Clase generice - Generics Java Generics este o tehnologie Java prin care a fost introdus in Java (odata cu distributia 1.5) conceptul de clase generice Conceptul este asemănător celui de "template" din C++ Diferenta fundamentala: C++ : expandare la compilare pentru fiecare tip Java: eradicarea tipului la compilare castul catre tipul de baza, fara expandarea codului Declaratia de clasa: [public] class NumeClasa<T1, T2,..., Tn> {... } Metode generice: [public/protected/private] [static] <T1, T2,..., Tn> tip numemetoda(listaparametrii) [throws E1,...,Em] {...}

11 Crearea colectiilor proprii Cea mai largă utilizare a claselor generice este în crearea colecțiilor O colecție simplă conține o clasă de bază în care se află elementele colecției și un iterator care să permită accesarea iterativă a elementelor Crearea iteratorilor Un iterator este o clasă care implementează interfața Iterator<E> Interfata Iterator<E> Declaratia de interfata: public interface Iterator<E>; Metode abstracte: boolean hasnext(); E next(); void remove();

12 Crearea colecției Colecția este o clasă care implementează interfața Iterable<T> Interfata Iterable<T> Declaratia de interfata: public interface Iterable<T> ; Metode abstracte Iterator<T> iterator(); default void foreach(consumer<? super T> action)

13 Operatorul wildcard Este utilizat pentru a flexibiliza utilizarea claselor generice, astfel: <?> semnifica tip necunoscut este utilizat cand nu se cunoaste sau nu are importanță tipul de bază <? extends Tip> ține locul unui tip de bază (upper-bounded wildcard) <? super Tip> ține locul unui tip derivat (Lower-bounded wildcard)

14 Metode default Metodele default permit adăugarea de noi funcționalități interfețelor fără să facem modificări la nivelul claselor implementatoare Este o facilitate introdusă cu versiunea Java 8 Au apărut din necesitatea de a adăuga noi funcționalități interfețelor vechi în versiunea Java 8 (Exemplu: traversarea funcțională a colecțiilor) Tehnic, metodele default sunt metode care au o implementare la nivel de interfață. Deci modificatorul default permite implementarea metodei la nivel de interfață. La nivelul clasei implementatoare o metodă default din interfață poate fi invocată astfel: NumeInterfata.super.numeMetoda() Dacă o clasă implementează două interfețe care conțin câte o metodă default cu aceeași semnătură, clasa va trebui să facă o implementare proprie metodei, pentru a elimina ambiguitatea

15 Interfețele Consumer și Predicate Declarație: public interface Consumer<T>; Metodă: void accept(t t); // Execută operațiunea implementată asupra obiectului t Metode default: default Consumer<T> andthen(consumer<? super T> after); // Întoarce consumerul care efectueaza operatia curenta si apoi operatia specificată în after Declarație: public interface Predicate<T>; Metodă: boolean test(t t); // Execută testul asupra obiectului t Metode default: default Predicate<T> and(predicate<? super T> other); // Execută și logic cu un alt predicat default Predicate<T> negate(); // Intoarce predicatul negație default Predicate<T> or(predicate<? super T> other); // Sau logic

16 Prelucrarea functionala a colectiilor Facilitate oferita de Java 1.8. Consta in prelucrarea prin intermediul unor obiecte Stream care permit diverse operatii pe elementele colectiei Interfata la baza: public interface BaseStream<T,S extends BaseStream<T,S>> extends AutoCloseable; T tipul elementului din Stream S tipul de stream Interfete derivate: public interface DoubleStream extends BaseStream<Double,DoubleStream>; public interface IntStream extends BaseStream<Integer,IntStream> public interface Stream<T> extends BaseStream<T,Stream<T>>; Obtinerea stream-urilor se face prin metode ale colectiilor: Stream<E> stream(); Stream<E> parallelstream();

17 Crearea obiectelor Stream prin StreamSupport Clasa StreamSupport permite crearea de obiecte Stream în colecțiile proprii Obiectele Stream sunt create prin metode statice stream ale clasei StreamSupport care crează obiecte de tip DoubleStream, IntStream, LongStream sau Stream<T> Exemplu Stream<T> public static <T> Stream<T> stream(spliterator<t> spliterator, boolean parallel); // un obiect Spliterator<T> este folosit pentru pentru partiționarea și traversarea elementelor dintr-o structură-sursă (vector, colecție, flux de intrare etc.) O implementare simplificată și incompletă a interfeței Spliterator este clasa Spliterators.AbstractSpliterator<T>: public abstract static class Spliterators.AbstractSpliterator<T> extends Object implements Spliterator<T>;

18 Constructor: protected AbstractSpliterator(long est, int additionalcharacteristics); Crează un spliterator cu o mărime estimată și cu specificarea unor caracteristici precum ORDERED, DISTINCT, SORTED, SIZED, NONNULL, IMMUTABLE, CONCURRENT, sau SUBSIZED Metodă abstractă: boolean tryadvance(consumer<? super T> action); // Funcționalitate asemănătoare metodelor hasnext și next din Iterator. Întoarce true dacă există elemente în spliterator, iar elementul este furnizat prin Consumer

19 Exemplu. Metoda stream de mai jos crează un obiect Stream într-o colecție proprie de tip listă simplu înlănțuită. Referința first este referința la primul element din listă iar referința t este o referință de lucru folosită pentru accesarea elementelor din listă public class MyList<T> implements Iterable<T> { private MyElement<T> first, t;... public Stream<T> stream() { t = first; return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(0, 0) public boolean tryadvance(consumer<? super T> action) { if (t == null) { return false; } else { action.accept(t.getinfo()); t = t.getnext(); return true; } } }, true); }...

20 Metode Stream Traversare void foreach(consumer<? super T> action); // executa o actiune pe fiecare element din stream Interfata Consumer este o interfata functionala prin care se executa o actiune asupra unui obiect. Actiunea este implementata prin metoda accept(object obj). Filtrare Stream<T> filter(predicate<? super T> predicate); // filtreaza datele din stream dupa filtrul creat in predicate Sortare Stream<T> sorted(); // T trebuie sa fie un tip care implementeaza Comparable<T> Stream<T> sorted(comparator<? super T> comparator); // se implementeaza comparatorul

21 Determinarea elementelor distincte Stream<T> distinct(); Elementele sunt diferențiate în funcție de implemetarea din equals Prelucrare personalizată a elementelor din stream <R> Stream<R> map(function<? super T,? extends R> mapper) unde mapper este o funcție care se aplică fiecărui element din stream. Prelucrari particulare: DoubleStream maptodouble(todoublefunction<? super T> mapper); IntStream maptoint(tointfunction<? super T> mapper) LongStream maptolong(tolongfunction<? super T> mapper) Exemplu double mediamaxima = listastudenti.stream().maptodouble(student-> student.getmedia()).max().getasdouble();

22 Caracteristici ale programării funcționale Se bazează pe apeluri structurate de funcții <function1>(<function2>(<function3> ) ) Fiecare funcție primește valori de la alte funcții și transmite valori altor funcții Numele sunt utilizate doar ca parametrii formali Un nume este asociat întotdeauna cu o singură valoare Ordinea executării operațiunilor nu influenteaza rezultatele Modificările repetate se realizează prin apeluri de funcții imbricate Noile valori pot fi asociate cu același nume prin apeluri recursive

23 Interfețe funcționale O interfață funcțională este o interfață care conține doar o singură metodă abstractă O interfață funcțională poate conține una sau mai multe metode default sau metode statice Utilizare extinsă în implementarea obiectelor Stream sau în interfața grafică

24 Interfața public interface Function<T,R>; Reprezintă o funcție care acceptă un argument de tip T și întoarce un rezultat de tip R Metodă abstractă: R apply(t t); // Conține codul asociat funcției Metode default: default <V> Function<V,R> compose(function<? super V,? extends T> before); //Întoarce o funcție compusă din funcția before și funcția curentă - mai întâi execută before si apoi rezultatul este prelucrat prin funcția curentă default <V> Function<T,V> andthen(function<? super R,? extends V> after); //Întoarce funcția a cărei execuție este urmată de execuția unei funcții after

25 Exemplu 1. Să se definească o funcție care adună elementele dintr-un vector de numere reale și să se calculeze suma Double[] a = {10.0, 20.0, 30.0}; Function<Double[], Double> f1 = (new Function<Double[], Double>() public Double apply(double[] t) { double s = 0; for (double v : t) { s += v; } return s; } }); System.out.println(f1.apply(a)); 2. Să se calculeze pătratul sumei prin metoda andthen care va implementa calculul pătratului

26 System.out.println(f1.andThen( new Function<Double, Double>() public Double apply(double t) { return t*t; } } ).apply(a)); 2. Să se genereze vectorul aleator mai întâi folosind metoda compose și apoi să se calculeze suma System.out.println(f1.compose(new Function<Integer, Double[]>() public Double[] apply(integer t) { Double[] v = new Double[t]; for (int i = 0; i < t; i++) { v[i] = Math.random() * t; } return v; } }).apply(10));

27 Interfața public interface BiFunction<T,U,R>; T - tipul primului argument U - tipul ultimului argument R - tipul rezultatului Metoda abstractă R apply(t t, U u) Metodă default: default <V> BiFunction<T,U,V> andthen(function<? super R,? extends V> after)

28 Interfețele UnaryOperator și BinaryOperator Sunt extensii ale interfețelor Function și BiFunction pentru situațiile în care rezultatele sunt de același tip cu public interface UnaryOperator<T> extends public interface BinaryOperator<T> extends BiFunction<T,T,T>

29 Exemple String nume1 = "Popa Marius", nume2 = "Pop Adrian"; UnaryOperator<String> uo = new UnaryOperator<String>() public String apply(string t) { return t.touppercase(); } }; BinaryOperator<String> bo = new BinaryOperator<String>() public String apply(string t, String u) { if (t.length() > u.length()) { return t; } else { return u; } } }; System.out.println(uo.apply(nume1)); System.out.println(bo.apply(nume1, nume2));

30 Referințele la metode Referințele la metode permit reutilizarea unei metode ca funcție Sintaxa: target_reference::method_name Pot fi referite atât metode statice cât și metode de instanță Exemplul 1 Double[] a = {10.0, 20.0, 30.0}; Function<Double[],Double> f2 = Operatiuni::produs; System.out.println(f2.apply(a)); unde clasa Operatiuni are o metodă statică produs astfel definită: public static Double produs(double[] s) {... } Exemplul 2 Operatiuni o = new Operatiuni(); Function<Integer,Double> f3 = o::produs; System.out.println(f3.apply(3)); Clasa Operatiuni are o metodă de instanță produs astfel definită: public Double produs(integer m) {... ) // Calculează produsul primelor m valori reale dintr-un vector câmp al clasei

31 Expresiile lambda Expresiile Lambda simplifică modul de transmitere a comportamentului ca parametru Comportamentul transmis este cel implementat printr-o metodă a unei interfețe funcționale Sintaxa unei expresii lambda este: (args1, args2, ) -> { body } - dacă body constă dintr-o singură instrucțiune nu sunt necesare acoladele și nici instrucțiunea return; - dacă există un singur parametru nu sunt necesare parantezele rotunde - dacă nu există parametrii sunt obligatorii parantezele rotunde - specificarea tipului pentru argumente este opțională

32 Accesarea variabilelor locale din domeniul de vizibilitate Accesarea variabilelor locale se face în aceleași condiții ca la clasele locale sau anonime - variabilele locale trebuie să fie finale sau efectiv finale (nu se modifică după inițializare) Variabilele locale nu pot fi mascate in expresiile lambda - expresiile lambda nu creeaza un nou nivel de domeniu de vizibilitate referinta this se refera la clasa care conține expresia și nu la expresie in sine

33 Referințele la metode și expresiile lambda Referințele la metode permit reutilizarea unei metode și ca funcție lambda Exemplul 1 - Pentru o metodă statică Function<Double[], Double> f4 = (Double[] ta) -> Operatiuni.produs(ta); System.out.println(f4.apply(a)); echivalent cu Function<Double[],Double> f2 = Operatiuni::produs; System.out.println(f2.apply(a)); Exemplul 2 Operatiuni o = new Operatiuni(); Function<Integer, Double> f5 = (Integer t) -> o.produs(t); System.out.println(f5.apply(3)); echivalent cu Operatiuni o = new Operatiuni(); Function<Integer,Double> f3 = o::produs; System.out.println(f3.apply(3));