deque和map java 效率_java的Set、Map、Deque集合；实现排序

一、集合：一组(n个)数据作为一个集合处理

1、java集合框架( java collection framework)：

2、java集合包括：

1)接口

2)实现类

3)算法

二、Set集合，相当于数学里面的集合

1、特点：

1)Set是一个无序集合，无下标

2)Set中数据不重复

3)Set中允许有NULL元素

2、实现类：

1)HashSet，增、删、改、查的性能比较：添加元素速度较快，原因是无序。用法：

public class HashSetDemo {

public static void main(String[] args) {

Set s1=new HashSet();

Set s2=new HashSet();

HashSet s3=new HashSet();

//添加元素

s3.add(100);

s3.add(200);

s3.add(300);

s3.add(100);//添加重复元素，Set会认为是相同数据

s3.add(null);

//遍历HashSet，因为没有顺序，不可以用for(int i=0;i

for(int i: s3){

System.out.println(i);

}

//遍历HashSet

Iterator i=s3.iterator();//迭代器模式，获取HashSet的迭代对象，比for循环快

while(i.hasNext()){//判断是否还有下一个函数

System.out.println(i.next());//获取下一个元素输出

}

//删除，因为没有下标，只能删除对象

s3.remove(100);

s3.size();//获取元素个数

}

}2)TreeSet，有序的Set，但并非通过下标实现，而是添加/删除元素时，自动排序。

添加元素的类型，默认情况下，只能添加可以排序的数据。用法参考代码：

public static void main(String[] args) {

TreeSet ts=new TreeSet();

ts.add(100);

ts.add(300);

ts.add(99);

Iterator iterator=ts.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

TreeSet ts1=new TreeSet();

ts1.add("abc");

ts1.add("ccc");

ts1.add("bbb");

Iterator iterator1=ts1.iterator();

while(iterator1.hasNext()){

System.out.println(iterator1.next());

}

}

三、Map集合：“键-值”对的集合，key-Value，也称entry。其实现类有：

1、HashMap，特点：

1)添加时，若key相同时，会覆盖以前的Value，即Key不能重复。Value可以重复。

2)Key和value可以为空

3)最多只有一个Key值为null，但可以有任意多个null的Value值

用法参考代码：

public class HashMapDemo {

public static void main(String[] args) {

Map m1=new HashMap();

Map m2=new HashMap();

//尖括号中第一个类型参数代表key类型，第二个类型参数，代表Value类型

//添加元素Map里面的key和Value分别存放于两个Set里面

HashMap m3=new HashMap();

m3.put("k2", 100);

m3.put("k1", 50);

m3.put("k3", 70);

m3.put("k1", 50);

m3.put("k2", 200);

m3.put("k4", 70);

m3.put(null, null);

System.out.println(m3);

System.out.println(m3.get("k1"));

//遍历Map，根据keySet

Set keySet=m3.keySet();//获取存放所有Key值的集合

for(String s:keySet){//其中s代表keySet集合中的每一个元素

//根据Key值来获取Value

System.out.println(m3.get(s));

}

//遍历Map，根据entrySet，查询Key值为“k1”的value

Set> entrySet = m3.entrySet();// 获取存放所有Key值的集合

for (Entry e : entrySet) {// 其中s代表keySet集合中的每一个元素

// 根据Key值来获取Value

if(e.getKey().equals("k1")){

System.out.println(e.getValue());

}

}

}

}

2、TreeMap 有序的集合：根据Key值进行排序，特点：

1)若key相同时，会覆盖以前的Value。

2)Key值不允许添加null，因为需要进行Key值排序。

3)可以有任意多个null的Value值。

用法参考代码：

