Coffee break #174. Iba't ibang Paraan para Gumawa ng Bagay sa Java.String sa Int sa Java - Paano I-convert ang String sa Integer

Iba't ibang paraan upang lumikha ng isang bagay sa Java

Source: Medium Sa tutorial na ito, matututo tayo ng iba't ibang paraan para gumawa ng object sa Java. Ang Java object ay isang instance ng isang Java class. Ang bawat bagay ay may estado, pag-uugali, at pagkakakilanlan. Ang mga patlang (mga variable) ay nag-iimbak ng estado ng isang bagay, habang ang mga pamamaraan (mga function) ay nagpapakita ng pagkilos ng isang bagay. Ang mga klase ay nagsisilbing "mga blueprint" kung saan nilikha ang mga instance ng object sa runtime.

Paglikha ng isang Bagay sa Java

Ang paglikha ng bagay ay ang proseso ng paglalaan ng memorya upang mag-imbak ng data sa mga patlang ng klase (tinatawag ding mga variable). Ang prosesong ito ay madalas na tinatawag na paglikha ng isang halimbawa ng isang klase. Mayroong apat na magkakaibang paraan upang lumikha ng mga bagay sa Java:

1. gamit ang bagong keyword
2. pamamaraan newInstance()
3. clone() na pamamaraan
4. deserializing ng isang bagay

Ngayon tingnan natin ang bawat isa sa mga nabanggit na pamamaraan nang detalyado.

Bago ang keyword

Ito ang pinakakaraniwang paraan upang lumikha ng isang bagay sa Java. Ang bagong keyword ay lumilikha ng isang instance ng isang klase sa pamamagitan ng paglalaan ng memory para sa isang bagong instance ng tinukoy na uri. Pagkatapos ng bago ay dumating ang tagabuo - isang espesyal na pamamaraan na responsable para sa paglikha ng isang bagay at pagsisimula ng mga patlang ng nilikha na bagay. Ang isang bagay ay nilikha gamit ang bagong operator at sinimulan sa isang constructor. Narito ang isang halimbawa ng paglikha ng Java object gamit ang bagong operator :

Date today = new Date();

Ang expression na ito ay bumubuo ng isang bagong Date object ( Date ay isang klase sa loob ng java.util package ). Ang solong sugnay na ito sa code ay nagsasagawa ng tatlong operasyon: deklarasyon, instantiation, at initialization. Ang petsa ngayon ay isang variable na deklarasyon na nagpapaalam sa compiler na ngayon ay tumutukoy sa isang bagay na may uri na Petsa . Ang bagong operator ay nagpapasimula ng klase ng Petsa (lumilikha ng isang bagong bagay na Petsa sa memorya), at ang Petsa() ay nagpapasimula ng bagay. Isaalang-alang ang halimbawa sa ibaba:

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Michael Cole";
        this.uid = 101;
    }

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {

        Person p1 = new Person();
        Person p2 = new Person("John Bodgan", 102);
        System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
        System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
    }
}

Mula sa code na ito, lumikha kami ng isang Person object gamit ang bagong keyword :

• Ang p1 object ay tumatawag sa isang di-parameterized na constructor na may variable na value ng pangalan na nakatakda sa "Michael Cole" at ang UID ay nakatakda sa 101.
• Tinatawag ng p2 object ang parameterized constructor, kung saan ipinapasa nito ang value na "John Bodgan" at 102 sa constructor. Ang mga value na ito ay itatalaga sa isang variable na pangalan at UID.

Gamit ang newInstance() na pamamaraan

Ang newInstance() na pamamaraan sa Java ay ginagamit upang dynamic na lumikha ng isang instance ng isang bagay ng isang naibigay na klase. Mayroong dalawang karaniwang paggamit ng newInstance() na pamamaraan :

• newInstance() method mula sa java.lang.Class API
• newInstance() method mula sa java.lang.reflect.Constructor API

Gamit ang newInstance() mula sa Class API

Upang lumikha ng object ng isang klase sa runtime, dapat nating tawagan ang newInstance() na pamamaraan mula sa Class API, na nagbabalik ng object ng klase na iyon. Ang newInstance() na paraan ng java.lang.Class na klase ay hindi kumukuha ng anumang mga parameter o argumento at maaaring tawaging no-argument constructor para sa klase na iyon. Tingnan natin ang ilang halimbawang code para gumawa ng object ng Person class gamit ang newInstance() na paraan ng java.lang.Class class :

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Carl Max";
        this.uid = 101;
    }

   // getters and setters...
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class c = Class.forName("com.medium.option2.Person");
        @SuppressWarnings("deprecation")
        Person p = (Person) c.newInstance();
        System.out.println("Name: " + p.getName());
        System.out.println("UID: " + p.getUid());
    }
}

