Collection集合与Map集合

手可摘鑫晨

已于 2022-06-06 12:21:31 修改

阅读量161

点赞数 2

文章标签： p2p linq 网络协议 java eclipse

于 2022-06-06 09:08:03 首次发布

本文链接：https://blog.csdn.net/m0_61562689/article/details/125138046

版权

1，Collection集合

Collection<E>：单列集合（接口）

List<E>（接口）：

特点：

1，有索引值

2，可以重复

3，有序排列

List<E>接口中的成员方法：

void add(int index,E e);

E remove(int index);

E get(int index);

E set(int index,E e);

List<E> subList(int beginIndex,int endIndex);

int indexOf(Object o);

int lastIndexOf(Object o);

public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		list.add("dd");
		list.add("ee");		
		list.add(0, "aaa");
		System.out.println(list);
		String removeElement = list.remove(0);
		System.out.println("被删除的元素是："+removeElement);//被删除的元素是：aaa
		System.out.println(list);
		String element = list.get(0);
		System.out.println(element);//aa		
		String replaceElement = list.set(0, "aaa");
		System.out.println("被替换的元素是："+replaceElement);//被替换的元素是：aa
		System.out.println(list);		
		List<String> list2 = list.subList(1, 3);//左闭右开
		System.out.println(list2);		
	}

实现类：

ArrayList(底层实现是数组)

特点：查询快，增删慢

LinkedList(底层实现是链表)

特点：查询慢，增删快

LinkedList<E>类独有的成员方法：

void addFirst(E e);

void addLast(E e);

String removeFirst();

String removeLast();

String getFirst();

String getLast();

public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		list.add("dd");
		list.add("ee");
		
		list.addFirst("aaa");
		list.addLast("eee");
		System.out.println(list);
		
		String first = list.removeFirst();
		System.out.println(first);//aaa
		String last = list.removeLast();
		System.out.println(last);//eee
		System.out.println(list);
		
		first = list.getFirst();
		System.out.println(first);//aa
		last = list.getLast();
		System.out.println(last);//ee		
		
	}

Set（接口）：

特点：

1，没有索引值

2，不能重复

实现类：

TreeSet(底层是红黑树，可排序)

注意：TreeSet新增元素的时候，泛型必须是Comparable类型

构造方法：

public TreeSet();

public TreeSet(Comparator<> c);

public class Test06 {
	public static void main(String[] args) {
		//TreeSet新增元素的时候，泛型必须是Comparable类型
		Set<Person> set = new TreeSet<>();
		set.add(new Person("张三"));
		set.add(new Person("张三疯了"));
		set.add(new Person("张三小"));
		System.out.println(set);
	}
}

class Person implements Comparable<Person>{
	private String name;
	public Person(String name) {
		super();
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}
	  	//主要要说比较的规则
	  		//升序：当前对象-参数对象
	  		//降序：参数对象-当前对象	 
	@Override
	public int compareTo(Person o) {
		//升序
		int result = this.name.length()-o.name.length();		
	}
}

public class Test07 {
	public static void main(String[] args) {		
		//创建Comparator类型的对象
		Comparator<Teacher> c = new Comparator<Teacher>() {
			@Override
			public int compare(Teacher t1, Teacher t2) {				
				  //	升序：
				  //		参数1-参数2
				  //	降序：
				  //		参数2-参数1				 
				int result = t2.getName().length()-t1.getName().length();
				return result;
			}
		};		
		Set<Teacher> set = new TreeSet<>(c);
		set.add(new Teacher("张三"));
		set.add(new Teacher("张三疯了"));
		set.add(new Teacher("张三小"));
		System.out.println(set);
	}
}

class Teacher{
	private String name;	
	public String getName() {
		return name;
	}
	public Teacher(String name) {
		super();
		this.name = name;
	}
	@Override
	public String toString() {
		return "Teacher [name=" + name + "]";
	}
}

HashSet(底层是哈希表，无序)

哈希表：数组+链表+红黑树

注意：如果自定义类型的对象，我们希望添加到HashSet集合中，我们认为成员变量的值相同，就为同一个元素，则需要覆盖重写hashCode方法和equals方法。

LinkedHashSet(底层是链表+哈希表，有序)

2，Collection集合的常用方法

