Collection详解

最新推荐文章于 2024-03-06 14:52:03 发布

W1455267492

最新推荐文章于 2024-03-06 14:52:03 发布

阅读量2k

点赞数

CC 4.0 BY-SA版权

文章标签： collection

本文链接：https://blog.youkuaiyun.com/W1455267492/article/details/97948293

一张图

[外链图片转存失败(img-iDk35ERA-1564570780813)(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中通过内部类完成了对于改接口的实现获取的其实是实现类对象

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、迭代器

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());
		}	
	}
}

package com.mage.collection.lian;
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;
	}
}

ArrayList类

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

常见方法：

迭代：

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

LinkedList类

底层：双向链表

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

常见方法：

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

Vectorl类

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

HashSet类

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

l pollFirst pollLast removeFirst removeLast
添加 offer offerFirst offerLast addFirst addLast