小小初识java(38)-List集合[超详细]

探索技术前行者

于 2024-10-11 11:37:52 发布

阅读量185

点赞数 2

文章标签： java 开发语言 eclipse idea ide list 青少年编程

本文链接：https://blog.csdn.net/d1092794537/article/details/142849389

版权

ArrayList
- 特点：有序【添加顺序】不唯一
- 数据结构：数组

ArrayList0：包装类

由于ArrayList底层基于Object[]实现的，所以所有的引用数据类型都可以存储在集合里面，但是基本数据类型不可以，为了保证基本数据类型也可以存储在集合里面，所以引出包装类。

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

int x = 45;
Integer y = x;//自动打包封箱
Integer a = new Integer(88);
int b = a;//自动解包拆箱

包装类里面提供一个方法可以将字符串转换成对应的基本数据类型

//情况一
Integer x = 100;
Integer y = 100;
System.out.println(x == y);//true 因为Integer缓存是-128到127，所以x,y从缓存中取出

//情况二
Integer x = 200;
Integer y = 200;
System.out.println(x == y);//false

//情况三
Integer x = new Integer(100);
Integer y = new Integer(100);
System.out.println(x == y);//false

//情况四
Integer x = new Integer(200);
Integer y = new Integer(200);
System.out.println(x == y);//false

/**
	Integer自动的缓存：-128到127
*/

ArrayList1:基本用法及特点

创建对象

//如何创建ArrayList对象
//5.0之前 默认往集合里面装的都是Object类型的对象
ArrayList list = new ArrayList();
//jdk5.0开始 可以加泛型
ArrayList<Integer> list = new ArrayList<Integer>();
//jdk7.0开始 后面的泛型可以自动推断

添加元素

list.add(元素)；一次添加一个元素
Collections.addAll(集合,元素,元素..);一次添加多个元素

修改某个下标对应的元素
```
list.set(下标,元素)
```
得到某个元素
```
list.get(下标);
```
得到某个元素第一次/最后一次出现的出现的下标
注意：如果根据自定义引用数据类型(如：Student类对象)进行查找，此时需要重写equals()

int x = list.indexOf(元素);
int y = list.lastIndexOf(元素);

判断集合里面是否存在某个元素
```
boolean x = list.contains(元素)
```
判断集合是否为空
```
boolean x = list.isEmpty()
```
将集合转换成数组

//方式一
ArrayList<Integer> list = new ArrayList<>();
Object[] data = list.toArray();
System.out.println(Arrays.toString(data));
//方式二
ArrayList<Integer> list = new ArrayList<>();
目标数组 = list.toArray(目标数组);
Integer[] data = new Integer[list.size()];
data = list.toArray(data);
System.out.println(Arrays.toString(data));

集合遍历

for + 下标

for(int x = 0;x < list.size();x++){
	System.out.println(list.get(x));
}

foreach

for(Integer x : list){
	System.out.println(x);
}

迭代器

for(Iterator<String> car = list.iterator();car.hasNext();){
	String name = car.next();
	if(name.startsWith("A")){
		System.out.println(name);
	}
}

ArrayList2：如何删除元素

list.remove(int 下标)：指定下标删除
list.remove(Object 元素)：指定元素删除---->调用equals()

ArrayList<Teacher> list = new ArrayList<>();
Teacher t3 = new Teacher("老师a",34,5500.0);
Teacher t4 = new Teacher("老师a",33,5500.0);
Collections.addAll(list,t3);
list.remove(t4);
/**
	当list调用remove()根据元素进行删除时，会自动调用equals(),
	当equals()返回true时，则进行删除，否则，不删除。
	而equals()需要进行重写来确定删除的规则
*/
class Teacher{
	String name;
	int age;
	double salary;
	public Teacher(String name,int age,double salary){
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	@Override
	public String toString(){
		return name + age + "岁:" + salary;
	}
	@Override
	public boolean equals(Object obj){
	    if(obj == null || !(obj instanceof Teacher)) return false;
        if(obj == this) return false;
		return this.name.equals(((Teacher)obj).name) &&
			   this.salary == ((Teacher)obj).salary;
	}
}

list.clear()：清空集合
一个remove()只能删除一个元素

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"A","B","C","A","A");
list.remove("A");//一个remove方法只能删除一个对象
System.out.println(list); //BCAA

ArrayList3

list.remove(元素)能不能删除成功取决于equals()

/**
	ArrayList类里面remove(元素)的方法能不能删除成功取决于equals()
	底层拿着被删除的元素和集合里面的元素做equals()
*/

