list集合框架

 

目录

​​​​​1.了解list集合的特点

2.通过Linkedlist实现堆栈以及队列的容器

3.增长因子论证

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

5.list集合如何进行优化

------------------------------------------------------------------------------------------------------------------------

​​​​​1.了解list集合的特点

就是集合框架的数据结构（增删改查）

package com.zbb.list;

import java.util.ArrayList;
/**
 * 对list集合容器的增删改查
 * 注意：做集合元素剔除，不能够在原集合遍历的时候进行操作
 * @author zjjt
 *
 */
public class Demo1 {
	public static void main(String[] args) {
		 ArrayList list = new ArrayList<>();
//	    新增
	    list.add("zs");
	    list.add("ls");
	    list.add("ww");
	    list.add("zl");
//	    查询
	    System.out.println(list.get(1));
	    for (Object obj : list) {
	      System.out.println(obj);
	    }
//	    修改
	    list.set(1, "老六");
	    System.out.println("------------------------------------");
	    for (Object obj : list) {
	      System.out.println(obj);
	    }
//	    删除
	    Object obj2 = list.remove(1);//返回值是删除的元素
	    list.remove("ww");
	    System.out.println(obj2);
	    System.out.println("--------------------------------------");
	    for (Object obj : list) {
	      System.out.println(obj);
	    }
	}
			
}

控制台输出如下：

 list三种遍历形式

package com.zbb.list;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * list三种遍历形式
 * @author Administrator
 *
 */
public class Demo2 {
	public static void main(String[] args) {
		ArrayList list=new ArrayList<>();
		//新增
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("麻子");
		//增强for循环
		for (Object obj : list) {
			System.out.println(obj);
		}
		
		System.out.println("-------------------");
		
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("---------迭代器--------");
		Iterator it = list.iterator();
		//System.out.println(it.hasNext());//判断集合中是否有下一个
		//System.out.println(it.next());//直接进入下一个
		while(it.hasNext()) {//指针概念
			System.out.println(it.next());
		}
	}
}

2.通过Linkedlist实现堆栈以及队列的容器

源码如下

package com.zbb.list;
 
import java.util.LinkedList;
 
/**
 * 通过Linkedlist实现队列以及堆栈的容器
 * @author zjjt
 *
 *堆栈：特点：先进后出
 *队列：特点：先进先出
 */
public class Dome3 {
	public static void main(String[] args) {
		//Duilie duilie = new Duilie(new LinkedList<>());//队列
		Duizhan duilie = new Duizhan(new LinkedList<>());//堆栈
		duilie.push("qq");
		duilie.push("ww");
		duilie.push("ee");
		duilie.push("rr");
		System.out.println(duilie.pop());
		System.out.println(duilie.pop());
		System.out.println(duilie.pop());
		System.out.println(duilie.pop());
	}
}
class Duilie{
	
	private LinkedList ll;
	
	public Duilie(LinkedList ll) {
		super();
		this.ll = ll;
	}
	//存
	public void push(Object obj) {
		ll.add(obj);
	}
	//取
	public Object pop() {
		return ll.remove();
	}
	
}
 
class Duizhan{
	
	private LinkedList ll;
	
	public Duizhan(LinkedList ll) {
		super();
		this.ll = ll;
	}
	//存
	public void push(Object obj) {
		ll.add(obj);
	}
	//取
	public Object pop() {
		return ll.removeLast();
	}
	
}

堆栈：将LinkedList进行封装，实现堆栈新进后出的功能

package com.zbb.list;

import java.util.LinkedList;

/**
 * 通过linkedlist实现队列以及堆栈的容器
 * @author zjjt
 *
 */
public class Demo3 {
	public static void main(String[] args) {
		Duizhan dl = new Duizhan(new LinkedList<>());
		dl.push("zs");
		dl.push("ls");
		dl.push("ww");
		dl.push("ll");
		System.out.println(dl.pop());
		System.out.println(dl.pop());
		System.out.println(dl.pop());
		System.out.println(dl.pop());
	}
}

class Duizhan{
	private LinkedList ll;

	public Duizhan(LinkedList ll) {
		super();
		this.ll = ll;
	}
	
	//存
	public void push(Object obj) {
		ll.add(obj);
	}
	
	//取
	public Object pop() {
		return ll.removeLast();
	}
}

队列：将LinkedList进行封装，实现队列先进先出的功能特点 

package com.zbb.list;

import java.util.LinkedList;

/**
 * 通过linkedlist实现队列以及堆栈的容器
 * @author zjjt
 *
 */
public class Demo3 {
	public static void main(String[] args) {
		Duilie dl = new Duilie(new LinkedList<>());
		dl.push("zs");
		dl.push("ls");
		dl.push("ww");
		dl.push("ll");
		System.out.println(dl.pop());
		System.out.println(dl.pop());
		System.out.println(dl.pop());
		System.out.println(dl.pop());
	}
}
class Duilie{
	private LinkedList ll;

	public Duilie(LinkedList ll) {
		super();
		this.ll = ll;
	}
	
	//存
	public void push(Object obj) {
		ll.add(obj);
	}
	
	//取
	public Object pop() {
		return ll.remove();
	}
}

 

3.增长因子论证

package com.zbb.list;
import java.lang.reflect.Field;
import java.util.ArrayList;

