DEV Community: Illya Kysil

Type Pattern Matching - CORBA Style

Illya Kysil — Fri, 09 Oct 2020 00:00:00 +0000

package io.github.ikysil.javaplayground.narrow;

import java.util.List;
import java.util.Optional;

public class TypeNarrowDemo {

    static final class Types {

        private Types() throws IllegalAccessException {
            throw new IllegalAccessException();
        }

        static <T> T narrowToNull(final Object obj, final Class<T> expectedType) {
            if (expectedType.isInstance(obj)) {
                return expectedType.cast(obj);
            }
            return null;
        }

        static <T> Optional<T> narrow(final Object obj, final Class<T> expectedType) {
            return Optional.ofNullable(obj)
                .map(o -> narrowToNull(o, expectedType));
        }

    }

    public static void main(String[] args) {
        System.out.println("TypeNarrowDemo Demo");
        if (Types.narrowToNull("test", Object.class) != null) {
            System.out.println("SUCCESS: String is Object");
        }
        Types.narrow("test", Object.class)
            .ifPresent(o -> System.out.println("SUCCESS: String is Object: " + o));
        if (Types.narrowToNull("test", List.class) == null) {
            System.out.println("SUCCESS: String is NOT List");
        }
        Types.narrow("test", List.class)
            .ifPresentOrElse(
                o -> System.out.println("ERROR: String is NOT List: " + o),
                () -> System.out.println("SUCCESS: String is NOT List")
            );
    }

}

GitHub Repository: java-playground

Type Switch with Functional Java 8

Illya Kysil — Wed, 06 May 2020 20:17:40 +0000

package io.github.ikysil.javaplayground.typeswitch;

import javax.swing.*;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class TypeSwitchDemo {

    static class TypeSwitch<T> {

        private final T instance;

        private TypeSwitch(T instance) {
            this.instance = instance;
        }

        static <T> TypeSwitch<T> of(final T instance) {
            return new TypeSwitch<>(instance);
        }

        static <T> TypeSwitch<T> of(final Supplier<T> instanceSupplier) {
            return new TypeSwitch<>(instanceSupplier.get());
        }

        <I> TypeSwitch<T> instanceOf(final Class<I> type, final Consumer<I> consumer) {
            if (type.isInstance(instance)) {
                consumer.accept(type.cast(instance));
            }
            return this;
        }

        void noneMatches(final Consumer<Object> consumer) {
            consumer.accept(instance);
        }

    }

    public static void main(String[] args) {
        System.out.println("TypeSwitch Demo");
        TypeSwitch.of(new JLabel())
            .instanceOf(JComponent.class, o -> System.out.println("matched JComponent"));
        TypeSwitch.of(new Object())
            .instanceOf(JComponent.class, o -> System.out.println("matched JComponent"))
            .noneMatches(o -> System.out.printf("none matched: %s of %s%n", o, o.getClass()));
    }

}

GitHub Repository: java-playground

Implementing Fluent Builder with Functional Java 8

Illya Kysil — Wed, 07 Nov 2018 00:00:00 +0000

package playground;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.swing.*;

import static playground.JavaPlayground.Builder.of;

public class FunctionalBuilderDemo {

    static class Builder<T> {

        private final T instance;

        private Builder(final T instance) {
            Objects.requireNonNull(instance, "instance is required");
            this.instance = instance;
        }

        static <T> Builder<T> of(final T instance) {
            return new Builder<>(instance);
        }

        static <T> Builder<T> of(final Supplier<T> supplier) {
            return new Builder<>(supplier.get());
        }

        public Builder<T> with(final Consumer<T> c) {
            c.accept(instance);
            return this;
        }

        public <V> Builder<T> with(final BiConsumer<T, ? super V> c, final V value) {
            c.accept(instance, value);
            return this;
        }

        public <V> Builder<T> add(final Supplier<Collection<? super V>> c, final V value) {
            c.get().add(value);
            return this;
        }

        public <V> Builder<T> add(final Function<T, Collection<? super V>> c, final V v) {
            c.apply(instance).add(v);
            return this;
        }

        public <V> Builder<T> add(final Function<T, Collection<? super V>> c, final V... v) {
            c.apply(instance).addAll(Arrays.asList(v));
            return this;
        }

        public <V> CollectionBuilder<T, V> collectInto(final Function<T, Collection<? super V>> c) {
            return new CollectionBuilder<>(this, c);
        }

        public <V> CollectionBuilder2<T, V> collect(final Collection<V> c) {
            return new CollectionBuilder2<>(this, c);
        }

        public <V> CollectionBuilder2<T, V> collect(final Supplier<Collection<V>> c) {
            return collect(c.get());
        }

