Java 集合框架（List篇）

1、List集合

当我们需要保存一组数据时，集合框架就是非常常用的工具之一。Java语言提供了许多不同类型的集合框架。其中最常用的是List集合框架。

List接口是Java集合框架中最基本的一种形式，它允许存储重复元素，并可以按照索引访问集合中的元素。List集合的实现类有ArrayList、LinkedList和Vector等。

ArrayList是基于动态数组实现的List集合。动态数组指的是在数组声明时无需给出数组大小，在运行时动态扩展。ArrayList支持常见的集合操作，如添加、获取、删除、清空和遍历等操作。由于ArrayList是基于动态数组实现的，所以随机访问元素的速度很快，但是插入和删除元素会导致数据移动，因此效率相对较低。

LinkedList是基于双向链表实现的List集合，它也支持常见的集合操作。由于LinkedList是基于链表实现的，所以插入和删除元素的效率很快，但是随机访问元素的效率相对较低。

Vector也是基于动态数组实现的List集合，但是它是线程安全的。Vector支持与ArrayList相同的操作，但是由于是线程安全的，所以在并发环境下效率相对较低。

总的来说，List集合框架是一个非常常用且重要的部分。选择不同的实现类可以根据需求来平衡不同的集合操作的效率。

1、list的特点

list集合有两个特点：

特点	描述	代码
有序	List集合数据存进去的顺序和取出来的顺序一致
不唯一	List集合数据允许添加重复数据

2、遍历方式

1、foreach

2、迭代器（Iterator ）

3、for循环

根据下标获取

3、删除

删除有三种方式：

1. 正向删除
2. 逆向删除
3. 迭代器删除

其实前两种方式都是差不多的，List集合删除推荐使用迭代器。

1、正向删除

2、逆向删除

3、迭代器删除

先移动下标，在删除元素。

4.增长因子论证

概念：初始化大小10、负载因子1.5、向下取整
公式：容器大小*1.5倍
例如：10*1.5=15、15*1.5=22、22*1.5=33 …

List集合优化目的在于利用合理的存储空间存下所有元素数据，不多不少，不造成空间浪费。

如果定义成一定的数，只要在这个数内都会是你定义的这个数，超过了才会增加。

5、ArrayList的数据结构

1、堆栈

堆栈的特点：先进后出

public class Demo {
    public static void main(String[] args) {
        LinkedList ll = new LinkedList();
        ll.add("lisi");
        ll.add("zs");
        ll.add("ww");
        DuiZhan duizhan= new DuiZhan(ll);
        System.out.println(duizhan.pop());
        System.out.println(duizhan.pop());
        System.out.println(duizhan.pop());
    }
}
class DuiZhan{
    LinkedList ll = null;
    public DuiZhan(LinkedList ll){
        this.ll = ll;
    }

    public void add(String a){
        ll.add(a);
    }

    public String pop(){
        return (String) ll.removeLast();
    }
}

2、队列

队列的特点：先进先出

public class Demo {
    public static void main(String[] args) {
        LinkedList ll = new LinkedList();
        ll.add("lisi");
        ll.add("zs");
        ll.add("ww");
        Duilie duilie = new Duilie(ll);
        System.out.println(duilie.pop());
        System.out.println(duilie.pop());
        System.out.println(duilie.pop());
    }
}
class Duilie{
    LinkedList ll = null;
    public Duilie(LinkedList ll){
        this.ll = ll;
    }

    public void add(String a){
        ll.add(a);
    }

    public String pop(){
        return (String) ll.remove();
    }
}

3、集合框架ArrayList中的重复元素去重及其底层原理（去重）

public class Demo5 {
    	public static void main2(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println("目前集合容器中的元素：" + list);
		if (!list.contains("b")) {
			list.add("b");
		}
		System.out.println("目前集合容器中的元素：" + list);
	}

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Student("zs", 16));
		list.add(new Student("ls", 17));
		list.add(new Student("ww", 18));
		System.out.println("目前集合容器中的元素：" + list);
		if (!list.contains(new Student("ls", 17))) {
			list.add(new Student("ls", 17));
		}
		System.out.println("目前集合容器中的元素：" + list);
		if (list.contains(new Student("ls", 17))) {
			list.remove(new Student("ls", 17));
		}
		System.out.println("目前集合容器中的元素：" + list);
	}
}

class Student {
	private String name;
	private int age;

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


	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		System.out.println("调用了equals方法。。。");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) 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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

ArrayList中可能有重复元素，用Stream API去重底层实现是将ArrayList转化为HashSet集合，重复元素会被自动去除。ArrayList底层是数组结构，在扩容时会创建新数组，重复元素虽然存在但无法被访问。

很简单的理解就是重写equals()方法

2、迭代器原理

3、泛型

JDK1.5以上才有。
1）以类型为参数的类叫做泛型
2）泛型的默认类型为Object
3）作用：提高程序的健壮性、简化代码

4、装拆箱

1、装箱

int a=10;
Integer b=new Integer(a);

装箱：值类型到引用类型

2、拆箱

Integer c=new Integer(10);
int d=c.intValue();

拆箱：引用类型到值类型

5、ArrayList、LinkedList和Vector的区别

1、ArrayList和LinkedList的区别

• 相同点

1、LinkedeList和ArrayList都实现了List接口。

2、ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。

• 不同点

1、ArrayList底层实现是数组，而LinkedList是双向链表。

2、ArrayList查询快（下标）、增删改慢、LinkedList是查询慢，但是在插入删除时效率比较高。

2、ArrayList和Vector的区别

• 相同点

1、ArrayList和Vector都是用数组实现的

2、默认初始化大小都是10

• 不同点

1、Vector多线程是安全的，而ArrayList不是。Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的。（ArrayList每次存储时会检查空间大小，不够时会扩充为原来的1.5倍，Vector会扩充为原来空间的2倍）

希望对你们有用！！！