Ang Class.forName (ang ganap na kwalipikadong pangalan ng klase) ay naglo-load ng klase na pinangalanang Person , pagkatapos ay gagawa ang newInstance() ng bagong object ng uri na Person at nagbabalik ng reference dito. Ngayon, gamit ang Person reference sa p , maaari nating tawagan ang getters() at setter() nito para magsagawa ng ilang mga aksyon. Paalala:

• Parehong Class.forName() at newIstance() ay nagtatapon ng mga eksepsiyon na dapat pangasiwaan gamit ang try and catch blocks o ang throws na keyword .
• Ang newInstance() na paraan mula sa Class API ay hindi na ginagamit mula noong Java 9.

Gamit ang newInstance() mula sa Constructor API

Ang newInstance() method ng Constructor class ( java.lang.reflect.Constructor ) ay katulad ng newInstance() method ng Class class , maliban na ito ay tumatanggap ng mga parameter para sa mga parameterized constructor. Ipakita natin ang diskarteng ito sa pamamagitan ng paglikha ng object ng Person class gamit ang newInstance() na paraan ng java.lang.reflect.Constructor class :

public class PersonTwo {
    private String name;
    private int uid;

    public PersonTwo() {
        this.name = "Maya Kumari";
        this.uid = 101;
    }

    public PersonTwo(String name) {
        this.name = name;
        this.uid = 102;
    }

