集合和数组的区别

　　共同点：都是存储数据的容器

　  不同点：数组的容量是固定的，集合的容量是可变的

ArrayList的构造方法和添加方法

　　在出现E的地方我们使用引用数据类型替换即可 , 在<E>中指定数据类型，集合就默认存储该类型的数据，不是该类型数据就会报错，

　　ArrayList 没加<E>,可以存储任意数据类型　　

　　ArrayList<E>： 可调整大小的数组实现 ；<E>是一种特殊的数据类型，泛型。

　　<> 泛型: 对集合容器存储的数据类型进行限制

　　举例：ArrayList<String>,  ：存储String类型的元素，ArrayList<Student>：存储Student类型的数据

　　ArrayList<String> array = new ArrayList<String>(); ：红字尖括号里面的部分可以不写【jdk7之后】；即ArrayList<String> array = new ArrayList<>();

ArrayList类常用方法

成员方法【E代表元素】

import java.util.ArrayList;

class Test {
    public static void main(String[] args) {
        //创建集合 ，创建一个String类型的集合，
        ArrayList<String> array = new ArrayList<String>();

        //添加元素 默认在末尾追加
        array.add("hello");
        array.add("world");
        array.add("java");

        //public boolean remove(Object o)：删除指定的元素，返回删除是否成功
       // System.out.println(array.remove("world")); 删除成功返回True
       // System.out.println(array.remove("javaee")); 没有这个元素，删除失败，返回False

        //public E remove(int index)：删除指定索引处的元素，返回被删除的元素
//        System.out.println(array.remove(1)); 返回删除该元素的值，该处返回world这个元素

        //IndexOutOfBoundsException  数组下标越界异常
//        System.out.println(array.remove(3));删除没有该下标的元素会造成   数组下标越界异常

        //public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
//        System.out.println(array.set(1,"javaee")); 

        //IndexOutOfBoundsException 数组下标越界异常
//        System.out.println(array.set(3,"javaee"));

        //public E get(int index)：返回指定索引处的元素
//        System.out.println(array.get(0));
//        System.out.println(array.get(1));
//        System.out.println(array.get(2));
        //System.out.println(array.get(3)); //IndexOutOfBoundsException数组下标越界异常//public int size()：返回集合中的元素的个数
        System.out.println(array.size());

        //输出集合
        System.out.println("array:" + array);
    }
}

ArrayList存储字符串并遍历

　　创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

/*
    思路：
        1:定义学生类
        2:创建集合对象
        3:创建学生对象
        4:添加学生对象到集合中
        5:遍历集合，采用通用遍历格式实现
 */

public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 33);
        Student s3 = new Student("麻子", 18);

        //添加学生对象到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //遍历集合，采用通用遍历格式实现
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge()); // 打印出student类的属性
        }
    }

    public class Student { // 一个student类
        private String name; // 私有类
        private int age;

        public Student() { // 空参构造构造方法
        }

        public Student(String name, int age) { // 有参构造方法
            this.name = name;
            this.age = age;
        }

        public String getName() { // 获取私有属性方法
            return name;
        }

        public void setName(String name) {  // 获取私有属性方法
            this.name = name;
        }

        public int getAge() {  // 获取私有属性方法
            return age;
        }

        public void setAge(int age) {   // 获取私有属性方法
            this.age = age;
        }
    }
}

键盘录入学生信息到集合

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

package array;

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

/*
    思路：
        1:定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
        2:创建集合对象
        3:键盘录入学生对象所需要的数据
        4:创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        5:往集合中添加学生对象
        6:遍历集合，采用通用遍历格式实现
 */
public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //为了提高代码的复用性，我们用方法来改进程序
        addStudent(array);
        addStudent(array);
        addStudent(array);

        //遍历集合，采用通用遍历格式实现
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i); // 此处获得的是该集合中元素的地址
            System.out.println(s.getName() + "," + s.getAge());
        }
    }

    /* 两个明确： 返回值类型：void
    参数：ArrayList<Student> array
    */
    public static void addStudent(ArrayList<Student> array) {
        //键盘录入学生对象所需要的数据，Scanner类
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄:");
        int age = sc.nextInt(); //创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age); //往集合中添加学生对象
        array.add(s);
    }

    static class Student {
        private String name;
        private int age;

        public Student() {
        }

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

关于remove()方法的细节问题

package com.heima.test;

import java.util.ArrayList;

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

        思路：
        1. 创建集合对象
        2. 调用add方法，添加字符串
        3. 遍历集合，取出每一个字符串元素
        4. 加入if判断，如果是test字符串，调用remove方法删除
        5. 打印集合元素

       // 注意: 根据元素进行删除, 只能删除集合中的第一个元素
        list.remove("test");
     */
    public static void main(String[] args) {
        // 1. 创建集合对象
        ArrayList<String> list = new ArrayList<>();
        // 2. 调用add方法，添加字符串
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");
        // 3. 遍历集合，取出每一个字符串元素
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            // 4. 加入if判断，如果是test字符串，调用remove方法删除
            //if(s.equals("test")){}这种方法不推荐，万一s是一个null，就会出现空指针异常，所以使用常量调用equeals避免产生空指针异常
            if("test".equals(s)){
                list.remove(i);
                i--; //每次删除目标元素之后，其余元素会上移将删除后的下标补齐，然后指针才下移到i+1的下标，判断元素
            }
        }
        System.out.println(list);
    }
}