一、集合:一组(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<Integer> s2=new HashSet<Integer>();
HashSet<Integer> s3=new HashSet<Integer>();
//添加元素
s3.add(100);
s3.add(200);
s3.add(300);
s3.add(100);//添加重复元素,Set会认为是相同数据
s3.add(null);
//遍历HashSet,因为没有顺序,不可以用for(int i=0;i<s3.size();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<Integer> ts=new TreeSet<Integer>();
ts.add(100);
ts.add(300);
ts.add(99);
Iterator iterator=ts.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
TreeSet<String> ts1=new TreeSet<String>();
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<String,Integer>();
//尖括号中第一个类型参数代表key类型,第二个类型参数,代表Value类型
//添加元素Map里面的key和Value分别存放于两个Set里面
HashMap<String,Integer> m3=new HashMap<String,Integer>();
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<String> keySet=m3.keySet();//获取存放所有Key值的集合
for(String s:keySet){//其中s代表keySet集合中的每一个元素
//根据Key值来获取Value
System.out.println(m3.get(s));
}
//遍历Map,根据entrySet,查询Key值为“k1”的value
Set<Entry<String,Integer>> entrySet = m3.entrySet();// 获取存放所有Key值的集合
for (Entry<String,Integer> 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<String,Integer>();
//尖括号中第一个类型参数代表key类型,第二个类型参数,代表Value类型
//添加元素Map里面的key和Value分别存放于两个Set里面
TreeMap<String,Integer> m3=new TreeMap<String,Integer>();
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<String> keySet=m3.keySet();//获取存放所有Key值的集合
for(String s:keySet){//其中s代表keySet集合中的每一个元素
//根据Key值来获取Value
System.out.println(m3.get(s));
}
//遍历Map,根据entrySet,查询Key值为“k1”的value
Set<Entry<String,Integer>> entrySet = m3.entrySet();// 获取存放所有Key值的集合
for (Entry<String,Integer> e : entrySet) {// 其中s代表keySet集合中的每一个元素
// 根据Key值来获取Value
if(e.getKey().equals("k1")){
System.out.println(e.getValue());
}
}
}
}
3、Hushtable线程安全的map,不会因为多个线程抢一个资源而出现数据错误。
1、添加元素时只允许在队尾添加
2、删除元素时只允许在对首删除
3、实现类:ArrayDeque,双端队列,支持在队列2端进行添加/删除操作,是一个可变长的集合,用法参考代码:
public static void main(String[] args) {
ArrayDeque ad1=new ArrayDeque();
ArrayDeque<Integer> ad2=new ArrayDeque<Integer>();
//10代表默认长度
ArrayDeque<Integer> ad3=new ArrayDeque<Integer>(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 <span style="color:#FF0000;">implements Comparable</span>{//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
<span style="color:#FF0000;">public int compareTo(Object o)</span> {//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<Contact> ts1=new TreeSet<Contact>();
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<Contact> ts1=new ArrayList<Contact>();
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
]