Java'da Immutability

 Java'da Immutability

Giriş

Immutability, bir nesnenin oluşturulduktan sonra durumunun değiştirilememesi durumudur. Immutable nesneler, yazılım geliştirmede birçok avantaja sahiptir. Örneğin, immutability aşağıdakileri sağlar:

• Veri tutarlılığı: Immutable nesneler, verilerin her zaman tutarlı olmasını sağlar. Bu, özellikle çoklu iş parçacığı kullanan uygulamalarda önemlidir.
• Kod okunabilirliği ve sürdürülebilirliği: Immutable nesneler, kodun daha okunabilir ve sürdürülebilir olmasını sağlar. Bu, çünkü immutable nesnelerin davranışları daha öngörülebilirdir.
• Performans: Immutable nesneler, performansı artırabilir. Bu, çünkü immutable nesneler, mutable nesnelere göre daha az bellek kullanır ve daha az güncelleme gerektirir.

Java'da Immutable Nesneler

Java'da immutability, aşağıdaki kurallara uyularak sağlanır:

• Sınıf final olmalıdır: Final sınıflar, yeni nesneler oluşturmak için kullanılamaz. Bu, immutable nesnelerin kalıtılmasını engeller.
• Alanlar final olmalıdır: Final alanlar, yalnızca sınıfın oluşturulma aşamasında ayarlanabilir. Bu, immutable nesnelerin durumunun daha sonra değiştirilmesini engeller.
• Alanlar private olmalıdır: Private alanlar, yalnızca sınıfın iç işleyişi tarafından erişilebilir. Bu, immutable nesnelerin durumunun yanlışlıkla değiştirilmesini engeller.

Java'da Immutable Nesne Örnekleri

Java'da, immutability sağlayan birçok yerleşik sınıf vardır. Örneğin, String sınıfı immutable'dır. String nesnesinin durumu, replace() gibi yöntemler kullanılarak değiştirilmeye çalışıldığında, yeni bir String nesnesi oluşturulur.

Java'da, immutability sağlayan kendi sınıflarımızı da oluşturabiliriz. Örneğin, aşağıdaki kodda, ImmutablePerson sınıfı immutable bir kişi nesnesi temsil eder:

