集合

最新推荐文章于 2023-06-15 00:01:23 发布

原创最新推荐文章于 2023-06-15 00:01:23 发布 · 141 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#集合 #接口 #Collections类

JavaOOP 专栏收录该内容

12 篇文章

订阅专栏

本文深入讲解了Java集合框架中的Collection和Map接口及其主要实现类，包括ArrayList、HashSet、HashMap等的特点与使用方法，并提供了丰富的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

集合

数组的弊端：一但创建使用后，其大小地址不可改变，而真实当中，数组的个数是不可知的，所以通过集合来解决这个问题;

集合（位于util包中）,集合最大的作用：存储对象（储存对象可以考虑数组和集合）

collection（是集合中最大的接口，区分connection(是连接jdbc用的)，区分Collections(类，两个不同的东西)）

Map（接口）

接口下有多个子接口，子接口下有多个实现类

重点子接口:

List(列表)，集合元素是有序的，可以重复，一个一个存储的

Set（集），集合元素是无序的，不可重复，一个一个存储的

Map（映射），集合是具有“key-value”对的集合，一对一对存储的

重点实现类：

ArrayList,有序的可重复（Collection c=new ArrayList(); ArrayList list=new ArrayList();）

HashSet，无序的不可重复（Set s=new HashSet;）,无序不等于随机性（元素存进去后顺序是无序的，一但确定顺序是不会改变的），底层原理hash算法（重复添加元素，是不能添加进去的，也就是hash算法只会算出一样的值），添加元素所有类必须要求重写equals()和hashCode()方法。

HashMap，无序的（Map map=new HashMap(); HashMap map1=new HashMap();）

集合中常见方法

Collection中的常用方法（15个）

package com.cdz.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class FangFa {
	public static void main(String[] args) {
		Collection co1=new 	ArrayList();
		Collection co2=new 	ArrayList();
		
		System.out.println(co1.size());        //返回此 collection 中的元素个数。
		
		co1.add(1);                            //给指定的集合添加元素，只添加一个元素
		co2.add("abc");
		System.out.println(co1);
		
		co1.clear();                           //移除此 collection 中的所有元素（可选操作）。		
		System.out.println(co1);
		 
		System.out.println(co1.isEmpty());    //集合是否为空，如果为空则返回 true。不为空则返回false
				
		Integer[] a=new Integer[]{1,2,3};             //作用：把指定的数组转成集合
		List<Object> asList = Arrays.asList(a);//这里的a必须是一个类
		//该方法不适用于基本数据类型（byte,short,int,long,float,double,boolean）
		for(Object b:asList)
			System.out.println(b);
		System.out.println(asList);//返回的也是一个类	
	}
}

package com.cdz.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class FangFa2 {
	public static void main(String[] args) {
		Collection co1=new 	ArrayList();
		Collection co2=new 	ArrayList();
		co1.add("ab");//只添加一个元素
		co1.add("dfd");
		co1.add("fdf");
		
		System.out.println("1-------------");
		Object[] array1 = co1.toArray();//把集合变成数组/无参toArray()只能转换成Object类型
		for(Object arr:array1)
			System.out.println(arr);
		System.out.println(array1);//返回的也是一个类
		
		System.out.println("2-------------");
		String[] s=new String[co1.size()];		
		String[] array2 = (String[]) co1.toArray(s);//把集合变成指定类型的数组/有参toArray(指定类型),
		                                            //需要强制转换
		for(Object arr:array2)
			System.out.println(arr);
		
		System.out.println("3-------------");
		co2.addAll(co1);//把集合1的所有元素添加到集合2中
		System.out.println(co2);
		
	}
}