/**
 * list集合如何进行优化
 * 	当代码中出现了多次add操作，涉及到了list集合容量多次改变，这是十分耗性能的操作，此时通过
 * 设定初始化容量，即可优化性能
 * 
 * list集合长度是可变的，数组长度是不可变的；
 * 结论1：list集合底层的数据结构是数组
 * 结论2：增长因子 0.5，初始容量 10
 */
public class Demo4 {
	public static void main(String[] args) throws Exception {
//		String[] arr = new String[10];
//		arr = new String[11];
//		arr[11] = "zs";
//		arr = new String[12];
//		arr[12] = "zs";
		ArrayList<Object> list = new ArrayList<>(100);
		for (int i = 0; i < 200; i++) {
			list.add(i);
			getlen(list);
		}
	}

	private static void getlen(ArrayList<Object> list) throws Exception {
		Field f = list.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] elementData = (Object[]) f.get(list);
		System.out.println("当前集合的元素个数："+list.size()+"；当前list集合的容量是："+elementData.length);
	}
}

运行结果如下 

 

剔除

案例：

 1,4,6,8,9,11,3 剔除集合中的奇数    ConcurrentModificationException

不能删除元素

企业中,调用第三方接口 ，要针对一些数据做过滤

结论：做集合元素剔除，不能够在原集合遍历的时候进行操作

代码如下：

package com.zbb.list;
 
import java.util.ArrayList;
 
/**
 * 对list集合容器得增删改查
 * 注意：做集合元素剔除，不能够在原集合遍历的时候进行操作
 * @author zjjt
 */
public class Dome1 {
 
	public static void main(String[] args) {
		ArrayList list = new ArrayList<>();
		//新增
		list.add("qq");
		list.add("ww");
		list.add("ee");
		list.add("rr");
		//查询
		//System.out.println(list.get(1));
		
		for (Object obj : list) {
			System.out.println(obj);
		}
		
		//修改
		list.set(1, "rr");
		System.out.println("!!!!!!!!!!!!!!!!!!!!!!");
		for (Object obj : list) {
			System.out.println(obj);
		}
		
		//删除
		//Object obj2 = list.remove(1);//返回是删除的元素
		list.remove("ee");
		//System.out.println(obj2);
		System.out.println("!!!!!!!!!!!!!!!!!!!!!!");
		for (Object obj : list) {
			System.out.println(obj);
		}
	
//		
//	     1,4,6,8,9,11,3 剔除集合中的奇数   ConcurrentModificationException
//									不能删除元素
//		企业中,调用第三方接口 ，要针对一些数据做过滤
//		结论：做集合元素剔除，不能够在原集合遍历的时候进行操作
		ArrayList<String> list2 = new ArrayList<>();
		ArrayList<Integer> list3 = new ArrayList<>();
 
		list2.add("1");
		list2.add("4");
		list2.add("6");
		list2.add("8");
		list2.add("9");
		list2.add("12");
		list2.add("11");
		for (String obj : list2) {
			if(Integer.valueOf(obj)%2==1) {
				list2.remove(obj);
			}
			
		}
	
		
	
	}
	
 
	
}

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

package com.zbb.list;

import java.util.ArrayList;

/**
 * list集合去重底层原理
 * 结论：去重引用对象时，底层调用的是对象的equals方法
 * @author zjjt
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		ArrayList list = new ArrayList<>();
		
		//新增
		list.add("zs");
		list.add("ls");
		list.add("ww");
		System.out.println(list);
		
		ArrayList listnew = new ArrayList<>();
		for (Object object : listnew) {
			if(!list.contains(object)) {
				list.add(object);
			}
		}
		System.out.println(listnew);
		
	}
	public static void main2(String[] args) {
		ArrayList list = new ArrayList<>();
		
		//新增
		list.add(new Person("zs", 12));
		list.add(new Person("ls", 12));
		list.add(new Person("ww", 12));
		list.add(new Person("ww", 12));
		System.out.println(list);//4个
		
		ArrayList listnew = new ArrayList<>();
		for (Object object : listnew) {
			if(!list.contains(object)) {
				list.add(object);
			}
		}
		System.out.println(listnew);//3个
		
	}
}
class Person{
	private String name;
	private int 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;
	}
	
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", 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("重写");
//		return super.equals(obj);
//	}
//	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) 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方法

5.list集合如何进行优

增加容量前  当代码中出现多次add操作，涉及到list集合容量多次改变，这是十分耗性能的操作，此时通过
 设定初始化容量，即可优化性 
  list集合长度是可变的，数组长度是不可变的，
  结论1：list集合的数据结构是数组
  结论2：增长因子0.5，初始容量10

 完整代码

package com.zbb.list;
 
import java.lang.reflect.Field;
import java.util.ArrayList;
 
/**
 * 
 * @author
 */
 
public class Dome4 {
	public static void main(String[] args) throws Exception{
		//String[] arr = new String[10];
		//arr[11] = "zs";
		//arr = new String[12];
		//arr[12] = "zs";
		
		ArrayList<Object> list = new ArrayList<>(100);
		for (int i = 0; i < 200; i++) {
			list.add(i);
			getlen(list);
		}
	}
 
	private static void getlen(ArrayList<Object> list) throws Exception {
		Field f = list.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] elementData = (Object[]) f.get(list);
		System.out.println("当前集合的元素个数："+list.size()+"；当前list集合的容量是："+elementData.length);
	}
}

 今天的分享就到这啦~我们下期见~~

---