public final class ImmutablePerson {

    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Bu sınıfta, name ve age alanları final'dır ve private'dır. Bu, bu alanların yalnızca sınıfın oluşturulma aşamasında ayarlanabileceği ve yalnızca sınıfın iç işleyişi tarafından erişilebileceği anlamına gelir.

Immutability'nın Faydaları

Immutability, yazılım geliştirmede birçok avantaj sağlar. Bu avantajlardan bazıları şunlardır:

• Veri tutarlılığı: Immutable nesneler, verilerin her zaman tutarlı olmasını sağlar. Bu, özellikle çoklu iş parçacığı kullanan uygulamalarda önemlidir.
• Kod okunabilirliği ve sürdürülebilirliği: Immutable nesneler, kodun daha okunabilir ve sürdürülebilir olmasını sağlar. Bu, çünkü immutable nesnelerin davranışları daha öngörülebilirdir.
• Performans: Immutable nesneler, performansı artırabilir. Bu, çünkü immutable nesneler, mutable nesnelere göre daha az bellek kullanır ve daha az güncelleme gerektirir.

Immutability'nın Dezavantajları

Immutability'nın bazı dezavantajları da vardır. Bu dezavantajlardan bazıları şunlardır:

• Esneklik: Immutable nesneler, mutable nesnelere göre daha az esnektir. Bu, çünkü immutable nesnelerin durumu daha sonra değiştirilemez.
• Karmaşıklık: Immutable nesneler, mutable nesnelere göre daha karmaşık olabilir. Bu, çünkü immutable nesnelerin durumları, yeni nesneler oluşturarak değiştirilmelidir.

Immutability ve Listeler

Java'da, listeler, verileri saklamak için yaygın olarak kullanılan bir veri yapısıdır. Listeler, mutable veya immutable olabilir.

Mutable listeler, verilerin daha sonra değiştirilebilmesini sağlar. Bu, listelerin esnekliğini artırır, ancak aynı zamanda veri tutarlılığını ve performansı da azaltabilir.

Immutable listeler, verilerin değiştirilemeyeceğini garanti eder. Bu, veri tutarlılığını ve performansı artırır, ancak aynı zamanda esnekliği azaltabilir.

Java'da, immutable listeler oluşturmak için birkaç yol vardır. Bir yol, Collections.unmodifiableList() yöntemini kullanmaktır. Bu yöntem, mevcut bir mutable listeyi immutable bir listeye dönüştürür.

Bir başka yol, ImmutableList.of()

Immutability ve Recordlar

Java 16'dan itibaren, Java'da recordlar adı verilen yeni bir veri yapısı tanıtıldı. Recordlar, Immutable nesnelerdir.

Recordlar, Immutable nesnelerin oluşturulmasını kolaylaştırır. Örneğin, aşağıdaki kodda, Person recordu Immutable bir kişi nesnesi temsil eder:

record Person(String name, int age) {
}

Bu recordta, name ve age alanları final'dır ve private'dır. Bu, bu alanların yalnızca recordun oluşturulma aşamasında ayarlanabileceği ve yalnızca recordun iç işleyişi tarafından erişilebileceği anlamına gelir. Recordlar, immutable listeler oluşturmak için de kullanılabilir. Örneğin, aşağıdaki kodda, ImmutablePersons listesi Immutable bir kişi listesi temsil eder:

record ImmutablePerson(String name, int age) {
}

List ImmutablePersons = List.of(
    new ImmutablePerson("John Doe", 30),
    new ImmutablePerson("Jane Doe", 25)
);

Bu kod, List.of() yöntemini kullanarak ImmutablePerson recordlarından oluşan bir liste oluşturur.

Immutability ve Uygulamalar

Immutability, birçok farklı uygulamada kullanılabilir. Örneğin, immutability:

• Veri tutarlılığını artırabilir. Immutable nesneler, verilerin her zaman tutarlı olmasını sağlar. Bu, özellikle çoklu iş parçacığı kullanan uygulamalarda önemlidir.
• Kod okunabilirliğini ve sürdürülebilirliğini artırabilir. Immutable nesneler, kodun daha okunabilir ve sürdürülebilir olmasını sağlar. Bu, çünkü immutable nesnelerin davranışları daha öngörülebilirdir.
• Performansı artırabilir. Immutable nesneler, performansı artırabilir. Bu, çünkü immutable nesneler, mutable nesnelere göre daha az bellek kullanır ve daha az güncelleme gerektirir.

Sonuç

Immutability, yazılım geliştirmede birçok avantaj sağlayan bir kavramdır. Immutable nesneler, veri tutarlılığını, kod okunabilirliğini ve performansı artırabilir.

Generated By Google Bard

REST mi? WEBSOCKET mi?

Rest vs Websockets

Bu yazımda istemci-sunucu iletişiminin temellerini inceleyeceğiz.Rest ve Websocket'i
projelerimizde kullanmak için hangisini ne zaman seçmemiz doğru olur bu konuda fikir edineceğiz.


Ağ iletişimi için oluşturulmuş OSI modeli bulunmaktadır.
Bu model 7 katmandan oluşmaktadır.
    1.Physical (Fiziksel Katman)
    2.Data Link (Veri Bağlantı Katmanı)
    3.Network (Ağ Katmanı)
    4.Transport (Taşıma Katmanı)
    5.Session (Oturum Katmanı)
    6.Presentation (Sunu Katmanı)
    7.Application (Uygulama Katmanı)

Uygulama katmanı son kullanıcıya en yakın olandır ve iletişime katılan uygulamalarla etkileşime girmekten sorumludur. FTP, SMTP, SNMP,HTTP ve WebSocket gibi bu katmanda kullanılan birkaç popüler protokol vardır.

WebSocket kalıcı bir TCP bağlantısı üzerinden çift yönlü, tam çift yönlü iletişimi sağlayan bir iletişim protokolüdür.WebSocket, 2011 yılında IETF tarafından RFC 6455 olarak bir iletişim protokolü olarak standartlaştırılmıştır. Günümüzde çoğu modern web tarayıcıları, WebSocket protokolünü desteklemektedir.

İnternetteki her yerde bulunmasından dolayı hepimiz HTTP'nin farkında olsak da, aynı zamanda bir uygulama katmanı iletişim protokolüdür. HTTP, istek yanıtına dayalı bir protokoldür.
REST (Temsili Durum Aktarımı), web hizmetleri oluşturmak için HTTP'ye bir dizi kısıtlama getiren mimari bir stildir.

WebSocket, istemci ve sunucu arasında iki yönlü iletişim için bir protokol tanımlarken, değiş tokuş edilecek mesaja herhangi bir koşul getirmez. Bu, iletişimdeki tarafların alt protokol müzakeresinin bir parçası olarak kabul etmeleri için açık bırakılmıştır.Önemsiz uygulamalar için bir alt protokol geliştirmek uygun değildir. Neyse ki, STOMP gibi kullanıma hazır birçok popüler alt protokol var.
STOMP, Basit Metin Yönelimli Mesajlaşma Protokolü anlamına gelir ve WebSocket üzerinden çalışır.

HTTP ve WebSocket'ı, her ikisi de uygulama katmanı protokolleri olduğu gibi doğrudan karşılaştırabilsek de, REST'i WebSocket ile karşılaştırmanın doğal olmadığını unutmayın.Daha önce gördüğümüz gibi REST, iletişim için HTTP'yi kullanan mimari bir stildir.Dolayısıyla, WebSocket ile karşılaştırmamız çoğunlukla HTTP'deki yetenekler veya eksiklikler ile ilgili olacaktır.

Handshake (El sıkışma), iletişim kuran taraflar arasında otomatik olarak iletişim protokolü müzakere yöntemini ifade eder. HTTP, durumsuz bir protokoldür ve bir istek-yanıt mekanizmasında çalışır. Her HTTP isteğinde, sunucuyla soket üzerinden bir TCP bağlantısı kurulur.İstemci daha sonra sunucu kaynakla veya bir hatayla yanıt verene kadar bekler. İstemciden gelen sonraki istek, önceki istek hiç olmamış gibi tekrar eder.

WebSocket, HTTP ile karşılaştırıldığında çok farklı çalışır ve gerçek iletişimden önce bir Handshake
(el sıkışma) ile başlar.WebSocket durumunda, istemci HTTP'de bir Protokol Handshake(El Sıkışma) isteği başlatır ve ardından sunucu HTTP'den WebSocket'a yükseltme kabul etmeye yanıt verene kadar bekler.Tabi ki, Protokol Handshake( El Sıkışma) HTTP üzerinden gerçekleştiğinden, önceki şemadan gelen sırayı izler. Ancak bağlantı kurulduktan sonra, oradan istemci ve sunucu daha fazla iletişim için WebSocket'e geçer.

WebSocket ve HTTP arasındaki temel fark, WebSocket’ın kalıcı bir TCP bağlantısı üzerinde çalışırken, HTTP her istek için yeni bir TCP bağlantısı oluşturmasıdır.Şimdi açıkçası, her istek için yeni TCP bağlantısı oluşturmak çok başarılı değil ve HTTP bunun farkında değil. Aslında, HTTP / 1.1'in bir parçası olarak, HTTP'nin bu eksikliğini gidermek için kalıcı bağlantılar tanıtıldı.
Bununla birlikte, WebSocket, kalıcı TCP bağlantılarıyla çalışmak için sıfırdan tasarlanmıştır.

Kalıcı TCP iletişimi üzerinde çalışan WebSocket ile, hem sunucu hem de istemcinin birbirinden bağımsız ve aslında birçok iletişim kurucu tarafa veri göndermesi mümkündür.Buna iki yönlü iletişim denir.

WebSocket iletişiminin bir başka ilginç özelliği de tam çift yönlü olmasıdır. Şimdi bu terim ilginç gelebilirken; bu sadece sunucunun ve istemcinin aynı anda veri gönderebileceği anlamına gelir.Bunu, sunucunun verileri yanıtlayabilmesi için isteği tam olarak alana kadar beklemesi gereken HTTP'de olanlarla karşılaştırın.

Hem HTTP hem de WebSocket, TLS'nin güvenlik avantajlarından yararlanır. HTTP, bunu kullanmak için URL şemalarının bir parçası olarak https sunarken, WebSocket, aynı etki için URL şemalarının bir parçası olarak wss'ye sahiptir.Bir RESTful servisini veya bir WebSocket iletişimini güvenceye almak çok derin bir konudur ve burada ele alınamaz. Şimdilik, her ikisinin de bu konuda yeterince desteklendiğini varsayalım.

Sonuç

WebSocket’ın HTTP’deki eksikliklerden ortaya çıkmasına rağmen, aslında bir HTTP’nin yerine geçmediğini unutmamak önemlidir. Bu yüzden ikisinin de yeri ve kullanımları var. Nasıl karar verebileceğimizi  anlayalım.

Bir çalışanın kaydını almak gibi sunucu ile zaman zaman iletişimin gerekli olduğu senaryoların çoğu için, HTTP / S üzerinden REST hizmetini kullanmak hala mantıklı. Ancak, sunucudan gerçek zamanlı güncellemeler gerektiren bir hisse senedi fiyatı uygulaması gibi daha yeni istemci tarafı uygulamalar için WebSocket’tan yararlanmak çok kolaydır.

Genelleme, WebSocket, push tabanlı ve gerçek zamanlı iletişimin gereksinimi daha uygun şekilde tanımladığı durumlar için daha uygundur. Ek olarak, WebSocket, bir mesajın aynı anda birden fazla müşteriye gönderilmesi gereken senaryolar için iyi çalışır. Bunlar, RESTful hizmetleri üzerinden istemci ve sunucu iletişiminin yasaklayıcı olmasa zor geleceği durumlardır.


Alıntı

Restful Jersey Webservis Projesi

