集合
集合概述
- 集合主要有两大子接口:collection和map,这两大接口主要区别就是map中存储的元素都是一对数据(KEY:VALUE)。
- collection的两个子接口:list和set。list和set的区别:list可以重复,但是set储存的元素不可重复。set根据hash值来判断元素是否相等。可以重写判断相等的算法。
- list的三个实现类(用于使用过程中的):arraylist(列表),vector(矢量),linkedlist(链表)
- set的三个实现类(用于使用过程中的):treeset,hashset,linkedhashset。
- map的三个实现类(用于使用过程中的):treemap,hashmap,hashtable。
collection接口中的一些实现类
list子接口的实现类
- i.ArrayList类:存储数据有序,可重复。线程不安全,底层是数组实现,查询快但是修改慢。
e.g增删改查例
public class TestCollection {
public static void main(String[] args) {
//创建ArrayList类的对象,赋给父类对象变量的引用
List<Integer> list=new ArrayList();
//增
list.add(1);
list.add(1, 2);//向index为1的位置插入数字2,用的时候不能和前面的插入元素的index有距离。
for(int i:list) {
System.out.println(i);
}
//删
int removedElement=list.remove(0);
System.out.println("removedElement:"+removedElement);
for(int i:list) {
System.out.println(list.indexOf(i)+":"+i);//打印删除后list的index和对应的值
}
//改查
list.set(0,3);
System.out.println(list.get(0));
}
}
- LinkedList:链表,存储空间不连续,修改快,查找慢,同样是线程不安全的,可以通过实现Comparator接口来对元素排序。
e.g增删改查排序例。
public class TestCollection {
public static void main(String[] args) {
//创建ArrayList类的对象,赋给父类对象变量的引用
List<Integer> list=new LinkedList();
TestCollection collection=new TestCollection();
//增
list.add(1);
list.add(5);
list.add(10);
list.add(4);
list.add(6);
list.add(1, 2);//向index为1的位置插入数字2,用的时候不能和前面的插入元素的index有距离。
collection.printList(list);
//删
int removedElement=list.remove(0);
System.out.println("removedElement:"+removedElement);
collection.printList(list);
//改查
list.set(0,3);
collection.printList(list);
CompareMethod compare=new CompareMethod();
list.sort(compare);
collection.printList(list);
}
public void printList(List<Integer> list) {
for(int i:list) {
System.out.print("index"+list.indexOf(i)+":"+i+";");//打印list的index和对应的值
}
System.out.println();
}
}
class CompareMethod implements Comparator{
@Override
public int compare(Object o1, Object o2) {
Integer x=(Integer) o1;
Integer y=(Integer) o2;
if(x>y) {
return 1;
}else if(x<y) {
return -1;
}
return 0;
}
}
- vector:是线程安全的!!!,查询快,修改慢,处理效率比上面两个类都低。
e.g增删改查例
public class TestVector {
public static void main(String[] args) {
List<String> list=new Vector<String>();
TestVector collection=new TestVector();
//增加
list.add("尾巴1号");
list.add("尾巴2号");
list.add("尾巴3号");
collection.printVector(list);
//删除
String removedElement=list.remove(1);
System.out.println("removedElement:"+removedElement);
//修改
list.add("尾巴4号");
collection.printVector(list);
list.set(2, "尾巴5号");
collection.printVector(list);
CompareMethodv2 compareMethodv2=new CompareMethodv2();
list.sort(compareMethodv2);
collection.printVector(list);
}
public void printVector(List<String> list) {
for(String s:list) {//查
System.out.print("index:"+list.indexOf(s)+"---"+s+";");
}
System.out.println();
}
}
class CompareMethodv2 implements Comparator{
int num1;
int num2;
@Override
public int compare(Object o1, Object o2) {
String st1=(String) o1;
String st2=(String) o2;
this.num1=this.getNumFromString(st1);
this.num2=this.getNumFromString(st2);
if(this.num1<this.num2) {//实现反向排序
return 1;
}else if(this.num1>this.num2) {
return -1;
}else {
return 0;
}
}
public int getNumFromString(String str) {
//使用正则匹配数字
Pattern pattern=Pattern.compile("[0-9]+");
Matcher matcher=pattern.matcher(str);
if(matcher.find()) {
int i=Integer.parseInt(matcher.group());
return i;
}else {
System.out.println("字符串中不包括数字");
return 0;
}
}
}
--------------------------------------------------------
结果:
index:0---尾巴1号;index:1---尾巴2号;index:2---尾巴3号;
removedElement:尾巴2号
index:0---尾巴1号;index:1---尾巴3号;index:2---尾巴4号;
index:0---尾巴1号;index:1---尾巴3号;index:2---尾巴5号;
index:0---尾巴5号;index:1---尾巴3号;index:2---尾巴1号;
set集合
i.treeset实现类:插入元素是有序的,不可重复,不能插入控制,线程不安全。
e.g. 实现自定义排序,添加,删除元素
package com.leeyu.test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestSet {
public static void main(String[] args) {
//初始化treeset对象
Set<String> set=new TreeSet<String>();
TestSet treeset=new TestSet();
//添加元素
set.add("第1个元素");
set.add("第2个元素");
set.add("第3个元素");
set.add("第4个元素");
set.add("第5个元素");
treeset.printSet(set);
//删除第4个元素
set.remove("第4个元素");
treeset.printSet(set);
//自定义排序---需要自定义实现Comparator接口的类。
//创建新元素
String newStr1="尾巴10号";
String newStr2="尾巴1号";
String newStr3="尾巴6号";
String newStr4="尾巴8号";
String newStr5="尾巴3号";
SortByNumInString nis=new SortByNumInString();
//自定义排序需要构造treeset时传入自定义的排序类的对象。
Set<String> set2=new TreeSet(nis);
//添加创建的元素
set2.add(newStr1);
set2.add(newStr2);
set2.add(newStr3);
set2.add(newStr4);
set2.add(newStr5);
//输出存入treeset后的结果。(自动排序)
treeset.printSet(set2);
}
public void printSet(Set<?> set) {
//遍历set集合的元素
Iterator<?> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next()+" ");
}
System.out.println();
}
}
class SortByNumInString implements Comparator{
@Override
public int compare(Object o1, Object o2) {
String str1=(String) o1;
String str2=(String) o2;
// System.out.println(str1);
// System.out.println(str2);
//创建正则模板
String regex="\\d+";
Pattern pattern=Pattern.compile(regex);
//匹配str1中的字符串
Matcher matcher1=pattern.matcher(str1);
//匹配str2中的字符串
Matcher matcher2=pattern.matcher(str2);
int num1=0;
int num2=0;
while(matcher1.find()) {
num1=Integer.parseInt(matcher1.group());
// System.out.println(num1);
}
while(matcher2.find()) {
num2=Integer.valueOf(matcher2.group());
// System.out.println(num2);
}
if(num1>num2) {
return 1;
}else if(num1<num2) {
return -1;
}else {
return 0;
}
}
}
结果--------------
第1个元素 第2个元素 第3个元素 第4个元素 第5个元素
第1个元素 第2个元素 第3个元素 第5个元素
尾巴1号 尾巴3号 尾巴6号 尾巴8号 尾巴10号
- hashset:数据不可重复,可以有空元素(唯一),数据无顺序(插入数据顺序是根据计算的hash值顺序来的),线程不安全,性能较好。
e.g.
package com.leeyu.test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestHashSet{
public static void main(String[] args) {
Set<String> set=new HashSet();
set.add("尾巴");
set.add("尾巴号");
set.add("尾巴3号");
set.add("尾巴号l");
set.add(null);
set.add("");
set.add("尾巴");
set.add(null);
TestHashSet hashset=new TestHashSet();
hashset.printSet(set);
System.out.println(set.size());
//查询set中是否有空值返回时布尔类型的变量
System.out.println(set.contains(null));
System.out.println(set.contains(""));
}
public void printSet(Set<?> set) {
//遍历set集合的元素
Iterator<?> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next()+" ");
}
System.out.println();
}
}
结果-----------------
null 尾巴号l 尾巴号 尾巴3号 尾巴
6
true
true
- iii.LinkedHashSet:基于链表结构,数据是有序的,可以存在空值,遍历速度最快,但是插入删除数据没有hashset快,也是线程不安全的。
e.g.
package com.leeyu.test;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class TestLinkedHashSet {
public static void main(String[] args) {
TestLinkedHashSet linkedHashSet=new TestLinkedHashSet();
Set<String> set=new LinkedHashSet();
//向set中添加新元素(顺便验证空值和元素唯一性)
set.add("尾巴5号");
set.add("尾巴2号");
set.add("尾巴1号");
set.add("尾巴3号");
set.add("尾巴4号");
set.add(null);
set.add("尾巴4号");
//打印元素
linkedHashSet.printSet(set);
//删除操作
set.remove("尾巴3号");
linkedHashSet.printSet(set);
//查询是否包含一个元素
System.out.println(set.contains(null));
}
public void printSet(Set<?> set) {
Iterator<?> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next()+" ");
}
System.out.println();
}
}
结果-------------------
尾巴5号 尾巴2号 尾巴1号 尾巴3号 尾巴4号 null
尾巴5号 尾巴2号 尾巴1号 尾巴4号 null
true
map集合
- i.treemap:通过树状结构来存储数据,数据有序(根据key值排序,可自定义),key不能存储空值,value可以存空值,线程不安全。
package com.leeyu.test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestTreeMap {
public static void main(String[] args) {
//自定义排序实例
SortByNumWithinString sortByNumWithinString=new SortByNumWithinString();
Map<String,String> map=new TreeMap<String,String>(
sortByNumWithinString);
//添加元素
map.put("weiba1", "第一个元素");
map.put("weiba4", "第二个元素");
map.put("weiba2", "第三个元素");
map.put("weiba3", "第四个元素");
map.put("weiba5", "第五个元素");
TestTreeMap treemap=new TestTreeMap();
//打印结果
treemap.printMap(map);
//删除元素(根据key)
String remove = map.remove("weiba2");
System.out.println("删除的元素是value:"+remove);
treemap.printMap(map);
//修改元素
map.replace("weiba5", "weiba5");
System.out.println("修改之后:");
treemap.printMap(map);
}
public void printMap(Map<?,?> map) {
Set<?> entrySet = map.entrySet();
Iterator<?> iterator = entrySet.iterator();
while(iterator.hasNext()) {
System.out.println("entry:"+iterator.next()+" ");
}
System.out.println();
}
}
class SortByNumWithinString implements Comparator{
@Override
public int compare(Object o1, Object o2) {
String str1=(String) o1;
String str2=(String) o2;
int num1=0;
int num2=0;
String regex="\\d+";
Pattern pattern=Pattern.compile(regex);
Matcher matcher1 = pattern.matcher(str1);
Matcher matcher2 = pattern.matcher(str2);
while(matcher1.find()) {
num1=Integer.parseInt(matcher1.group());
}
while(matcher2.find()) {
num2=Integer.parseInt(matcher2.group());
}
return num1<num2?1:(num1==num2?0:-1);
}
}
结果-----------------------------
entry:weiba5=第五个元素
entry:weiba4=第二个元素
entry:weiba3=第四个元素
entry:weiba2=第三个元素
entry:weiba1=第一个元素
删除的元素是value:第三个元素
entry:weiba5=第五个元素
entry:weiba4=第二个元素
entry:weiba3=第四个元素
entry:weiba1=第一个元素
修改之后:
entry:weiba5=weiba5
entry:weiba4=第二个元素
entry:weiba3=第四个元素
entry:weiba1=第一个元素
ii.HashMap:存入数据无顺序,key和value都可以储存空值,线程不安全
e.g.
package com.leeyu.test;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestHashMap {
public static void main(String[] args) {
Map<String,String> map=new HashMap();
//增加数据
map.put("weiba1", "121");
map.put("weiba5", "121");
map.put("weiba2", null);
map.put("weiba3", "121");
map.put("weiba4", "121");
map.put(null, "121");
TestHashMap hashmap=new TestHashMap();
//打印结果
hashmap.printMap(map);
//删除
map.remove("weiba4");
hashmap.printMap(map);
//修改
map.replace("weiba3", "weiba3");
hashmap.printMap(map);
}
public void printMap(Map<?,?> map) {
Set<?> entrySet = map.entrySet();
Iterator<?> iterator = entrySet.iterator();
while(iterator.hasNext()) {
System.out.println("entry:"+iterator.next());
}
System.out.println();
}
}
iii.Hashtable:线程安全的
package com.leeyu.test;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestHashtable {
public static void main(String[] args) {
Map<String,String> map=new Hashtable();
//添加元素
map.put("weiba01", "01");
map.put("weiba02", "02");
map.put("weiba03", "03");
map.put("weiba04", "04");
TestHashtable hashtable=new TestHashtable();
//调用遍历map集合方法
hashtable.printHashtable(map);
//删除元素
String remove = map.remove("weiba03");
System.out.println("删除的value:"+remove);
hashtable.printHashtable(map);
//替换元素
map.replace("weiba01", "weiba");
hashtable.printHashtable(map);
}
public void printHashtable(Map<?,?> map) {
Set<?> entrySet = map.entrySet();
Iterator<?> iterator = entrySet.iterator();
while(iterator.hasNext()) {
System.out.print("entry:"+iterator.next()+" ");
}
System.out.println();
}
}
结果------------------------------------------------
entry:weiba01=01 entry:weiba04=04 entry:weiba03=03 entry:weiba02=02
删除的value:03
entry:weiba01=01 entry:weiba04=04 entry:weiba02=02
entry:weiba01=weiba entry:weiba04=04 entry:weiba02=02