此资料是根据黑马程序员Java零基础视频教程提供的笔记进行修改而成，仅用于个人学习。

学习视频：https://www.bilibili.com/video/BV17F411T7Ao/?p=111&vd_source=a0fb36c5a191d7be68335738a8b342a2

1. ArrayList

1.1 集合相比数组的优势

长度可变。
添加数据的时候不需要考虑索引，自动扩容缩容，默认将数据添加到末尾。

1.2 ArrayList类概述

什么是集合

提供一种存储空间可变的存储模型，存储的数据容量可以发生改变。
ArrayList集合的特点

长度可以变化，只能存储引用数据类型。基本数据类型用包装类。

数组既可以存储基本数据类型，也可以存储引用数据类型。
泛型的使用

用于约束集合中存储元素的数据类型。

JDK7之前，前后<>中的泛型都要写出来。

JDK7之后，后面的泛型可以不写。

1.3 ArrayList类常用方法

1.3.1 构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

1.3.2 示例代码

import java.util.ArrayList;

public class ArrayListDemo1 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合的对象
        //泛型：限定集合中存储数据的类型
        //JDK7之前，前后<>中的泛型都要写出来
        ArrayList<String> list = new ArrayList<String>();

        //JDK7之后，后面的泛型可以不写
        //此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
        //这个类在底层做了一些处理，所以打印对象不是地址值，而是集合中存储数据内容
        //在展示的时候会拿[]把所有的数据进行包裹
        ArrayList<String> list1 = new ArrayList<>();
        //此时，没有数据内容，所以打印[]
        System.out.println(list1);   //[]

        //不能存储基本数据类型
        //ArrayList<int> int1 = new ArrayList<>();
        //要使用包装类
        ArrayList<Integer> integer = new ArrayList<>();
    }
}

1.3.3 成员方法

方法名	说明
public boolean add(要添加的元素)	将指定的元素追加到此集合的末尾
public boolean remove(要删除的元素)	删除指定元素,返回值表示是否删除成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素，防止索引越界
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数

1.3.4 示例代码

import java.util.ArrayList;
/*
    boolean add(E e)        添加

    boolean remove(E e)     删除
    E remove(int index)

    E set(int index,E e)    修改

    E get(int index)        查询
    int size()              获取长度

 */
public class ArrayListDemo2 {
    
    
    public static void main(String[] args) {
    
    

        //1.创建一个集合
        ArrayList<String> list = new ArrayList<>();


        //2.添加元素, 从源码可以看出添加后返回true
        System.out.println(list.add("aaa"));    //true
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println("此时的集合内容："+list);//此时的集合内容：[aaa, aaa, bbb, ccc]


        //3.删除元素，从源码可以看出删除成功后返回true，失败后返回false
        boolean result1 = list.remove("aaa");
        System.out.println("删除结果："+result1);  //删除结果：true
        System.out.println("此时的集合内容："+list);//此时的集合内容：[aaa, bbb, ccc]
        //没有ddd元素，删除失败
        boolean result2 = list.remove("ddd");
        System.out.println("删除结果："+result2);  //删除结果：false
        //根据指定索引删除，删除成功返回删除的内容
        String str = list.remove(2);
        System.out.println("删除的内容是："+str);  //删除的内容是：ccc
        System.out.println("此时的集合内容："+list);//此时的集合内容：[aaa, bbb]
        // 防止索引越界
        //String str2 = list.remove(9);   异常IndexOutOfBoundsException


        //4.修改元素
        System.out.println("修改之前的集合内容："+list);//修改之前的集合内容：[aaa, bbb]
        String result = list.set(1, "ddd");
        System.out.println("被修改的是："+result);//被修改的是：bbb
        System.out.println("修改之后的集合内容："+list);//修改之后的集合内容：[aaa, ddd]

        
        //5.查询指定元素
        String s = list.get(0);
        System.out.println("0索引元素是："+s);//0索引元素是：aaa

        
        //6.遍历集合
        for (int i = 0; i < list.size(); i++) {
    
    
            //i 索引
            //list.get(i) 元素
            String st = list.get(i);
            System.out.print(st+" ");//aaa ddd 
        }
    }
}

2. 包装类

2.1 分类

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

2.2 使用包装类原因

JAVA是一种面向对象语言，JAVA中的类把方法与数据连接在一起，构成了自包含式的处理单元，在JAVA中不能定义基本类型对象。为了能将基本类型视为对象进行处理，并能连接相关的方法，JAVA为每个基本类型都提供了包装类。这样便可以把这些基本类型转换为对象来处理，需要说明的是JAVA是可以直接处理基本类型的，但在有些情况下需要将其作为对象来处理，这时就需要将其转换为包装内。

jdk1.5之后，自动拆箱装箱，相关知识后续讲解~

3. ArrayList存储字符串并遍历

3.1 案例需求

定义一个集合，添加字符串，并进行遍历。

3.2 代码实现

