Java集合类知识点总结

集合：只能存储对象，对象类型可以不一样，长度可变。

常用的接口和类：

1、list接口（有序、可重复）：arraylist类、linkedlist、vector类

2、set接口（无序、不能重复）:hashset类、treeset类

3、map接口（键值对、键唯一、值不唯一）：hashmap类、hashtable类、treemap类

集合类的循环遍历

1、普通for循环：如 for（int i=0;i<arr.size();i++）{…}

2、foreach（增强型for循环）：如 for（object　i：arr）{…}

3、iterator（迭代器）：如 iterator it = arr.iterator();while(it.hasnext()){ object o =it.next(); …}

注意：无法在遍历的过程中对数组或者集合进行修改，而for循环可以在遍历的过程中对源数组或者集合进行修改

arraylist、linkedlist和vector的区别

arraylist：效率高，多用于查询

linkedlist：多用于插入和删除

vector：线程安全，多用于查询

代码：

import java.util.arraylist;
import java.util.iterator;
import java.util.linkedlist;
import java.util.list;
import java.util.vector;

public class listtest {
	public static void main(string[] args){
		list arraylist=new arraylist();
		list linkedlist=new linkedlist();
		list vector=new vector();
		
		arraylist.add("1"); //字符类型
		arraylist.add("1"); //重复元素
		arraylist.add("2");
		arraylist.add(1); //数字类型
		
		linkedlist.add("1");
		linkedlist.add("1");
		linkedlist.add("2");
		linkedlist.add(1);
		
		vector.add("1");
		vector.add("1");
		vector.add("2");
		vector.add(1);
		
		for(object obj:arraylist){ //foreach循环
			system.out.println(obj);
		}
		
		for(int i=0;i<linkedlist.size();i++){ //普通for循环
			system.out.println(arraylist.get(i));
		}
		
		iterator it = vector.iterator(); //迭代器
		while(it.hasnext()){
			object j=it.next();
			system.out.println(j);
		}
	}
}

hashset和treeset的区别

hashset：hashset 是哈希表实现的,hashset中的数据是无序的，可以放入null，但只能放入一个null

treeset：treeset是二差树实现的,treeset中的数据是自动排好序的，不允许放入null值

代码：

public class settest {
	public static void main(string[] args){
		set hashset=new hashset();
		set treeset=new treeset();
		
		hashset.add("1"); //字符类型
		hashset.add("1"); //重复元素
		hashset.add("2");
		hashset.add(1); //数字类型
		
		treeset.add("1");
		treeset.add("1");
		treeset.add("2");
//		treeset.add(1); //报错，treeset不能添加不同的数据类型
		
		for(object i:hashset){ //foreach循环
			system.out.println(i);
		}
		
		iterator it = treeset.iterator(); //迭代器
		while(it.hasnext()){
			object j=it.next();
			system.out.println(j);
		}
	}
}

注意：set接口没有get方法，所以不能使用普通for循环来遍历

hashmap、hashtable和treemap的区别

hashmap：hashmap允许存在一个为null的key，多个为null的value

hashtable：hashtable的key和value都不允许为null

treemap：能够把它保存的记录根据键排序,默认是按键值的升序排序，也可以指定排序的比较器，当用iterator 遍历treemap时，得到的记录是排过序的

代码：

import java.util.hashmap;
import java.util.hashtable;
import java.util.iterator;
import java.util.map;
import java.util.set;
import java.util.treemap;

public class maptest {
	public static void main(string[] args){
		map hashmap=new hashmap();
		map hashtable=new hashtable();
		map treemap=new treemap();
		
		hashmap.put(1, "1"); //字符类型值
		hashmap.put(2, "1"); //同值不同键
		hashmap.put(3, "2");
		hashmap.put(4, 1); //数字类型值
		hashmap.put("5", 1); //字符类型键
		
		hashtable.put(1, "1");
		hashtable.put(2, "1");
		hashtable.put(3, "2");
		hashtable.put(4, 1);
		hashtable.put("5", 1);
		
		treemap.put(1, "1");
		treemap.put(2, "1");
		treemap.put(5, "2");
		treemap.put(4, 1);
//		treemap.put("5", 1); //报错，treemap不能添加不同类型的键
		
		//遍历hashmap键
		for(object key:hashmap.keyset()){
			system.out.println(key);
		}
		//遍历hashtable值
		for(object value:hashtable.values()){
			system.out.println(value);
		}

		//遍历hashmap键值对
		set set = hashmap.keyset();
		for(iterator iter = set.iterator(); iter.hasnext();){
			object key = iter.next();
			object value = hashmap.get(key);
			system.out.println(key+"\t"+value);
		}
		
		//迭代遍历hashtable键值对,倒序！
		iterator table = hashtable.entryset().iterator();
		while(table.hasnext()){
			map.entry entry = (map.entry) table.next(); 
			object key = entry.getkey(); //取键
			object value = entry.getvalue(); //取值
			system.out.println(key+"\t"+value); 
		}
		
		//迭代遍历treemap键值对
		iterator tmp = treemap.entryset().iterator();
		while(tmp.hasnext()){
			map.entry entry = (map.entry) tmp.next(); 
			object key = entry.getkey(); //取键
			object value = entry.getvalue(); //取值
			system.out.println(key+"\t"+value); 
			
		}
	}
}

关于线程安全的类有：vecto、hashtabl、stringbuffe

非线程安全：arraylist 、linkedlist、hashmap、hashset、treemap、treeset、stringbulider

注意：concurrenthashmap可代替hashmap用于线程安全，且效率比hashtable高

java自身的机制并不能完全保证线程安全。需要自己手动编码控制。