     Bu proje bir android uygulamasının kullanacak olduğu webservisdir. Proje java teknolojileri kullanılarak yazılmıştır. Başta maven ile bağımlılıklar kontrol altına alınmıştır. JAX-RS webservisidir. Projede veritabanı hibernate ile yazılmıştır.

     Webservis kısmında restful jersey frameworkü kullanılmıştır. Veritabanına kayıt girilmesi için servlet/jsp kullanılarak basit bir kayıt sayfaları oluşturulmuştur. Bu jsp sayfalarının görünümüne özen göstermedim çünkü benim için önemli olan webservis kısmıdır.

     Projenin kodlarını istediğiniz gibi uygulamalarınızda kullanabilirsiniz. Alıntı yapacak olursanız kaynak gösterirseniz iyi olur.

Yararlı olması dileğiyle.

Kodlara ulaşmak için github adresine gidin

Adisyon Otomasyonu

Bu yazımda proje ödevi olarak yaptığımız lokanta adisyon programını sizlerle paylaşıyorum.
Projenin kodlarını java swing kullanarak yazdık.Veritabanı olarak postgresql kullandık.
Projenin yapılış amacıda veritabanı ile proje yapmayı öğrenmekti.

Projeyi ve projenin kodlarını anlatmayacağım kodları indirip incelediğinizde anlayacağınızı sanıyorum. Projenin kullanılışı vs. Rapor.pdf dosyasında mevcuttur.

Proje dosyalarına github adresinden ulaşabilirsiniz.

JavaDoc nedir?

JavaDoc nedir?
  Projelerimizde yazmış olduğumuz sınıfların başkaları tarafından kolay anlaşılmasını sağlamak için kullanılan bir yapıdır. Özellikle jar haline getirilmiş APIlerin kullanımında kullanıcıyı bilgilendirmek için çok önemlidir.

  JavaDoc bize dökümantasyon yazmak için bir format sunar.Bu formatta HTML etiketleri kullanılabileceği gibi JavaDoc'a ait etiketlerde mevcuttur.  JavaDoc dokümantasyonunu, class, interface ya da enum tiplerinden önce, nesne ve sınıf değişkenlerinden önce ve constructorlar dahil olmak üzere metotlardan önce, /**   */ formatında yazılır.  

  Dökümantasyonu yapılmış kodu HTML dökümantasyonu haline getirmek için jdk ile gelen javadoc aracı ile şu şekilde yapabilirsiniz.

javadoc -d documentation sınıf.java

Böylelikle sınıfımızın dokümantasyonunu "documentation" isimli bir dosyaya çıkarmış oluyoruz. Bir başka yolu kullandığınız IDE'lerin generate javadoc özelliğini kullanabilirsiniz.

JavaDoc'un etiketleri

@author     -> Geliştiren kişi
@param     -> Parametre tipi ve anlamı
@throws ,@exception    -> İstisna durumları ve anlamları
@return    -> Dönüş tipi
@see    -> Başka bir yere referans sağlar
@since    -> Hangi sürüm ile eklendiği
@version    -> Son güncellendiği sürüm
{@code}            -> Kodu belirtmek için
@deprecated    -> Artık kullanılmaması istemi
{@value}         -> Statik alanın doc açıklamada kullanıldığı zaman, o sabitin değerini gösterir.
{@link}          -> Başvurulan sınıfın belirtilen paket, sınıf veya üye adı belgelere işaret görünür .
{@linkplain}     -> Bağlantının etiketine hariç {@link}, Özdeş kod yazı daha düz metin olarak görüntülenir.
@serial             -> Varsayılan serializable alan için doc yorumda kullanılır.     
@serialData      -> writeObject () veya writeExternal tarafından yazılmış verileri belgelemektedir
@serialField     -> Bir ObjectStreamField bileşeni belgelemektedir.
{@inheritDoc}    -> En yakın kalıtsal sınıf veya uygulanabilir arayüz gösterir.
{@docRoot}     -> Üretilen her sayfa üretilen belgenin kök dizinine göre yolunu gösterir.   
{@literal}     -> literal metni belirtir. kapalı metin, HTML biçimlendirme veya iç içe javadoc etiketleri içermeyen olarak yorumlanır.

Küçük bir örnek ise şöyle verilebilir.

/**
* Merhaba, Dünya!
* Bu program javaya ilk başladığımızda yazacağımız programdır.
* Çıktı olarak konsol ekranına Merhaba,Dünya! yazar.
*
*
* @author  Eren Çetinkaya Cruz
* @version 1.0
* @since   2016-03-24 
*/
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
} 

Alışkanlık edinmek JavaDoc'u bundan sonraki yazılarımda kullanmaya çalışacağım.

Daha detaylı olarak JavaDoc resmi sitesinden öğrenebilirsiniz.
Başka bir kaç yer ingilizce olarak tutorialpoints veya türkçe olarak Akin Kaldiroglu hocamızın yazılarından faydalanabilirsiniz. 

Eclipse Apache Tomcat 8 Görünmeme Sorunu

  Yazılımla uğraşırken bir hataya daha rastladım ve bu hatayıda ileride karşılaşırsam diye kayıt altına almaktayım. Gelelim hatamıza javaEE ile çalışırken eclipce'in javaEE sürümünün son versiyonunu indirmeme rağmen Apache Tomcat son versiyonlarının eclipse tarafından tanınmadığı bir hata aldım.
  İnternette biraz araştırma yaptıktan sonra aşağıdaki çözüme ulaştım.
Çözüm :
1- Eclipse açıyoruz sonra Help => Install New Software tıklıyoruz.
2- "Kepler- http://download.eclipse.org/releases/kepler" yada
    "Luna – http://download.eclipse.org/releases/luna" bunu kopayalıyoruz.
3- "Web, XML, and Java EE Development" kısmını açıyoruz.
4-  JST Server Adapters ve JST Server Adapters Extensions öğelerini indiriyoruz.
  - İndirme işlemi bitince Apache Tomcat'i tanıtmaya geçiyoruz
5- Window / Preferences / Server / Runtime Environments yolunu izliyoruz.
6- Add butonuna tıklıyoruz sonra yükleyeceğimiz versiyonu seçiyoruz.
7- Apache Tomcat'in yolunu belirtiyoruz Ok  butonuna basıp işlemlerimizi bitiriyoruz.

Böylece Apache Tomcat tanıtma işlemimizi yapıyoruz.

Metindeki Harflerin Sayısını Bulma

  Bu yazımızda bir metnin içinde geçen harflerin sayısını bulmaya çalışacağız.
Algoritma şöyle çalışmaktadır.
  İlk olarak metnin içindeki harf dışındaki karakterleri ayrıştırıyoruz. Bu metin içinde kaç farklı harf var ise onları buldurup farklı harf sayısı kadar dizi oluşturuyoruz.
  Sonra algoritmanın ana kısmına geçiyoruz yani metnin ayrıştırılmış tüm karakterlerini birbir bakarak kontrol ediyoruz. Metnin tüm karakterlerini kontrol ettiğimizden aynı karakteri tekrar yazmamak için dizimiz içinde o an kontrol edilen karakterin olup olmadığına bakıyoruz eğer yoksa yeni harf nesnesi oluşturup onu dizimize ekliyoruz.
  Bütün karakterler kontrol edildikten sonra dizimizi yazdırıyoruz.Yazdırırken metnin içindeki sıraya
