java常用基本集合类操作

public class CollectionsIntroduction {

@SuppressWarnings("unchecked")
public static void main(String[] args){
	
	/**
	 * 数组大小不可变，但性能好，，集合大小可变，性能偏弱
	 * 
	 * 集合分为四大类：Collection,List,Set,Map，，均为接口，由具体的实现类实例化
	 * 		List和Set来自于Collection，Map独立，，集合类中都包含Iterator，用于遍历如list.iterator()得到 Iterator类
	 */
	List list = new ArrayList();
	Map map = new HashMap();
	Set set = new HashSet();
	int[] arr = new int[5];
	
	/**
	 * 	List: 按添加顺序保存的一系列对象组合，元素可重复
	 * 	Set: 数学集合，内部元素不可重复，对象有顺序，但是不是按照插入顺序排列，，有交并减的概念；；（用equals函数判断对象重复，若已存在集合中，后添加的将被忽略，而不是覆盖）
	 * 	Map: 键值对组合，键唯一，值任意，，内部有排序，但不是插入顺序
	 */
	
	for(int i=0; i<5; i++){
		list.add(i, Math.random());
	}
	System.out.println(list);
	
	for(int i=0; i<5; i++){
		map.put(i, Math.random()*10);		//打印出 = 连接的键值对
	}
	System.out.println("map!!");
	System.out.println(map);
	
	for(int i=0; i<5; i++){
		set.add(i);
	}
	System.out.println(set);
	
	for(int i=0; i<5; i++){
		arr[i] = (int) Math.random();
	}
	System.out.println(arr);	//直接打印数组，出来的是对象地址，不是内部元素
	/**
	 * 所以，集合类直接打印可以打印出元素，数组类直接打印打不出元素，只能打出类对象
	 */
	
	/**
	 * 	带Hash前缀的，一般都具有快速查找能力,如 HashMap和HashSet
	 * 	带有Tree前缀的一般是 升降序有序排序的，，如TreeMap和TreeSet
	 * 	LinkedHashMap 和 LinkedHashSet 既具有 HashMap和HashSet的功能，同时也是按照插入顺序排列，具有list的特点
	 * 	Quene是一个队列，Stack是一个堆栈
	 * 	Hashtable不推荐
	 */
	
	
	/**
	 * 	list集合遍历有三种形势
	 * 		1、普通for循环
	 * 		2、foreach形势for循环	(本质是)
	 * 		3、iterator遍历
	 * 	另外，list还有一个单独的遍历器 ListIterator，使用 list.listIterator()获得，可以向前或者向后遍历，更方便
	 */
	
	//以List为例
	List<Integer> list2 = new ArrayList<Integer>();
	for(int i=0; i<5; i++){
		list2.add(i*2);
	}
	
	//普通for循环
	for(int i=0; i<list2.size(); i++){
		System.out.println("普通for-->"+list2.get(i));
	}
	//foreach
	for(int i : list2){
		System.out.println("foreach-->"+i);
	}
	//iterator迭代器
	Iterator<Integer> it = list2.iterator();
	while(it.hasNext()){
		System.out.println("iterator_for-->"+it.next());
	}
	
	System.out.println("*****************");
//***********************************//
	
	/*
	 * Set遍历，遍历方式基本同上，还可以使用 toArray()转换为数组对象，进行遍历
	 */
	Set<Integer> s = new HashSet<Integer>();
	for(int i=0; i<5; i++){
		s.add(new Random().nextInt(10));
	}
	System.out.println(s);
	Object[] arr_set = (Object[]) s.toArray();	//返回的是个Object数组，，，尝试转型Integer数组，不为何总是报错
	System.out.println(s.toArray().getClass());
	System.out.println(s.getClass());
	for(Object i : s){
		System.out.println(i);
	}
	
	
	/*
	 * Map遍历，大体有2中形势
	 * 	1、先得到keySet键值集合，再遍历键值，通过get(key)取值
	 * 	2、直接得到entrySet键值对集合，，一一取值
	 */
	
	Map<Integer,String> map2 = new HashMap<Integer,String>();
	Random rand = new Random();
	for(int i=1; i<4; i++){
		int v = rand.nextInt(100);
		System.out.println(v);
		map2.put(i, String.valueOf(v));
	}
	map2.put(20, "110");
	map2.put(10, "120");
	
	System.out.println(map2);			//打印出的完全是按照插入顺序来的？？
	System.out.println("=========");
	
	System.out.println(map2.keySet());	//keySet顺序 与 values 出来的顺序一致
	System.out.println(map2.values());
	
	for(int x : map2.keySet()){
		System.out.println(x + "-->" + map2.get(x));
	}
	for(Map.Entry<Integer, String> entry : map2.entrySet()){
		System.out.println(entry.getKey() + "==>" + entry.getValue());
	}
	
	/*
	 * 	集合类不推荐在遍历的时候进行添加或者删除元素，但可以进行修改，，，因为添加或者删除会变动元素的index，造成紊乱
	 * 	-->因为集合中的元素，删除一个，后续的元素会自动向前补齐
	 * 
	 * 	有两种方式可以多条删除元素：1️。先拿出数组对象，以数组对照删除； 	2。使用遍历器
	 */
	
	System.out.println(list2);
	ArrayList<Integer> list2_copy = (ArrayList<Integer>) list2;
	//1、使用对应数组 一一指定元素
	Object[] list_arr = list2.toArray();		//一个集合类执行 toArray() 之后，得到一个 Object[] 类，无法具体指定数组元素类型，只能到Object级别
	for(Object i : list_arr){
		list.remove(i);
	}
	//2、使用遍历器
	Iterator ite = list2_copy.iterator();
	while (ite.hasNext()){
		ite.next();				//使用遍历器删除时，必须先next()，再remove(),；且只能在next()之后调用一次
		ite.remove();			//删除首位
		System.out.println("list2_copy: " + list2_copy);
	}
	
	/*
	 * 	删除集合元素的最佳实践：从集合尾部开始删除，这样永远不会改变现有集合元素的index索引
	 */
	
	/*
	 * ****************************************************
	 * 	list链表常用方法总结：
	 * 	list.add			1.在尾部添加元素，boolean返回		2.在指定index处添加元素，void返回
	 * 	list.addAll			作用使用同上，只不过 可以批量集合collection添加
	 * 	list.clear			清空
	 * 	list.clone			浅拷贝链表，返回Object
	 * 	list.contains		是否含有某元素, boolean返回
	 * 	list.containsAll	是否含有集合内全部元素
	 * 	list.ensureCapacity(min)	传入一个最小容量值，list自动扩充以确保至少大雨这个容量
	 * 	list.get(index)		获取index位置的元素	
	 * 	list.indexOf(obj)	获取某元素的下标值,第一个元素下标 或者 -1（标识不存在）
	 * 	list.isEmpty()		是否为空链表
	 *  list.iterator		返回迭代器Iterator<..>类
	 *  list.remove(index)			删除index位置的元素，后面的元素自动前移，返回被删除的元素
	 *  list.remove(obj)			删除第一个obj元素，返回boolean，表示是否成功删除
	 *  list.set(index,obj)			将index位置的元素修改为obj，返回修改前的该元素
	 *  list.size					链表大小，实质是内部元素的个数
	 *  list.sublist(fromIndex,toIndex)				返回子链表，链表的一部分,from下标到to下标，左闭右开，返回List类型
	 *  list.toArray()				将链表转成数组，，但是是Object[]类型，因为没指定类型，深度拷贝
	 *  list.toArray(int[] a)		将链表转成数组，，但是是int[]类型的数组（前提是能够实现类型转换）,参数是定好的数组，标识将list中的元素填充到数组中
	 * 	list.toString		顺序输出元素，以数组形式
	 * 	list.trimToSize		将list容量削减到前好事size的大小，用于减小内存
	 */	
	/*
	 * **********************************************
	 * 	map.clear			清空map
	 * 	map.containsKey(obj)		是否含所有某个key，返回boolean
	 * 	map.containsValue(obj)		是否含有某个value,返回boolean
	 * 	map.entrySet()		返回每一个键值对entry的集合set，具体是 Map.Entry<..,..>
	 * 	map.get(key)		通过key取对应的value值,若不存在key则返回null
	 * 	map.keySet			返回键的集合，set类型
	 * 	map.put(key,value)			插入一对键值对，key->value
	 * 	map.remove(key)		删除key键的键值对，返回对应的value
	 * 	map.values()		返回一个Collection对象，包含所有的values
	 * 
	 */
	/*
	 * *******************************************
	 * 	String
	 * 	s.charAt(index)		获取字符串index位置上的字符，返回字符char
	 * 	s.codePointAt(index)		获取字符串index位置字符在unicode编码中的int字符点，即对饮的数字，如'a'对应97
	 * 	s.compareTo(s1)		s与s1字符串进行字典序比较，返回负数标识s<s1,返回正数s>s1,返回0标识s.equals(s1)，即代表两字符串完全相等，是equals函数的另一种表示
	 * 	s.compareToIgnoreCase(s1)	同上，只不过不考虑大小写进行比较
	 * 	s.concat(s1)		在s尾部连接s1，相当于 + s1，返回新的字符串
	 * 	s.contains(str)		传入一个字符串，判断s中是否含有它，返回boolean
	 * 	s.endWith(str)		判断是否s以 str 为结尾，返回boolean
	 * 	s.equals(s1)		判断两字符串是否完全相等，
	 * 	s.equalsIgnoreCase(s1)		判断两字符串忽略大小写，是否完全相等
	 * 	s.getBytes()				获取字符串的byte数组对象，默认编码
	 * 	s.getBytes(charset)			以特定编码获取byte数组，如传入UTF-8字符串
	 * 	s.getChars(srcBegin, srcEnd, dst, dstBegin)			将字符串中部分字符序列复制到特定字符数组中，前两个参数是起止字符下标位置，
	 * 														第三参数是char[]数组，用于存放复制的字符序列，第四参数是char数组的起始复制位置
	 * 	s.indexOf(char)				返回字符串中某字符 c 的首次出现的位置下标，没有返回-1
	 * 	s.indexOf(str)				返回字符串中子串str的首次出现位置下标，没有返回-1
	 * 	s.lastIndexOf(char/str)		基本同上，只不过返回的是最后一个出现的位置下标
	 * 	s.isEmpty()					判断字符串是否为空
	 * 	s.length()					返回字符串长度
	 * 	s.matches(String regex)		返回boolean，是否匹配正则式
	 * 	s.regionMatches(toffset, other, ooffset, len)		判断比较两字符串局部是否相等，1：s的开始位置，2：另一个字符串，3：另一个字串的开始位置，4：比较的长度
	 * 	s.replace(oldc,newc)		全部替换个字符，将串s中的oldc字符全部换成newc，返回替换之后的全新字符串
	 * 	s.replace(str/regex, newstr)		替换子串，子串也可以用正则表示，所有正则匹配到的子串都被替换成新串
	 * 	s.split(regex)				字符串分割，以正则式分割条件， 返回string数组
	 * 	s.toCharArray()				将字符串转化为 字符数组
	 * 	s.toLowerCase()				全部转成小写
	 * 	s.toUpperCase()				全部转成大写
	 * 	s.trim						去掉字符串首尾空格
	 * 	String.valueOf(..)			参数可以是bool,char,int,byte,long,[]等诸多类型，将其转化为字符串，如s,valueOf(1) -> "1"
	 * 	String.copyValueOf(char[] c)		将字符数组转化为新的字符串
	 * 	String.format()				str=String.format("Hi,%s", "王力"); ->Hi,王力
	 */
	String s0 = "aqwer";
	boolean u = s0.contains("ertf");
	int x = s0.codePointAt(0);
	
	Collection<Integer> c ;//= new Collection<Integer>();
	
	
	System.out.println(u);
}

}