java StringBuilder

第1章   StringBuilder类

1.1    StringBuilder概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuilder就可以解决这个问题。

1.2    StringBuilder和String的区别?

l String的内容是固定的。

l StringBuilder的内容是可变的。

1.3    构造方法

l 无参数构造方法

n public StringBuilder() 构造一个空的StringBuilder容器

l 带有字符串参数的构造方法

n public StringBuilder(String str)构造一个StringBuilder容器,并将字符串添到容器

public classDemo01StringBuilder {

    publicstaticvoidmain(String[]args) {

        StringBuilder builder= new StringBuilder();

        System.out.println(builder);

       

        StringBuilder builder2= new StringBuilder("itcast");

        System.out.println(builder2);

    }

}

1.4    方法

l  添加功能

n public StringBuilder append(任意类型):添加数据，并返回自身对象

l  反转功能

n public StringBuilderreverse()

publicclass Demo02StringBuilder {

    publicstaticvoidmain(String[]args) {

        //创建对象

        StringBuilderbuilder= newStringBuilder();

       

        //publicStringBuilder append(任意类型)

        //StringBuilderbuilder2 = builder.append("hello");

       

        /*

        System.out.println("builder:"+builder);

        System.out.println("builder2:"+builder2);

        System.out.println(builder == builder2);//true

        */

       

        /*

        builder.append("hello");

        builder.append("world");

        builder.append(true);

        builder.append(100);

        */

       

        //链式编程

        builder.append("hello").append("world").append(true).append(100);

       

        System.out.println("builder:"+builder);

       

        //publicStringBuilderreverse()

        builder.reverse();

        System.out.println("builder:"+builder);

    }

}

 

1.5    String和StringBuilder的互转

l  String转成StringBuilder

n  StringBuilder构造方法,或者append方法

l  StringBuilder转成String

n  StringBuilder类的方法 public String toString()

 

1.6    练习

l  数组元素格式拼接

举例：int[] arr = {1,2,3};结果：[1, 2, 3]

publicclass Demo04StringBuilderTest {

    publicstaticvoidmain(String[]args) {

        //定义一个数组

        int[]arr = {1,2,3};

       

        //调用方法

        String s= arrayToString(arr);

       

        //输出结果

        System.out.println("s:"+s);

    }

   

    /*

     * 写方法实现拼接

     * 两个明确：

     *      返回值类型：String

     *      参数列表：int[]arr

     */

    publicstaticString arrayToString(int[]arr) {

        StringBuilderbuilder= newStringBuilder();

        builder.append("[");

        for(intx=0;x<arr.length;x++) {

            if(x==arr.length-1) {

                builder.append(arr[x]).append("]");;

            }else{

                builder.append(arr[x]).append(", ");

            }

        }

        String result= builder.toString();

        returnresult;

    }

}

l  字符串反转

publicclass Demo05StringBuilderTest {

    publicstaticvoidmain(String[]args) {

        //1:键盘录入一个字符串

        Scanner sc= new Scanner(System.in);

        System.out.println("请输入一个字符串：");

        String s= sc.nextLine();

       

        //3:调用方法

        String result= myReverse(s);

       

        //4:输出结果

        System.out.println("result:"+result);

    }

   

    /*

     * 2:写方法实现反转

     * 两个明确：

     *      返回值类型：String

     *      参数列表：String

     */

    publicstaticString myReverse(Strings) {

        //String --StringBuilder -- reverse() -- String

        StringBuilder builder= newStringBuilder(s);

        builder.reverse();

        String result= builder.toString();

        returnresult;

    }

}

l  判断字符串的对称性

 对称性是指一个字符串进行反转后,还和原来的字符串一致.例如: abcba,反转后还是abcba,反转前后是一致的

public staticvoid main(String[] args) {

        String str= "abcba";

        booleanbool =symmetric(str);

        System.out.println(bool);

    }

    /*

     * 实现字符串对称行判断

     * 返回布尔值

     *   参数类型:String

     *   返回值: boolean

     */

    publicstaticbooleansymmetric(Stringstr){

        //创建StringBuilder对象

        StringBuilder builder= new StringBuilder();

        //将字符串添加到容器

        builder.append(str);

        //反转字符串

        builder.reverse();

        //获取反转后的字符串

        String str2= builder.toString();

        //String类equals方法判断两个字符串是否相等

        returnstr.equals(str2);

    }

 

第2章   ArrayList集合

2.1    对象数组的案例

l 创建一个学生数组，存储三个学生对象并遍历

