09 ArrayList类和StringBuilder类

一、ArrayList类

1.1 ArrayList集合的概述和基本使用

java.util.ArrayList<E>集合类是一个引用类型,使用有三步:
	1.导包(找到我们要使用的东西)
        格式: import 包名.类名;
		ArrayList: import java.util.ArrayList;
		java.lang包中的内容可以直接使用
		快捷键: alt + 回车
		
    2.创建对象
    	类名 对象名 = new 类名(实际参数...);
		数组:
			int[] array = new int[3];
			左侧int: 表示数组容器中可以存储数据的类型
			左侧[]: 表示数组
			
		java.util.ArrayList<E>集合:
			集合是一个容器,要存储数据时,就需要指定所存储的数据是什么类型的
			ArrayList: 表示它是一个集合容器
			<E>: <>中写的是该集合容器中所存储的数据是什么类型的
			举例1:
				创建ArrayList集合对象list1,只能用来存储字符串数据
				ArrayList<String> list = new ArrayList<String>();
        	举例2:
				创建ArrayList集合对象list2,只能用来存储Student对象
				ArrayList<Student> list2 = new ArrayList<Student>();

	3.常用方法:             
		public boolean add(E e) ： 
			将方法指定的参数e添加到此集合的尾部。
			其中E: 就是创建ArrayList集合对象时<>中指定的类型

1.2 ArrayList集合的常用方法

ArrayList集合常用方法: 增(C)删(D)改(U)查(R)的方法 CRUD的操作
	public boolean add(E e) ：将指定的元素添加到此集合的尾部。
	public void add(int index,E e) ：在此集合中的指定位置index处插入指定的元素e。
	public boolean remove(Object o) ：删除指定的元素，返回删除是否成功   集合中有相同的元素的时候从左往右删除第一个指定的元素
	public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
	public E set(int index,E element) ：修改指定索引处的元素，返回被修改的元素。
	public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
	public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
	public boolean isEmpty(): 判断集合是否为空		
	public void clear(): 清空集合元素
    	public int indexOf(Object o):根据指定元素返回对应的索引值。如果集合中有相同的元素的时候，从左往右获得第一个指定元素的索引值。

public class Demo02ArrayListMethod {
    public static void main(String[] args) {
        //创建ArrayList集合对象list,存储数据类型String
        ArrayList<String> list = new ArrayList<>();

        //public boolean add(E e) ：将指定的元素添加到此集合的尾部。
        list.add("AAA");
        list.add("CCC");
        System.out.println(list);//[AAA, CCC]

        //public void add(int index,E e) ：在此集合中的指定位置index处插入指定的元素e。
        list.add(1, "BBB");
        System.out.println(list);//[AAA, BBB, CCC]: AAA的索引编号0,BBB的索引编号1,CCC的索引编号2

        //public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
        String s = list.get(0);
        System.out.println(s);//AAA

        //public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
        int size = list.size();
        System.out.println("集合元素数量: " + size);//3

        s = list.get(list.size() - 1);
        System.out.println(s);//CCC


        //public boolean isEmpty(): 判断集合是否为空
        System.out.println("集合是否为空: " + list.isEmpty());//false

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

        //list.add("BBB");
        //System.out.println(list);

        //删除BBB
        boolean result = list.remove("BBB");
        System.out.println("删除BBB是否成功?" + result);//true
        System.out.println(list);//[AAA, CCC]

        //通过索引删除CCC
        //public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
        String whoRemoved = list.remove(1);
        System.out.println("谁被删除了呢? " + whoRemoved);//CCC
        System.out.println("删除CCC后集合元素: " + list);//[AAA]


        //public E set(int index,E element) ：修改指定索引处的元素，返回被修改的元素。
        //把AAA --> A
        String whoUpdate = list.set(0, "A");
        System.out.println("谁被修改了呢? " + whoUpdate);//AAA
        System.out.println("修改AAA后集合的内容: " + list);//[A]


        //public void clear(): 清空集合元素
        list.clear();

        System.out.println("集合元素个数: "+list.size());//0
        System.out.println("集合是否为空: "+list.isEmpty());//true
    }
}