import java.util.ArrayList;
/*	创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合*/
public class Test1 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();

        //2.添加元素
        list.add("点赞了吗？");
        list.add("收藏了吗？");
        list.add("投币了吗？");
        list.add("转发了吗？");

        //3.遍历
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
    
    
            if(i == list.size() - 1){
    
    
                System.out.print(list.get(i));
            }else{
    
    
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.println("]");
        //结果:[点赞了吗？, 收藏了吗？, 投币了吗？, 转发了吗？]

        //4.直接打印
        System.out.println(list);//[点赞了吗？, 收藏了吗？, 投币了吗？, 转发了吗？]
    }
}

4. ArrayList存储数字并遍历

4.1 案例需求

定义一个集合，添加数字，并进行遍历。

4.2 代码实现

import java.util.ArrayList;

public class Test2 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合,不能写 int
        ArrayList<Integer> list = new ArrayList<>();

        //2.添加元素
        //jdk5以后 int Integer 之间是可以互相转化的
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        //3.遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
    
    
            if(i == list.size() - 1){
    
    
                System.out.print(list.get(i));
            }else{
    
    
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.println("]");
        //结果：[1, 2, 3, 4, 5]

        //4.直接打印
        System.out.println(list);//[1, 2, 3, 4, 5]
    }
}

5. ArrayList存储字符并遍历

5.1 案例需求

定义一个集合，添加字符，并进行遍历。

5.2 代码实现

import java.util.ArrayList;

public class Test3 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合,不能写 char
        ArrayList<Character> list = new ArrayList<>();

        //2.添加元素
        //jdk5以后 int Integer 之间是可以互相转化的
        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');

        //3.遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
    
    
            if(i == list.size() - 1){
    
    
                System.out.print(list.get(i));
            }else{
    
    
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.println("]");
        //结果：[a, b, c, d]

        //4.直接打印
        System.out.println(list);//[a, b, c, d]
    }
}

6. ArrayList存储学生对象并遍历

6.1 案例需求

需求：定义一个集合，添加一些学生对象，并进行遍历。

学生类的属性为：姓名，年龄。

6.2 代码实现

/*JavaBean类*/
public class Student {
    
    
    //1.私有化成员变量
    //2.空参构造方法
    //3.带全部参数的构造方法
    //4.get/set方法

    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;
    }
}



/*测试类*/

import java.util.ArrayList;

public class Test4 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<Student> list = new ArrayList<>();

        //2.创建学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);

        //3.添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //4.遍历集合
        for (int i = 0; i < list.size(); i++) {
    
    
            //i 索引 list.get(i) 元素/学生对象
            //System.out.println(list.get(i));   这是打印的地址值
            
            Student stu = list.get(i);
            //使用get方法获取属性再打印
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

6.3 新增需求

要求：学生对象的数据来自键盘录入。

6.4 代码实现

package com.thk.test;

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

public class Test5 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<Student> list = new ArrayList<>();

        //长度为0
        //2.键盘录入学生的信息并添加到集合当中
        Scanner sc = new Scanner(System.in);

        //注意：写在外面就只有一个对象，后续只是将属性进行修改，最终添加到集合的地址都是一个！！！
        //Student s = new Student();

        //注意：这里循环条件不能是list.size(),因为一开始长度是0
        for (int i = 0; i < 3; i++) {
    
    
            //放在里面才能创建三个对象
            Student s = new Student();

            System.out.println("请输入学生的姓名");
            String name = sc.next();
            System.out.println("请输入学生的年龄");
            int age = sc.nextInt();

            //把name和age赋值给学生对象
            s.setName(name);
            s.setAge(age);

            //把学生对象添加到集合当中
            list.add(s);
        }
        //3.遍历
        for (int i = 0; i < list.size(); i++) {
    
    
            //i 索引 list.get(i) 元素/学生对象
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

6.5 注意点

刚开始集合的长度为零，不能作为循环判断的条件。
创建多个对象的语句必须写在循环里面，这样才能创建多个不同的对象，他们的地址值才不一样。如果将创建对象写在外面，那么其实就只创建了一个对象，最终只是对这个对象的属性值进行修改。添加到集合里面的还是同一个对象的地址值。

在这里插入图片描述

7. 添加用户对象并判断是否存在

7.1 案例需求

main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password
要求：定义一个方法，根据id查找对应的学生信息。

如果存在，返回ture

如果不存在，返回false

7.2 代码实现

/*JavaBean*/
package com.thk.test;

public class User {
    
    
    private String id;
    private String username;
    private String password;


    public User() {
    
    
    }

    public User(String id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }
}



/*测试类*/
import java.util.ArrayList;

/*需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的用户信息。
如果存在，返回true
如果不存在，返回false*/
public class Test6 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();

        //2.创建三个用户对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","12345678");
        User u3 = new User("heima003","wangwu","1234qwer");

        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4.调用方法查看id是否存在
        boolean flag = contains(list, "heima003");

        //5.打印结果
        System.out.println(flag);

    }

    //1.我要干嘛？   根据id查找用户
    //2.我干这件事需要什么才能完成？   list  id
    //3.调用处是否需要使用方法的结果？ 返回
    public static boolean contains(ArrayList<User> list, String id){
    
    
        for (int i = 0; i < list.size(); i++) {
    
    
            /*链式编程
            if(list.get(i).getId().equals(id)){
             return true;
            }*/

            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
    
    
                //如果找到了直接返回true
                return true;
            }
        }
        //当循环结束表示集合里面所有的元素都已经比较完毕，还没有一样的，那么返回false就可以了
        return false;
    }
}