göre yazdırılıyor.

Örnek bir metin ve sonucu şöyledir.
Bir cümle giriniz...
Bu bir deneme yazısıdır.
B -> 1
u -> 1
b -> 1
i -> 1
r -> 2
d -> 2
e -> 3
n -> 1
m -> 1
y -> 1
a -> 1
z -> 1
ı -> 3
s -> 1

Main metodu ve ana metodu koydum diğerlerini github adresinde bulabilirsiniz.

 public static void main(String[] args) {
        Harf harfDizisi[] = null;
        String cumlemiz = "";
        
        cumlemiz = cumleyiAl();

        harfDizisi = harfSay(cumlemiz);

        ciktiVer(harfDizisi);
    }

public static Harf[] harfSay(String cumle) {
        Harf harfDizisi[] = null;
        int farkliHarfSayisi = 0;
        int sayac = 0;

        farkliHarfSayisi = kacFarkliHarfVarKontrolEt(cumle);
        //harf dizimizi burada oluşturuyoruz
        harfDizisi = new Harf[farkliHarfSayisi];

        // cumlenin tum harflerini tektek konrol ediyoruz
        for (int i = 0; i < cumle.length(); i++) {
            char kontrolEdilecekHarf = cumle.charAt(i);

            int ayniHarfSayisi = ayniHarfSaysiniBul(cumle, kontrolEdilecekHarf);

            //aynı harften yok baska bir harf buyuzden dizimize ekliyoruz
            if (!aynisindanHarfDizisindeVarMi(harfDizisi, kontrolEdilecekHarf)) {
                //diziye yeni harf oluşturup ekliyoruz
                harfDizisi[sayac] = new Harf(kontrolEdilecekHarf, ayniHarfSayisi);
                sayac++;
            }
        }

        return harfDizisi;
    }

Kodlara ulaşmak için github adresine gidin

Hızlı sıralama - Quick Sort

  Hızlı(Quick sort) sıralama algoritması çok hızlı algoritmalardan birisidir. Sadece eğitim amaçlı değil programların içerisinde de sıralama için kullanılmaktadır. Algoritma çok basittir ve yerinde sıralama yapar yani tek dizi üzerinde elemanların yerlerini değiştirerek işlem yapar. Böyle olması da zaman açısından ve alan açısından hız demektir.

Algoritmanın çalışma mantığı
  Sayı dizisinden herhangi bir sayıyı dayanak eleman(pivot) eleman olarak seç.
  Sayı dizisini dayanak elemandan(pivot) küçük olan tüm sayılar dayanak elemanın(pivot) önüne, dayanak elemandan(pivot) büyük olan tüm sayılar dayanak elemanın(pivot)  arkasına gelecek biçimde düzenle (dayanak elemana eşit olan sayılar her iki yana da geçebilir).
  Bu bölümlendirme işleminden sonra eleman sıralanmış son dizide olması gerektiği yere gelir. Algoritmanın bu aşamasına bölümlendirme aşaması denir.
  Dayanak elemanın sol ve sağ yanında olmak üzere oluşan iki ayrı küçük sayı dizisi, hızlı sıralama algoritması bu küçük parçalar üzerinde yeniden özyineli olarak çağrılarak sıralanır.

Algoritmanın karmaşıklığı
Hızlı sıralama algoritması n adet sayıyı, ortalama bir durumda, {O}(nlog(n)) karmaşıklığıyla, en kötü durumda ise {O}(n^2) karmaşıklığıyla sıralar.

Hızlı sıralama algoritması java kodları

 public static void hizliSiralama(int dizi[], int sol, int sag) {
  int indis = parca(dizi, sol, sag);
  if (sol < indis - 1) {
   hizliSiralama(dizi, sol, indis - 1);
  }
  if (indis < sag) {
   hizliSiralama(dizi, indis, sag);
  }
 }

 public static int parca(int dizi[], int sol, int sag) {
  int i = sol, j = sag;
  int gecici;
  int dayanakEleman = dizi[(sol + sag) / 2];

  while (i <= j) {
   
   //soldan başlayarak dayanak elemanı(pivot)tan küçük elemanı bul
   while (dizi[i] < dayanakEleman) {
    i++;
   }
   //sağdan başlayarak dayanak elemanı(pivot)tan büyük elemanı bul
   while (dizi[j] > dayanakEleman) {
    j--;
   }
   //bulunan elamanların yerlerini değiştir
   if (i <= j) {
    gecici = dizi[i];
    dizi[i] = dizi[j];
    dizi[j] = gecici;
    i++;
    j--;
   }
  };

  return i;
 }

Kodlara ulaşmak için github adresine gidin

Birleştirmeli Sıralama - Merge Sort

  Merge sort (bireşen sıralama), diziyi ardışık olarak en küçük alt dizilerine kadar yarılayan sonra da onları sıraya koyarak bireştiren özyineli bir algoritmadır. Yarılama işlemi en büyük alt dizi en çok iki öğeli olana kadar sürer. Sonra merge (bireşim) işlemiyle altdiziler ikişer ikişer bölünüş sırasıyla sıralı olarak bir üst dizide bireşir. Süreç sonunda en üstte sıralı diziye ulaşılır.

Algoritmanın çalışma mantığı şu şekildedir. 
  Sıralı olmayan listeyi ortadan eşit olarak iki alt listeye ayırır.
  Alt listeleri kendi içinde sıralar.
  Sıralı iki alt listeyi tek bir sıralı liste olacak şekilde birleştirir.

Algoritmanın karmaşıklığı 
  Birleştirme sıralaması böl ve yönet algoritmasına güzel bir örnektir. Birleştirme sıralamasının karmaşıklığını hesaplamak için sıralanacak N elemanlı diziyi bir ağaç yapısına taşıyınca her bir düğüm bir alt diziyi temsil eder.
  Ağaç tam olarak n seviye içerir. k sayısı 0'dan n-1'e kadar ağaç seviyesini temsil etsin, yukarıdan aşağıya doğru ağacın k. seviyesinde 2^k tane düğüm bulunur. Bu düğümlerin her biri 2^{n-k}uzunluğunda bir alt diziyi temsil eder.
  Bir alt dizinin eleman sayısı 2^{n-k} olduğu için en fazla 2^{n-k} karşılaştırma yapılabilir. Ağacın her seviyesindeki alt dizi sayısı ve yapılabilecek en fazla karşılaştırma sayısı2^k . 2^{n-k} = 2^n ' dır. n seviye ağaç için toplam n . 2^n karşılaştırma yapılır. Elde edilen n . 2^n değerinin asimptotik üst sınırı O(NlgN) değeridir.

 Birleştirmeli sıralama algoritması java kodları

 public static void birlestirmeliSiralama(int alt, int üst,int[] sirasizDizi) {
  if (alt < üst) {
   int orta = (alt + üst) / 2;
   //sirasiz dizimi yerel değişken yaptığımdan diziyide metodlara yolladım
   birlestirmeliSiralama(alt, orta, sirasizDizi); 
   birlestirmeliSiralama(orta + 1, üst,sirasizDizi);
   birlestir(alt, orta, üst,sirasizDizi);
  }
 }

 public static void birlestir(int alt, int orta, int üst,int[] sirasizDizi) {
  int[] yedekDizi = new int[sirasizDizi.length];
  int i, j, k;
// a dizisinin her iki yarısını yedekDizi dizinine kopyala
  for (i = alt; i <= üst; i++) {
   yedekDizi[i] = sirasizDizi[i];
  }
  i = alt;
  j = orta + 1;
  k = alt;
  // her adımda bir sonraki en büyük terimi kopyala
  while (i <= orta && j <= üst) {
   if (yedekDizi[i] <= yedekDizi[j]) {
    sirasizDizi[k++] = yedekDizi[i++];
   } else {
    sirasizDizi[k++] = yedekDizi[j++];
   }
  }
// varsa, ilk yarıdan arta kalan terimlerin hepsini kopyala
  while (i <= orta) {
   sirasizDizi[k++] = yedekDizi[i++];
  }
 }

