目录

前言：

1. ArrayList数据结构

1.1 ArrayList的特点

1.2 ArrayList 的三种遍历方式

2. LinkedList数据结构

2.1 LinkedList的特点

3. 什么是堆栈与队列？

3.1 堆栈的特点：先进后出

3.2 队列的特点：先进先出

3.3 用LinkedList完成一个堆栈容器和队列容器

4. 增长因子论证

4.1 list集合存储过程

 4.2 list的扩容因子     

5. 集合框架ArrayList中的重复元素去重及其底层原理

5.1 字符串去重

5.2 对象去重

---

前言：

        学集合框架就是了解容器的数据结构（增删改查）

---

1. ArrayList数据结构

1.1 ArrayList的特点

首先ArrayList底层是一个数组，顾名（Array）思义。如数组的特点有序根据下标进行排序，元素可重复。

如图所示：数组可根据下标找到指定元素，并按加入顺序进行排序。

 实战论证：

public static void main(String[] args) {
		List list = new ArrayList();
		// 添加三个内容
		list.add("ikun");
		list.add("小黑子");
		list.add("针食泥鸭");
		System.out.println("目前集合容器中的元素：" + list);
		// 查找第二个内容
		System.out.println(list.get(1));
	}

    //打印结果：小黑子

 

1.2 ArrayList 的三种遍历方式

public static void main(String[] args) {
		List list = new ArrayList();
		// 添加三个内容
		list.add("ikun");
		list.add("小黑子");
		list.add("针食泥鸭");

		// 1.fori
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		// 2.foreach
		for (Object o : list) {
			System.out.println(o);
		}

		// 3.Iterator（迭代器）
		Iterator it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}

2. LinkedList数据结构

2.1 LinkedList的特点

如图所示：  LinkedList是一种链表

       该特点：根据节点依次往下查找元素，因此查询效率比ArrayList低。因为该集合是无序的，删除该集合中的某一元素并不会对其他元素造成变化，所以在新增和删除的时候比ArryList要快

3. 什么是堆栈与队列？

都是一种数据结构

3.1 堆栈的特点：先进后出

 如图所示：假如三个跳水运动员依次跳入池水（容器）里，而最后跳入水中的要比前面的人先出去（不要反驳我的例子，我也感觉有点怪诞😥）

3.2 队列的特点：先进先出

 如图所示：例如有一条隧道，一行人从里面走过，第一个进去的人肯定也是第一出去（排除一个是老人，残疾，后面的人不准跑）防止有杠精🙅

3.3 用LinkedList完成一个堆栈容器和队列容器

package com.ycxw;

import java.util.LinkedList;

/**
 * 用LinkedList完成一个堆栈容器和队列容器
 * 
 * @author justz
 *
 */
public class Text_02 {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("ikun");
		list.add("小黑子");
		list.add("姬霓太美");
		// 实例化堆栈对象
		dui z = new dui(list);
		// 调用弹栈方法打印输出
		System.out.println("堆栈容器：");
		System.out.println(z.pop());
		System.out.println(z.pop());
		System.out.println(z.pop());

		// 实例化队列对象
		lie l = new lie(list);
		System.out.println("队列容器：");
		System.out.println(l.duilie());
		System.out.println(l.duilie());
		System.out.println(l.duilie());
	}
}

// 定义一个堆栈对象
class dui {
	private LinkedList ll;

	public dui(LinkedList ll) {
		super();
		this.ll = ll;
	}

	// 定义一个弹栈方法pop
	// 当这个方法被调用时，后存进的内容要先输出，先存入的内容后输出
	public Object pop() {
		return ll.removeLast();
	}
}

// 定义一个队列对象
class lie {
	private LinkedList ll;

	public lie(LinkedList ll) {
		super();
		this.ll = ll;
	}

	// 当这个方法被调用时，先存进的内容要先输出，后存入的内容后输出
	public Object duilie() {
		return ll.remove();
	}

}

运行结果：

4. 增长因子论证

4.1 list集合存储过程

以ArrayList为例以数组方式进行存储，数组长度是不可变的，默认是10；

public class Text_03 {
	public static void main(String[] args) throws Exception {
		ArrayList list = new ArrayList(); //修改ArrayList(50) 默认长度就为50
		list.add("1");
		elementDataLength(list);
	}

	// 该方法是获取底层数组的长度
	private static void elementDataLength(ArrayList l) throws Exception {
		Field f = l.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] o = (Object[]) f.get(l);
		System.out.println("当前集合底层数组容量长度为：" + o.length);
	}
}

 4.2 list的扩容因子     

package com.ycxw;

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

public class Text_03 {
	public static void main(String[] args) throws Exception {
		ArrayList list = new ArrayList();
		for (int i = 0; i < 50; i++) {
			list.add(i);
			System.out.print("当前集合长度"+i+"\r");
			elementDataLength(list);
		}
	}

	// 该方法是获取底层数组的长度
	private static void elementDataLength(ArrayList l) throws Exception {
		Field f = l.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] o = (Object[]) f.get(l);
		System.out.println("当前集合底层数组容量长度为：" + o.length);
	}
}

运行结果：

 由此结论：

        当添加内容超过默认数组长度会自动扩容，增长因子为 ‘原容量的1.5倍 ，因此我们可对其进行调优，根据需求修改默认底层数组长度减少扩容次数，从而提高效率。

ArrayList list = new ArrayList(50);  可根据需求定义默认长度，超过该长度才进行扩容

5. 集合框架ArrayList中的重复元素去重及其底层原理

5.1 字符串去重

public class Text_04 {
	public static void main(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);

	}
}

5.2 对象去重

必须要重写equals方法，由此结论list底层对象去重原理就是：存储对象的euqlas方法返回值决定；

package com.ycxw;

import java.util.ArrayList;
import java.util.List;

public class Text_04 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new ikun("小黑子"));
		list.add(new ikun("真爱粉"));
		list.add(new ikun("纯路人"));
		list.add(new ikun("纯路人"));
		System.out.println("目前集合容器中的元素：" + list);

		// 新建一个集合保存遍历旧集合的内容
		List newlist = new ArrayList();
		for (Object object : list) {
			// 判断不包含相同就添加
			if (!newlist.contains(object)) {
				newlist.add(object);
			}
		}

		System.out.println("去重后集合容器中的元素：" + newlist);
	}
}

// 定义一个实体对象
class ikun {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public ikun(String name) {
		super();
		this.name = name;
	}

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

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ikun other = (ikun) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

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

}

本篇到这里结束啦，感谢观看！关注我持续更新哦🫰