        public <V> CollectionBuilder2<T, V> collect() {
            return collect(new ArrayList<>());
        }

        public T instance() {
            return instance;
        }

    }

    static class CollectionBuilder<T, V> {

        private final Builder<T> builder;

        private final Function<T, Collection<? super V>> c;

        public CollectionBuilder(final Builder<T> builder, final Function<T, Collection<? super V>> c) {
            this.builder = builder;
            this.c = c;
        }

        public Builder<T> collect() {
            return builder;
        }

        public CollectionBuilder<T, V> add(final V value) {
            c.apply(builder.instance()).add(value);
            return this;
        }

    }

    static class CollectionBuilder2<T, V> {

        private final Builder<T> builder;

        private final Collection<V> c;

        public CollectionBuilder2(final Builder<T> builder, final Collection<V> c) {
            this.builder = builder;
            this.c = c;
        }

        public Builder<T> into(final Function<T, Collection<? super V>> finalCollector) {
            finalCollector.apply(builder.instance()).addAll(c);
            return builder;
        }

        public CollectionBuilder2<T, V> add(final V value) {
            c.add(value);
            return this;
        }

    }

    public static class Victim {

        private final Collection<String> strings = new ArrayList<>();

        private final Collection<Number> numbers = new ArrayList<>();

        Collection<String> getStrings() {
            return strings;
        }

        Collection<Number> getNumbers() {
            return numbers;
        }

        @Override
        public String toString() {
            return "Victim{" +
                "strings=" + strings +
                ", numbers=" + numbers +
                '}';
        }

    }

    public static void main(String[] args) {
        System.out.println("Functional Builder Demo");
        final JLabel jLabelInstance = of(new JLabel())
            .with(o -> o.setText("test"))
            .with(JLabel::setText, "test")
            .with(JLabel::setText, null)
            .with(JLabel::setDisabledIcon, of(new ImageIcon())
                .with(ImageIcon::setDescription, "icon description")
                .instance()
            )
            .instance();
        System.out.println(jLabelInstance);
        final ArrayList<JLabel> arrayListInstance = of(ArrayList<JLabel>::new)
            .with(List::add, new JLabel())
            .with(List::add, jLabelInstance)
            .instance();
        System.out.println(arrayListInstance);
        final Object instance = of(Victim::new)
            .add(Victim::getStrings, "asd")
            .add(Victim::getStrings, "asd", "def")
            .collectInto(Victim::getStrings)
            .add("qwe")
            .collect()
            .collect(ArrayList<String>::new)
            .add("poi")
            .into(Victim::getStrings)
            .<Integer>collect()
            .add(123)
            .into(Victim::getNumbers)
            .instance();
        System.out.println(instance);
    }

}

Switching JVM on Ubuntu with Bash

Illya Kysil — Sat, 03 Nov 2018 00:00:00 +0000

Just add following to your .bash_aliases:

alias resetjdkpath='
    PATH=`echo $PATH | sed -Ee 's/[/]usr[/]lib[/]jvm[^:]+//g' | sed -Ee 's/:+/:/g'`
'

alias orjdk7='
    resetjdkpath
    JAVA_HOME=/usr/lib/jvm/java-7-oracle
    J2SDKDIR=${JAVA_HOME}
    J2REDIR=${JAVA_HOME}/jre
    PATH=${JAVA_HOME}/bin:${JAVA_HOME}/db/bin:${JAVA_HOME}/jre/bin:$PATH
    DERBY_HOME=${JAVA_HOME}/db
    java -version
'

alias orjdk8='
    resetjdkpath
    JAVA_HOME=/usr/lib/jvm/java-8-oracle
    J2SDKDIR=${JAVA_HOME}
    J2REDIR=${JAVA_HOME}/jre
    PATH=${JAVA_HOME}/bin:${JAVA_HOME}/db/bin:${JAVA_HOME}/jre/bin:$PATH
    DERBY_HOME=${JAVA_HOME}/db
    java -version
'

alias orjdk9='
    resetjdkpath
    JAVA_HOME=/usr/lib/jvm/java-9-oracle
    J2SDKDIR=${JAVA_HOME}
    J2REDIR=${JAVA_HOME}/jre
    PATH=${JAVA_HOME}/bin:${JAVA_HOME}/db/bin:${JAVA_HOME}/jre/bin:$PATH
    DERBY_HOME=${JAVA_HOME}/db
    java -version
'

alias opjdk8='
    resetjdkpath
    JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
    J2SDKDIR=${JAVA_HOME}
    J2REDIR=${JAVA_HOME}/jre
    PATH=${JAVA_HOME}/bin:${JAVA_HOME}/db/bin:${JAVA_HOME}/jre/bin:$PATH
    DERBY_HOME=${JAVA_HOME}/db
    java -version
'