publicclass Student {

    private Stringname;

    privateintage;

    public Student() {

       

    }

    public Student(Stringname,intage) {

        this.name =name;

        this.age =age;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(Stringname) {

        this.name =name;

    }

    publicint getAge() {

        returnage;

    }

    publicvoid setAge(intage) {

        this.age =age;

    }

}

publicclass Demo01Array {

    publicstaticvoidmain(String[]args) {

        //创建学生数组

        Student[] students= new Student[3];

       

        //创建学生对象

        Student s1= new Student("曹操",40);

        Student s2= new Student("刘备",35);

        Student s3= new Student("孙权",30);

       

        //把学生对象作为元素赋值给学生数组

        students[0]= s1;

        students[1]= s2;

        students[2]= s3;

       

        //遍历学生数组

        for(intx=0;x<students.length;x++) {

            Student s= students[x];

            //System.out.println(s);

            System.out.println(s.getName()+"---"+s.getAge());

        }

    }

}

 

2.2    为什么出现集合类

我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。

而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?数组和StringBuilder。

但是呢? StringBuilder的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。

而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用，由此可见集合的长度是可变的。

2.3    ArrayList类的构造方法和成员方法

l ArrayList<E>集合:大小可变数组的实现

n <E>:是一种特殊的数据类型，泛型。

n 在出现E的地方我们使用引用数据类型替换即可

n 举例：ArrayList<String>,ArrayList<Student>

l 构造方法

n ArrayList()

l 成员方法

n 添加元素

u public boolean add(E e):添加元素

u public void add(int index,Eelement):在指定的索引处添加一个元素

publicclass Demo01ArrayList {

    publicstaticvoidmain(String[]args) {

        //创建集合对象

        ArrayList<String>list = new  ArrayList<String>();

       

        //add(E e):添加元素

        list.add("hello");

        list.add("world");

        list.add("java");

       

        //add(intindex,E element):在指定的索引处添加一个元素

        list.add(1,"android");

       

        System.out.println("array:"+list);

    }

}

n 获取元素

u public E get(int index):返回指定索引处的元素

n 集合长度

u public int size():返回集合中的元素的个数

n 删除元素

u public boolean remove(Objecto):删除指定的元素，返回删除是否成功

u public E remove(int index):删除指定索引处的元素，返回被删除的元素

n 修改元素

u public E set(int index,Eelement):修改指定索引处的元素，返回被修改的元素

publicclass Demo02ArrayList {

    publicstaticvoidmain(String[]args) {

        //创建集合对象

        ArrayList<String>array = newArrayList<String>();

       

        //添加元素

        array.add("hello");

        array.add("world");

        array.add("java");

       

        //public Eget(int index):返回指定索引处的元素

        System.out.println("get:"+array.get(0));

        System.out.println("get:"+array.get(1));

        System.out.println("get:"+array.get(2));

       

        //public intsize():返回集合中的元素的个数

        System.out.println("size:"+array.size());

       

        //publicboolean remove(Object o):删除指定的元素，返回删除是否成功

        System.out.println("remove:"+array.remove("world"));//true

        System.out.println("remove:"+array.remove("world"));//false

       

        //public Eremove(int index):删除指定索引处的元素，返回被删除的元素

        System.out.println("remove:"+array.remove(0));

       

        //public Eset(int index,E element):修改指定索引处的元素，返回被修改的元素

        System.out.println("set:"+array.set(0,"android"));

       

        //输出

        System.out.println("array:"+array);

    }

}

2.4    ArrayList类案例

l  练习一

存储字符串并遍历

publicclass Demo03ArrayList {

    publicstaticvoidmain(String[]args) {

        //创建集合对象

        ArrayList<String>list = newArrayList<String>();

       

        //添加元素

        list.add("hello");

        list.add("world");

        list.add("java");

       

        //获取元素

        //原始做法

        System.out.println(list.get(0));

        System.out.println(list.get(1));

        System.out.println(list.get(2));

        System.out.println("----------");

       

        for(inti=0;i<3;i++) {

            System.out.println(list.get(i));

        }

        System.out.println("----------");

       

        //如何知道集合中元素的个数呢?size()

        for(inti=0;i<list.size();i++) {

            System.out.println(list.get(i));

        }

        System.out.println("----------");

       

        //最标准的用法

        for(inti=0;i<list.size();i++) {

            String s= list.get(i);

            System.out.println(s);

        }

    }

}

 

l  练习二

使用集合存储整数该怎么存储,对于基本数据类型集合是不存储的,因此不能写int,但是可以存储基本类型的包装类型Integer

publicclass Demo02ArrayListTest {

public staticvoid main(String[] args) {

        ArrayList<Integer> list = newArrayList<Integer>();

        list.add(1);

        list.add(2);

        list.add(3);

        list.add(4);

        for(intx = 0 ;x <list.size();x++ ){

            Integer i= list.get(x);

            System.out.println(i);

        }

    }

 

l  练习三

给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。

publicclass Demo03ArrayListTest {

    publicstaticvoidmain(String[]args) {

        //定义字符串数组

        String[] strArray= {"张三丰","宋远桥","张无忌","殷梨亭","张翠山","莫声谷"};

       

        //创建集合对象

        ArrayList<String>list = newArrayList<String>();

       

        //遍历字符串数组，获取到每一个字符串元素

        for(intx=0;x<strArray.length;x++) {

            //把获取到的字符串元素添加到集合

            list.add(strArray[x]);

        }

       

        //遍历集合

        for(intx=0;x<list.size();x++) {

            String s= list.get(x);

            //要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台

            if(s.startsWith("张")) {

                System.out.println(s);

            }

        }

    }

}

l  练习四

存储自定义对象并遍历

publicclass Student {

    private Stringname;

    privateintage;

   

    public Student() {

       

    }

    public Student(Stringname,intage) {

        this.name =name;

        this.age =age;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(Stringname) {

        this.name =name;

    }

    publicint getAge() {

        returnage;

    }

    publicvoid setAge(intage) {

        this.age =age;

    }

}

publicclass Demo03ArrayListTest {

    publicstaticvoidmain(String[]args) {

        //创建集合对象

        ArrayList<Student>array = newArrayList<Student>();

       

        //创建学生对象

        Student s1= new Student("赵丽颖",18);

        Student s2= new Student("唐嫣",20);

        Student s3= new Student("景甜",25);

        Student s4= new Student("柳岩",19);

       

        //把学生对象作为元素添加到集合中

        array.add(s1);

        array.add(s2);

        array.add(s3);

        array.add(s4);

       

        //遍历集合

        for(intx=0;x<array.size();x++) {

            Student s= array.get(x);

            System.out.println(s.getName()+"---"+s.getAge());

        }

    }

}

l  练习五

创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合

publicclass Student {

    private Stringname;

    private Stringage;

    public Student() {

 

    }

    public Student(Stringname,Stringage) {

        this.name =name;

        this.age =age;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(Stringname) {

        this.name =name;

    }

    public String getAge() {

        returnage;

    }

    publicvoid setAge(Stringage) {

        this.age =age;

    }

}

publicclass Demo04ArrayListTest {

    publicstaticvoidmain(String[]args) {

        //创建集合对象

        ArrayList<Student>list = newArrayList<Student>();

        Scanner sc= new Scanner(System.in);

       for(int x = 0 ; x < 3 ; x++){

        System.out.println("请输入学生姓名：");

        String name= sc.nextLine();

        System.out.println("请输入学生年龄：");

        String age= sc.nextLine();

       

        Student s= new Student();

        s.setName(name);

        s.setAge(age);

       

        //把学生对象作为元素存储到集合中

        list.add(s);

    }

 }

        //遍历集合

        for(intx=0;x<list.size();x++) {

            Student s= list.get(x);

            System.out.println(s.getName()+"---"+s.getAge());

        }

    }

   

l  练习六

  引用数据类型(类)作为方法的参数

  可以将遍历集合的代码抽取为一个方法,每次需要遍历集合,调用方法即可,方法不明确遍历的集合是谁,因此将集合作为方法的参数传递

public staticvoid main(String[] args) {

        //创建集合ArrayList对象

        ArrayList<Student> list = newArrayList<Student>();

        //创建4个学生类对象

        Student s1= new Student("赵丽颖","18");

        Student s2= new Student("唐嫣","20");

        Student s3= new Student("景甜","25");

        Student s4= new Student("柳岩","19");

        //将学生对象添加到集合中

        list.add(s1);

        list.add(s2);

        list.add(s3);

        list.add(s4);

        //调用方法,传递集合对象

        printStudent(list);

    }

    /*

     *  方法传递集合进行遍历

     *  参数:集合对象

     *  返回值 :无

     */

    publicstaticvoidprintStudent(ArrayList<Student>list){

        for(intx = 0 ;x <list.size();x++){

            Student s= list.get(x);

            System.out.println(s.getName()+" "+s.getAge());

        }

    }

l  练习七

  引用类型(类)作为方法的返回值

public staticvoid main(String[] args) {

        ArrayList<Student> list = getArrayList();

        for(intx = 0 ;x <list.size();x++){

            Student s= list.get(x);

            System.out.println(s.getName()+" "+s.getAge());

        }

    }

 

    /*

     * 方法中创建集合对象,向集合中存储Student对象,将集合返回

     * 参数:无

     * 返回值:集合对象

     */

    publicstatic ArrayList<Student>getArrayList() {

        // 创建集合ArrayList对象

        ArrayList<Student> list = newArrayList<Student>();

        // 创建4个学生类对象

        Student s1= new Student("赵丽颖","18");

        Student s2= new Student("唐嫣","20");

        Student s3= new Student("景甜","25");

        Student s4= new Student("柳岩","19");

        // 将学生对象添加到集合中

        list.add(s1);

        list.add(s2);

        list.add(s3);

        list.add(s4);

        // 调用方法,传递集合对象

        returnlist;

    }