二、ArrayList类的练习

2.1 ArrayList集合存储基本数据类型

/*
    ArrayList集合容器中只能存储引用类型数据,不能存储基本类型数据
    如果非得向ArrayList集合中存储基本类型数据的话,在创建ArrayList集合对象时<>需要写基本类型对应的引用类型
    简单来讲: 每个基本类型都对应了一个类(包装类)

        基本类型                包装类
        byte                    Byte
        short                   Short
        int                     Integer
        long                    Long
        float                   Float
        double                  Double
        char                    Character
        boolean                 Boolean

    注意:
        ArrayList集合存储基本类型数据时,只需要在创建集合对象时<>中写基本类型对应的包装类
        其它操作(添加/获取数据)都可以按照基本类型完成
 */
public class Demo04ArrayListBase {
    public static void main(String[] args) {
        //创建ArrayList集合对象list,指定存储数据的类型是整数(byte/short/int/long)
        //错误的:<>中不能写基本类型
        //ArrayList<int> list = new ArrayList<int>();
        //ArrayList<long> list2 = new ArrayList<long>();

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

        //add方法添加数据
        list.add(new Integer(100));
        list.add(200);
        list.add(300);

        //遍历
        for (int i = 0; i < list.size(); i++) {
            int num = list.get(i);
            System.out.println(num);
        }
    }
}

2.2 ArrayList集合练习-存储学生对象并遍历

package itheima03;

import pojo.Student;

import java.util.ArrayList;
import java.util.Scanner;

/*
    需求:
        创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
        3个学生对象信息通过键盘录入

    实现步骤:
        1.创建标准的学生Student类(之前创建好了,在pojo包中)
        2.创建ArrayList集合对象list,存储数据类型Student
        3.创建键盘录入Scanner类的对象
        4.因为需要存储3个学生对象,使用for循环
        4.1 获取键盘录入的一个学生信息(姓名和年龄)
        4.2 把步骤4.1中获取的一个学生信息(姓名和年龄)封装成Student对象stu
        4.3 把步骤4.2中封装的Student对象stu添加到集合对象list中
        5.使用for循环遍历集合对象list
        5.1 获取当前Student对象student
        5.2 输出当前Student对象student的相关信息
 */
public class Demo05EachArrayList {
    public static void main(String[] args) {
        //2.创建ArrayList集合对象list,存储数据类型Student
        ArrayList<Student> list = new ArrayList<>();
        //3.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //4.因为需要存储3个学生对象,使用for循环
        for (int i = 1; i <= 3; i++) {
            //4.1 获取键盘录入的一个学生信息(姓名和年龄)
            System.out.println("请输入第"+i+"个学生的姓名: ");
            String name = sc.next();
            System.out.println("请输入第"+i+"个学生的年龄: ");
            int age = sc.nextInt();
            //4.2 把步骤4.1中获取的一个学生信息(姓名和年龄)封装成Student对象stu
            Student stu = new Student(name, age);
            //4.3 把步骤4.2中封装的Student对象stu添加到集合对象list中
            list.add(stu);
        }
        //5.使用for循环遍历集合对象list
        for (int i = 0; i < list.size(); i++) {
            //5.1 获取当前Student对象student
            Student student = list.get(i);
            //5.2 输出当前Student对象student的相关信息
            System.out.println("姓名: " + student.getName() + ", 年龄: " + student.getAge());
        }
    }
}

2.3 删除ArrayList集合存储的指定的字符串

package itheima01;

import java.util.ArrayList;

public class Demo08 {
    public static void main(String[] args) {
       /* 需求：
        创建一个存储String的集合，内部存储（test，张三，李四，test，test）字符串
        删除所有的test字符串，删除后，将集合剩余元素打印在控制台*/

        ArrayList<String> list = new ArrayList<>();
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if ("test".equals(s)) {
                /*
                    注意:
                        因为执行完毕remove方法,立刻执行i++,
                        remove方法删除当前元素后,后面的元素会前移,
                        如果有多个连续的元素需要被删除的话,可能会删不完整(有遗漏)
                    解决方案:
                        在执行i++之前,先执行i--
                 */
                list.remove(i--);
            }
        }
        System.out.println(list);
    }
}

