集合框架(二)-优快云博客

本文回顾了Collection、List、Set特点及相关集合区别与常用API，如ArrayList和LinkedList。介绍了Map使用，包括常用API和遍历方式，还阐述了泛型作用，以及Collections常用API，如排序、获取最值和打乱元素等。

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

集合框架(二)

回顾

Collection、List、Set的特点

Collection：不唯一的，无序的

List：不唯一的 有序

Set：唯一的 无序的

Collection和Collections的区别？

Collection是集合的顶级接口

Collections是集合的工具类

ArrayList的常用API

存储数据：

boolean add(Object obj); 向集合后追加元素

void add(int index,Object obj); 向集合的指定位置添加元素原有位置元素依次后移

删除数据：

remove(int index); 根据下标来删除元素

remove(Object obj); 将指定值删除

获取集合的长度： size();

**获取集合中的元素：**get(int index);

**判断集合中是否包含指定元素：**contains(Object obj);

LinkedList的常用API

addFirst(Object obj);

addLast(Object);

removeFirst();

removeLast();

getFirst();

getLast();

ArrayList和LinkedList的区别

ArrayList 底层是数组结构，它在每一次增删时都会重新创建新的数组，所以在增删方面效率比较低。因为数组有固定的下标，所以在查询方面效率比较高。

LinkedList 底层是链表结构(数据值和指针域组成) ，在增删方面尤其是首尾增删效率比较高，但是因为没有固定的下标，所以在查询方面效率比较低。

HashSet

equals() hashcode()

集合的遍历

ArrayList：

1.for(int i = 0; i < list.size(); i++){

}

2.增强for

for(临时类型临时的变量名 : 集合名){

}

3.迭代器

Iterator<xxx>   iterator = list.iterator();
	while(iterator.hasNext()){
			iterator.next();

		}

LinkedList：

同上！

HashSet：

1.增强for

2.迭代器

1.Map的使用

HashMap

HashTable

课程编码和课程信息对应的需求。

BD001 -> Java课程

BD002 -> UI课程

BD003 -> C#课程

Key -Value 键值对夫妻对！

常用API

put(Object key,Object value); 存储键值对
get(Object key); 根据键(唯一的)获取值
containsKey(Object key); 判断是否包含指定键
containsValue(Object value); 判断是否包含指定值
size(); 获取集合长度
Set keySet(); 获取所有键集合
Collection values(); 获取所有值的集合
clear(); 清空所有数据

Map集合的遍历

使用迭代器

1.1Map集合获取所有的键集合

1.2遍历键集合(迭代器)，然后通过键获取值
使用增强for

2.1Map集合获取所有的键集合

2.2遍历键集合(增强for)，然后通过键获取值
使用键值对集合

3.1Map集合获取entrySet(键值对的Set集合)

3.2遍历entrySet将其中每一个entry取出来

3.3从entry中将键和值取出来

public static void main(String[] args) {

		// 创建集合
		Map<String,String> map = new HashMap<String,String>();
		// 添加到集合中   存储时无序
		map.put("CN", "中国");
		map.put("US", "美国");
		map.put("UK", "英国");
		
		// 键必须唯一   值可以重复
		// 如果给相同的key进行赋值  那么会进行覆盖(更新)
		map.put("CN", "中国1");
		
		System.out.println("---------------1--------------------");
		Collection<String> values = map.values(); // 所有值的集合
		for (String value : values) {
			System.out.println(value);
		}
		
		System.out.println("----------------2-------------------");
		Set<String> keySet = map.keySet();//所有键的集合
		for (String key : keySet) {
			System.out.println(key);
			//根据键获取值
			String value = map.get(key);
			System.out.println("打印值"+value);
		}
		
		//可以用map的迭代器遍历
		Iterator<String> iterator = keySet.iterator();
		while(iterator.hasNext()) {
			String key = iterator.next();
			String value = map.get(key);
			System.out.println(key +"=="+value);
		}
		
		
		System.out.println("---------------3--------------------");
		//获取所有键值对集合
		Set<Entry<String, String>> entrySet = map.entrySet();
		for (Entry<String, String> entry : entrySet) {
			System.out.println(entry);
			String key = entry.getKey(); // 获取键
			String value = entry.getValue();//获取值
			System.out.println(key+"   -- >    "+value);
		}
		
		//可以用map的迭代器遍历
		Iterator<Entry<String, String>> iterator2 = entrySet.iterator();
		while(iterator.hasNext()) {
			Entry<String, String> next = iterator2.next();
			String key = next.getKey();
			String value = next.getValue();
			System.out.println(key +"=="+value);
		}
		
	}

2. 泛型的作用

包装类型

必须使用引用数据类型

public class Demo3 {
    public static void main(String[] args) {

        // 泛型：用来限制集合中元素的类型(获取数据后可以不用强转)
        // 泛型在限定类型时，类型必须是引用数据类型
        // int -> Integer
        /*ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(20);*/

        // double -> Double
        /*ArrayList<Double> arrayList = new ArrayList<Double>();
        arrayList.add(20.1);
        System.out.println(arrayList);*/
        // byte -> Byte
        // short -> Short
        // long -> Long
        // float -> Float
        // boolean -> Boolean
        // char -> Character

        // 基本数据类型是没有方法和属性(类的信息)的
        Integer a = 10;
    }
}

3. Collections的了解

常用API

sort(集合); 给集合进行排序升序

		List<Integer> list=Arrays.asList(1,7,2,3,6,5);
		Collections.sort(list);
		System.out.println(list);//[1, 2, 3, 5, 6, 7]

max() / min() 获取最大值最小值
shuffle() 打乱集合内元素

public static void main(String[] args) {
		List<Integer> list=Arrays.asList(1,2,3,6,5);
		Integer max = Collections.max(list);
		System.out.println(max);//输出最大值6
	}