boolean add(E e);	新增一个元素
boolean addAll(E e);	新增多个元素
boolean isEmpty();	判断集合是否为空
boolean contains(E e);	查找元素是否存在
boolean containsAll(E e);	查找多个元素是否都存在
boolean remove(E e);	删除该元素
boolean removeAll(E e);	删除多个元素
int size();	集合元素的个数
void clear();	清空集合
Object[] toArray();	将集合转换为数组
Iterator<E> iterator();	返回一个Iterator对象，用来遍历集合

3，Iterator迭代器

（1）获取迭代器对象

Iterator i = 集合对象.iterator();

（2）判断是否有下一个元素

i.hasNext();

（3）获取元素

i.next();

public static void main(String[] args) {
		Collection<String> c = new ArrayList<>();
		c.add("张三");
		c.add("李四");
		c.add("王五");		
		//获取迭代器对象
		Iterator<String> iterator = c.iterator();
		while(iterator.hasNext()) {
			String element = iterator.next();
			System.out.println(element);
	}

4，增强for循环

介绍：增强for循环的底层就是迭代器。可以遍历集合、数组。

格式：

for(数组的数据类型/集合的泛型变量名:要遍历的集合/数组){

System.out.println(变量名);

}

5，Collections类

static <T> boolean addAll(Collection<T> c,T... array);	添加多个元素到集合中
static void sort(List<> list);	对集合进行升序排序
static <T extends Comparable<T>> void sort(List<T> list);	对集合根据Comparable接口中方法进行排序
static <T> void sort(List<T> list,Comparator<T> c);	对集合根据Comparator接口中方法进行排序
static void shuffle(List<?> list);	对集合进行乱序排序
Collections.reverse(List<T> list);	对集合进行反序排序

6，Map集合

Map<K,V>：双列集合接口

特点：

（1）一个元素是有一个K,一个V两部分组成.

（2）K V可以是任意的引用数据类型。

（3）一个K对应唯一的一个V。K不能重复。

常用实现类：

HashMap implements Map

底层：哈希表

特点：新增顺序和取出顺序不一定一致(无序)

LinkedHashMap extends HashMap

底层：哈希表+链表

特点：新增顺序和取出顺序一致(有序)

TreeMap

底层：红黑树（可排序）

Hashtable：线程安全，效率低

HashMap：线程不安全，效率高

常用方法：

V put(K k,V v);	如果K存在，则新的V替换旧的V，返回被替换的V。如果K不存在，则返回null。
V remove(Object key);	删除元素,根据key删除整个元素，返回被删除元素的V。如果Key不存在，则返回null。
V get(Object key);	根据key获取V，如果key不存在则返回null。
boolean containsKey(Object key);	如果K存在，返回true。如果K不存在，返回false。
boolean containsValue(Object value);	如果V存在，返回true。如果V不存在，返回false。
boolean isEmpty();	判断集合是否为空。
void clear();	清空集合
int size();	获取集合中元素的个数

案例：将双列集合转换为单列集合

public static void main(String[] args) {
		Map<String,Double> map = new HashMap<>();
		map.put("张三", 90.0);
		map.put("张三丰", 99.0);
		map.put("张三疯了", 90.0);		
		  //把Map双列集合转换为单列集合		 
		//获取所有的V
		Collection<Double> values =  map.values();
		System.out.println(values);
		//获取所有的K
		Set<String> set = map.keySet();
		System.out.println(set);
		for(String key:set) {
			//根据key获取V
			Double v = map.get(key);
			System.out.println(key+"--"+v);
		}
	}

Entry<K,V>接口：

K getKey();
V getValue();

public static void main(String[] args) {
		Map<String,Double> map = new HashMap<>();
		map.put("张三", 90.0);
		map.put("张三丰", 99.0);
		map.put("张三疯了", 90.0);
		//获取所有的Entry
		Set<Entry<String,Double>> entrySet =  map.entrySet();
		Iterator<Entry<String,Double>> iterator = entrySet.iterator();
		while(iterator.hasNext()) {
			Entry<String,Double> entry = iterator.next();
			String key = entry.getKey();
			Double value = entry.getValue();
			System.out.println(key+"--"+value);
		}
	}

7，可变参数

定义：

方法名(数据类型... 变量名);

注意事项：

1.一个方法只能有一个可变参数
2.如果有多个参数，可变参数必须是最后一个

public static void main(String[] args) {
		int[] array = {10,20,30,40,50};
		method(array);		
//		method(1,2,3,4,5);//1,2,3,4,5		
//		method();//0
	}	
	public static void method(int... nums) {
		System.out.println(nums.length);
		//我们就把可变参数作为数组去处理
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
	}