我要做技术！！-java基础篇学习笔记&理解5---集合

最新推荐文章于 2024-04-16 16:33:40 发布

yan1yu3

最新推荐文章于 2024-04-16 16:33:40 发布

阅读量78

点赞数

文章标签： java集合

本文链接：https://blog.csdn.net/yan1yu3/article/details/101532768

版权

集合

集合概述

集合主要有两大子接口：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

yan1yu3

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
我要做技术！！-java基础篇学习笔记&理解5---集合

集合集合概述集合主要有两大子接口：collection和map，这两大接口主要区别就是map中存储的元素都是一对数据（KEY:VALUE）。collection的两个子接口：list和set。以上说的这些接口实际操作过程中不常使用，经常用的是下方的子接口。list的三个实现类（用于使用过程中的）：arraylist(列表)，vector（矢量），linkedlist（链表）set的三个...
复制链接

扫一扫