一、集合：一组（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();//获取元素个数
}
}添加元素的类型，默认情况下，只能添加可以排序的数据。用法参考代码：
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
]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
]
扫一扫
1048
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