Kodlara ulaşmak için github adresine gidin

Eklemeli Sıralama - Insertion Sort

Eklemeli sıralama algoritması diziyi her adımda öğe öğe oluşturan bir sıralama algoritmasıdır.
Küçük Veri kümeleri üzerinde kullanıldığında verimlidir.Çoğunluğu zaten sıralanmış olan diziler üzerinde kullanıldığında verimlidir.
Sıralanacak diziyi yerinde sıralar, ek bir bellek alanı gerektirmez.

Algoritmanın çalışma mantığı şu şekildedir.
Geçici olarak atanan dizi elemanının yerini bulunup oraya koyulması üzerine çalışır.Yeri bulmak için
dizi içerisinde geçici elemanın bulunduğu yerden başa doğru kaydırma işlemi yapılmaktadır.

Algoritmanın karmaşıklığı
En kötü başarım: Eklemeli sıralama algoritması en kötü durumda, örneğin liste tersten sıralıysa O(n^2) karmaşıklıkla çalışır.
En iyi başarım: Eklemeli sıralama algoritması en iyi durumda, örneğin liste sıralıysa sadece  n-1 karşılaştırma yapar ve
 O(n) karmaşıklıkla çalışır.
Ortalama başarım: Eklemeli sıralama algoritması ortalama O(n^2) karmaşıklıkla çalışır.

Örnek
1.(5 1 4 2 8 ) \to ( 1 5 4 2 8 )
gecici = 1 olur j=0 olur 1-5 karşılaştırılıp 5 bir sağ kaydırılıp 1 j'ye koyulur
2.(1 5 4 2 8 ) \to ( 1 4 5 2 8 )
gecici = 4 olur j=1 olur 4-5 karşılaştırılıp 5 bir sağ kaydırılıp 4 j'ye koyulur
3.(1 4 5 2 8 ) \to ( 1 2 4 5 8 )
gecici = 2 olur 2-5 sonra 2-4 karşılaştırılıp 4 ve 5 bir sağ kaydırılır
her kaydırma için j bir azaltılır ve 2 j'ye koyulur
4.( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
sıralı olduğundan değişim yapılmaz

Eklemeli sıralama algoritması java kodları

public static void eklemeliSiralama(int[] dizi) {
  int gecici = 0, j = 0;
  
  for (int i = 1; i < dizi.length; i++) {
   gecici = dizi[i]; // i. eleman gecici yapıyoruz   
   j = i - 1; //i nin bir eksiğini j ye atıyoruz
   
   // j sıfırdan büyükse ve
   //  geçici, dizinin j. elamanından küçük olana kadar kaydırma yap
   while (j >= 0 && gecici < dizi[j]) {
    dizi[j + 1] = dizi[j];
    j = j - 1;
    dizi[j + 1] = gecici;
   }

  }
 }

Kodlara ulaşmak için github adresine gidin

Seçmeli Sıralama - Selection Sort

Seçmeli sıralama algoritması, küçük boyutlu dizileri sıralarken veya dizinin bir bölümü sıralı ise yer değiştirme işlemi yapılmadığı için tercih edilir.

Algoritmanın çalışma mantığı şu şekildedir.

1.Listedeki en küçük değerli öğeyi bul.
2.İlk konumdaki öğeyle bulunan en küçük değerli öğenin yerini değiştir.
3.Yukarıdaki adımları listenin ilk elemanından sonrası için (ikinci elemandan başlayarak) yinele.

Algoritmanın karmaşıklığı
Seçmeli sıralama algoritması listenin en küçük elemanının nerede olduğunu bilmediği ve her bir eleman için tüm elemanlarla karşılaştırma yaptığı için liste içindeki elemanların rastgele sıralanmış ya da eşit elemanlardan oluşmasını dikkate almaz, bu sebeple seçmeli sıralama algoritması her durumda O(n^2) karmaşıklığıyla çalışır.

Örnek:

1. ( 5 1 4 2 8 ) \to ( 1 5 4 2 8 )

i=0 minIndis=0 (5 değeri) ile baslar j=1 (1 değeri) en küçük olduğundan minIndis=1 olur değiştiririz.

2.( 1 5 4 2 8 ) \to ( 1 2 4 5 8 )

i=1 minIndis=1 (5 değeri) ile baslar j=3 (2 değeri) en küçük olduğundan minIndis=3 olur değiştiririz.

3.( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )

Döngümüz devam edecektir ama sıralama işlemi bu adımda bitti.

Seçmeli sıralama algoritması java kodları

 public static void secmeliSiralama(int[] dizi) {
  int yedek;
  int minIndis;
  
  for (int i = 0; i < dizi.length; i++) {
   minIndis = i;
   //Son indisten başlayarak karşılaştırmaya devam ediyoruz
   for (int j = i; j < dizi.length; j++) {
    //minIndis den daha küçük değer varsa indisi değiştiriyoruz
    if (dizi[j] < dizi[minIndis]) {
     minIndis = j;
    }
   }
   //burada değiştirme işlemini yapıyoruz
   yedek = dizi[i];
   dizi[i] = dizi[minIndis];
   dizi[minIndis] = yedek;
  }

 }

Kodlara ulaşmak için github adresine gidin

Kabarcık Sıralama - Bubble Sort

     Bu yazımızda kabarcık sıralama (Bubble Sort) algoritmasını inceleyeceğiz.Öncelikle kabarcık sıralama algoritması hakkında bilgi verelim.Adına kabarcık sıralaması denmesinin nedeni büyük olan sayıların aynı suyun altındaki bir kabarcık gibi dizinin üstüne doğru ilerlemesidir.

Algoritmanın çalışma mantığı şu şekildedir.
     Kabarcık sıralaması dizinin başından başlar ve dizi elemanlarını sırayla seçer. Seçilen dizi elemanı kendinden sonra gelen elemandan büyükse bu iki elemanın yerleri değiştirilir. Bu işlem sonucunda dizinin en büyük elemanı dizi sonuna yerleştirildiğinden bir sonraki adımda arama sınırı bir eleman geri çekilir. Bu işlem, dizinin sonundaki elemanın karşılaştırılmasına kadar yinelenerek sürdürülür.

Algoritmanın karmaşıklığı
     Kabarcık sıralama algoritmasının ortalama ve en kötü durumdaki karmaşıklığı {O}(n^2)'dir. Algoritma ortalama ve en kötü durumda (n^2) / 2 adet karşılaştırma ve yer değiştirme gerçekleştirir.

Algoritmanın işleyişi
     İçeriği "5 1 4 2 8" olan bir dizi kabarcık sıralaması ile en küçükten en büyüğe doğru aşağıdaki biçimde sıralanır. Her adımda dizinin kalın olarak işaretlenmiş elemenları karşılaştırılan elemanlardır.

Birinci Geçiş:
( 5 1 4 2 8 ) \to ( 1 5 4 2 8 ) İlk iki elemanı karşılaştırır ve yerlerini değiştirir.
( 1 5 4 2 8 ) \to ( 1 4 5 2 8 )
( 1 4 5 2 8 ) \to ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 ) Elemanlar zaten sıralı olduğu için algoritma yerlerini değiştirmez.
İkinci Geçiş:
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Artık dizi sıralıdır ancak algoritma işlemin bittiğini bilmemektedir. 
Algoritmanın dizinin sıralandığını anlaması için bütün dizinin üzerinden hiçbir değişiklik yapmadan tam bir geçiş yapması gerekir.
Üçüncü Geçiş:
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Sonuç olarak dizi sıralanmıştır ve algoritma sonlanır.

