集合框架(二)

本文回顾了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
  1. put(Object key,Object value); 存储键值对
  2. get(Object key); 根据键(唯一的)获取值
  3. containsKey(Object key); 判断是否包含指定键
  4. containsValue(Object value); 判断是否包含指定值
  5. size(); 获取集合长度
  6. Set keySet(); 获取所有键集合
  7. Collection values(); 获取所有值的集合
  8. clear(); 清空所有数据
Map集合的遍历
  1. 使用迭代器

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

    1.2遍历键集合(迭代器),然后通过键获取值

  2. 使用增强for

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

    2.2遍历键集合(增强for),然后通过键获取值

  3. 使用键值对集合

    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
  1. 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]
  1. max() / min() 获取最大值 最小值
  2. 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
	}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值