public class TreeMapDemo {

public static void main(String[] args) {

Map m1=new TreeMap();

Map m2=new TreeMap();

//尖括号中第一个类型参数代表key类型，第二个类型参数，代表Value类型

//添加元素Map里面的key和Value分别存放于两个Set里面

TreeMap m3=new TreeMap();

m3.put("k2", 100);

m3.put("k1", 50);

m3.put("k3", 70);

m3.put("k1", 50);

m3.put("k2", 200);

m3.put("k4", 70);

System.out.println(m3);

System.out.println(m3.get("k1"));

//遍历Map，根据keySet

Set keySet=m3.keySet();//获取存放所有Key值的集合

for(String s:keySet){//其中s代表keySet集合中的每一个元素

//根据Key值来获取Value

System.out.println(m3.get(s));

}

//遍历Map，根据entrySet，查询Key值为“k1”的value

Set> entrySet = m3.entrySet();// 获取存放所有Key值的集合

for (Entry e : entrySet) {// 其中s代表keySet集合中的每一个元素

// 根据Key值来获取Value

if(e.getKey().equals("k1")){

System.out.println(e.getValue());

}

}

}

}

3、Hushtable线程安全的map，不会因为多个线程抢一个资源而出现数据错误。

四、Deque(队列)集合：先进先出。特点：

1、添加元素时只允许在队尾添加

2、删除元素时只允许在对首删除

3、实现类：ArrayDeque，双端队列，支持在队列2端进行添加/删除操作，是一个可变长的集合，用法参考代码：

public static void main(String[] args) {

ArrayDeque ad1=new ArrayDeque();

ArrayDeque ad2=new ArrayDeque();

//10代表默认长度

ArrayDeque ad3=new ArrayDeque(10);

ad3.add(100);

ad3.add(20);

ad3.add(100);

//添加到对首

ad3.addFirst(10);

ad3.addFirst(86);

//添加到对尾

ad3.addLast(15);

System.out.println(ad3);

//删除对尾的元素

ad3.removeLast();

System.out.println(ad3);

//删除对尾的元素

ad3.removeFirst();

System.out.println(ad3);

//删除某一个元素

ad3.remove(100);//删除第一个和它相同的元素

System.out.println(ad3);

//访问元素

System.out.println("第一个元素："+ad3.getFirst());//访问第一个

System.out.println("最后一个元素："+ad3.getLast());//访问最后一个

//删除并返回第一个元素

System.out.println("删除并返回第一个元素："+ad3.pop());//访问某一个元素

System.out.println(ad3);

//peek返回对首的数据

System.out.println("访问对首的数据："+ad3.peek());//访问某一个元素

//向对首添加数据

ad3.push(200);//向对首添加数据

System.out.println(ad3);

}运行结果：

[86, 10, 100, 20, 100, 15]

[86, 10, 100, 20, 100]

[10, 100, 20, 100]

[10, 20, 100]

第一个元素：10

最后一个元素：100

删除并返回第一个元素：10

[20, 100]

访问对首的数据：20

[200, 20, 100]

五、对非基本类型数据对象实现排序

1、Comparable接口：单元素排序

1)其抽象方法：public int compareTo(T o)

根据比较的结果返回：

-1：调用compareTo方法的对象小于o，其中o代表被比较的对象

0：调用compareTo方法的对象等于o

1：调用compareTo方法的对象大于o

2)使用步骤：

a)实现接口Comparable

b)实现抽象方法：指定排序规则

c)使用，参考代码：

//定义非基本类型数据类，在该类中实现排序

public class Contact implements Comparable{//a)实现接口Comparable

private String name;

private int phone;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getPhone() {

return phone;

}

public int setPhone(int phone) {

return this.phone = phone;

}

//Object o代表被比较的对象，按照phone大小实现排序

@Override

public int compareTo(Object o) {//b)实现抽象方法：指定排序规则

Contact c1=(Contact)o;

if(this.phone > c1.getPhone() ){

return 1;

} else if(this.phone == c1.getPhone()){

return 0;

}else{

return -1;

}

}

//以下内容与排序无关，只是为了更好的显示排序之后的结果

public String toString(){

//将每个属性，拼接到一个字符串

StringBuffer buffer=new StringBuffer();

StringBuilder builder=new StringBuilder();

//append相当于一个+

builder.append("姓名："+name+"\n");

builder.append("电话："+phone+"\n");

return builder.toString();//将拼接好的字符串转换为String类型

}

}//在TreeSet对自定义的排序数据进行排序输出