Kabarcık sıralama algoritması java kodları

public static void KabarcikSiralama(int[] dizi) {
  int temp;   // Yer değiştirmede kullanılacak geçici değişken
  
  for (int i = 1; i < dizi.length; i++) {
   for (int j = 0; j < dizi.length - i; j++) {
    
    //Önce gelen elaman bir sonrakinden büyükse ikisi yer değiştiriyor
    if (dizi[j] > dizi[j + 1]) {
     temp = dizi[j];
     dizi[j] = dizi[j + 1];
     dizi[j + 1] = temp;
    }
    
   }
  }
  
 }
  

Kodlara ulaşmak için github adresine gidin

Java Mükemmel Sayı

    Bu yazımızda mükemmel sayıları bulan program kodunu yazacağız. Mükemmel sayılar kendisi hariç pozitif tam bölenlerinin toplamı kendisine eşit olan sayıdır.
    Örnek vermek gerekirse 6 bir mükemmel sayıdır. 6 sayısının pozitif çarpanları 1x2x3 dür. Bu çarpanların toplamı kendisine eşittir.
( 1+2+3=6 )

 public static void main(String[] args) { 
  Scanner cr = new Scanner(System.in);
   
  int sayi;
  System.out.println("Bir sayi giriniz : ");
  sayi = cr.nextInt();  
  
  //kontrol edilecek sayıyı fonksiyonumuza yolluyoruz 
  if(mukemmelSayiBul(sayi)){
   System.out.println(sayi+" sayısı mükemmel sayıdır.");
  }else{
   System.out.println(sayi+" sayısı mükemmel sayı değildir.");
  }   
  
 }
 
 public static boolean mukemmelSayiBul(int sayi) {
  
  // kendisinden küçük tüm sayılara bölüyoruz ve tam bölen sayıları topluyoruz
  int toplam = 0;
  for (int i = 1; i < sayi; i++) {
   if (sayi % i == 0) {
    toplam += i;
   }
  }
  //toplam, sayımıza eşit ise mükemmel sayı olmuş oluyor 
  if (toplam == sayi) {
   return true;
  } else {
   return false;
  }
 }

Kodlara ulaşmak için github adresine gidin

Java Standart Sapma

    Bu yazımızda istatistik bilim dallarında kullanılan standart sapma formülünü koda dökeceğiz.   Standart sapma hakkında ayrıntılı bilgi almak isteyenler vikipedi sayfasından inceleyebilir.

  Scanner cr = new Scanner(System.in);

  int diziBoyutu;
  double ortalama = 0.0, ortToplam = 0.0, toplam = 0.0, k = 0.0;

  System.out.println("Kaç adet sayi gireceğinizi yazınız: ");
  diziBoyutu = cr.nextInt();

  int dizi[] = new int[diziBoyutu];

  //sayıları diziye aktarıyoruz
  System.out.println("Sayıları giriniz: ");
  for (int i = 0; i < diziBoyutu; i++) {
   System.out.println((i + 1) + ". sayıyı giriniz: ");
   dizi[i] = cr.nextInt();
  }

  // ortalamayı hesaplatıyoruz
  for (int j = 0; j < diziBoyutu; j++) {
   ortToplam = ortToplam + dizi[j];

  }
  ortalama = ortToplam / diziBoyutu;

  // dizinin elemanlarının ortalamayla olan farkının karesi alınıyor
  for (int s = 0; s < diziBoyutu; s++) {
   double r = (double) Math.pow((dizi[s] - ortalama), 2);
   toplam = toplam + r;
  }
  
  k = (toplam / (diziBoyutu));
  System.out.print("Standart sapma: ");
  System.out.println(Math.sqrt(k));

Kodlara ulaşmak için github adresine gidin

Java İkinci Derece Denklemin Kökünü Bulma

    Bu yazımızda ikinci derece denklemlerin kökünü bulan program yazacağız.
    Matematikten de bildiğiniz gibi ikinici derece denklemler ax² + bx + c şeklinde yazılır.Bu denklemi diskriminant yardımı ile çözeceğiz. Diskriminant formülümüz b² - 4ac idi.

    Diskriminantımız sıfırdan büyük ise denklemin iki gerçek kökü vardır.
    Diskriminantımız sıfırdan küçük  ise gerçek kök yoktur, karmaşık kök vardır.
    Diskriminantımız sıfıra eşit ise tek bir gerçek kök denir, kimi zaman buna daburut da denir.

    Eğer tek gerçek kök var ise kökümüz = -b / 2a ya eşittir.
    Eğer gerçek kök yok karmaşık kök var ise köklerimiz = -b (+ veya - ) (kök içinde diskriminant) / 2a dır.

    Matematiksel olarak formullerimizi oluşturduk artık bunu koda dökmek kaldı.

 
  Scanner sc = new Scanner(System.in);

  System.out.println("(ax²+bx+c) olmak üzere a, b ve c sıralanacak şekilde sayıları ekrana giriniz.");
  System.out.println("a sayısını giriniz.");
  double a = sc.nextInt();

  System.out.println("b sayısını giriniz.");
  double b = sc.nextInt();

  System.out.println("c sayısını giriniz.");
  double c = sc.nextInt();

  double delta = (b * b) - (4 * a * c);

  if (delta > 0) {
   double x1 = ((-1 * b) - Math.sqrt(delta)) / (2 * a);
   double x2 = ((-1 * b) + Math.sqrt(delta)) / (2 * a);
   System.out.println("x1=  " + x1 + "  x2=  " + x2);
  }

  if (delta < 0) {
   System.out.println("Denklemin Gerçel Kökü Yoktur.");
  }

  if (delta == 0) {
   double x = (-1 * b) / (2 * a);
   System.out.println("Çakışık kökü var x1= x2=  " + x);
  }

