[java] 集合-ArrayList篇

目录

数组和集合的区别

ArrayList

构造方法

成员方法

综合练习

指定格式遍历

添加学生对象并遍历

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

添加手机对象并返回要求的数据

---

数组和集合的区别

长度：

集合长度可变，可以自动扩容

数组长度固定

存储类型：

数组可以存基本数据类型和引用数据类型

集合存放引用数据类型，基本数据类型需要通过封装类存放，不能直接存放基本数据类型

ArrayList

构造方法

public static void main(String[] args){
//1.创建集合的对象
//泛型：限定集合中存储数据的类型
//JDK7以前
//ArrayList<String> list = new ArrayList<String>();
//JDK7:
ArrayList<String> list = new ArrayList<>();
//此时创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
//这个类在底层做了一些处理
//打印对象不是地址值，而是集合中存储数据内容
//在展示的时候会用[]把所有的数据进行包裏
System.out.printIn(list);//[]
}

成员方法

增删改查：

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 static void main(String[] args) (
//1.创建一个集合
ArrayList(String> list = new ArrayList<>();

//2.添加元素
list.add("aaa");//add函数返回值为boolean类型
list.add("aaa");//无论添加多少数据都返回true
list.add("bbb");
list.add("ccc");
System.out.println(list);//[aaa,aaa,bbb,ccc]

//3.删除元素
boolean result1 = list.remove( o: "aaa");//[aaa,bbb,ccc]
System.out.println(result1);//true
boolean result2 = list.remove( o: "ddd");//[aaa,bbb,ccc]
System.out.println(result2)；//false
System.out.println(list);//[aaa,bbb,ccc]

String str =list.remove(0);
System.out.println(str);//aaa-返回被删除的数据
System.out.println(list);//[bbb,ccc]


}

//示例：修改
public static void main(String[] args) (
//创建一个集合
ArrayList(String> list = new ArrayList<>();

//添加元素
list.add("aaa");//add函数返回值为boolean类型
list.add("aaa");//无论添加多少数据都返回true
list.add("bbb");
list.add("ccc");

//修改元素
String result=list.set(1,"ddd");
System.out.println(result);//aaa-返回被覆盖的元素
System.out.println(list);//[aaa,ddd,bbb,ccc]
}

//示例：查询
public static void main(String[] args) (
//创建一个集合
ArrayList(String> list = new ArrayList<>();

//添加元素
list.add("aaa");//add函数返回值为boolean类型
list.add("aaa");//无论添加多少数据都返回true
list.add("bbb");
list.add("ccc");

//修改元素
String s=list.get(0);
System.out.println(s);//aaa

System.out.println(list);//[aaa,aaa,bbb,ccc]
}

//示例：遍历
public static void main(String[] args) (
//创建一个集合
ArrayList(String> list = new ArrayList<>();

//添加元素
list.add("aaa");//add函数返回值为boolean类型
list.add("aaa");//无论添加多少数据都返回true
list.add("bbb");
list.add("ccc");

for(int i=0;i<list.size();i++){
//i索引
//list.get(i)元素
String str=list.get(i);
System.out.println(str);
//aaa
//aaa
//bbb
//ccc
}

综合练习

指定格式遍历

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

遍历格式参照：[元素1，元素2， 元素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("]");
}
}
//[星期一,星期二,星期三,星期四]

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

遍历格式参照：[元素1，元素2， 元素3]

public class Test2 {
public static void main(String[] args) {
//1.创建集合
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]

添加学生对象并遍历

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

**类的属性为：**姓名，年龄

创建student类

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

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

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

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

//4.遍历集合
for (int i = 0; i<list.size();i++) {
//i 索引 list.get(i) 元素/学生对象
Student stu = list.get(i);
System.out.println(stu.getName()+", "+ stu.getAge());
//因为这里的student类是自己定义的，不是系统定义的，所以不能直接打印对象stu
//需要使用student中的get方法进行打印
}
}
}

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

属性： 姓名，年龄。
要求：对象的数据来自键盘录入

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

for (int i= 0;i<list.size();i++){
System.out.printIn("看看我执行了吗?");//没有执行
//因为list.size()=0，所以没有进入这个for循环的执行语句
Student s= new Student();
list.add(s);
}
//集合里面是否有学生对象
//没有
System.out.println(list.size());//0
}
}

所以for循环的条件不能用list.size()：

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

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

for (int i= 0; i<3;i++){
Student s = new Student();
System.out.printIn("请输入学生的姓名");
String name = sc.next();
System.out.printIn("请输入学生的年龄"）;
int age = sc.nextInt();

//把name和age赋值给学生对象
s.setName(name);
s.setAge(age);
//把学生对象添加到集合当中
list.add(s);
}

System.out.printIn(list.size());//3

//4.遍历集合
for (int i = 0; i<list.size();i++) {
//i 索引 list.get(i) 元素/学生对象
Student stu = list.get(i);
System.out.println(stu.getName()+", "+ stu.getAge());
//遍历结果为三次输入的数据
}
}
}

