Set集合
List是有序的集合,Set是无序的集合
此处的有序和无序指的是取出的顺序和添加的顺序是否一致,一致即为有序,不一致则为无序
HashSet
//实例化set集合
HashSet hset = new HashSet();
添加元素 .add
查询集合元素数量 .size
注意Set不能存储相同的数据;例:
set.add("23");
set.add("23");
int size=set.size();
System.out.println(size);//输出为1
搜索并删除元素 .remove
set.remove("123");
TreeSet
TreeSet 内部使用二叉树(红黑树)进行实现。其内部节点是可以比较大小的,
同一个TreeSet对象中存储的内容都应该是可比较的,默认情况下不能存储不同类型
//实例化set集合
TreeSet tset = new TreeSet();
添加元素 .add
hset.add(2);
hset.add(200);
hset.add(1);
hset.add(78);
hset.add(188);
for(Object item : hset){//遍历
System.out.print(item+",");
}//输出1,2,78,188,200,
注意:TreeSet不能存null,null无法比较
类(class)存入TreeSet需要实现Comparator接口
class Student implements Comparable {
int score;
}
方法一:
public class EasySet {
public static void main(String[] args) {
Comparator<Student> com = (a, b) -> {
if (a.score == b.score) {
return 0;
}
return a.score > b.score ? 1 : -1;
};
TreeSet<Student> tss=new TreeSet<>(com);
Student stua=new Student(); stua.score=67;
Student stub=new Student(); stub.score=89;
Student stuc=new Student(); stuc.score=60;
Student stud=new Student(); stud.score=98;
tss.add(stua);
tss.add(stub);
tss.add(stuc);
tss.add(stud);
for (Student item : tss) {
System.out.println(item.score);
}
}
}
方法二:
public class EasySet {
public static void main(String[] args) {
TreeSet<Student> ttss=new TreeSet();
Student stue=new Student(); stue.score=74;
ttss.add(stue);
Student stuf =new Student(); stuf.score=83;
ttss.add(stuf);
Student stug =new Student(); stug.score=61;
ttss.add(stug);
Student stuh =new Student(); stuh.score=90;
ttss.add(stuh);
for (Student item : ttss) {
System.out.println(item.score);
}
}
}
class Student implements Comparable {
int score;
public int compareTo(Object o) {
if(o instanceof Student){
Student item=(Student)o;
if(this.score==item.score){
return 0;
}
return this.score>item.score?1:-1;
}else {
//o对象如果不是Student就无法比较 这是程序运行时出现的特殊情况
//异常情况 我们的方法处理不了这种情况 就要抛出一个异常对象
//告知调用此方法的代码
throw new ClassCastException("传入对象不可比较");
}
}
}
Map
Set 和 List 都是实现了Collection接口的,Map是单独一个接口。
Map 储存键值对,键(key)就是名字,值(value)存储对象
HashMap
public class EasyMap {
//Map 存储键值对 键 就是名字 值 存储对象
public static void main(String[] args) {
Map map = new HashMap();
//存放数据
map.put("A1", "张三");
//可以通过存入的key获取存入的对象
Object obj=map.get("A1");//获取A1对应的value值
System.out.println(obj);//"张三"
//通过key删除键值对
Object rem_obj=map.remove("A1");
System.out.println("删除的value值:"+rem_obj);//删除的value值:张三
//是否包含key
map.containsKey("A1");
//是否包含value值
map.containsValue("张三");
//获取所有的key
Set setkey=map.keySet();
//获取所有的value
Collection con=map.values();
}
}
HashMap 的底层实现是数组加链表
HashMap 的数组默认容量为16,容量每次扩容成两倍 ;HashMap扩容阈值为0.75,存入12个内容就扩容 ;一个链上的元素如果达到8就对该链进行树化,一支树上的元素如果低于6这个树就会退化成链;最小树化容量阈值为64,如果数组的长度没有达到64,优先扩容
TreeMap
TreeMap的key应该是能比较的,key不能是null值
Hashtable
Hashtable的key和value都不能是null值 ;Hashtable 是线程安全集合
ConcurrentHashMap
线程安全,效率较高
泛型
泛型,广泛的数据类型 ;是确保类型安全的一种途径
定义:类或方法上定义泛型
import javax.xml.crypto.dsig.spec.XSLTTransformParameterSpec;
import java.util.*;
public class EasyGenericity <J,M,N,Y,Easy>{
private M m;
public void test(M m,N n){
}
public static<J extends List> J testA(J j){//就近原则//定义上限
return j;
}
public static <A>void testAA(List<? super A> a){//定义下限
}
public <E> E test(E e){
//返回的类型和传入的类型是同一种
return e;
}
public static void main(String[] args) {
testA(new ArrayList());
//testA(new HashSet());
//类型安全
List list = new ArrayList();
list.add("123");
list.add(new Object());
for (Object o : list) {
//类型转换时没有明确对象的数据类型进行强制数据类型转换
//会抛出ClassCaseException(类型转换异常)
//类型不安全
String str = (String)o;//此语句是不正确的
System.out.println(str);
}
//泛型使用
List<String> listA=new ArrayList<>();
Map<String,Object> map=new HashMap<>();
}
}
遍历方式
访问根节点的顺序
先序遍历
先序遍历:A->B->D->E->C->F->G
中序遍历
中序遍历:D->B->E->A->F->C->G
后序遍历
后序遍历:D->E->B->F->G->C->A