Kodlara ulaşmak için github adresine gidin

Java Sayi Tahmin Oyunu

    Bu yazımda basit bir sayi tahmin oyunu programı yazacağız. Oyunu basit olarak anlatmak gerekirse ilk olarak kullanıcıdan tahmin için kaç hakkı olmasını istediğini alıyoruz. Sonra rastgele 0-100 arası bir sayı üretiyoruz. Bir döngünün içinde kullanıcıdan aldığımız sayı ile rastgele oluşturulan sayımızı karşılaştırarak kulanıcıyı yönlendiriyoruz.

  int bulunmasiGerekenSayi;
  int tahminSayisi, tahminEtmeSayaci = 1;
  Scanner okuyucu = new Scanner(System.in);
  Random rnd = new Random();

  //random olarak 0-100 arası sayı üretip rastSayi adlı değişkenimize atıyoruz
  bulunmasiGerekenSayi = rnd.nextInt(100);

  System.out.println("Sayıyı bulmak için kaç tahmin hakkınız olsun ? :");
  tahminSayisi = okuyucu.nextInt();

  int tahminEdilenSayi = 0;
  boolean oyunaDevam = true;// oyunun devam edip etmemesini kontrol için kullanılacak

  System.out.println("0-100 arası bir sayi giriniz : ");

  while (oyunaDevam) {

   //okuyucudan bir sayı tahmin etmesini istiyoruz
   tahminEdilenSayi = okuyucu.nextInt();

   //tahmin edilen sayi rastgele oluşturulan sayıya eşitse tebrik edip döngüden çıkıyoruz
   if (tahminEdilenSayi == bulunmasiGerekenSayi) {
    System.out.println("Tebrikler sayıyı " + tahminEtmeSayaci + ". tahminde buldunuz ... ");
    oyunaDevam = false;
    //yapmış olduğumuz tahmin sayisi bulmak istediğimmiz tahmin sayısından fazla ise oyunu bitiriyoruz
   } else if (tahminEtmeSayaci > tahminSayisi - 1) {
    System.out.println("Oyunu kaybettiniz, bulmanız gereken sayı " + bulunmasiGerekenSayi + " idi.");
    oyunaDevam = false;
   }//tahmin edilen sayı ile rastgele sayı karşılaştırılıp duruma göre yeniden sayı istiyoruz
   else if (tahminEdilenSayi > bulunmasiGerekenSayi) {
    System.out.println("Daha küçük bir sayı giriniz :");
   } else if (tahminEdilenSayi < bulunmasiGerekenSayi) {
    System.out.println("Daha büyük bir sayı giriniz :");
   }

   tahminEtmeSayaci++;
  }
 }

Kodlara ulaşmak için github adresine gidin

Java Alt Küme Bulma Programı

     Bu yazımızda bir kümenin tüm alt kümelerini bulan bir program yazacağız.Programımızın algoritması dizimizin tüm elemanlarını bulunduğumuz satırın ikiye modunu alarak bulmaya dayanmaktadır.

  //Kumemizin eleman sayısını alıyoruz 
  Scanner okuyucu = new Scanner(System.in);
  System.out.print("Kumenin eleman sayısını giriniz : ");
  int elemanSayisi = okuyucu.nextInt();

  //Kumemizin elemanlaarını kume isimli diziye atıyoruz
  int kume[] = new int[elemanSayisi];
  for (int i = 0; i < elemanSayisi; i++) {
   System.out.print((i + 1) + ". Eleman: ");
   kume[i] = okuyucu.nextInt();
  }

  //Kümemizi yazdırıyoruz
  System.out.print("{");
  for (int i = 0; i < elemanSayisi; i++) {
   System.out.print(kume[i]);
   if (i != elemanSayisi - 1) {
    System.out.print(",");
   }
  }
  System.out.print("}");
  System.out.println(" kümesinin alt kümeleri ");

  //Alt kümelerimizin sayısını bulduruyoruz ve altküme dizimizi oluşturuyoruz
  int altKumeSayisi = (int) Math.pow(2, (elemanSayisi));
  String altKumeler[] = new String[altKumeSayisi];
  String altKume = "";

  int sayi = 0;
  int sayac = 0;
  for (int i = 0; i < altKumeSayisi; i++) {
   sayi = i;
   altKume = "{";
   sayac = 0;

   for (int j = 0; j < elemanSayisi; j++) {
    //gelinen sayının 2 ye modu alınır böylece binary sistemde varlığı kontrol edilir
    if (sayi % 2 == 1) {
     if (sayac == 0) {
      altKume += kume[j];
     } else {  //alt kümelerde 2 ve daha fazla eleman varsa yazdırmak için kullanılır
      altKume += "," + kume[j];
     }
     sayac++;
    }
    //sayı 2 den küçük ise artık kontrole gerek kalmaz döngüden çıkılır
    if (sayi == 1) {
     break;
    }
    // burada bilinen decimal sayıyı binary' e çevirme işlemi yapılır(2 ye bölme)
    if (sayi >= 2) {
     sayi = sayi / 2;
    }
   }
   //Bulunan elemanlar bir string te tutulur ve bu string de bir diziye eklenir
   altKume += "}";
   altKumeler[i] = altKume;
   altKume = "{";
  }

  String temp = "";   // Yer değiştirmede kullanılacak geçici değişken
  // Her karşılaştırmadan sonra yeniden kaldığımız yerden devam etmemizi sağlayan döngü
  for (int i = 1; i < altKumeSayisi; i++) {
   // Dizinin ardışık elamanlarını karşılaştırmak için kullandığımız döngü
   for (int j = 0; j < altKumeSayisi - i; j++) {
    //Önce gelen elaman bir sonrakinden büyükse(karakter sayısı) ikisi yer değiştiriyor
    if (altKumeler[j].length() > altKumeler[j + 1].length()) {
     temp = altKumeler[j];
     altKumeler[j] = altKumeler[j + 1];
     altKumeler[j + 1] = temp;
    }
   }
  }

  //Alt kümeleri yazdır
  for (int i = 0; i < altKumeSayisi; i++) {
   System.out.println((i + 1) + ". " + altKumeler[i]);
  }

Kodlara ulaşmak için github adresine gidin

Java Harf Üçgeni

   Bu örneğimizde harfleri kullanarak üçgen oluşturacağız. Oluşturduğumuz bu üçgenin her bir satırı palindromik olmuş olacak. Palindrom, tersten okunuşu da aynı olan cümle, sözcük ve sayılara denilmektedir.Örneğin 101,12321,aba,abcba vb. gibidir.
Oluşturacağımız şekil böyle olacaktır.