package com.cdz.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class FangFa2 {
	public static void main(String[] args) {
		Collection co1=new 	ArrayList();
		Collection co2=new 	ArrayList();	
		co1.add("ab");
		co1.add("dfd");
		co1.add("fdf");
		co2.add("ab");
		co2.add("dfd");
		co2.add("fdf");
		System.out.println("集合co1="+co1);
		//创建一个Co2的类
		co2.add(new Co2("ab"));//添加了一个对象，体现集合的作用（存储对象）
		System.out.println("集合co2="+co2);
		System.out.println("类Co2="+new Co2("ab"));
		
		System.out.println("--------------------------");
		System.out.println("-----------1--------------");
		System.out.println(co1.contains("ab"));//判断集合co1是否包含ab该元素，返回boolean类型	
		
		System.out.println("-----------2--------------");
		boolean contains1 = co2.contains(new Co2("ab"));
		//这里不只是比较了对象里的内容，还比较了地址，如果只比较对象里的内容，必须得重写类里的hashCode，equals
		//方法(这个可像添加构造器一样，添加)		
		System.out.println(contains1);
		
		System.out.println("-----------3--------------");
		co2.add(new String("www"));	
		boolean contains2 = co2.contains(new String("www"));
		//这里并没有重写hashCode,equals,是因为，String包装类，自动重写了
		System.out.println(contains2);
		
		System.out.println("-----------4--------------");
		System.out.println(co2.containsAll(co1));//集合co2中包含了co1吗
		
		System.out.println("-----------5--------------");
		System.out.println(co1.equals(co2));//集合co1等于co2吗（不比较地址）
		
		System.out.println("-----------6--------------");
		System.out.println(co1.hashCode());//返回集合中的哈希码值（根据内容计算）
		
		System.out.println("-----------7--------------");
		Iterator iterator = co1.iterator();//该集合元素上进行迭代的迭代器,与下面for是一样的
		while(iterator.hasNext()){//只能争对集合使用，不能用于数组
			System.out.println(iterator.next());
		}
		System.out.println("-------------------------");
		for(Object o:co1){//可以用于数组，集合
			System.out.println(o);
		}
		
		System.out.println("-----------8--------------");
		boolean remove = co1.remove("ab");//移除元素
		System.out.println(co1);
		//co1.clear();                      //清空
		//System.out.println(co1);
		
		System.out.println("-----------9--------------");
		co2.removeAll(co1);//在集合co2中把集合co1里有的元素删除
		System.out.println(co2);
		
		System.out.println("-----------10--------------");
		boolean retainAll = co1.retainAll(co2);
		System.out.println(co1);//求交集，并把交集的值给co1;
	}
}

类Co2:重写hashcode和equals

package com.cdz.collection;

public class Co2 {
	//1.属性
	private String name="ab";
	//2.方法
	public String getName() {
		return name;
	}	
	public void setName(String name) {
		this.name = name;
	}
	//3.构造器
	public Co2() {
		super();
	}
	public Co2(String name) {
		super();
		this.name = name;
	}
	@Override//菜单栏source------>Generate hashcode and equals
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		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;
		Co2 other = (Co2) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
	//4.代码块
	//5.内部类
}

注意：

用到对象.方法的地方都可以shift+alt+l，把类型转出来，也就是他应该要用到的类型，Object是任何类都可以，通用的，集合用到的类型是包装类

ArrayList中的部分方法

package com.cdz.arraylist;

import java.util.ArrayList;

public class FangFa {
	public static void main(String[] args) {
		ArrayList list1=new ArrayList();
		ArrayList list2=new ArrayList();
		list1.add("a");
		list1.add("b");
		list1.add("c");
		System.out.println("集合list1:"+list1);
		System.out.println(list1.indexOf("f"));//返回此列表中首次出现的指定元素索引，没有就返回-1
		
		Object clone = list1.clone();//复制一份给Object
		System.out.println(clone);
		
		list1.remove("b");//移除元素
		System.out.println(list1.get(0));
		
		list1.set(1, "b");//指定位置修改元素
		System.out.println(list1);
		
		list1.add(2, "c");//指定位置增加元素
		System.out.println(list1);
		
		System.out.println(list1.get(2));//指定位置上查找元素
	}
}

