集合框架知识总汇之（list集合）

目录

、​编辑

1.UML 统一建模语 ：

3.List集合：

3.1特点：

3.2遍历方式：

3.3List优化 ( 初始容量10,负载因子1.5 )

        3.4LinkedList(队列&堆栈)

3.5如何对Arraylist进行去重处理？

---

、

面试常问题：1.Collection是List，Set，Map的父类吗？Collection是List，Set的父类，但不是Map                        集合的父类。

                      2.集合是什么？集合同常被理解为一个容器。学习集合框架就是了解容器的数据结构（增删改查）

                      3.ArrayList集合 与 LinkedList 区别 ？

                        ArrayList特点：查看修改快，新增删除慢。

                        LinkedList特点：查看修改慢，新增删除快。

1.UML 统一建模语 ：

        1.1.分类：类图（以上图为类图），

        1.2.用例图（具体划分到每个职责，这在做项目时会经常用到）；

2.子类继承父类的所有属性和方法同时可以增加自己的属性和方法。

3.List集合：

3.1特点：

        A.有序

        B.对象可以重复

3.2遍历方式：

        a.foreach

        b.fori

        c.Iterator（迭代器）

public static void main(String[] args) {
        ArrayList list=new ArrayList<>();
//      增加
        list.add("张三a");
        list.add("张三b");
        list.add("张三b");
        list.add("张三c");
        list.add("张三d");
​
//      修改
        list.set(0, "老六");
        for (Object object : list) {
        System.out.println(object);
        }
        System.out.println("--------------");
    
//      删除
        Object obj2 = list.remove(0);
        for (Object object : list) {
        System.out.println(object);
        }
         System.out.println("--------------");
    
//      查询(三种方式)
//      ①
        for (Object object : list) {
            System.out.println(object);
        }
        System.out.println("--------------");
//      ②
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("--------------");
    //调用list中iterator方法
        Iterator itt =  list.iterator();
        while(itt.hasNext()) {
            System.out.println(itt.next());
        }
    
    }

3.3List优化 ( 初始容量10,负载因子1.5 )

     作为数组而言：下标不能超越定义的范围，而集合长度却是没有范围限制的。 由于list集合底层是数组，当我们每次添加到list集合中就会改变集合的容量。所以我们把list初始容量调高就会提升运行的效率。

import java.lang.reflect.Field;
import java.util.ArrayList;

public class myproject {

	public static void main(String[] args) throws Exception {
		ArrayList<Object> list=new ArrayList<>(50);
		for (int i = 0; i < 100; i++) {
			list.add(i);
			huoqu(list);
		}
	}
	private static void huoqu(ArrayList<Object> list) throws Exception{
		Field f= list.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] elementData=(Object[])f.get(list);
		System.out.println("当前集合的元素个数："+list.size()+";当前list集合的容量是："+elementData.length);
	}
}

 我们先给定arraylist初始容量为50，当添加的值大于50时容量添加至75，所以推出arraylist的增长因子是1.5

3.4LinkedList(队列&堆栈)

        ①队列&堆栈区别：队列：先进先出

                                       堆栈：先进后出

我们可以把堆栈想象成给P90装子弹，先装的就会后打出去。而队列则相反。

3.5如何对Arraylist进行去重处理？

1.一般我们会用从if+contains来去重。但我们测试：

//Person对象类
class Person{
	private String name;
	private int 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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	
}

import java.util.ArrayList;

public class demo2 {
	public static void main(String[] args) {
		ArrayList list = new ArrayList<>();
		// 新增
		list.add(new Person("aa", 1));
		list.add(new Person("bb", 2));
		list.add(new Person("cc", 3));
		list.add(new Person("dd", 4));
		System.out.println(list);
		// 这里我们得到的是4个：[Person [name=aa, age=1], Person [name=bb, age=2], Person
		// [name=cc, age=3], Person [name=dd, age=4]]

		ArrayList listnew = new ArrayList<>();
		for (Object object : list) {
			if (!listnew.contains(object)) {
				listnew.add(object);
			}
		}
		System.out.println(listnew);
		// 这里我们得到的还是4个：[Person [name=aa, age=1], Person [name=bb, age=2], Person
		// [name=cc, age=3], Person [name=dd, age=4]]

	}

}

所以这里使用contain方法行不通！！！

这里我们可以用重新equals方法。

//Person对象类
class Person{
	private String name;
	private int 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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("调用了此方法");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

此时在运行就达到去重效果了。

为啥重写equles就能够去重？因为equals中将新建的对象的属性都进行了判断当属性一直的时候，就会去重