0          
1         A
2        ABA
3       ABCBA
4      ABCDCBA
5     ABCDEDCBA
6    ABCDEFEDCBA
7   ABCDEFGFEDCBA
8  ABCDEFGHGFEDCBA
9 ABCDEFGHIHGFEDCBA 

Şeklimizin java kodları:

int i, satirSayisi = 10;
char harf;   // harfleri kullanacağımızdan harf adında char tipinde değişken oluşturuyoruz  
  
//satırlarımızı oluşturduğumuz for blogumuz
for (i = 0; i < satirSayisi; i++) {
   
harf = 'A';   //for her tekrar yaptıgında harf değişkenimize A değerini atıyoruz
System.out.print((i%10)+" ");   // hangi satırda olduğumuzu göstermek için kullandık
   
//üçgen şekli elde edebilmemiz için sol tarafda bosluk olusturuyoruz
for (int j = 0; j < satirSayisi - 1 - i; j++) {
    System.out.print(" ");
}
//şimdide harflerimizi yazıdırıyoruz burası A'dan Z'ye kadar artarak giden kısım
for (int j = 0; j < i ; j++) {   //bulunduğumuz satır kadar harf yazdırıyoruz

  System.out.print(harf);
  harf++;
if (harf >= 'Z') //harf değerimiz eğer Z olursa A ya geri dönüyoruz
 harf = 'A';
}
   
 harf--; //geri dönüş yapabilmemiz için harf değerini 1 azalttık
   
//burası Z'den A'ya kadar azalarak giden kısım
for (int j = 1; j < i ; j++) {  //geri giderken 1 eksik yazmamız gerektiğinden j'yi 1 ile başlattık
 harf--;
 System.out.print(harf);    
  if (harf <= 'A')  //harf değerimiz eğer A olursa Z ye geri dönüyoruz
 harf = 'Z';
  }
 System.out.print("\n");

}

Kodlara ulaşmak için github adresine gidin

Java Yıldızlarla Şekil Çizme 3

Bugün yıldızlarla özel bir şekil çizeceğiz.

*-----------------*
 \ ************* / 
  \ *         * /
   \ *       * /
    \ *     * /
     \ *   * /
      \ * * /
       \ * /
        \ /
         *

Bu şekli çizen kodları yazmaya çalışacağız. Şeklimizi anlatacak olursak şeklimizin bazı yerleri sabittir.        Örneğin ilk satır ve son satır sabittir. Şeklimizi çizmek için 1'den 6'ya kadar bir sayı verildiğinde oluşan şekiller farklıdır. 6 dan sonra asıl şeklimiz oluşmaya başlamaktadır.

Şeklimizi çizebilmek için bazı satırların oranlarını bulmamız gerekir.

// ilk satırın tire sayısını bulma
for (int s = 0; s < sayi - 2; s++) {
  tireSayisi = tireSayisi + 2;
}
//ikinci satırın yıldız sayısını bulma
for (int k = 0; k < sayi - 4; k++) {
  yildizSayisi = yildizSayisi + 2;
}
//orta alandaki bosluk sayısını bulma
for (int n = 0; n < sayi - 6; n++) {
  boslukSayisi = boslukSayisi + 2;
}

Bu oranları bulduktan sonra şimdi ilk satırımızı oluşturalım.

// ilk satırı oluşturuyoruz
System.out.print("*");
for (int j = 0; j < tireSayisi; j++) {
System.out.print("-"); //bulduğumuz tire sayısı kadar tire yazdırıyoruz
}
System.out.print("*");

System.out.println();// ikinci satıra geçmek için kullandık

Daha sonra son satırımızı ve sondan önceki satırı oluşturalım çünkü buralar sabit kısımlar.

 if (sayi > 2) {
 // sayi 3 veya 3'den büyük ise burası çalışacak ve en altın bir üsütünü oluşturacak
   for (int i = 0; i < 1; i++) {
       for (int j = 0; j < sayi - 2; j++) {
        System.out.print(" ");
       }
      System.out.print("\\");
      System.out.print(" ");
      System.out.print("/");

   }
    System.out.println();
 }
                
  //son satırı çiziyoruz
  for (int r = 0; r < sayi-1; r++) {
   System.out.print(" ");
  }
System.out.print("*");

Geri kalan satırlarımız değişkenliği oluşturan satırlar.

if (sayi > 3) {// sayi 4 veya 4'den büyük ise burası çalışacak
    
     System.out.print(" \\ ");
     for (int j = 0; j < yildizSayisi; j++) {
      System.out.print("*");//ikinci satırı oluşturuyoruz
     }
     System.out.print(" / ");
                                        
    System.out.println();// alt satıra geçmek için kullandık

    //en önemli yer burası çünkü 6 ve 6'dan sonra orta kısımı burası oluşturacak                                
    for (int m = 0; m < sayi - 5; m++) { //6 dan sonraki her satır için ortayı genişletiyoruz

     for (int j = 0; j < m + 2; j++) {
      System.out.print(" "); 
     }
     System.out.print("\\");
     System.out.print(" ");
     System.out.print("*");
     for (int j = boslukSayisi; j > 0; j--) {
      System.out.print(" ");  //ortadaki boslukları oluşturuyoruz
     }
     System.out.print("*");
     System.out.print(" ");
     System.out.print("/");
     System.out.println();
     boslukSayisi = boslukSayisi - 2;
    }

   }
   if (sayi > 4) {// sayi 5 veya 5'den büyük ise burası çalışacak
    
    for (int i = 0; i < 1; i++) {
     for (int j = 0; j < sayi - 3; j++) {
      System.out.print(" ");
     }
     System.out.print("\\ ");
     System.out.print("*");
     System.out.print(" /");

    }
    System.out.println();

   }

Kodlara ulaşmak için github adresine gidin

Java Yıldızlarla Şekil Çizme 2

Java yıldızlarla şekil çizme 2. örnekler ile devam ediyoruz.

Şimdi yaptıklarımızı biraz anlatacak olursak ilk örneklerde parça parça yapmış yaptığımız şekilleri birleştirerek yeni şekiller üretiyoruz.

İlk örneğimiz bu şekili çıkaran kodlar

-------------------Düz üçgen şekli-----------------------
0                   *
1                 ***
2               *****
3             *******
4           *********
5         ***********
6       *************
7     ***************
8   *****************
9 *******************

Kodları görünce anlayacaksınız ki kodlar bir önceki örneklerin birleştirilmiş halidir.

ikinci örneğimiz bu şekili çıkaran kodlar

-------------------Ters üçgen şekli-----------------------
0 *******************
1   *****************
2     ***************
3       *************
4         ***********
5           *********
6             *******
7               *****
8                 ***
9                   *

ve son örneğimiz baklava şeklini çıkaran kodlar
-------------------Baklava şekli-----------------------
0                   *
1                 ***
2               *****
3             *******
4           *********
5         ***********
6       *************
7     ***************
8   *****************
9 *******************
0 *******************
1   *****************
2     ***************
3       *************
4         ***********
5           *********
6             *******
7               *****
8                 ***
9                   *

üst kısmı çizen kodlar ->

alt kısmı çizen kodlar ->

Kodlara ulaşmak için github adresine gidin