概述
目录
一、List集合的增删改查
二、List集合的三种遍历方式
三、LinkedList实现堆栈和队列
四、增长因子的论证
五、List集合中的重复元素去重以及其底层原理
一、List集合的增删改查
首先我们来看看List集合的基础增删改查：
增加：
//标题
System.out.println("===list集合容器的增删改查===n");
//集合
ArrayList ls = new ArrayList<>();
//增加
ls.add("我");
ls.add("喜");
ls.add("欢");
ls.add("你");
循环遍历：
//循环遍历查询
System.out.println("❤❤❤❤循环遍历❤❤❤❤");
for (Object obj : ls) {
System.out.println(obj);
}
执行结果：
单个查询：
//根据下标查询
System.out.println("❤❤❤❤单个查询❤❤❤❤");
System.out.println(ls.get(1));
修改：
//修改
ls.set(0, "鸡婆");
System.out.println("❤❤❤❤修改后❤❤❤❤");
for (Object obj : ls) {
System.out.println(obj);
}
删除：
//根据下标删除
Object o = ls.remove(0);
//根据对象删除
ls.remove("鸡婆");
//打印测试
System.out.println("❤❤❤❤删除的元素❤❤❤❤");
System.out.println(o);
System.out.println("❤❤❤❤删除后的集合❤❤❤❤");
for (Object obj : ls) {
System.out.println(obj);
}
全部的执行结果：
案例1：剔除集合中的奇数
1.1 ：定义集合并遍历：
ArrayList<String> ls2 = new ArrayList<>();
ls2.add("1");
ls2.add("4");
ls2.add("5");
ls2.add("8");
ls2.add("9");
ls2.add("11");
System.out.println("❤❤❤❤剔除前的集合❤❤❤❤");
for (String string : ls2) {
System.out.println(string);
}
执行结果：
1.2 开始剔除：
ArrayList<String> ls3 = new ArrayList<>();
for (String obj2 : ls2) {
//判断
if(Integer.valueOf(obj2)%2==0) {
//如果除不断就把它加到新集合ls3中
ls3.add(obj2);
}
}
//打印测试
System.out.println("❤❤❤❤剔除后的集合❤❤❤❤");
for (String string : ls3) {
System.out.println(string);
}
执行结果：
注意点：做集合元素剔除时，不能在原集合遍历的时候进行操作。
二、List集合的三种遍历方式
我们首先创建一个集合：
//集合
ArrayList ls = new ArrayList<>();
//增加
ls.add("我");
ls.add("喜");
ls.add("欢");
ls.add("你");
方式一：foreach循环遍历
//foreach循环遍历
System.out.println("❤❤❤❤foreach循环遍历❤❤❤❤");
for (Object obj : ls) {
System.out.println(obj);
}方式二：for循环遍历
//for循环遍历
System.out.println("❤❤❤❤for循环遍历❤❤❤❤");
for (int i = 0; i < ls.size(); i++) {
System.out.println(ls.get(i));
}方式三：迭代器遍历
//迭代器遍历
System.out.println("❤❤❤❤迭代器遍历❤❤❤❤");
//迭代器
Iterator it = ls.iterator();
//System.out.println(it.hasNext());//判断是否有值
//System.out.println(it.next());//依次打印
while(it.hasNext()) {
//只要有值就打印
System.out.println(it.next());
}执行结果：
三、LinkedList实现堆栈和队列
首先创建两个类：
堆栈类：
//创建一个堆栈类
class DuiZhan{
private LinkedList ll;
public DuiZhan(LinkedList ll) {
super();
this.ll = ll;
}
//存值
public void add(Object obj) {
ll.add(obj);
}
//取值
public Object get() {
return ll.removeLast();
}
}
队列类：
//创建一个队列类
class DuiLie{
private LinkedList ll;
public DuiLie(LinkedList ll) {
super();
this.ll = ll;
}
//存值
public void add(Object obj) {
ll.add(obj);
}
//取值
public Object get() {
return ll.remove();
}
}
实例化堆栈和队列类并赋值 ：
//队列
DuiLie dl = new DuiLie(new LinkedList<>());
//存值
dl.add("你");
dl.add("喜");
dl.add("欢");
dl.add("她");
dl.add("嘛");//堆栈
DuiZhan dz = new DuiZhan(new LinkedList<>());
//存值
dz.add("你");
dz.add("喜");
dz.add("欢");
dz.add("她");
dz.add("嘛");
分别取值：
System.out.println("❤❤❤❤队列取值❤❤❤❤");
//取值
System.out.println(dl.get());
System.out.println(dl.get());
System.out.println(dl.get());
System.out.println(dl.get());
System.out.println(dl.get());//取值
System.out.println(dz.get());
System.out.println(dz.get());
System.out.println(dz.get());
System.out.println(dz.get());
System.out.println(dz.get());
执行结果：
结论：堆栈是先存后取，队列是先存先取。
四、增长因子的论证
首先，我们应该都知道list集合长度是可变的 数组长度是不可变的。
但其实List集合的数据结构就是数组，而在每一次数组容量不足的时候就会增加，类似扩容。
那么下面就让我们来论证一下这个说法：
我们直接利用循环来模拟一下：
ArrayList<Object> ls = new ArrayList<>();
for (int i = 0; i < 200; i++) {
ls.add(i);
//调用查看集合容量大小的方法
getlen(ls);
}
这里就直接放上查看集合容量大小的方法：
//测试集合容量大小的方法
private static void getlen(ArrayList<Object> ls) throws Exception {
Field f = ls.getClass().getDeclaredField("elementData");
f.setAccessible(true);
Object[] elementData = (Object[]) f.get(ls);
System.out.println("当前集合的元素个数："+ls.size()+"t当前集合的容量是："+elementData.length);
}
我们来看看执行结果就明白了：
我们可以清楚的发现每次超出容量的时候就增长了容器的容量，并且增长因子就是0.5。
但是当代码中出现了多次add操作，涉及到了list集合容量多次改变，这是十分耗性能的操作。
如何优化呢：此时通过设定初始化容量，即可优化性能。
ArrayList<Object> ls = new ArrayList<>(100);
for (int i = 0; i < 200; i++) {
ls.add(i);
//调用查看集合容量大小的方法
getlen(ls);
}
执行结果：
五、List集合中的重复元素去重以及其底层原理
首先我们还是来定义一个List集合：
//集合
ArrayList ls = new ArrayList<>();
//增加
ls.add("我");
ls.add("喜");
ls.add("欢");
ls.add("你");
ls.add("我");
我们先来看看最简单的一个基础去重：
ArrayList ls2 = new ArrayList<>();
for (Object object : ls) {
if(!ls2.contains(object)) {
//只要不包含的就加进去
ls2.add(object);
}
}
//打印测试
System.out.println(ls2);
执行结果：
但是一旦集合中是一个个对象那这种方法就不可用了：
//集合
ArrayList ls3 = new ArrayList<>();
//增加
ls3.add(new Ren("我",18));
ls3.add(new Ren("喜",3));
ls3.add(new Ren("欢",10));
ls3.add(new Ren("你",19));
ls3.add(new Ren("我",18));
System.out.println(ls3);
ArrayList ls4 = new ArrayList<>();
for (Object object : ls3) {
if(!ls4.contains(object)) {
//只要不包含的就加进去
ls4.add(object);
}
}
//打印测试
System.out.println(ls4);
执行结果：
我们可以发现并没有去重
解决办法：其实只需要重写实体类的equals方法就好了：
/**
* 重写equals方法
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Ren other = (Ren) 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;
}
再次执行：
结论： 去除引用对象时，底层调用的是对象的equals方法，如果要去重就重写equals方法。
好啦，今天都是关于List集合的一些底层原理以及方法，然后今天Leaf的学习笔记分享就到这里啦，后面还会有更多的学习笔记分享，欢迎一起来讨论学习噢~
最后
以上就是魁梧黑夜为你收集整理的List集合的全部内容，希望文章能够帮你解决List集合所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复