HashMap中的部分方法

Map<Object key,Object value>,key用Set存放的，不可重复（无序），value 用Collection存放的，可重复;当有多个一样的元素同时存进集合，只能存放最后一个key=value,前一个被覆盖

package com.cdz.hashmap;

import java.util.HashMap;
import java.util.Map;

public class FangFa {
	public static void main(String[] args) {
		Map map=new HashMap();//Map<Object key,Object value>/<关键字，类型的值>
		HashMap map1=new HashMap();
		map.put(1, "abc");//向map集合中添加健值对
		map.put(2, "fdd");
		map.put(3, "abc");
		System.out.println(map);
		map1.put(1, "abc");//向map集合中添加健值对
		map1.put(2, "fdd");
		map1.put(3, "abc");
		
		System.out.println(map1);
		
		System.out.println(map.size());//集合中健值对的个数
		
		System.out.println(map.get(2));//通过key来取valuer 
		
		boolean conKey = map.containsKey(5);//映射包含指健值的映射关系，返回ture(集合里面是否包含key=5的这个值)
		System.out.println(conKey);
		
		boolean conValue = map.containsValue("abc");//如果此映射将一个或多个键映射到指定值，
		                                    //则返回 true。(集合里面是否包含value="abc"的这个值)
		System.out.println(conValue);
		
		System.out.println(map.isEmpty());//判断是否为空
				
		System.out.println(map.equals(map1));//判断两个集合是否相等（比较指定对象是否相等）
				
	}
}

遍历key集，遍历vlaues集，遍历key-values对

package com.cdz.hashmap;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class FangFa {
	public static void main(String[] args) {
		// Map<K, V> map=new HashMap<>();
		Map map = new HashMap();// Map<Object key,Object value>/<关键字，类型的值>
		map.put(1, "abc");// 向map集合中添加健值对
		map.put(2, "fdd");
		map.put(3, "abc");

		// 遍历Key集
		Set keySet = map.keySet();// map集合中获取key//由于set是存放无序的，也就是key是无序的
		for (Object k : keySet) {
			System.out.println(k);
		}

		// 遍历vlaues集
		Collection values = map.values();// map集合中获取values
		// Collection是存放有序的，这里的values根据key来有序放的
		for (Object v : values) {
			System.out.println(v);
		}

		// 遍历key-values对1
		Set keySet2 = map.keySet();
		for (Object k2 : keySet2) {
			System.out.println(k2 + " " + map.get(k2));
		}
		System.out.println(map);//这个得出是整个集合，不是一个一个的
		// 遍历key-values对2
		Set en = map.entrySet();
		for (Object e : en) {
			System.out.println(e);
		}

	}
}

类Collections

Collections 是一个静态类，可以直接类.方法使用

package com.cdz.collections;

import java.util.ArrayList;
import java.util.Collections;

public class Lei {
	public static void main(String[] args) {
		ArrayList arrList= new ArrayList();
		ArrayList arrList1= new ArrayList();
		arrList.add(1);
		arrList.add(5);
		arrList.add(3);
		
		//Collections是一个静态的类，所以可以类.方法（工具类）
		Collections.sort(arrList);//对集合排序（升序）
		System.out.println(arrList);
		
		Collections.swap(arrList, 0, 2);//指定列表索引位置，交换元素;
		System.out.println(arrList);
		
		Object max = Collections.max(arrList);//求最大值
		System.out.println(max);
		
		Object min = Collections.min(arrList);//求最小值
		System.out.println(min);
		
		Collections.reverse(arrList);//反转列表
		System.out.println(arrList);
		
		boolean disjoint = Collections.disjoint(arrList, arrList1);//指定两个集合中没有相同元素,返回true
		System.out.println(disjoint);                              //有相同的元素就返回false
		
		
	}
}