Collection接口
1.Collection
Collection接口是集合的父接口。
1.1 List接口
List接口中存储一组有序的，可以重复的元素
1.1.1 ArrayList
数据结构
ArrayList集合特点和数据结构
底层实现是一个Object数组，有下标，有序，可以为null，可以重复，线程不安全
查询修改快，因为有下标
增删慢，因为需要移动元素
ArrayList集合源代码解读：
1.当我们调用无参构造 初始化一个初始为空的数组
2.当我们第一次添加元素的时候 将数组容量改为10
3.如果长度不够 将扩容为原来的1.5倍
常用方法
package com.qfedu.test1;
import java.util.ArrayList;
import java.util.InputMismatchException;
/**
* Collection
* List
* ArrayList类常用方法
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(10);
list.add(3.5);
list.add('a');
list.add("hello");
list.add(false);
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(20);
list1.add(35);
list1.add(30);
list1.add(55);
list1.add(60);
System.out.println(list1.size());
System.out.println(list1.remove(0));
System.out.println(list1.size());
list1.set(0, 666);
System.out.println(list1.get(0));
System.out.println(list1.isEmpty());
list1.clear();
System.out.println(list1.isEmpty());
ArrayList<Student> list2 = new ArrayList<Student>();
Student stu1 = new Student("赵四", 20);
list2.add(stu1);
list2.add(new Student("赵四", 20));
list2.add(new Student("赵四", 20));
list2.add(new Student("赵四", 20));
list2.add(new Student("赵四", 20));
list2.add(new Student("赵四", 20));
list2.remove(stu1);
System.out.println(list2.size());
}
}
遍历
package com.qfedu.test2;
import java.util.ArrayList;
import java.util.Iterator;
/**
* ArrayList集合遍历方式
* 1.普通for循环
* 2.迭代器遍历
* 3.增强for循环
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 200000; i++) {
list.add(i);
}
// 方式1 普通for循环
long beginTime = System.currentTimeMillis();
for(int i = 0; i < list.size();i++) {
System.out.println(list.get(i));
}
long endTime = System.currentTimeMillis();
System.out.println("普通for循环耗时" + (endTime - beginTime));
// 方式2 迭代器遍历
beginTime = System.currentTimeMillis();
Iterator<Integer> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
endTime = System.currentTimeMillis();
System.out.println("迭代器耗时" + (endTime - beginTime));
// 方式3 增强for循环 底层实现依然还是迭代器 是JDK1.5新增的写法
beginTime = System.currentTimeMillis();
for(Integer i :list) {
System.out.println(i);
}
endTime = System.currentTimeMillis();
System.out.println("增强for循环耗时" + (endTime - beginTime));
}
}
1.1.2 LinkedList
数据结构
LinkedList数据结构
双向链表，没有初始大小，不需要扩容，没有个数上限，有序(插入顺序)，可以为null，可以重复，线程不安全
查询，修改慢，因为没有下标，我们根据某个序号查找元素必须先找到与之相邻的元素，以此类推
删除，添加块，因为不需要移动元素，只需要改变新的指针即可
常用方法
package com.qfedu.test4;
import java.util.LinkedList;
/**
* LinkedList 集合常用方法
* @author WHD
*/
public class Test1 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
list.add("a");
list.addFirst("hello");
list.addLast("world");
System.out.println(list.remove(0));
System.out.println(list.size());
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list.size());
list.add("ABC");
list.add("DEF");
list.set(0, "abc");
System.out.println(list.get(0));
System.out.println(list.getLast());
System.out.println(list.isEmpty());
list.clear();
System.out.println(list.isEmpty());
}
}
遍历方式
package com.qfedu.test5;
import java.util.Iterator;
import java.util.LinkedList;
/**
* LinkedList 三种遍历方式
* 1.普通for循环
* 2.迭代器
* 3.增强for循环
*
* LinkedList数据结构
* 双向链表，没有初始大小，不需要扩容，没有个数上限，有序(插入顺序)，可以为null，可以重复，线程不安全
* 查询，修改慢，因为没有下标，我们根据某个序号查找元素必须先找到与之相邻的元素，以此类推
* 删除，添加块，因为不需要移动元素，只需要改变新的指针即可
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<Integer>();
for (int i = 0; i < 200000; i++) {
list.add(i);
}
// 方式1 普通for循环
// long begin = System.currentTimeMillis();
// for(int i= 0;i < list.size();i++) {
// System.out.println(list.get(i));
// }
//
// long end = System.currentTimeMillis();
// System.out.println("普通for循环耗时" + (end - begin));
// 方式2 迭代器遍历
long begin = System.currentTimeMillis();
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
long end = System.currentTimeMillis();
System.out.println("迭代器耗时" + (end - begin));
// 方式3 增强for循环
begin = System.currentTimeMillis();
for(Integer i : list) {
System.out.println(i);
}
end = System.currentTimeMillis();
System.out.println("增强for循环耗时" + (end - begin));
}
}
1.1.3 Vector
ArrayList和Vector的区别
ArrayList线程安全 | Vector线程不安全
ArrayList没有默认值 | Vector默认值为10
扩容1.5倍 | 扩容2倍
package com.qfedu.test5;
import java.util.Vector;
public class TestVector {
public static void main(String[] args) {
Vector<String> v = new Vector<String>();
v.add("a");
v.add("b");
v.add("c");
v.add("d");
v.remove(1);
v.set(0, "hello");
System.out.println(v.get(0));
System.out.println(v.size());
v.clear();
System.out.println(v.isEmpty());
// 遍历的方式三种 普通for 迭代器 增强for
}
}
1.2接口
Set接口存储一组唯一的，无序的对象，不允许两个对象equals比较为ture ,并且hashcode相同
1.2.1HashSet
HashSet的特点，无序，不能重复，去除重复的原理，两个对象equals比较为ture,并且hashcode相同
底层是有一个hashMap维护的
package com.qfedu.test4;
import java.util.HashSet;
import java.util.Iterator;
public class TestHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add("a");
set.add("a");
set.add("A");
set.remove("a");
for (String v : set) {
System.out.println(v);
}
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
set.clear();
System.out.println(set.isEmpty());
System.out.println(set.size());
HashSet<Student> stuSet = new HashSet<Student>();
Student stu1 = new Student("赵四", 25);
Student stu2 = new Student("赵四", 25);
Student stu3 = new Student("赵四", 25);
stuSet.add(stu1);
stuSet.add(stu2);
stuSet.add(stu3);
System.out.println(stuSet.size());
}
}
package com.qfedu.test4;
public class Student implements Comparable<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;
}
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student stu) {
if(this.getAge() > stu.getAge()) {
return 1;
}else if(this.getAge() < stu.getAge() ) {
return -1;
}
return 0;
}
@Override
public boolean equals(Object obj) {
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;
}
@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;
}
}
1.2.2TreeSet
TreeSet底层维护的是一个TreeMap
有序的Set集合，比较的顺序，元素必须实现Comparable接口,重写comparaTo方法
package com.qfedu.test5;
import java.util.Iterator;
import java.util.TreeSet;
import com.qfedu.test4.Student;
/**
* TreeSet底层维护的是一个TreeMap
* 有序的Set集合 比较的顺序
* @author WHD
*
*/
public class TestTreeSet {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<String>();
set.add("a");
set.add("d");
set.add("f");
set.add("c");
for (String v : set) {
System.out.println(v);
}
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
TreeSet<Student> stuSet = new TreeSet<Student>();
Student stu1 = new Student("赵四1", 26);
Student stu2 = new Student("赵四2", 23);
Student stu3 = new Student("赵四3", 25);
stuSet.add(stu1);
stuSet.add(stu2);
stuSet.add(stu3);
for (Student stu : stuSet) {
System.out.println(stu);
}
}
}
1.2.3 LinkedHashSet
一个基于双向链表的Set集合 有序的 插入顺序
package com.qfedu.test5;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class TestLinkedHashSet {
public static void main(String[] args) {
LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
set.add(110);
set.add(11);
set.add(12);
set.add(3);
set.remove(11);
System.out.println(set.size());
// set.clear();
System.out.println(set.isEmpty());
for (Integer i : set) {
System.out.println(i);
}
Iterator<Integer> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
浙公网安备 33010602011771号