一.Collection接口
首先如图所见，Collection是整个集合框架的顶级接口，是Set和List的父接口，但不是Map的父接口，Map也是一个顶级接口
二.List集合的特点
总的来说学习框架就是为了学习容器的数据结构（增删改查），因为java本就是面向对象，万物皆对象。
基本特点:
增删改查
有序
可重复
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
System.out.println(list);
list.add("b");
System.out.println(list);
list.remove(0);// 根据下标删除,返回值为Boolean
list.remove("a");// 直接删除所填对象,返回值为下标
list.set(0, "Y");//修改对应下标的值
System.out.println(list.get(0));// 查出对应下标的值
有序性和可重复在输出结果中可以看出
三.遍历方式(3种)
1.for循环
for (int i = 0; i <list.size(); i++) {
System.out.println(list.get(i));
}
2.foreach
for (String string : list) {
System.out.println(string);
}
3.迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
四.LinkedList
ArrayList 查询修改快,删除增加慢
LinkedList 查询修改慢,删除增加快
堆栈：按照一定顺序插入数据，输出结果与插入的数据完全相反 先进慢出
队列：按照一定顺序插入数据，输出结果与插入的数据完全相同 先进先出
如何用LinkdList实现队列和堆栈：
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
DuiLie dl=new DuiLie(list);
//调用pop push
d1.push("a");
d1.push("b");
d1.push("c");
System.out.println(d1.pop());//一次只取一个值
DuiZhan dz=new DuiZhan(list);
//调用pop push
d1.push("a");
d1.push("b");
d1.push("c");
System.out.println(d1.pop());//一次只取一个值
}
}
//实现队列
class DuiLie{
LinkedList<String> ll=null;
public DuiLie(LinkedList ll){
this.ll=ll;
}
//从容其中取出元素
public String pop() {
return ll.removeFirst();
}
//添加元素到容器
public void push(String s) {
ll.add(s);
}
}
//实现堆栈
class DuiZhan{
LinkedList<String> ll=null;
public DuiZhan(LinkedList ll){
this.ll=ll;
}
//从容其中取出元素
public String pop() {
return ll.removeLast();
}
//添加元素到容器
public void push(String s) {
ll.add(s);
}
}五.增长因子论证与List的优化
List集合底层是数组结构,它是“可变数组”，一旦超过默认数组大小会自动扩容，增长因子为0.5
论证过程如下：
package com.lj.list;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
public class demo3 {
public static void main(String[] args) throws SecurityException, Exception {
ArrayList list = new ArrayList<>(50);//定义大概数据的数组长度就是list的优化
for (int i = 0; i < 100; i++) {
System.out.println(i);
list.add(i);
printELementDataLeng(list);
}
}
private static void printELementDataLeng(List<String> list) throws Exception, SecurityException {
// TODO Auto-generated method stub
Field f = list.getClass().getDeclaredField("eLementData");
f.setAccessible(true);
Object[] LementData = (Object[]) f.get(list);
System.out.println(LementData.length);//目前list集合底层存储数据的数组长度
}
}五.list集合去重原理
list方法去重只跟去重对象的equals有关
/**
* list集合去重与去重对象的equals方法有关
* @author My
*
*/
public class demo4 {
public static void main(String[] args) {
List list=new ArrayList<>();
list.add(new Student("xx", 11));
list.add(new Student("xxx", 12));
list.add(new Student("xxxx", 13));
if(!list.contains( new Student("xxx", 12))) {
list.add(new Student("xxx", 12));
}
for (Object object : list) {
System.out.println(object);
}
}
}
class Student {
private String name;
private int age;
public Student() {
// TODO Auto-generated constructor stub
}
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 Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@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集合是有序的