三、 ArrayList集合作为方法参数和返回值【重点】

3.1 ArrayList集合作为方法参数

/*
    注意:
        1.引用变量保存的内存地址值
        2.ArrayList也是引用变量,保存的也是内存地址值
        3.当使用ArrayList作为方法参数/返回值类型的时候,传递/返回的都是内存地址值
 */
public class Demo01ArrayListParams {
    public static void main(String[] args) {
        //创建ArrayList集合对象list,存储数据的类型Person
        ArrayList<Person> list = new ArrayList<>();

        //向list中添加多个Person对象
        list.add(new Person("张三",18));
        list.add(new Person("李四",28));

        //调用printArrayList方法,完成遍历
        printArrayList(list);
    }

    //定义方法,完成存储Person对象的ArrayList集合对象的遍历
    public static void printArrayList(ArrayList<Person> list) {
        //使用for循环遍历
        for (int i = 0; i < list.size(); i++) {
            //获取当前元素
            Person p = list.get(i);
            p.show();
        }
    }
}

public class Person {
    //成员变量
    private String name;
    private int age;

    //定义方法,展示信息
    public void show() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }

   	//空参/满参构造方法
    //setter and getter方法
}

3.2 ArrayList集合作为方法参数调用图解

3.3 ArrayList集合作为方法返回值

/*
    ArrayList类型作为方法返回值
        注意: 首次定义Person类,只有一个String name属性
    
    ArrayList是引用类型,保存的是集合对象在内存空间的地址值
        使用ArrayList作为方法返回值,返回的是ArrayList集合对象的地址值
 */
/*
    ArrayList集合作为方法的返回值
        1.引用类型变量保存的是内存地址值
        2.ArrayList集合对象保存的是内存地址值
        3.ArrayList集合作为方法的返回值的话,返回的是内存地址值
 */
public class Demo02ArrayListReturn {
    public static void main(String[] args) {
        //调用getArrayList方法,获取存储多个Person对象的ArrayList集合对象
        ArrayList<Person> list = getArrayList();

        //遍历ArrayList集合对象list
        for (int i = 0; i < list.size(); i++) {
            //获取当前元素
            Person p = list.get(i);
            p.show();
        }
    }

    //定义方法,该方法返回存储多个Person对象的ArrayList集合对象
    public static ArrayList<Person> getArrayList() {
        //创建ArrayList集合对象
        ArrayList<Person> list = new ArrayList<>();

        //向list中添加多个Person对象
        list.add( new Person("张三",18) );
        list.add( new Person("李四",28) );

        //返回list集合对象
        return list;
    }
}

四、StringBuilder类

4.1 StringBuilder类的概述

使用String进行字符串的大量拼接时,产生大量垃圾,效率低
使用StringBuilder字符串的大量拼接时,产生垃圾少,效率高

4.2 StringBuilder类的构造方法

/*
    StringBuilder的构造方法
        public StringBuilder() ：
            构造一个空的StringBuilder容器,内部是默认长度为16的字符数组

        public StringBuilder(String str) ：
            构造一个StringBuilder容器，并将方法参数字符串str添加进去

    注意:
        打印引用类型变量,默认调用toString方法(帮助我们把数据转换成字符串的形式)
 */
public class Demo01StringBuilder {
    public static void main(String[] args) {
        // 构造一个空的StringBuilder容器,内部是默认长度为16的字符数组
        StringBuilder sb = new StringBuilder();
        System.out.println("---"+sb+"---");
        System.out.println(sb.toString());

        //构造一个StringBuilder容器，并将方法参数字符串str添加进去
        StringBuilder sb2 = new StringBuilder("HelloWorld");
        System.out.println(sb2);//HelloWorld
        System.out.println(sb2.toString());//HelloWorld

    }
}

