Java容器类总结

package test2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.TreeMap;
import java.util.TreeSet;

public class Test {
	public static void main(String[] args) {
		Collection<Integer> collection=new ArrayList<Integer>(Arrays.asList(2,3,4,5));
		//泛型也支持向上转型,传递子类
		Integer[] is=new Integer[]{6,7,8,9,0};
		collection.addAll(Arrays.asList(is));
		Collections.addAll(collection, 1,2,3,4);
		Collections.addAll(collection, is);
		System.out.println(collection);
		System.out.println();
		//显式类型参数声明
		List<Integer> list=Arrays.<Integer>asList(1,2,3,5);
		//为什么这里在输入一个就报错?了解底层实现才能解释
		//list.add(2);
		System.out.println(list);
		System.out.println("------------------------------");
		System.out.println(fill(new ArrayList<String>()));//按照被插入的顺序存储元素
		System.out.println(fill(new LinkedList<String>()));//按照被插入的顺序存储元素,两个list的区别仅在于某些操作效率不同
		System.out.println(fill(new HashSet<String>()));//不允许重复元素,随机存储,为的是最快的获取元素
		System.out.println(fill(new TreeSet<String>()));//不允许重复元素,按照比较结果的升序排列,也就是前面小后面大
		System.out.println(fill(new LinkedHashSet<String>()));//不允许重复元素,按照插入元素存储
		System.out.println(fill(new HashMap<String,String>()));//键值对,键不能重复,存储随机,最快获取
		System.out.println(fill(new TreeMap<String,String>()));//键值对,键不能重复,按照键的升序排列
		System.out.println(fill(new LinkedHashMap<String,String>()));//键值对,键不能重复,按照插入顺序排列,还保留了hash的查询速度
		//Collections和Arrays一样,一个是对容器的各种操作,一个是对数组的各种操作
		//对list进行排序
		Collections.sort(list); 
		//打乱顺序
		Collections.shuffle(list);
		//subList 交集操作
		list.subList(1,3);
		//contains
		list.contains(11);
		//containsAll
		list.containsAll(list);
		//retainAll
		list.retainAll(list);
		//addAll
		list.addAll(list);
		//toArray 类似于字符串转化数组操作
		list.toArray();
		//替换一处元素
		list.set(1, 11);
		list.clear();
		System.out.println(list.isEmpty());;
		//总结,容器类中有大量的方法,熟脸掌握这些方法是提高开发效率的必备。
		//在工具类Collections中,有addAll()、sort()、shuffle()等常用方法
		//在list及其子类中,有add、remove、get、addAll、subList、retainAll、contains、containsAll、toArray等一系列常用方法
		
		//迭代器可以遍历删除元素、迭代器统一了对容器的访问方式
		//ListIterator只能适用于list,可以双向移动,可以修改元素
		//linkedlist有许多同质的方法,为了实现栈、队列、双端队列而增加的接口方法
		//stack
		//set 接口和collection相同,没有其他额外的接口,只是实现了这些接口而已
		//用TreeSet排序是按照字典序,大小写分开,如果不想分开,可以向构造器传入String.CASE_INSENSITIVE_ORDER比较器
		
		//用map统计数据出现次数的最好方法
		Map<Integer,Integer> map=new HashMap<Integer,Integer>();
		int[] array=new int[]{2,3,4,6,2,6,89,5,4,3};
		//不管键存在不存在,直接get,然后用null判断,为null则初始化为1,否则则加一操作
		for(int num:array){
			Integer a=map.get(num);
			map.put(num, a==null?1:a+1);
		}
		System.out.println(map);
		//map其他用法和方法
		map.containsKey(1);//key只能有一个
		map.containsValue(2);//value可以有多个重复,只要key不同就行
		map.keySet();	//返回键的set序列
		map.values();	//返回值的collection
		map.entrySet();	//返回键值对的set序列
		Map.Entry<Integer, Integer> entry=(Entry<Integer, Integer>) map.entrySet();
		entry.getKey();
		entry.getValue();
		//queue 因为linkedlist实现queue的接口,所以可以将linkedlist向上转型来完成queue的操作
		Queue<Integer> queue=new LinkedList<Integer>();
		//只要实现了iterable返回一个iterator对象,就可以使用foreach语法对容器或者自己的实现类进行遍历
	}
	static Collection<String> fill(Collection<String> collection){
		collection.add("rat");
		collection.add("cat");
		collection.add("dog");
		collection.add("dog");
		return collection;
	}
	static Map<String, String> fill(Map<String, String> map){
		map.put("rat", "fuzzy");
		map.put("cat", "rags");
		map.put("dog", "bosco");
		map.put("dog", "spot");
		return map;
	}
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值