集合框架之List

一，UML（集合类图和用列图）

UML类图是描述程序中类的信息及各个类之间的关系。

UML的作用：

所有的面向对象语言都离不开类的概念，理解了程序中类的设计也就理解了程序的一半。但类的具体描述方式在各个类中都不一样，UML类图的提出是为了能够脱离语言的限制，抽象地描述各个类的信息及各个类之间的关系。

二，List集合的基本特点： 增删改查 有序性 可重复

package com.whw.list;

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

public class Dome01 {
	public static void main(String[] args) {
		
		List<String> list=new ArrayList<String>();
		//增加元素
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println("现有的元素："+list);
		//移除下标为0的元素
		System.out.println(list.remove(0));
		//移除一个指定元素(如果元素存在则删除，返回一个true，如果没有则返回一个false)
		System.out.println(list.remove("b"));
		//输出移除元素后的集合
		System.out.println("现有的元素："+list);
		//元素替换
		list.set(0,"e");
		System.out.println("现有的元素："+list);
		
		
	}
}

运行结果：
现有的元素：[a, b, c]
a
true
现有的元素：[c]
现有的元素：[e]

List集合的三种遍历方式

public class Dome02 {
	public static void main(String[] args) {
		
		List<String> list=new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		
		//fori循环遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("------------------------");
		
		//foreach遍历
		for (String s : list) {
			System.out.println(s);
		}
		
		System.out.println("------------------------");
		
		//迭代器遍历
		Iterator<String> it=list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
	}
}

ArrayList，LinkedList 的比较与分析

比较：

ArrayList 查询修改快，删除新增慢
LinkedList 查询修改慢，删除新增快
分析：ArrayList如列表，它有下标，是紧挨着的，查询和修改可以快速找到。

但想删除一个或者是增加一个元素，就要把它断开，如在c和d之间增加一个e，则需要先找到位置，在从中断开，在添加新元素，然后在连接起来，相比LinkedList比较耗时。

分析：LinkedList如列表下图，它像几个圆，没有固定节点，删除，增加加入一个节点就行，不用移动其他元素，很快，但查询和修改就比较耗时

新增和修改，直接切断连接，加进去很，如下图

堆栈和队列

堆栈的特点：从在外面的开始拿（反向输出）
队列的特点：从第一个进来的开始拿

堆栈分析：（堆栈就像一个碗一样，不管你是第几个进去的，你取的时候它总是会从最外面的开始拿，顺序是【c,b,a】，也就是反向输出）

队列：（队列是有序的，第几个进去的，就第几个出来，顺序是【a,b,c,d,e,f】）

堆栈和队列

public class Dome03 {
	public static void main(String[] args) {
 
		LinkedList<String> list = new LinkedList<>();
		Duilie di = new Duilie(list);
		Duizhan de = new Duizhan(list);
		
		di.push("a");
		di.push("b");
		di.push("c");
		
		de.push("d");
		de.push("e");
		de.push("f");
 
		// 只能一个一个查
		System.out.println(di.pop());
		System.out.println(di.pop());
		System.out.println(di.pop());
		
		System.out.println("===========================");
		
		System.out.println(de.pop());
		System.out.println(de.pop());
		System.out.println(de.pop());
	}
}
 
// 队列
class Duilie {
	LinkedList<String> li = null;
 
	public Duilie(LinkedList<String> li) {
		this.li = li;
	}
 
	// 获取的方法
	public String pop() {
		return li.removeFirst();
	}
 
	// 增加的方法
	public void push(String s) {
		li.add(s);
	}
}
 
// 堆栈
class Duizhan {
	LinkedList<String> li = null;
 
	public Duizhan(LinkedList<String> li) {
		this.li = li;
	}
 
	// 获取的方法
	public String pop() {
		return li.removeLast();
	}
 
	// 增加的方法
	public void push(String s) {
		li.add(s);
	}
}

运行结果：

增长因子论证

增长因子论证三特点：

1，List集合底层是素组结构

2，它是“可变数组”，一旦超越默认数组大小，就会自动扩容

3，扩容的增长因子为0.5（扩容大小=数组的大小*0.5+原来的大小）

（代码展示！）其中我们用到了泛型 作用：提高程序健壮性，简化代码，泛型的默认值是Object
其中我们用到了泛型 作用：提高程序健壮性，简化代码，泛型的默认值是Object

/**
 * 1，List集合底层是素组结构 
 * 2，它是“可变数组”，一旦超越默认数组大小，就会自动扩容 
 * 3，扩容的增长因子为0.5
 */
public class Dome04 {
	public static void main(String[] args) throws SecurityException, Exception {
		ArrayList list=new ArrayList<>();
		for (int i = 1; i <= 100; i++) {
			System.out.println(i);
			list.add(i);
			printElementDataLength(list);
		}
	}
	private static void printElementDataLength (ArrayList<String> list) throws Exception, SecurityException {
		Field f = list.getClass().getDeclaredField("elementData");
		f.setAccessible(true);
		Object[] elementData=(Object[]) f.get(list);
		System.out.println("目前ListJ集合底层存储数据的数组长度为："+elementData.length);
	}

运行结果：
在这里插入图片描述
其中我们也可以在这行代码中设置初始值，如果知道文件的大概的大小，设置初始值可以提高效率。

ArrayList list=new ArrayList<>(50);

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

public class Dome05 {
	public static void main(String[] args) {
 
		List list = new ArrayList<>();
//		list.add("a");
//		list.add("b");
//		list.add("c");
//
//		//如果没有这个元素就增加
//		if(!list.contains("d")) {
//			list.add("d");
//		}
//		System.out.println(list);
		
		list.add(new Student("aa", 18));
		list.add(new Student("bb", 17));
		list.add(new Student("cc", 16));
		
		//list集合是有序的
		if(!list.contains(new Student("bb", 17))) {
			list.add(new Student("bb", 17));
		}
		for (Object o : list) {
			System.out.println(o);
		}
	}
}
 
class Student {
	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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public int hashCode() {
		System.out.println("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("equals方法被调用");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) 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()方法，List是有序的，当找到它时，方法就会停止调用）（判从只与实体类的equals()方法有关）

StarUML绘图

那么到这里就结束了，下次再见！