-
No records found.
Ogłoszenie
Nazwa firmy
Stanowisko
Województwo ???region.kind???
Miasto
Ulica
Umowa o pracę
???agreement.???
b2b
???agreement.???
Umowa cywilnoprawna
???agreement.???
Praca zdalna %
Podróże %
Godzin tygodniowo Od do
Godziny pracy
Ilość dni wolnych Od do
Od kiedy zatrudnienie ASAP
Czas zatrudnienia
???longContract.???
Branża
Oferujemy
O projekcie
Wymagane technologie
Aplikuj
e-mail
Imię
Nazwisko
Rodzaj umowy
  •  
  • b2b
  • O prace
  • Cywilnoprawna
Oczekiwanie finansowe
brutto/netto
  •  
  • brutto
  • netto
Informacje dla firmy
CV
Choose
List motywacyjny
Choose
Akceptuj regulamin
Wyrażam zgodę na przetwarzanie danych przez właściciela
strony java.edu.pl oraz akceptuje regulamin
Regulamin
Regulamin
Kontakt z administratorem serwisu jest pod adresem e-mail: 
admin@java.edu.pl

Regulamin

§ 1.
Regulamin korzystania ze strony java.edu.pl zwanej dalej
jako serwis.
Niniejszy regulamin określa zasady korzystania z serwisu pod adresem java.edu.pl.
Regulamin może być w każdym czasie jednostronnie zmieniany przez właściciela
serwisu w całości lub w części.
Regulamin w nowym brzmieniu obowiązuje od momentu opublikowania go na stronach
internetowych serwisu.
§ 2.
Serwis jest dostępny bezpłatnie za pośrednictwem przeglądarki internetowej na
stronie java.edu.pl..
Wymagana jest rejestracja aby dokonywać wpisów na forum,
rozpoczęcie korzystania z serwisu następuje
po aktywacji linku w e-mailu.
W serwisie używane są pliki cookies.

§ 3.
Obowiązki użytkownika:
Użytkownik serwisu zobowiązuje się do podania danych zgodnych z prawdą i
przestrzegania regulaminu.
Użytkownik oświadcza że ma ukończone 16 lat.
Użytkownik ma obowiązek chronić swoje konto oraz hasło przed osobami trzecimi.
Użytkownik ponosi wszelką odpowiedzialność za treść ogłoszeń a także zgodność z
obowiązującymi, miejscowymi przepisami prawa i zwyczajami oraz postanowieniami niniejszego
regulaminu.
Zabrania się publikowania treści reklam, oraz niestosownych wiadomości pod rygorem usunięcia 
lub zablokowania konta.
Rejestrując się w serwisie i akceptując regulamin Użytkownik wyraża zgodę na
otrzymywanie na podany podczas rejestracji adres poczty elektronicznej
materiałów informacyjnych, ofert handlowych i wiadomości o charakterze
reklamowym.

§ 4.
Odpowiedzialność i prawa właściciela serwisu.
Właściciel serwisu dokona wszelkich starań aby portal działał zgodnie z oczekiwaniami
24h na dobę ale nie ponosi żadnej odpowiedzialności za wszelkiego rodzaju
błędne działanie serwisu.
Serwis przeznaczony jest do komunikowania się osób za pośrednictwem
internetu publikowania postów w forum. 
Oprócz forum znajdują się artykuły.
Właściciel zastrzega sobie prawo do usuwania, zablokowania, nakazu zmiany loginu użytkownika
lub zmiany treści konta użytkownika bez podania przyczyny.
Właściciel serwisu zastrzega możliwość przeglądania wszystkich danych
znajdujących się w serwisie, w tym wiadomości, za wszelkiego rodzaju spam, materiały o treści reklamowej,
komercyjnej, niezgodnej z funkcjonalnością serwisu osoba to rozpowszechniająca będzie 
blokowana a treści usuwane.
Właściciel serwisu nie ponosi żadnej odpowiedzialności w szczególności
cywilnej, karnej i administracyjnej, za korzystanie przez Użytkowników z
Serwisu.