public class ComParableDemo {

public static void main(String[] args) {

TreeSet ts1=new TreeSet();

Contact c1=new Contact();

c1.setName("cbd");

c1.setPhone(1510920);

Contact c2=new Contact();

c2.setName("bee");

c2.setPhone(1310920);

Contact c3=new Contact();

c3.setName("aeq");

c3.setPhone(1710920);

ts1.add(c1);

ts1.add(c2);

ts1.add(c3);

//打印集合时会自动调用Contact的toString方法，只用于在控制台打印

System.out.println(ts1);

}

}运行结果(按照程序中自定义指定的排序规则进行排序输出)：

[姓名：bee

电话：1310920

, 姓名：cbd

电话：1510920

, 姓名：aeq

电话：1710920

]2、Comparator接口：支持多重排序(多个字段同时排序)，实现步骤：

1)针对每个属性分别实现接口Comparator，指定多个排序规则

2)分别实现抽象方法compare

3)使用排序规则代码：Collections.sort(ts1,new NameOrder());

参考代码：

a)定义非基本类型数据类

public class Contact{

private String name;

private int phone;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getPhone() {

return phone;

}

public int setPhone(int phone) {

return this.phone = phone;

}

//以下内容与排序无关，只是为了更好的显示排序之后的结果

public String toString(){

//将每个属性，拼接到一个字符串

StringBuffer buffer=new StringBuffer();

StringBuilder builder=new StringBuilder();

//append相当于一个+

builder.append("姓名："+name+"\n");

builder.append("电话："+phone+"\n");

return builder.toString();//将拼接好的字符串转换为String类型

}

}

b)对Contact类中name属性实现Comparator接口，实现抽象方法compare，指定排序规则

public class NameOrder implements Comparator{

//Object o代表被比较的对象，按照phone大小实现排序

@Override

public int compare(Object o1, Object o2) {

Contact c1=(Contact)o1;

Contact c2=(Contact)o2;

//根据字符串自带的compareTo方法，比较2个字符串

return c1.getName().compareTo(c2.getName());

}

}

c)对Contact类中phone属性实现Comparator接口，实现抽象方法compare，指定排序规则

public class PhoneOrder implements Comparator{

@Override

public int compare(Object o1, Object o2) {

Contact c1=(Contact)o1;

Contact c2=(Contact)o2;

if(c1.getPhone() > c2.getPhone() ){

return 1;

} else if(c1.getPhone() == c2.getPhone()){

return 0;

}else{

return -1;

}

}

}

d)使用排序规则：Collections.sort(ts1,new NameOrder())，因为sort只能使用List

public class ComparatorDemo {

@SuppressWarnings("unchecked")

public static void main(String[] args) {

ArrayList ts1=new ArrayList();

Contact c1=new Contact();

c1.setName("cbd");

c1.setPhone(1510920);

Contact c2=new Contact();

c2.setName("bee");

c2.setPhone(1310920);

Contact c3=new Contact();

c3.setName("aeq");

c3.setPhone(1710920);

ts1.add(c1);

ts1.add(c2);

ts1.add(c3);

Collections.sort(ts1,new NameOrder());//实现name排序

System.out.println(ts1);

Collections.sort(ts1,new PhoneOrder());//实现phone排序

//打印集合时会自动调用Contact的toString方法，只用于在控制台打印

System.out.println(ts1);

}

}运行结果：

[姓名：aeq

电话：1710920

, 姓名：bee

电话：1310920

, 姓名：cbd

电话：1510920

]

[姓名：bee

电话：1310920

, 姓名：cbd

电话：1510920

, 姓名：aeq

电话：1710920

]