本文介绍了List集合的特点，包括增删改查操作、有序性和数据可重复性，并通过示例展示了foreach、for循环和iterator三种遍历方式。还对比了ArrayList和LinkedList的数据结构，讨论了增长因子在ArrayList中的作用，以及如何利用equals方法实现对象去重。最后，文章提到集合比数组更具灵活性，适合动态扩展容量的需求。
目录
为什么要学习集合呢？
数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求
一.集合体系结构
二.list集合的特点
a.增删改查
b.有序
c.数据可重复
package com.ctb.list;
import java.util.ArrayList;
import java.util.List;
/**
* list集合的特点
* 1.增删改查
* 2.有序
* 3.数据可重复
* @author biao
*
*/
public class Demo1 {
public static void main(String[] args) {
List list = new ArrayList<>();
// 增加
list.add("a");
list.add("b");
list.add("c");
// 删除
list.remove("b");
// 修改
list.set(0, "d");
// 查询
System.out.println(list);list.add("a");list.add("a");
}
}
三.三种遍历方式
a.foreach遍历
b.for循环遍历
c.iterator迭代器遍历
package com.ctb.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* list集合遍历的三种方式
* 1.foreach遍历
* 2.for循环遍历
* 3.iterator迭代器遍历
* @author biao
*
*/
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList<>();
// 增加
list.add("a");
list.add("b");
list.add("c");
//1.foreach遍历
for (Object object : list) {
System.out.println(object);
}
//2.for循环遍历
for (int i = 0; i <list.size(); i++) {
System.out.println(list.get(i));
}
//3.iterator迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
Object object = (Object) it.next();
System.out.println(object);
}
}
}
四.Linkedlist与Arraylist
linkedlist对比arraylist的数据结构
linkedlist:查询修改慢，增加删除快
arraylist：查询修改快，增加删除慢
压栈操作(就是在栈中存入内容)
//先规定栈的最大容量
Object[] objs;
//获取当前栈容量
int size;
public void SQ(int MaxLen) {
this.objs = new Object[MaxLen];
}
//进行压栈操作(就是在栈中存入内容)
public void push(Object x) {
//先给当前指针位置赋值,然后指针变大
System.out.println("压栈操作,压入内容为" + (objs[size++] = x));
}
弹栈操作(获取栈顶数据,然后弹出栈中,栈容量减少)
//先规定栈的最大容量
Object[] objs;
//获取当前栈容量
int size;
public void SQ(int MaxLen) {
this.objs = new Object[MaxLen];
}
//弹栈操作
public void popu() {
//获取栈顶数据,然后弹出栈中,栈容量减少
System.out.println("弹出栈顶内容:" + objs[size - 1]);
size--;
}linkedlist完成堆栈容器
removeLast()：删除并返回此列表中的最后一个元素。
removeFirst()：从此列表中删除并返回第一个元素。
package com.ctb.list;
import java.util.LinkedList;
/**
* linkedlist完成堆栈容器
*
* @author biao
*
*/
public class Demo3 {
public static void main(String[] args) {
// LinkedList的特点：查询修改慢，增加删除快
LinkedList list = new LinkedList<>();
// 增加数据到集合中
list.add("a");
list.add("b");
list.add("c");
list.add("d");
DuiZhan dz = new DuiZhan(list);
// 调用下面xjhc的方法，后存进去的元素要先输出，先存进去的后输出，
// 就像桶装羽毛球，先放进去的后拿出来
System.out.println(dz.xjhc());
System.out.println(dz.xjhc());
System.out.println(dz.xjhc());
// System.out.println(dz.xjhc());
System.out.println(list);
}
}
class DuiZhan {
private LinkedList list;
public DuiZhan(LinkedList list) {
super();
this.list = list;
}
// 压栈操作(就是在栈中存入内容)
// 弹栈操作(获取栈顶数据,然后弹出栈中,栈容量减少)
public Object xjhc() {
return list.removeLast();
}
}输出结果：
五.增长因子--list调优
ArrayList的扩容因子是1.5 ，增长因子为0.5
ArrayList 的容量为 10 ，一次扩容后是容量为 15
了解数组长度不可变，集合长度可变的原因
package com.ctb.list;
import java.lang.reflect.Field;
import java.util.ArrayList;
/**
* list调优--增长因子
* 1+0.5增长因子为0.5，扩容因子为1.5
*
* 了解数组长度不可变，集合长度可变的原因
*
* @author biao
*
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
// ArrayList的特点：查询修改快，增加删除慢
ArrayList list = new ArrayList<>(20);
for (int i = 0; i <= 100; i++) {
list.add(i);
System.out.println("打印前" + list + "\r");
getArrLength(list);
}
getArrLength(list);
}
// arraylist对象底层数组的长度
private static void getArrLength(ArrayList list) throws Exception {
Field f = list.getClass().getDeclaredField("elementData");
f.setAccessible(true);
System.out.println("elementData的长度是:" + ((Object[]) f.get(list)).length);
}
}
输出结果：
六.集合框架list去重以及底层原理
a.元素去重
package com.ctb.list;
import java.util.ArrayList;
import java.util.List;
/**
* list底层对象去重原理
*
* @author biao
*
*/
public class Demo5 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("f");
list.add("c");
System.out.println("去重前："+list);
if (!list.contains("b")) {
list.add("d");
}
System.out.println("去重后："+list);
}
}b.对象去重
在集合中对象去除重复要注意，一定要重写equals方法，否则无效
package com.ctb.list;
import java.util.ArrayList;
import java.util.List;
/**
* list底层对象去重原理
*
* @author biao
*
*/
public class Demo5 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Cat(1, "小翔子"));
list.add(new Cat(2, "小例子"));
list.add(new Cat(3, "小狗子"));
System.out.println("去重前："+list);
if (!list.contains(new Cat(3, "小狗子"))) {
list.add(new Cat(3, "小狗子"));
}
System.out.println("去重后："+list);
}
}
class Cat{
private int cid;
private String cname;
public Cat() {
// TODO Auto-generated constructor stub
}
public int getCid() {
return cid;
}
public void setCid(int cid) {
this.cid = cid;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "Cat [cid=" + cid + ", cname=" + cname + "]";
}
public Cat(int cid, String cname) {
super();
this.cid = cid;
this.cname = cname;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Cat other = (Cat) obj;
if (cid != other.cid)
return false;
if (cname == null) {
if (other.cname != null)
return false;
} else if (!cname.equals(other.cname))
return false;
return true;
}
}
set集合与map集合敬请下回讲解哦😉
希望大家能点点爱心与收藏哦💕💕💕
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
