List集合详解

孤留光乩

已于 2023-08-22 10:32:25 修改

阅读量880

点赞数 8

分类专栏： Java EE 文章标签： list java 数据结构

于 2023-06-13 22:49:49 首次发布

本文链接：https://blog.csdn.net/weixin_74268571/article/details/131197453

版权

Java EE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

四.Linkedlist与Arraylist

linkedlist对比arraylist的数据结构

压栈操作(就是在栈中存入内容)

弹栈操作(获取栈顶数据,然后弹出栈中,栈容量减少)

linkedlist完成堆栈容器

五.增长因子--list调优

ArrayList的扩容因子是1.5 ，增长因子为0.5

为什么要学习集合呢？

数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了

集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求

一.集合体系结构

二.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集合敬请下回讲解哦😉

希望大家能点点爱心与收藏哦💕💕💕