7.3 新增需求

main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password
要求：定义一个方法，根据id查找对应的学生信息。

如果存在，返回索引

如果不存在，返回-1

7.4 代码实现

package com.thk.test;

import java.util.ArrayList;

/*需求：
1，main方法中定义一个集合，存入三个用户对象。
      用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的用户信息。
      如果存在，返回索引
      如果不存在，返回-1
*/
public class Test7 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();

        //2.创建三个用户对象
        User u1 = new User("heima001", "zhangsan", "123456");
        User u2 = new User("heima002", "lisi", "12345678");
        User u3 = new User("heima003", "wangwu", "1234qwer");

        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4.查找索引
        int index = getIndex(list, "heima002");

        //5.打印
        System.out.println("当前查找的索引："+index);
    }


    public static int getIndex(ArrayList<User> list, String id) {
    
    
        for (int i = 0; i < list.size(); i++) {
    
    
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
    
    
                return i;
            }
        }
        return -1;
    }
}

7.5 需求合并

package com.thk.test;

import java.util.ArrayList;

/*需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的用户信息。
如果存在，返回true
如果不存在，返回false*/
public class Test6 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();

        //2.创建三个用户对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","12345678");
        User u3 = new User("heima003","wangwu","1234qwer");

        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4.调用方法查看id是否存在
        boolean flag = contains(list, "heima003");

        //5.打印结果
        System.out.println(flag);

    }

    //1.我要干嘛？   根据id查找用户
    //2.我干这件事需要什么才能完成？   list  id
    //3.调用处是否需要使用方法的结果？ 返回
    public static boolean contains(ArrayList<User> list, String id){
    
    
        //合并需求Test6、Test7
        //如果返回的数大于0，说明存在，即返回true，反之不存在返回false
	    return getIndex(list,id) >= 0;
    }


    //存在返回索引、不存在返回-1
    public static int getIndex(ArrayList<User> list, String id) {
    
    
        for (int i = 0; i < list.size(); i++) {
    
    
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
    
    
                return i;
            }
        }

        return -1;
    }
}

8. 集合类型的方法返回

8.1 案例需求

定义Javabean类: Phone

Phone属性：品牌，价格。

main方法中定义一个集合，存入三个手机对象。

分别为︰小米，1000。苹果，8000。锤子2999。

定义一个方法，将价格低于3000的手机信息返回。

8.2 技巧

如果我们要返回多个数据，可以把这些数据先放到一个容器当中，再把容器返回。

8.3 代码实现

/*javaBean类*/

public class Phone {
    //Phone属性：品牌，价格。
    private String brand;
    private int price;

    public Phone() {
    }


    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}



/*测试类*/
package com.thk.test;

/*
需求：
        定义Javabean类：Phone
        Phone属性：品牌，价格。
        main方法中定义一个集合，存入三个手机对象。
        分别为：小米，1000。苹果，8000。锤子 2999。
        定义一个方法，将价格低于3000的手机信息返回。
*/

import java.util.ArrayList;

public class Test8 {
    public static void main(String[] args) {

        //1.创建集合对象
        ArrayList<Phone> list = new ArrayList<>();

        //2.创建手机的对象
        Phone p1 = new Phone("小米",1000);
        Phone p2 = new Phone("苹果",8000);
        Phone p3 = new Phone("锤子",2999);

        //3.添加数据
        list.add(p1);
        list.add(p2);
        list.add(p3);

        //4.调用方法
        ArrayList<Phone> phoneInfoList = getPhoneInfo(list);

        //5.遍历集合
        for (int i = 0; i < phoneInfoList.size(); i++) {
            Phone phone = phoneInfoList.get(i);
            System.out.println(phone.getBrand() + ", " + phone.getPrice());
        }

    }

    //技巧：
    //如果我们要返回多个数据，可以把这些数据先放到一个容器当中，再把容器返回
    //集合 数组
    public static ArrayList<Phone> getPhoneInfo(ArrayList<Phone> list){
        //定义一个集合用于存储价格低于3000的手机对象
        ArrayList<Phone> resultList = new ArrayList<>();
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            Phone p = list.get(i);
            int price = p.getPrice();
            //如果当前手机的价格低于3000，那么就把手机对象添加到resultList中
            if(price < 3000){
                resultList.add(p);
            }
        }
        //返回resultList
        return resultList;
    }
}

day10——ArrayList