Collection详解

最新推荐文章于 2022-06-19 23:13:27 发布

W1455267492

最新推荐文章于 2022-06-19 23:13:27 发布

阅读量450

点赞数 1

文章标签：详解collection

本文链接：https://blog.csdn.net/W1455267492/article/details/98101662

版权

一张图

[外链图片转存失败(img-Goi31IRj-1564662892841)(D:\360MoveData\Users\万达爷\Desktop\码歌学习\7-29\集合.png)]

泛型

1：什么是泛型?

广泛的类型也是一种数据类型而这种数据类型可以是任意类型编写过程当中不能确定该类型
创建对象时可以指定泛型的具体类型

2：

泛型是编译期行为，只能在编译器有效如果能够跨过编译期那么泛型就没有任何意义

泛型类

如何定义泛型类
在类后加<> 括号中编写任意长度任意字符不能是数值
一般情况下我们通过大写的26个字母去声明当前泛型 T type E element

泛型类<具体类型> 变量名 = new 泛型类<>();

泛型接口

实现类实现泛型接口时不指定泛型类型此时创建实现类对象是可以指定泛型类型
class UserServiceImpl implements UserService
实现类实现泛型接口时指定泛型类型那么将确定泛型类型
class UserServiceImpl implements UserService

泛型方法

方法中使用泛型该方法就是一个泛型方法
静态方法无法使用泛型类中声明的泛型类型因为泛型类型的确定是创建对象时确定的
而静态方法是先于对象存在的，如果要使用，在当前静态方法上声明泛型类型
public static <泛型类型> vaid 方法名()

public class Test {
	public static void main(String[] args) {
		//使用泛型类
		Genric<Integer> g = new Genric<Integer>();//对于当前g对象而言 它的泛型E的类型是String
		g.add(123);//参数只能是integer类型
		
		//声明泛型类 不指定泛型的具体类型
		Genric g1 = new Genric();
		g1.add("123");// 此时泛型E的类型是String
		g1.add(1);//此时泛型类型是Integer
		Genric.fun("123");
	}
}

迭代器

Iterable 是java.lang包下的接口实现改接口都能够作为foreach的目标

Iterator 是java.util包下的接口迭代器用来迭代当前集合对象的

Iterator 是一个接口 ArrayList中通过内部类完成了对于改接口的实现获取的其实是实现类对象

比较器：

外部比较器：

java.util.Compartor接口指定的。

如果要使用外部比较器，实现该接口重写compare方法
自定义排序规则可以随着业务扩展随时变化的

内部比较器

java.lang.Comparable接口指定

如果要使用内部比较器，实现该接口重写compareTo方法
不利于后期扩展

collection接口

存储元素的特点无序可重复对于所有的集合框架中的对象只能存储引用类型

添加元素

add(Object) 添加元素返回是否添加成功 true/false

addAll(Coll) 添加一个集合

删除元素

clear()清空所有元素

remove()移除一个

removeAll(Coll) 移除交集

retainAll(Coll) 保留交集

修改元素

没有修改元素

查看元素

isEmpty

size

contains

containsAll

package com.mage.collectio.lian;
import java.util.ArrayList;
import java.util.Collection;

public class Test01 {
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		coll.add("玛利亭");
		coll.add(2);
		System.out.println(coll);
		Collection coll2 = new ArrayList();
		coll2.add("肖立亭");
		coll2.add("java");
		
		System.out.println(coll.addAll(coll2));
		System.out.println(coll);
		
		//coll.clear();
		System.out.println(coll.remove("java"));
		System.out.println(coll.removeAll(coll2));
		System.out.println(coll.retainAll(coll2));
		System.out.println(coll);
        
		System.out.println("查看当前集合是否为null:"+coll.isEmpty());
		System.out.println("查看当前集合元素个数："+coll.size());
		System.out.println("查看当前集合是否包含元素2："+coll.contains(2));
	}
}

List接口

有序可重复可以是null值

定义：

public interface List extends Collection

常见方法：

增加：add(index,obj) add(obj) addAll(Coll) addAll(index,coll)
删除：remove(index/obj) clear() removeAll(Coll) retainAll(coll)
修改： set(index,obj)
查看：indexOf(obj) lastIndexOf(obj) subList(sindex,eindex)
isEmpty() get(index) size() contains(obj) contaisAll(coll)
迭代：
普通for 增强for 迭代器(iterator[不能支持并发修改] listIterator[支持并发修改])

package com.mage.collection;
import java.util.ArrayList;
import java.util.List;

public class Test03 {
	public static void main(String[] args) {
		//创建对象
		List ls = new ArrayList()
		//添加元素
		ls.add(1);
		ls.add(1, "李四");//无返回值
		ls.add(2);  //[1，李四，2]
		ls.add("嘿嘿");
		//删除操作
		ls.remove(Integer.valueOf(1));// int   Object
		//修改
		ls.set(0, "嘿嘿");
		//查看元素
		System.out.println("为null判定："+ls.isEmpty());
		Object obj = ls.get(0);
		System.out.println("查看指定位置上的元素："+obj);
		System.out.println(ls);
		List newLs = ls.subList(0, 1);
		System.out.println(newLs);
		System.out.println("查询指定元素的所有："+ls.indexOf(2));
		System.out.println("查询指定元素的索引(最后一次)："+ls.lastIndexOf("嘿嘿"));
		System.out.println("元素个数："+ls.size());	
	}
}

