/*
Klasa String
> Java poseduje ugrađenu klasu String
> Tipove delimo na primitivne i klasne
> String je nekako između ta dva
* Dozvoljava se sintaksa dodele kao kod primitivnih tipova
* String t = ”Zdravo svima :)”;
> Ipak, String je zvanično klasni tip


> Stringovi u Javi su imutabilni
> Alociraju se na hip memoriji
> Odnosno, string u Javi predstavlja konstantu


Imutabilnost stringa - dobre strane
> Potencijalno možemo uštedeti na memoriji
> Usled imutabilnosti, sigurni smo da string neće biti promenjen
> Time omogućavamo da jedna stringovna konstanta bude više puta referencirana

Na primer:

public static void main(String[] args) {
String s1 = ”Zdravo”;
String s2 = ”Zdravo”;
String t1 = ”svete”;
String t2 = t1;
String t3 = ”svete”;

}

Zamislimo HEAP i upisane dve stringovne konstante: ”Zdravo” i ”svete”.
Na prvu string konstantu ukazuje s1, s2.
Na drugu string konstantu ukazuje t1,t2,t3 

Imutabilnost stringa - loše strane
> Izmene stringa zahtevaju alokaciju memorije u pravljenju novog stringa
> Naše operacije su često takve da želimo izmeniti originalni string bez
ikakvih kopiranja

*/
import java.util.Scanner;

/**
 * Program prikazuje kako mozemo vrsiti modifikaciju Stringa.
 */
public class Primer03Imutabilnost {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Unesite liniju teksta:");
        String t = sc.nextLine();

        String ms = uMalaSlova(t);
        // U klasi String postoji metod toLowerCase() koji za dati string
        // vraca novi u kome su velika slova prevedena u mala,
        // a ostali karakteri su nepromenjeni.
        // U ovom primeru nije koriscen radi ilustracije iteriranja kroz string.
        System.out.println("Mala slova: " + ms);

        // Metod toUpperCase() radi suprotno, prevodi mala u velika slova.
        String vs = t.toUpperCase();
        // Metodom replace() zamenjujemo svaku pojavu podstringa datim stringom
        // (moze i svaku pojavu jednog karaktera da zameni drugim karakterom)
        String vsBezBelina = vs.replace(" ", "");
        System.out.println("Velika slova bez belina: " + vsBezBelina);

        // Uneta linija teksta je ostala nepromenjena
        System.out.println("Uneta linija: " + t);
        sc.close();
    }

    static String uMalaSlova(String t) {
        // Stringovi su imutabilni (nepromenljivi)
        // tako da cemo transformaciju izvrsiti
        // nad nizom karaktera koji cemo posle
        // vratiti kao String
        char[] tmp = t.toCharArray();
        for (int i = 0; i < tmp.length; i++)
            if (Character.isUpperCase(tmp[i]))
                tmp[i] = Character.toLowerCase(tmp[i]);

        // ------------
        // Prvi nacin
        // ------------
        // Metod valueOf() od promenljive koju prima kao argument
        // vraca njenu stringovnu reprezentaciju.
        // Radi za vecinu primitivnih tipova podataka, nizove karaktera i objekte.
        // String.valueOf(true) se izracunava u "true"
        // String.valueOf(5.5) se izracunava u "5.5"
        return String.valueOf(tmp);

        // ------------
        // Drugi nacin
        // ------------
        // Pravimo objekat (string) od niza karaktera.
        // return new String(tmp);
    }
}

/*

Kako protiv novih stringova
> Pretpostavimo da želimo da generišemo string koji sadrži 10000 jedinica
public static void main(String[] args) {
String nums = ””;
for (int i = 0; i < 10000; i++)
nums = nums + 1;
System.out.println(nums);
}
> Potencijalno 10000 puta alociramo novi string (Za slučaj da kompilator ne optimizuje)
> Na kraju petlje, za sobom smo ostavili 9999 stringova koji su dalje nepotrebni
> Grubom i optimističnom računicom, potrošili smo oko 47 megabajta!

*/