Kategoria: Programowanie

Dwu argumentowy predykat, funkcja, konsument. Opis i porównanie

W poście tym przybliżam ciekawą funkcję wprowadzoną w Java8 jaką jest umożliwienie wprowadzania dwóch argumentów do Predykatu, Funkcji, Konsumenta i Dostawcy.

1. Predykat (Predicate)

Jest to funkcja, która przyjmuje jakiś argument i odpowiada: „tak” lub „nie”, w zależności od podanego jej elementu. Przykład predykatu jedno argumentowego gdzie sprawdzamy czy zmienna jest parzysta lub nie:
Predicate<Integer> p = i-> i%2==0;
W przypadku gdy predykat zwróci „tak”, to metoda umieści ten element w kolekcji wynikowej. W przeciwnym razie, ten element się tam nie znajdzie.

BiPredicate daje nam możliwość sprawdzenia warunków dla 2 argumentów. Poniżej przykład użycia:

import java.util.function.*
class Test {
public static void main(String [] args){
        BiPredicate<Integer, Integer> p = (a,b)  ->  (a+b) % 2  == 0;
        log.debug(p.test(10,20); // true
        log.debug(p.test(15); // false
    }
}

2. Funkcja

Przykład użycia funkcji gdzie na wejściu podajemy jeden argument typu Integer. W wyniku wykonania funkcji zwracamy mnożenie arguemntu prez samego siebie. Czyli jest to
function <Integer, Integer> f = i -> i*i

BiFunkcja w odróżnieniu od funkcji przedstawionej powyżej może na wejściu przyjąć 2 wartości i je przetworzyć.  Poniżej przykład użycia:

import java.util.function.*
class Test {
public static void main(String [] args){
        BiFunction<Integer, Integer, Integer> f = (a,b) -> a*b
        log.debug(p.apply(10,20); // 200
        log.debug(p.apply(1, 10); // 10
    }
}

3 Konsument

Przykład użycia konsumenta gdzie na wejściu przyjmujemy argument typu String. Następnie przekazujmy go do funkcji sopen.
Consumer<String> c = a -> sopen(a)

BiKonsument może przetworzyć na wejściu 2 argumenty.

Przykład użycia BiFunction oraz BiConsumer:
import java.util.function.*;
import java.util.*
class Employee {
    String name;
    double salary;

Employee(String name, double salary){
    this.name = name;
    this.salary = salary;
}
class Test {
    public static void main(String[] args){
        ArrayList<Employee> list = new ArrayList<Employee>();
        BiFunction<String, double, Employee> f = (name,salary) -> new Employee(name, salary);

    list.add(f.accept(„Adam”, 1000000000));
    list.add(f.accept(„Ada”, 1000));
    list.add(f.accept(„Anna”, 1000));

BiConsumer<Employee, Double> c = (e,d) -> e.salary = e.salary + d;

for (Employee e: list){
    c.accept(e, 600);

}

    for (Employee e :l){
        log.debug(e.salary);
        log.debug(e.name);
    }
    }
}

4. Dostawca (Supplier)

Zwraca (dostarcza) wartość typu Date.

Supplier<Date> s = () -> new Date();

Porównanie jedno i dwu argumentowego predykatu i funkcji:

Jedno argumentowy interfejs funkcjonalny. 
interface Predicate<T> {
    public boolean test(T t);
    default Predicate and(Predicate p);
    default Predicate or(Predicate p);
    default Predicate negate();
    static Predicate isEqual(Object o);
}

Zawiera jedna metodę abstrakcyjna (test) oraz 4 domyśle metody i jedna metodę statyczna.


Dwu argumentowy interfejs funkcjonalny:

interface BiPredicate<T, U> {
    public boolean test(T t, U u);
    default BiPredicate and(BiPredicate p);
    default BiPredicate or(BiPredicate p);
    default BiPredicate negate();
}
Nie posiada metody statycznej. Przyjmuje 2 argumenty w metodzie abstrakcyjnej.
Interfejs Funkcji:
interface Function<T,R> {
    public R apply(T t);
    default Function andThen(Function f);
    default Function compose(Function f);
          static Function identity();
}
Posiada jedne argument na wejściu (T) oraz zwraca jeden argument (R). Jedna metode abstrakcyjna oraz 2 domyślne i jedna statyczna.
Interfejs BiFunkcji:
interface BiFunction<T, U, R> {
    public R apply(T t, U u);
    default BiFunction andThen(Function f);
}
Posiada 2 argumenty na wejściu (T,U) oraz zwraca jeden argument (R). Warto zauważyć że domyślna metoda andThen przyjmuje na wejściu Funkcję f a nie BiFunckję.
Jednoargumentowy interfejs Konsument:
interface Consumer<T> {
    public void accept(T t);
    default Consumer andThen(Consumer c);
}
Przyjmuje jeden argument i nic nie zwraca. 
Dwuargumentowy interfejs Konsument:
interface Consumer<T> {
    public void accept(T t);
    default BiConsumer andThen(Consumer c);
}
Przyjmuje dwa argumenty ale nic nie zwraca. Metoda andThen używamy do łaczenia większej ilości Konsumentów.
    

Reactive streams i projekt Reactor ogólne informacje

W tym spisie zebrałem krótkie informacje na temat Reactive streams i project Reactor. Są również bardzo ciekawe linki, które w szybki sposób pomogą Ci wskoczyć na poziom umożliwiający programowanie z użyciem wspomnianych bibliotek.

Elementy występujące w Reactive streams możemy podzielić na:

  1. Publisher
  2. Subscriber
  3. Subscription
  4. Processor

Kiedy Subscriber zaczyna subskrybować Publisher zostaje utworzona Subskrybcja. Subskrybcja jest następnie przesyłana do metody onSubscribe.

Subscriber wysyła rządanie o elementy za pomocą onSubscribe i Publisher wysyła je. W przypadku gdy Publisher nie ma już więcej elementów do wysłania wywołana zostaje metoda onComplete.

W momencie gdy wystąpi błąd, subsrkypcja zostaje przerwana i zostaje wywołana metoda onError.
src: https://github.com/reactive-streams/reactive-streams-jvm


Projekt reactor

Aby nie tracić czasu podaje poniżej przydatne dla mnie informacje, które od razu pokazują jak stosować najbardziej używane elementy projektu Reactor:

  1. Flux
  2. Mono

Są to implementacje, interfejsu Publisher. Powyższe elementy muszą zostać zasubskrybowane. Można na nich operować za pomocą metod np:

  • map
  • flatMap
W źródłach poniżej znajdują się bardzo przydatne informacje na temat praktycznego użycia Reactor. W linku 1 kiedy używać jakiego operatora np. kiedy używać Mono.just a w którym przypadku jest lepszy Optional. Są też podane informacje jak transformować uzyskane dane.
W linku 2 są natomiast podane najlepsze praktyki. Są tam odpowiedzi na pytania np: Jak odebrać i obsłużyć żądanie synchroniczne.
Praktyczne ćwiczenia znajdują się natomiast w Linku 3 . Jest to projekt na GitHubie utworzony przez twórców projektu Reactor. Musimy w nim ukończyć rozpoczęty kod. Jest to wspaniałe ćwiczenie 🙂

src:

  1. https://projectreactor.io/docs/core/release/reference/#which-operator
  2. https://projectreactor.io/docs/core/release/reference/#faq
  3. https://github.com/reactor/lite-rx-api-hands-on



Linus Torvalds opowiada o GIT

Przedzieram się przez gąszcz informacji w internecie w celu znalezienia opisu wykorzystania narzędzi, które chce wykorzystać w mojej pracy. Natrafiłem na świetny filmik o tym jak Linus Torvalds opowiada o systemie wersjonowania GIT.

Git – rozproszony system kontroli wersji. Stworzył go Linus Torvalds jako narzędzie wspomagające rozwój jądra Linux. Git stanowi wolne oprogramowanie i został opublikowany na licencji GNU GPL w wersji 2.

Na stronie: http://taat.pl/artykuly/git-po-polsku/#branch możecie przeczytać jak obsłużyć ten program. Kapitalnie napisane.

Aplikacja Klient-Serwer TCP

I. Uzgadnianie stopniowe SERWER 
serwer wywołuje funkcję:

  •  socket stworzenie gniazda,
  •  bind dowiązanie do niego adresu protokołu (na który składa się adres IP oraz numer portu),
  •  listen (otwarcie bierne)  nasłuchiwanie w celu przyjęcia nadchodzących połączeń

II. Uzgadnianie stopniowe  KLIENT

  • Klient rozpoczyna otwarcie aktywne (ang. active open) połączenia, wywołując funkcję connect. To powoduje, że oprogramowanie TCP klienta wysyła segment danych  
  • wysłanie przez oprogramowanie TCP segmentu SYN (skrót od ang. synchronize), który zawiera początkowy numer kolejny danych jakie będą wysyłane przez klienta oraz odpowiednie nagłówki   

 III. Uzgadnianie stopniowe SERWER
serwer wysyła swój własny segment SYN, zawierający podobnie jak u klienta, jego początkowy numer kolejny danych, jakie będzie wysyłał, oraz potwierdzenie ACK (skrót od ang. acknowledgment), które jest potwierdzeniem otrzymania segmentu SYN od klienta   

IV. Uzgadnianie stopniowe  KLIENT  

Klient musi potwierdzić przyjęcie segmentu SYN od serwera   

Funkcja socket jest odpowiednikiem otrzymania własnego numeru telefonu. Funkcję bind można porównać do poinformowania innych ludzi o naszym numerze telefonu, pod który mogą oni zadzwonić. Funkcja listen odpowiada włączeniu się sygnału dźwiękowego, który słyszymy, gdy ktoś do nas dzwoni.   

  Dla porównania serwer UDP, który jest łatwiejszy ale nie mamy pewności czy pakiety zostały poprawnie wysłane.  

Microsoft Visual Studio -tworzenie gier

Zamierzam wespół z moim wspaniałym zespołem (patrz Ola:*) stworzymy grę typu: Worms.  Na stworzenie gry mamy czas do czerwca na razie będę wykorzystywał do tego celu Visual Studio 2010 +XNA Game Studio 4.0.

http://cpp0x.pl/ -swietna strona C++ 🙂 polecam!

http://msdn.microsoft.com/en-us/library/bb200104.aspx
http://www.unit1.pl/217,txt
http://www.ww.functionx.com/bcb/sockets/socket.htm
http://www.duke.edu/web/isis/gessler/borland/games.htm
świetna Polska strona z kursami programowania 
http://chomikuj.pl/eneste/e-magazyn/SDJ/Szperajc+w+nag*c5*82*c3*b3wkach*2c+czyli+wst*c4*99p+do+reverse+engineeringu,45278581.pdf
http://www.il.pw.edu.pl/~iap/IAPZ/vbkurs/iso2/wlasciw/dragmode.htm#appliesto

http://programowanie.cal.pl/cyfbar/kurs5.html