package com.mage.collection.lian;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class TestList {
	public static void main(String[] args) {
		List<String> li = new ArrayList<String>();
		li.add("光阴");
		li.add("天地玄黄");
		li.add("呵呵");
		System.out.println("普通for循环");
		for(int i = 0;i<li.size();i++) {
			System.out.println(li.get(i));
		}
		for(String str:li) {
			System.out.println(str);
		}
		System.out.println("正序迭代：");
		ListIterator it = li.listIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("逆序迭代：");
		while(it.hasPrevious()) {
			System.out.println(it.previous());
		}
	}
}

Set接口

无序唯一

定义：

public interface Set extends Collection

常见方法：

add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator

迭代方法：

foreach、迭代器

迭代器接口：

Iterator 用来迭代元素
Iterable 可以作为foreach的目标

比较器

内部比较器

外部比较器

package com.mage.collection.lian;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test01 {
	public static void main(String[] args) {
		Set<String> sets = new HashSet<String>();
		sets.add("万达爷");
		sets.add("万哥");
		sets.add("小平平");
		sets.add("吴姿");
		
		System.out.println(sets.add("小平平"));
		System.out.println(sets);
		System.out.println("迭代元素：");
		for(String str:sets) {
			System.out.println(str);
		}
		System.out.println("Iterator用for语句变种写法：");
		for(Iterator<String> it = sets.iterator();it.hasNext();) {
			System.out.println(it.next());
		}	
	}
}

Map接口

数据： k-v 键值的方式存储
k：唯一无序 (set) v 无序可重复 (collection)

常见方法：

put(k,v) get(k) containsKey(k) keySet()
remove(k) size() containsValue(v) values()

迭代方法：

获取键迭代键的过程中通过get方法获取值
for(Object key:keySet()){
sout(k+"="+map.get(k));
}
获取Entry对象，通过getKey和getValue获取键和值

//获取entry对象

// 返回一个set集合该集合中的每个元素都是 entry对象

Set<Entry<String, String>> kvs = mps.entrySet();

// 实际是 HashSet中的Node对象因为Node实现了Map中的Entry接口

for(Entry<String, String> entry:kvs) {

System.out.println(entry.getKey()+"==="+entry.getValue());

}

ArrayList类

扩容2倍
底层：数组
优缺点分析：通过索引获取元素以及迭代元素比较快但是添加、删除很慢

常见方法：

迭代：

普通for 增强for 迭代器(iterator[不能支持并发修改] listIterator[支持并发修改])

package com.mage.collection;
import java.util.ArrayList;
import java.util.Iterator;
public class Test08 {
	public static void main(String[] args) {
		ArrayList<String> ls = new ArrayList<>();
		//添加元素
		ls.add("人在囧途");
		ls.add("扫毒");
		ls.add("七龙珠");
		ls.add(1,"头号玩家");
		for(int i = 0;i<ls.size();i++) {
			System.out.println(ls.get(i));
		}
		for(String str:ls) {
			System.out.println(str);
		}	
		for(Iterator<String> it = ls.iterator();it.hasNext();) {
			System.out.println(it.next());
		}	
	}
}

LinkedList类

底层：双向链表

优缺点: 添加、删除快获取元素慢

常见方法：

和List一样多了一些头尾操作：
查看 getFirst getLast element头 peek peekFirst peekLast
删除 poll pollFirst pollLast removeFirst removeLast
添加 offer offerFirst offerLast addFirst addLast

package com.mage.collection;
import java.util.LinkedList;
public class Test09 {
	public static void main(String[] args) {
		//1: 创建对象
		LinkedList<String> ls = new LinkedList<>();
		//2:添加元素
		ls.add("不知火舞");
		System.out.println(ls.get(0));	
		System.out.println(ls);
		ls.add("橘右京");
		ls.add("娜可露露");
		ls.add("宫本武藏");
		// 多了一些针对于头尾元素的操作
		ls.addFirst("草薙京");
		ls.addLast("八神庵");
		System.out.println(ls.offer("春丽"));//添加到末尾
		System.out.println(ls.offerFirst("春丽"));//添加到末尾
		System.out.println(ls.offerLast("春丽"));//添加到末尾
		System.out.println(ls);
		System.out.println(ls.element());//获取头元素
		System.out.println(ls.getFirst());
		System.out.println(ls.getLast());
		System.out.println(ls);
		//ls = null;
		System.out.println(ls.peekFirst());
		System.out.println(ls.peek());	
	}
}

Vectorl类

底层：数组线程安全速度慢安全 1.5倍

HashSet类