    public PersonTwo(String name, Integer uid) {
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...
    public static void main(String[] args) {
        try {
            Class.forName("com.medium.option2.PersonTwo");

            Constructor c1 = PersonTwo.class.getConstructor();
            PersonTwo p1 = (PersonTwo) c1.newInstance();
            System.out.println("Name: " + p1.getName());
            System.out.println("UID: " + p1.getUid());

            Constructor c2 = PersonTwo.class.getConstructor(String.class);
            PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());

            Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
            PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
            System.out.println("Name: " + p3.getName());
            System.out.println("UID: " + p3.getUid());

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

Sa code sa itaas, kailangan muna nating i-load ang klase gamit ang Class.forName() method . Susunod, tatawagan namin ang getConstructor() na paraan upang tumugma sa mga uri ng data ng mga naipasa na parameter. Sa wakas, sa newInstance() na pamamaraan ay ipinapasa namin ang kinakailangang parameter ( null kung walang argumento). Ang newInstance() method ay magbabalik ng bagong object ng PersonTwo class sa pamamagitan ng pagtawag sa naaangkop na constructor.

Gamit ang clone() na pamamaraan

Ang clone() method ay bahagi ng Object class at ginagamit upang lumikha ng kopya ng isang umiiral na object. Lumilikha ito ng isang bagay ng klase nang hindi tumatawag sa anumang tagabuo ng klase. Upang mai-clone ang isang paraan, dapat na ipinatupad ng kaukulang klase ang Cloneable na interface , na isang marker interface. Ngayon ay gagawa tayo ng object ng Person class at pagkatapos ay i-clone ito sa isa pang object ng Person class :

public class Person implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name;
    private int uid;

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {
        Person p1 = new Person("Ryan", 101);
        try {
            Person p2 = (Person) p1.clone();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

Tandaan. Ang na-clone na bagay ay magre-refer sa parehong orihinal na bagay sa pamamagitan ng p2 reference . Gayunpaman, ang naka-clone na bagay ay magkakaroon ng hiwalay na pagtatalaga ng memorya. Nangangahulugan ito na ang anumang mga pagbabagong ginawa sa object na Tao na isinangguni ng p2 ay hindi magbabago sa orihinal na bagay na Tao na isinangguni ng p1 . Ito ay dahil ang clone() na pamamaraan ay lumilikha ng isang mababaw na kopya ng mga bagay.

Paggamit ng Object Deserialization

Ang Object deserialization ay ang proseso ng pagkuha ng isang bagay mula sa isang serye ng mga byte stream. Kabaligtaran ang ginagawa ng serialization. Ang pangunahing layunin nito ay upang mabawi ang isang nakaimbak na bagay mula sa database/network pabalik sa memorya. Kung gusto naming i-serialize o deserialize ang isang object, kailangan naming ipatupad ang Serializable interface (token interface). Isaalang-alang ang halimbawa sa ibaba:

public class PersonDriver {

    public static void main(String[] args) {
        Person p1 = new Person("Max Payne", 101);
        FileOutputStream fileOutputStream;
        try {
            fileOutputStream = new FileOutputStream("link to text file");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(p1);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fileInputStream;
        try {
            fileInputStream = new FileInputStream("link to text file");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            Person p2 = (Person) inputStream.readObject();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Dito muna namin i-serialize ang Person object sa pamamagitan ng reference p1 sa isang text file. Ang writeObject() method ay magsusulat ng byte stream ng object sa isang text file. Pagkatapos, gamit ang object deserialization, i-extract namin ang Person object pabalik sa p2 . Katulad nito, ang readObject() method ay magbabasa ng object mula sa input stream ng object. Sa wakas, ipi-print namin ang data mula sa object ng Person sa console.

Konklusyon

Sa artikulong ito, natutunan namin ang tungkol sa iba't ibang paraan ng paggawa ng object sa Java. Una, tiningnan namin ang paglikha ng mga bagay gamit ang bagong keyword , na siyang pinakakaraniwang paraan. Natutunan namin pagkatapos ang newInstance() na pamamaraan mula sa Class at Constructor classes , na isa pang sikat na paraan upang lumikha ng mga bagay. Pagkatapos ay ginamit namin ang clone() method , na lumilikha ng mababaw na kopya ng umiiral na bagay sa halip na lumikha ng bagong bagay. Panghuli, ginamit namin ang konsepto ng object serialization at deserialization upang lumikha ng mga object sa Java.

String sa Int sa Java - kung paano i-convert ang isang string sa isang integer

Source: FreeCodeCamp Ngayon ay matututunan mo kung paano i-convert ang isang string sa isang integer sa Java gamit ang dalawang paraan ng klase ng Integer - parseInt() at valueOf() . Makakatulong ito sa iyo kapag nagsasagawa ng mga mathematical operations gamit ang value ng isang string variable.

Paano i-convert ang isang string sa isang integer sa Java gamit ang Integer.parseInt

Ipinapalagay ng pagpipiliang ito na ang parseInt() na pamamaraan ay tumatagal ng isang string upang i-convert sa isang integer bilang isang parameter:

Integer.parseInt(string_varaible)

Bago tumingin sa isang halimbawa ng paggamit nito, tingnan natin kung ano ang mangyayari kapag nagdagdag ka ng string value at integer nang walang anumang conversion:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        System.out.println(age + 20);
        // 1020
    }
}

Sa code na ito, gumawa kami ng variable na edad na may string value na "10". Kapag idinagdag namin ang numero 20 sa isang integer na halaga, nagkamali kaming nakatanggap ng 1020 sa halip na ang tamang sagot na 30. Maaari itong itama gamit ang parseInt() na pamamaraan :

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.parseInt(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

Dito, upang i-convert ang variable ng edad sa isang integer, ipinasa namin ito bilang parameter sa parseInt() method - Integer.parseInt(age) - at inimbak ito sa isang variable na tinatawag na age_to_int . Ngayon kapag idinagdag sa isa pang integer nakukuha natin ang tamang karagdagan: age_to_int + 20 .

Paano i-convert ang isang string sa isang integer sa Java gamit ang Integer.valueOf

Gumagana ang valueOf() method sa parseInt() method . Ito ay tumatagal bilang isang parameter ng isang string na kailangang i-convert sa isang integer. Narito ang isang halimbawa:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.valueOf(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

Sa code sa itaas maaari mong makita ang parehong bagay tulad ng sa nakaraang seksyon:

• Nagpasa kami ng string bilang parameter sa valueOf() : Integer.valueOf(age) . Ito ay nakaimbak sa isang variable na tinatawag na age_to_int .
• Pagkatapos ay nagdagdag kami ng 10 sa ginawang variable: age_to_int + 20 . Ang resulta ay 30 sa halip na 1020.

Konklusyon

Sa artikulong ito, tinalakay namin ang pag-convert ng mga string sa mga integer sa Java. Upang i-convert ang isang string sa isang integer, dalawang pamamaraan ng klase ng Integer ang ginamit - parseInt() at valueOf() . Maligayang coding!