§ 5.
Strona java.edu.pl przetwarza dane osobowe i  jest Administratorem danych.
Celem przetwarzania danych jest wysłanie CV i innych danych dla oferty pracy danej firmy.
Osoba wysyłająca ofertę na dane ogłoszenie wyraża zgodę na przetwarzanie danych
do celów rekrutacyjnych dla firmy wystawiającej ogłoszenie oraz dla administratora java.edu.pl
celem weryfikacji czy należy się administratorowi prowizja za zatrudnienie danej osoby.
Dane będę archiwizowane na okres 2 lat (konieczność wyższa do celów księgowych). 
Będziemy dokładać wszelkich starań aby dane były bezpieczne.
Wglądu do swoich danych następuje po zalogowaniu lub przez adres admin@java.edu.pl.
Edycji swoich danych osobowych można dokonać po zalogowaniu lub przez adres admin@java.edu.pl.
Usunięcia swoich danych i/lub cofnięcia zgody na przetwarzanie danych osobowych 
wysyłając odpowiednią informację na adres admin@java.edu.pl, 
z adresu zarejestrowanego konta (aby dokonać weryfikacji właściciela konta).

1. Lambda
2. Streams
3. New Date and Time API
Wyrażenie Lambda to anonimowe metody, czyli nie posiadają nazwy.
Definiowane są przez funkcjonalny interface 
(który posiada tylko jedną metodę abstrakcyjną). 
Może posiadać publiczne metody definiowane przez Object takie jak equals().
Interface funkcjonalny definiuje typ obieku lambda. 
Wyrażenie Lambda wprowadza nowy operator -> nazywany lambda operator lub operator strzałki.
Po lewej stronie zdefinowane są parametr lambdy ( puste nawiasy gdy brak parametrów )
Po prawej stronie zdefiniowane jest ciało lambdy określające jej działanie.
Operator ten można nazwać "staje się" lub "idzie do".
Mamy dwa typy ciała Lambda: pojedyncze wyrażenie i blok kodu.

Przejdzmy do przykładów. Oto najprostrzy przyklad wyrażenia lambda, stała wartość bez parametrów: 
  1. () -> 3.14;
Lub bardziej dynamiczny przykład:
  1. () -> Math.random() * 100;
A teraz przyjrzyjmy się wyrażeniu Lambda z parametrem:
  1. (a) -> ( a % 2 ) == 0;
Dla parametrów przystych zwraca true. Można również określić jaki jest typ parametru (nie jset to wymagane):
  1. (int a) -> ( a % 2 ) == 0;
Jeżeli mamy jeden parametr to możemy również opuścić nawiasy:
  1. a -> ( a % 2 ) == 0;
Do przypisania wyrażenia Lambda potrzebujemy interface z jedną i tylko jedną metodą (wtedy nazywamy ją "funkconalnym interfacem"), nie potrzebujemy w tej metodzie użycia słowa kluczowego "abstract". W javie 8 dodana została defaultowa metoda, lecz jej użycie nie zmienia znaczenia interfacesu funkcjonalnego czyli jedna metoda abstrakcyjna i nawet kilka metod defaultowych może być użyta jako interfaces funkcjonalny.
  1. interface Liczba {
  2.    double getWartosc();
  3. }
  4.  
Jak mamy zdefinoiwany interface możemy przypisać do niego wyrażenie lambda: Liczba pi;
  1. pi = () -> 3.14;
I teraz możemy się odwołać do naszego wyrażenia Lambda:
  1. System.out.println( pi.getWartosc() );
Typ argumentów lambdy musi być spójny z parametrami wywołania. Jeżeli do naszego interfaceu "Liczba" spróbujemy przypisać String wyskoczy błąd:
  1. pi = () -> "java.edu.pl"; // błąd
Wyrażenia lambda możemy przypisywać kilka razy tak jak do zmiennej:
  1. Liczba zmienna;
  2. zmienna = () -> 3.14;
  3. System.out.println( zmienna.getWartosc() );
  4. zmienna = () -> 1.2345;
  5. System.out.println( zmienna.getWartosc() );
Przejdźmy do lambdy z dwoma parametrami:
  1. interface Liczba2 {
  2.         boolean test(int a, int b);
  3. }
  4.  
  5. Liczba2 sumaWiekszaOd10 = (a,b) -> ( a + b ) > 10;
  6. if ( sumaWiekszaOd10.test(4,6) ) {
  7.     System.out.println( " Suma liczb jest wi�ksza od 10 " );
  8. }