底层：数组+链表?
优缺点：添加、删除、修改效率都很高
常见方法：
add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator
迭代方法：
foreach、迭代器
注意事项：
hashset存储自定义对象时一定要重写hashcode和equals方法。

package com.mage.collection.hashset;
import java.util.HashSet;
import java.util.Set;
public class Test02 {
	public static void main(String[] args) {
		HashSet<User> sh = new HashSet<>();
		sh.add(new User(10,"肖狗"));
		sh.add(new User(9,"hanhan"));
		sh.add(new User(8,"建狗"));
		System.out.println(sh);
	}
}
class User{
	private int money;
	private String name;	
	public User() {
		// TODO Auto-generated constructor stub
	}
	public User(int money, String name) {
		super();
		this.money = money;
		this.name = name;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [money=" + money + ", name=" + name + "]";
	}	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + money;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (money != other.money)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}	
}

TreeSet:
底层：树红黑树 / 二叉树 / 平衡树
优缺点：维护数据的大小（有序），添加速度和删除速度高于ArrayList 比其他的都低
查询速度高于List 低于Hash。
如果对于存储的数据有排序的要求，那么首选TreeSet。
常见方法：
add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator
多了一些针对于排序元素的操作 first last floor ceiling higher lower
迭代方法：
foreach、迭代器
注意事项：
如果存储的元素需要按照指定的需求进行排序，创建TreeSet对象时指定比较器。
如果存在的元素是自定义对象：
1：要么自定义对象的所属类实现了内部比较器Comparable接口重写compareTo方法
2：要么创建TreeSet对象是指定外部比较器Comparetor接口重写compare方法
set中每个元素存储的时候都是存储在一个map集合中 map集合的键是set中的元素， map中的值是自动添加的一个默认值

package com.mage.collection.treeset;

import java.util.Comparator;
import java.util.TreeSet;

public class Test01 {
	public static void main(String[] args) {
		TreeSet<String> set = new TreeSet<>(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o2.length()-o1.length();
			}
		});
		set.add("史泰龙1");
		set.add("杰森斯坦森12");
		set.add("奥黛丽赫本123");
		set.add("小李子12");
		set.add("埃琳娜123");
		System.out.println(set);
	}

}

HashMap类

计算key值
底层：数组+链表?
优缺点：添加、删除、修改效率都很高
存储自定义对象作为键时要保证当前自定义类重写hashcode和equals方法
什么情况下要重写，当前两个对象的属性相同我们觉得是同一个对象此时要重写。

TreeMap类

计算key
底层：红黑树
优缺点：维护数据的大小（有序），添加速度和删除速度高于ArrayList 比其他的都低
查询速度高于List 低于Hash。
如果对于存储的数据有排序的要求，那么首选TreeMap。
如果存储的元素需要按照指定的需求进行排序，创建TreeMap对象时指定比较器。
如果存在的元素是自定义对象：
1：要么自定义对象的所属类实现了内部比较器Comparable接口重写compareTo方法
2：要么创建TreeMap对象是指定外部比较器Comparetor接口重写compare方法

package com.mage.map;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class Test03 {
	public static void main(String[] args) {
		TreeMap<String,Integer> ts = new TreeMap<>();
		ts.put("balabala小魔仙",30 );
		ts.put("z jake",136 );
		ts.put("yakamaka 花园宝宝", 45);
		System.out.println(ts);
		System.out.println("查找大于或等于给定元素的最小元素："+ts.ceilingKey("p"));
		System.out.println("查找大于或等于给定元素的最小元素："+ts.ceilingEntry("p"));
		Set<String> sets = ts.keySet();
		for(String key:sets) {
			System.out.println(key+"="+ts.get(key));
		}
		Set<Entry<String, Integer>> kvs = ts.entrySet();
		for(Entry<String, Integer> entry:kvs) {
			System.out.println(entry.getKey()+"="+entry.getValue());
		}	
	}
}

Arrays类

针对数组

Collections类

针对集合操作

30 );
ts.put(“z jake”,136 );
ts.put(“yakamaka 花园宝宝”, 45);
System.out.println(ts);
System.out.println(“查找大于或等于给定元素的最小元素：”+ts.ceilingKey(“p”));
System.out.println(“查找大于或等于给定元素的最小元素：”+ts.ceilingEntry(“p”));
Set sets = ts.keySet();
for(String key:sets) {
System.out.println(key+"="+ts.get(key));
}
Set<Entry<String, Integer>> kvs = ts.entrySet();
for(Entry<String, Integer> entry:kvs) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
}


#### Arrays类

                针对数组

#### Collections类

		针对集合操作

W1455267492

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collection详解

一张图[外链图片转存失败(img-Goi31IRj-1564662892841)(D:\360MoveData\Users\万达爷\Desktop\码歌学习\7-29\集合.png)]泛型1：什么是泛型?广泛的类型也是一种数据类型而这种数据类型可以是任意类型编写过程当中不能确定该类型创建对象时可以指定泛型的具体类型2：泛型是编译期行为，只能在编译器有效如果能够跨过编译期那么...
复制链接

扫一扫