//情况一
ArrayList<String> list = new ArrayList<>();
String x = new String("OK");
String y = new String("OK");
list.add(x);
System.out.println(list.size());//1
list.remove(y);//指定元素
System.out.println(list.size());//0
System.out.println(x.equals(y));//true

//情况二
ArrayList<Integer> list = new ArrayList<>();
//Integer会自动缓存：-128  127
Integer a = Integer.valueOf(777);
Integer b = Integer.valueOf(777);
list.add(a);
System.out.println(list.size());//1
list.remove(b);//元素
System.out.println(list.size());//0
System.out.println(b.equals(a));//true

//情况三(未重写equals())
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("张三");
Student s2 = new Student("张三");
list.add(s1);
System.out.println(list.size());//1
list.remove(s2);
System.out.println(list.size());//1
System.out.println(s1.equals(s2));//false

//情况四(重写equals())
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("张三");
Student s2 = new Student("张三");
list.add(s1);
System.out.println(list.size());//1
list.remove(s2);
System.out.println(list.size());//0
System.out.println(s1.equals(s2));//true

@Override
public boolean equals(Object obj){
    if(obj == null || !(obj instanceof Student))return false;
    if(obj == this)return true;
    return this.name.equals(((Student)obj).name);
}

list.contains(元素)：能不能返回true取决于equals()

//情况一(未重写equals())
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("Tom",23);
Student s2 = new Student("Tom",18);
list.add(s1);
System.out.println(list.contains(s2)); //false

//情况二(重写equals())
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("Tom",23);
Student s2 = new Student("Tom",18);
list.add(s1);
System.out.println(list.contains(s2)); //true

@Override
public boolean equals(Object obj){	
    //根据姓名判断是否相等 true:表示list包含  false:表示list不包含
    if(obj == null || !(obj instanceof Student)) return false;
    if(obj == this) return false;
    return this.name.equals(((Student)obj).name);
}

ArrayList4

谁主张谁举证
要被删除的对象会主动调用它自己类的equals()和集合里面的每个元素作比较

public class TestArrayList4{
	public static void main(String[] args){
		ArrayList<Object> list = new ArrayList<>();
		Student stu = new Student("张三");
		Teacher tea = new Teacher("Tom");
		list.add(stu);
        
		list.remove(stu);
		System.out.println(list.size());  //------------------1
        /*
        	因为list.remove(stu)删除的是Student类型，所以调用Student的equals()进行比较
        	又因为Student中重写的equals()不管什么对象比较都返回false,
        	则相比较对象不同，不能删除，list.size()为1
        */
        
        list.remove(tea);
		System.out.println(list.size());
        /*
        	因为list.remove(tea)删除的是Teacher类型，所以调用Teacher的equals()进行比较
        	又因为Teacher中重写的equals()不管什么对象比较都返回true,
        	则相比较对象相同，能删除，list.size()为0
        */
	}
}
class Student{
	String name;
	public Student(String name){
		this.name = name;
	}
	@Override
	public boolean equals(Object obj){
        //不管什么对象相比较，所有对象都认为不同，即所有对象比较都false,代表不同
		return false;
	}
}

class Teacher{
	String name;
	public Teacher(String name){
		this.name = name;
	}
	@Override
	public boolean equals(Object obj){
        //不管什么对象相比较，所有对象都认为相同，即所有对象比较都true,代表相同
		return true;
	}
}

ArrayList5：当我们使用迭代器在遍历集合的时候，不允许对集合的整体进行添加/删除，否则触发ConcurrentModificationException=CME异常；如果需求要求，一定要，一边遍历一边删除的话：迭代器的删除
- 迭代器对象.remove(): 迭代器删除当前的元素
- ```
删除3种方式：
	集合对象.remove(下标) 不需要调用equals()进行判断
	集合对象.remove(元素) 进行该方法时需要调用equals()进行判断
	迭代器对象.remove() 不需要调用equals()进行判断
```
ArrayList6：构造方法
- ArrayList list = new ArrayList(int 容量);//数组空间大小
- ArrayList list = new ArrayList();//默认10块
- ArrayList list = new ArrayList(单值集合);//将该集合元素装进list集合里面
- 扩容：list.ensureCapacity(int 容量) ;
  - 若创建ArrayList对象时没有设置空间大小，而在知道ArrayList所装的容量大小时，可以采用ensureCapacity方法进行扩容
- 缩容：list.trimToSize();
  - 若创建ArrayList对象时设置了空间大小，如20000，但是实际只存放了12000，则可以调整空间大小(调整为list包含元素的个数)