Możemy też wywołąć wyrażenie lambda używając jawnych argumentów funkcji:
  1. Liczba2 sumaWiekszaOd10 = (int a,int b) -> ( a + b ) > 10;
Ale jeżeli użyjemy jej w jednym argumencie to już trzeba we wszystkich argumentach ich użyć:
  1. Liczba2 sumaWiekszaOd10 = (int a,b) -> ( a + b ) > 10; // błąd
Wcale nie musimy nazwać argumentów lambdy tak jak jest w intefasie funkcjonalnym
  1. Liczba2 sumaWiekszaOd10 = (int mojaNazwa1, int mojaNazwa2) -> (mojaNazwa1 + mojaNazwa2) > 10;
Czasami potrzebujamy złożonego ciała lambdy, który nazywamy "blok lambdy" i używamy do tego nawiasów klamrowych. Ważne jest aby użyć słowa kluczowego return na końcu wyrażenia.
  1. interface Liczba {
  2.         int wartosc(int a);
  3. }
  4.  
  5. class BlokLambda {
  6.         public static void main(String args[]){
  7.                 Liczba silnia = (n) -> {
  8.                         int r = 1;
  9.                         for ( int i=1;i<=n; i++ ) {
  10.                                 r = i*r;
  11.                         }
  12.                         return r;
  13.                 };
  14.                 System.out.println("Silnia z 5 to: silnia.wartosc(5));
  15.         }
  16. }
Wewnatrz bloku lambdy możemy używać pętli, delkarować zmienne używać warunków "if" i "switch" podobnie jak w ciele metody. Nowe ciało lambdy musi być zakończone średnikiem ;. Mamy też możliwość użycia typów generycznych w interfacesie i użycia go przy użyciu Lambda:
  1. interface JakasLambda<T> {
  2.         T wartosc(T a);
  3. }
  4.  
  5. class BlokLambda {
  6.         public static void main(String args[]){
  7.                 JakasLambda<Integer> silnia = (n) -> {
  8.                         int r = 1;
  9.                         for ( int i=1;i<=n; i++ ) {
  10.                                 r = i*r;
  11.                         }
  12.                         return r;
  13.                 };
  14.                 System.out.println("Silnia z 5 to: silnia.wartosc(5));
  15.  
  16.                 JakasLambda<String> rewers= (s) -> {
  17.                         String odtylu= "";
  18.                         for ( int i=s.length()-1;i>=i; i-- ) {
  19.                                 odtylu += s.charAt(i);
  20.                         }
  21.                         return odtylu;
  22.                 };
  23.                 System.out.println("Lambda od tylu to: rewers.wartosc("Lambda"));
  24.         }
  25. }
Lambda może być także użyta jako argument funkcji:
  1. interface JakasLambda {
  2.         String wartosc(String a);
  3. }
  4.  
  5. class ArgLambda {
  6. public String strMetoda(JakasLambda lba,String s) {
  7.         return lba.wartosc(s);
  8. }
  9.  
  10.         public static void main(String args[]){
  11.                 String res1 = strMetoda((str)-> str.toUpperCase(),"Jakie litery?");
  12.                 System.out.println( res1 );
  13.  
  14.                 String res2 = strMedoda( (str) -> {
  15.                                          String odtylu= "";
  16.                                          for ( int i=s.length()-1;i>=i; i-- ) {
  17.                                                 odtylu += s.charAt(i);
  18.                                          }
  19.                                          return odtylu;
  20.                                        }, "blok odwrocony" );
  21.                 System.out.println( res2 );
  22.  
  23.                 JakasLambda rewers= (str) -> {
  24.                         String odtylu= "";
  25.                         for ( int i=s.length()-1;i>=i; i-- ) {
  26.                                 odtylu += s.charAt(i);
  27.                         }
  28.                         return odtylu;
  29.                 };
  30.                 System.out.println( strMetoda( (strMetoda(rewers, "Jaka kolejnosc?") );
  31.  
  32.         }
  33. }
Mamy możliwość wstawiania pojedynczego wyrażenia lambdy w parametrze metody lub bloku lambdy w parametrze metody, lub zdefiniowanej wartości lambda w parametrze funkcji. W wyrażeniach lambda można również używać wyjątków. Jeżeli rzucony wyjątek jest wyżej, trzeba użyć w interface funkcyjnym wyrażenia throws z listą wywołanych wyjątków.
  1. interface TablicaLiczb {
  2.         double wartosc(double[] n) throws IllegalArgumentException;
  3. }
  4.  
  5. class LambdaException {
  6.  
  7.         public static void main(String args[]) throws IllegalArgumentException {
  8.             TablicaLiczb sumaElem = (n) -> {
  9.                         if ( n.length == 0 ) {
  10.                                 throw new IllegalArgumentException();
  11.                         }
  12.                         double sum = 0;
  13.                         for (int i=0; i < n.length; i++) {
  14.                                 sum += n[i];   
  15.                         }
  16.                         return sum;
  17.                 };
  18.                 System.out.println( sumaElem.wartosc(new double[]{1.0,3.0, 5.0}) );
  19.                 double[] db = new double[]{1.0,3.0, 5.0}
  20.                 System.out.println( sumaElem.wartosc(db) );
  21.                 System.out.println( sumaElem.wartosc(new double[0]) );
  22.                 System.out.println( sumaElem.wartosc({1.0,3.0, 5.0}) ); // błąd
  23.                 System.out.println( sumaElem.wartosc(new double[]{1.0,3.0, 5.0}) );
  24.                
  25.         }
  26. }
W tym przykładzie widzimy też że tablice podajemy jako jedną zmienną (n). Gdybyśmy chcieli jawnie zadeklarować typ wtedy napisalibyśmy (double[] n). Jeżeli zmienna jest użyta wewnątrz lambdy a zadeklarowana zewnątrz lambdy to i tak staje się ona automatyczenie zmienną finalną ponieważ jest użyta wewnątrz lambdy.
  1. interface Liczba {
  2.         int wartosc(int a);
  3. }
  4. class Zmienna {
  5.         public static void main(String args[]) {
  6.                 int liczbaA = 10;
  7.                 Liczba lambda = (n) -> {
  8.                         int liczbaB = liczbaA + n;
  9.                         // użycie w lambdzie automatycznie robi ją final
  10.                         liczbaA = 3; // błąd: jest final
  11.                 };
  12.                 liczbaA = 5; // błąd jest final
  13.         }      
  14. }
W javie 8 powstała referencja do metod, jest to trochę powiązane z wyrażeniami lambda. odwołujemy się to statecznych metod przez :: (podwójny dwukropek) to statyczeniej metody Klasa::statecznaMetoda i używamy jej w interfajsie funkcyjnym jako referencji do funkcji:
  1. interface Wyrazenie {
  2.         String wartosc(String str);
  3. }
  4. class MojaKlasa {
  5.         static String strOdTylu(String str) {
  6.                 String odtylu= "";
  7.                 for ( int i=str.length()-1;i>=0; i-- ) {
  8.                         odtylu += str.charAt(i);
  9.                 }
  10.                 return odtylu;
  11.         }
  12. }
  13. class Demo {
  14.         static String strOper(Wyrazenie wyr, String str) {
  15.                 return wyr.wartosc(str);
  16.         }
  17.         public static void main(String args[]){
  18.                 System.out.println( strOper( MojaKlasa::strOdTylu , "To jest moj tekst!!") );          
  19.         }
  20. }
Można to samo zrobić z instancją klasy, dla metody która nie jest statyczna. w tym celu odwołujemy się podobnie jak we wcześniejszym przykładzie. objekt::mojaMetoda na stworzonym wcześniej obiekcie i nie statycznej metodzie.
  1. interface Wyrazenie {
  2.         String wartosc(String str);
  3. }
  4. class MojaKlasa {
  5.         String strOdTylu(String str) {
  6.                 String odtylu= "";
  7.                 for ( int i=str.length()-1;i>=0; i-- ) {
  8.                         odtylu += str.charAt(i);
  9.                 }
  10.                 return odtylu;
  11.         }
  12. }
  13. class Demo {
  14.         static String strOper(Wyrazenie wyr, String str) {
  15.                 return wyr.wartosc(str);
  16.         }
  17.         public static void main(String args[]) {
  18.                 MojaKlasa moja = new MojaKlasa (); // to jest dodane aby się do tego odwołać
  19.                 System.out.println( strOper( moja::strOdTylu , "To jest moj tekst!!") );               
  20.         }
  21. }
Można również użyć referencji z generykami:
  1. interface Porownaj<T> {
  2.         int wartosc(T[] var, T v);
  3. }
  4. class Tablica {
  5.         static <T> int liczWystapienia(T[] var, T v) {
  6.                 int licznik = 0;
  7.                 for( T t : var ) {
  8.                         if ( t.equals(v) ) licznik++;
  9.                 }
  10.                 return licznik;
  11.         }
  12. }
  13.  
  14. class Demo {
  15.         static <T> int mojaMetoda(Porownaj<T> f, T[] var, T v) {
  16.                 return f.wartosc(var,v);
  17.         }
  18.        
  19.         public static void main(String args[]) {
  20.                 System.out.println( mojaMetoda( Tablica::<String>liczWystapienia, newString[]{"a","b","c", "b" },"a")  );                             
  21.         }      
  22. }
Możemy również zrobić referencje do konstruktora za pomocą interface-u funkcyjnego. Referencje do konstruktorów robimy za pomocą wyrazenia Klasa::new, działa ona również z parametrami. Referencja odnosi się do tego konstruktora jaki paramater jest zdefiniowany w interface funkcjonalnym;
  1. interface Wyrazenie {
  2.         MojaKlasa wartosc(String str);
  3. }
  4. class MojaKlasa{
  5.         private String nazwa;
  6.         MojaKlasa() { nazwa = "domy�lna";}
  7.         MojaKlasa(String name) { nazwa = name; }
  8.         String nazwaKlasy(){ return nazwa;};
  9. }
  10. public class JavaApplication1 {
  11.         public static void main(String args[]) {
  12.                 Wyrazenie mojaRef = MojaKlasa::new;
  13.                 MojaKlasa moja = mojaRef.wartosc("Moja Klasa");
  14.                 System.out.println( moja.nazwaKlasy()  );
  15.         }
  16. }
Możemy mieć również konstruktor z generykami, wtedy odwołujemy się do generyki tworząc referencje do konstruktora.
  1. interface Wyrazenie<T> {
  2.         MojaKlasa<T> wartosc(T str);
  3. }
  4. class MojaKlasa<T>{
  5.         private T nazwa;
  6.         MojaKlasa() {nazwa = null;}
  7.         MojaKlasa(T name) { nazwa = name; }
  8.         T nazwaKlasy() {return nazwa;};
  9. }
  10. public class JavaApplication1 {
  11.         public static void main(String args[]) {
  12.                 Wyrazenie<String> mojaRef = MojaKlasa<String>::new;
  13.                 MojaKlasa<String> moja = mojaRef.wartosc("Moja Klasa");
  14.                 System.out.println( moja.nazwaKlasy()  );
  15.         }
  16. }
Jeżeli chcemy stworzyć referencje od tablicy obiektów odwołujemy się: MojaKlasa[]::new Ale czasami nie musimy tworzyć naszych własnych interfaceów funkcyjnych. JDK 8 udostępnia paczkę java.util.function: UnaryOperation<T> - Obiekt T i zwraca obiekt T, metoda to <T> T apply(<T> t); BinaryOperator<T> - operacja na dwóch obiektach T, zwraca obiekt T, metoda to <T> T apply(T t2,T t2); Consumer<T> - Operacja na obiekcie T, metoda to <T> void accept(T t); Supplier<T> - zwraca obiekt T, metoda to <T> T get(); Function<T,R> - Operacja na obiekcie T zwraca obiekt R, metoda to <R,T> R apply(T t); Predicate<T> - jeżli obiekt T spełnia jakieś ograniczenia, zwraca boolean, metoda to <T> boolean test(T t); np:
  1. class Demo {
  2.         public static void main(String args[]) {
  3.         Function<Integer,Integer> func = (n) -> {
  4.                 int wynik = 1;
  5.                 for (int i = 1; i <= n; i++ ) {
  6.                         result = i * wynik;
  7.                 }
  8.                 return wynik;
  9.         };
  10.                 System.out.println( func.apply(4)  );  
  11.         }
  12. }
created by freelancer.java.org.pl © 2018