Java Server Faces Login Security

JSF LOGIN SECURITY

Yayına ulaşmak için Tıklayınız....

 Projenin kodlarına erişmek için(Github) Tıklayınız...

Java – Binary Search Algorithm – İkili Arama Algoritması

BinarySearch sıralı olmayan dizilerde arama yaparken arama süresini dramatik bir şekilde düşüren bir algoritma ,yani dizinin başından başlayarak aradığımız elemanı aradığımız elamanın indisine kadar dönmek yerine çok daha efektif ve hızlı çalışıyor.

Teorik olarak değilde basitçe nasıl çalıştığını anlatalım. BinarySearch çocukken sayı tahmin etme oyununda farkında olmadan içgüdüsel kullandığımız algoritma . Bu oyunu oynamayanlar yada hatırlamayanlar için hatırlatalım.Örneğin arkadaşınız aklından 1-100 arasında sayı tutuyor ve sen sayı tahmin ettiğin zaman olası üç ihtimalden ,seçtiğin sayıdan yukarıda,aşağıda yada doğru bildiğini söyleyecek.

Sayıyı en az tahminle bulabilmeniz için 50 den başlamalıyız çünkü arkadaşımız tutuğu sayının aşağıda ve yukarıda olmasına göre her iki durumda tahmin edebileceğimiz sayı miktarını yarıya indirmiş olacağız örneğin daha yukarıda olduğunu söyledi sayının 51-100 arasında olduğunu anlamış olacağız.İkinci tahminimiz 75 olmalı ve şekilde sayıyı bulana kadar devam etmeli.

Yani gördüğünüz gibi BinarySearch algoritması ile sıralanmamış dizilerde çok daha kısa sürede ve daha az hamle ile aradığımız sayıyı buluyoruz.

Şimdi Java dilinde nasıl ifade edebiliriz ona bakalım.

Java Consumer and Producer

/***********************************************************************************
---------Processor--------
+lock
+liste
+LIMIT
 -consumer()
 -producer()
  -start()
-----------------------------
Processor sınıfı içinde bir bağlı liste tutmaktadır. Uretici maksimum üretim miktarı 10 olarak belirlenmiştir.
Uretim başlamadan tüketim yapılamaz.Tüketici 10 elamanını tükettikten sonra bekleme durumunda. Uretici ise LIMIT=10 ulaştığında üretimi durdurmaktadır.Taki  tüketici ürünleri alana kadar.
LIMIT=0 ise Üretici  üretmeye başlar.  LIMIT=10 ise Tüketici tüketmeye başlar. LIMIT=10 Üretim durmaktadır. LIMIT=0 ise Tüketici beklemektedir.

/*********************Source Code Java*************************************
package com.thre.aproach;

import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author ozaytunctan13
 */
public class Processor {

    private Object lock = new Object();
    private LinkedList<Integer> list = new LinkedList<>();
    private final int LIMIT = 10;
    private int value = 0;

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (lock) {
                while (list.size() == 0) {
                    lock.wait();
                }
                System.out.print("List is size " + list.size());
                int val = list.removeFirst();
                System.out.println(" consumer is value is  " + val);
                lock.notify();
            }
            Thread.sleep(1000);
        }
    }

    public void produce() throws InterruptedException {

        while (true) {
            synchronized (lock) {
                while (list.size() == LIMIT) {
                    try {
                        lock.wait();
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                list.add(value++);
                lock.notify();
            }

        }
    }

    public void start() {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    produce();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    consume();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (Exception e) {
        }
    }

    public static void main(String[] args) {
        Processor p = new Processor();
        p.start();
    }
}

Java Array

 /***
/* N- boyutlu bir dizi içerisinde herbir elemanın tekrarlanma sayısını bulan bir static Array.counterArray(int[]) fonksiyonu.
örneğin:
Array{1,1,1,4,6,4,4,5,6,1}
1 den>4 adet
4 ten>3 adet
5 ten>1 adet
6 dan>2adet gibi

*********************************************************************************

public class Array {
    public static int search(int[] k, int val) {
        for (int i = 0; i < k.length; i++) {
            if (k[i] == val) {
                return i;
            }
        }
        return -((int)Math.random()*val);
    }
    public static TValue counterArray(int[] dizi) {
        TValue t = new TValue();
        for (int i = 0; i < dizi.length; i++) {
            int val = dizi[i];
            int pc = 0;
            if (Array.search(Array.toCastInt(t.value.toArray()), val) < 0) {
                for (int j = i; j < dizi.length; j++) {
                    if (val == dizi[j]) {
                        pc++;
                    }
                }
                t.value.add(val);
                t.key.add(pc);
            } else {
                continue;
            }
        }
        return t;
    }
    private static int[] toCastInt(Object[] toArray) {
        int[] val = new int[toArray.length];
        for (int i = 0; i < val.length; i++) {
            val[i] = Integer.parseInt(toArray[i].toString());
        }
        return val;
    }
    public static void main(String[] args) {
          int[] d = {3,1,1,1,1,1,3,7,3,3,2,1,1};
        System.out.println("Array:"+Arrays.toString(d));
        TValue tem = Array.counterArray(d);
        System.out.println(tem.dump());
        System.out.println("search 2>index:"+Array.search(d, 2));
}
}

Java Netbeans Array Example

*********************************************************************************
*Java da  bir diziye n adet max-min aralığında rastgele sayı ekleyen ve bu sayıların birbirinden faklı olmasını sağlayan java kodu aşağıda verilmiştir.

* örneğin N =10 olduğunda max-min>=10 olmalıdır.

*N=20 ise max=25 min=5 ;  N<=(max-min) olmalıdır.

*********************************************************************************

public class Array {

    private static int binarySearch(int[] array, int val) {

        for (int i = 0; i < array.length; i++) {

            if (array[i] == val) {

                return i;

            }

        }

        int c = (int) ((Math.random() * (-(array.length - 1))) - 1);

        return c;

    }

    public static int[] uniqueRand(int min, int max, int adet) {

        int[] array = new int[adet];

        int in;

        int value;

        for (int i = 0; i < adet; i++) {

            do {

                value = (int) ((Math.random() * (max - min)) + min);

                in = Array.binarySearch(array, value);

            } while (!(in < 0));

            array[i] = value;

        }

        return array;

    }

    public static String toString(int[] a) {

        return Arrays.toString(a);

    }

    public static void main(String args[]) {

        int[] arr = Array.uniqueRand(10, 20, 8);

        System.out.println(Array.toString(arr));

    }

}

*********************************************************************

Cıktı:

run:

Array Lenght=8

Max=20;

Min=10;

[10, 12, 13, 18, 16, 15, 11, 17]

BUILD SUCCESSFUL (total time: 0 seconds)

Ram Management (Ram Yönetimi)

Bağlı Liste (MyLinkedList)