4.3 StringBuilder类的成员方法（没有static修饰，必须使用StringBuilder类的对象调用）

/*
    StringBuilder常用的方法有3个：
        public StringBuilder append(...) ：
            添加任意类型数据的字符串形式，并返回当前对象自身。

        public StringBuilder reverse() ：
            返回反转的字符序列

        public String toString() ：
            将当前StringBuilder对象转换为String对象。
 */
public class Demo02StringBuilderMethod {
    public static void main(String[] args) {
        //创建StringBuilder类的对象
        StringBuilder sb = new StringBuilder();

        //append方法:把数据原样添加到StringBuilder容器中
        sb.append(97);
        sb.append('a');
        sb.append("hello");
        sb.append(true);

        System.out.println(sb);

        //reverse方法: 实现StringBuilder容器内部的内容进行反转的
        sb.reverse();

        System.out.println(sb);

        //toString方法: 把StringBuilder对象转换成String对象
        String s = sb.toString();
        System.out.println(s);
    }
}

4.4 链式编程

/*
    append方法/reverse方法,返回值类型都是StringBuilder类型,
    而且其实就是调用append方法/reverse方法的StringBuilder对象本身
    所以StringBuilder类支持链式编程的

 */
public class Demo03StringBuilderMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("A");
        StringBuilder sb2 = sb.append("B");
        StringBuilder sb3 = sb2.append("C");
        System.out.println(sb);//ABC
        System.out.println(sb2);//ABC
        System.out.println(sb3);//ABC
        /*
            ==的使用:
            1.基本类型: 比较的是具体的数据值是否相同
            2.引用类型: 比较的是地址值是否相同
            发现结果都是true:
                说明引用变量sb/sb2/sb3 保存的地址值相同,操作的是同一个对象
         */
        System.out.println(sb == sb2);//true
        System.out.println(sb == sb3);//true
        System.out.println(sb2 == sb3);//true

        //如果使用对象调用方法后,该方法返回本类对象的话,可以使用链式编程
        StringBuilder sb4 = new StringBuilder();

        sb4.append(100).append('a').append("hello").append("false");

        System.out.println(sb4);

    }
}

4.5 StringBuilder练习-字符串反转

/*
    需求:
        定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
    例如:
        键盘录入 abc，输出结果 cba

     三要素:
        1.方法名称:  reverseString
        2.参数列表:  String str
        3.返回值类型: String

    reverseString的实现步骤
        1.把方法参数String类型的str,转换成StringBuilder对象sb
        2.StringBuilder对象sb调用reverse方法,实现内部的内容的反转
        3.StringBuilder对象sb调用调用toString方法,转换成String对象newStr
        4.返回String对象newStr

    main方法的实现步骤:
        1.定义String变量ss,并初始化
        2.调用reverserString方法,传递字符串ss,获取反转后的结果字符串,保存到String变量result中
        3.打印result
 */
public class Demo06ReverseString {
    public static void main(String[] args) {
        //1.定义String变量ss,并初始化
        String ss = "abc";

        //2.调用reverserString方法,传递字符串ss,获取反转后的结果字符串,保存到String变量result中
        String result = reverserString(ss);

        //3.打印result
        System.out.println("反转前: "+ss);
        System.out.println("反转后: "+result);
    }

    //定义一个方法，实现字符串反转。
    public static String reverserString(String str) {
        //1.把方法参数String类型的str,转换成StringBuilder对象sb
        StringBuilder sb = new StringBuilder(str);

        //2.StringBuilder对象sb调用reverse方法,实现内部的内容的反转
        sb.reverse();

        //3.StringBuilder对象sb调用调用toString方法,转换成String对象newStr
        String newStr = sb.toString();

        //4.返回String对象newStr
        return newStr;
    }

    //定义一个方法，实现字符串反转。
    public static String reverserString2(String str) {
        //链式编程
        return new StringBuilder(str).reverse().toString();
    }
}