//将创建对象放在for循环之外

Student s = new Student();

更改代码后：

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

//2.键盘录入学生的信息并添加到集合当中
Scanner sc = new Scanner(System.in);
//将创建对象放在for循环之外
Student s = new Student();

for (int i= 0; i<3;i++){
//Student s = new Student();
System.out.printIn("请输入学生的姓名");
String name = sc.next();
System.out.printIn("请输入学生的年龄"）;
int age = sc.nextInt();

//把name和age赋值给学生对象
s.setName(name);
s.setAge(age);
//把学生对象添加到集合当中
list.add(s);
}

System.out.printIn(list.size());//3

//4.遍历集合
for (int i = 0; i<list.size();i++) {
//i 索引 list.get(i) 元素/学生对象
Student stu = list.get(i);
System.out.println(stu.getName()+", "+ stu.getAge());
//遍历结果为三个相同的name和age
//值为最后一次输入的数据

}
}
}

集合中存放的是地址值

在更改代码后， 将创建对象操作放在for循环的外面，则这里只创建了一个student对象s，在集合中存放的是student对象s的地址值，这个集合进行了三次add操作，放的都是同一个对象s的地址值。即同一个地址值，指向同样的数据。

当键盘录入时，第二次键盘录入会覆盖第一次键盘录入的数据，第三次键盘录入会覆盖第二次键盘录入的数据，最终，s的地址值指向的数据为最后一次键盘录入的数据，而之前键盘录入的数据都被覆盖了，导致遍历集合得到三个相同的数据，即最入后一次键盘录的数据。

简单说就是在集合中放入了三个student对象，这三个对象其实为同一个对象，存放相同的地址值，指向相同的数据，即最后一次键盘录入的数据。

在更改代码前， 将会创建三次student对象，分别存放三次键盘录入的数据，集合中是这三个对象的地址值，最后遍历得到三次键盘录入的数据。

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

需求： main方法中定义一个集合，存入三个用户对象
用户属性： id, username, password
要求： 定义一个方法，根据id查找对应的用户信息

如果存在，返回true

如果不存在，返回false

创建用户类user

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

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

//2.创建三个用户对象
User u1 = new User( id: "001", username: "zhangsan", password: "123456");
User u2 = new User( id: "002", username: "Iisi", password: "12345678");
User u3 = new User( id: "003", username: "wangwu", password: "1234qwer");

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

//4.调用方法查看id是否存在
boolean flag = contains(list, id: "001");
//5.打印结果
System.out.println(flag);//true

public static boolean contains(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)){
//如果找到了直接返回true
return true;
}
}
//当循环结束表示集合里面的元素已经比较完毕
return false;
}
}

要求： main方法中定义一个集合，存入三个用户对象
用户属性： id, username, password
要求： 定义一个方法，根据id查找对应的用户信息

如果存在，返回索引

如果不存在，返回-1

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

//2.创建三个用户对象
User u1 = new User( id: "001", username: "zhangsan", password: "123456");
User u2 = new User( id: "002", username: "Iisi", password: "12345678");
User u3 = new User( id: "003", username: "wangwu", password: "1234qwer");

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

//4.查找索引
int index = getIndex(list, id: "001");
//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;
}
}

将代码合并，即返回true/false，也返回索引/-1

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

//2.创建三个用户对象
User u1 = new User( id: "001", username: "zhangsan", password: "123456");
User u2 = new User( id: "002", username: "Iisi", password: "12345678");
User u3 = new User( id: "003", username: "wangwu", password: "1234qwer");

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

//4.查找索引
int index = getIndex(list, id: "001");
//5.打印
System.out.println(index);
}
public static boolean contains(ArrayList<User> list, String id){
return getIndex(list,id)>=0;
}

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

添加手机对象并返回要求的数据

需求：

定义Javabean类：Phone
Phone属性： 品牌，价格

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

分别为：小米1000 苹果8000 锤子2999

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

创建phone类

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

public class Test8 {
public static void main(String[] args) {
//1.创建集合对象
ArrayList<Phone> list = new ArrayList<>();
//2.创建手机的对象
Phone p1 = new Phone( brand:"小米"，price:1000);
Phone p2 = new Phone( brand:"苹果"，price:8000);
Phone p3 = new Phone( brand:"每子"，price: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;
}
}
}