java基础之集合类

java基础之集合类

1、java集合概略图

2、集合示例（Collection接口的15个方法）

@Test
	public void test(){
		Collection coll = new ArrayList();
		//1、size（）：返回集合中元素
		System.out.println(coll.size());
		//2、add（Object obj）：向集合中添加一个元素
		coll.add(123);
		coll.add(new String ("AA"));
		coll.add(new Date());
		coll.add("BB");
		System.out.println();
		//3、AddAll（Collection coll）:将形参coll中包含的所有元素添加到当前集合中
		Collection coll1 = Arrays.asList(1,2,3);
		coll.addAll(coll1);	
		System.out.println(coll);		
		System.out.println(coll.size());
		//4、isEmpty（）：判断集合是否是空
		System.out.println(coll.isEmpty());
		//5、clear（）：清空集合元素
		coll.clear();
		System.out.println(coll.isEmpty());
	}

@Test
	public void test2(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String ("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		System.out.println(coll);
		//6、contains（Object obj）：判断集合中是否包含执行的obj元素，如果包含返回true，如果不包含，返回false
		//判断依据：根据元素所在类的equals（）方法进行判断。
		boolean b1 = coll.contains(123);
		boolean b2 = coll.contains(new String ("AA"));
		System.out.println(b2);
		//7、cotainsAll(Collection coll):判断当前集合中是否包含coll中的所有元素，如果包含，返回true；反之返回false。
		Collection coll1 = new ArrayList<>();
		coll1.add(123);
		coll1.add(new String("AA")); 
		boolean b3 = coll.containsAll(coll1);
		System.out.println(b3);
		//8、retainAll（Collection coll）:求当前集合与coll的共有元素，返回给当前集合
		coll1.add(456);
		coll.retainAll(coll1);
		System.out.println(coll);		
		//9、remove（Object obj）：删除集合中的obj元素，若删除成功，返回true；否则，返回false；
		boolean b4 = coll.remove("BB");
		System.out.println(b4);
		coll.removeAll(coll1);
		System.out.println(coll);
	}

@Test
	public void Test3(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String ("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		Collection coll1 = new ArrayList<>();
		coll1.add(123);
		coll1.add(new String("AA"));
		//10、removeAll（Collection coll） ：从当前集合中删除包含在coll中的元素（即取两个集合的差集）
		coll.removeAll(coll1);
		System.out.println(coll);
		//11、equals(Object obj)
		Collection coll2 = new ArrayList<>();
		coll2.add(123);
		coll2.add(new String("AA"));
		boolean b1 = coll1.equals(coll2);
		System.out.println(b1);
		//13、toArray()：将集合转化成数组
		Object[] objs = coll.toArray();
		for(Object object : objs){
			System.out.println(object);
		}
        //14、iterator（）：返回一个Iterator接口实现类的对象,进而实现集合的遍历
		Iterator iterator = coll.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}		
	}
* 集合：
 * 	Collection接口：
 * 		|--List接口：存储有序的，可以重复的元素
 * 			|--ArrayList(主要的实现类)、LinkedList（对于频繁的插入或者删除操作，建议选择）、vector
 * 		|--Set接口：存储无序的，不可重复的元素
 *			|--HashSet（主要实现类）、LinkedHashSet、TreeSet
 *  Map接口：存储“键-值”对数据
 *  		|--hashMap、LinkedHashMap、TreeMap、HashTable（子类--properties）

3、List接口

//ArrayList:List的主要实现类
	@Test
	public void test(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("BB"));
		//add(int index,Object obj):在指定的索引位置index添加元素obj
		list.add(0, 555);
		System.out.println(list);
		//get(int index):获取指定索引的元素
		Object object = list.get(1);
		System.out.println(object);
		//Object remove(int index):删除指定索引位置的元素。（注：Collection中也有remove方法，不过那是删除指定的对象，而不是指定索引的元素）
		list.remove(0);
		//Object set(int index , Object obj):设置指定索引位置的元素为obj
		list.set(0, "miehaha");
		System.out.println(list.get(0));
	}
	@Test
	public void test1(){
		//indexof（Object obj）：返回obj在集合中首次出现的位置。没有的话，返回-1.
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("BB"));
		System.out.println(list.lastIndexOf(456));
	}

4、重要：Set（HashSet（用的最多，数据不可重复，里面根据hashcode（）和equals（）进行数据的存储）、LinkedhashSet(按照插入的顺序进行输出)）

/*
	 * Set:存储的元素是无序的，不可重复的
	 * 1、无序性：无序性 ！=随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
	 * 2、不可重复性：当向set中添加进相同的元素的时候，后面的这个不能添加进去。
	 * 说明：要求添加进Set中元素所在的类，一定要重写equals（）和hashcode（）方法。
	 * 进而保证Set中元素的不可重复性。
	 * 
	 * Set集合中为了保证数据的不可重复存储采用了哈希算法。
	 * 当向Set中添加元素时，首先调用此对象的hashcode（）方法，计算此对象的hashcode（）值，此哈希值决定了对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存到这个位置；
	 * 若此位置已有对象存储，再通过equals（）方法比较这两个对象是否相同，如果相同，后一个对象就不能再添加进来。
	 * 此时要求hashcode（）和equals（）方法要一致。
	 */

主要其中hashcode（）和equals（）在Set接口中存储数据时的原理。

即存储时，首先查看两个对象hashcode（）值是否相同，如果相同，那么比较通过equals（）比较两个对象是否相同，如果相同，则只存储一个对象（前面的一个）。

注：但是存在两种情况：①实际对象利用equals（）比较，是两个相同对象，可是hashcode值不同，那么这两个对象依旧可以存储进Set中。原因：对象所在类没有重写hashcode（）方法或者重写的hashcode（）不好。

 ②实际对象利用equals（）比较，是两个不同对象，可是他们的hashcode值却相同，那么这两个对象会存储在set集合中的一个元素位置。原因：对象所在类重写的hashcode（）不好。

5、TreeSet

public class TestSet {
	/*
	 * TreeSet
	 * 1、向TreeSet中添加的元素必须是同一个类
	 * 2、可以按照添加进集合中的元素的指定的顺序进行遍历。像String，包装类等默认按照从小到大的顺序进行遍历。
	 * 3、当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序 ②定制排序
	 * 4、自然排序：要求自定义类实现java。lang。Comparable接口，并重写CompareTo（Object obj）方法，
	 * 在此方法中，执行按照自定义类的哪个属性进行排序。
	 *  注：向TreeSet中添加元素时，首先按照CompareTo（Object obj）方法进行比较，一旦返回0，虽然仅是两个对象的某一约定的属性值一样，
	 *  但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
	 *    》CompareTo（）、hashCode（）、equals（）方法要一致。
	 * 5、定制排序：
	 * 	     》CompareTo（）、hashCode（）、equals（）方法要一致。
	 */
	@Test
	public void test2(){
		//1、创建一个实现了Comparator的对象
		Comparator comparator = new Comparator() {
			//向Treeset中添加customor类的对象，在此compare（）方法中，致命是按照customor的哪个属性进行排序。
			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof Customer && o2 instanceof Customer ){
					Customer c1 = (Customer) o1;
					Customer c2 = (Customer) o2;
					int i =  c1.getId().compareTo(c2.getId());
					if(i == 0){
						return c1.getName().compareTo(c2.getName());
					}else {
						return i;
					}
				}
				return 0;
			}
		};
		//2、将此对象作为形参传递给TreeSet的构造器中
		TreeSet set = new TreeSet(comparator);
		//3、向TreeSet中添加Comparator 接口中的compare方法中涉及的类的对象。
		set.add(new Customer("AA", 1001));
		set.add(new Customer("BB", 1002));
		set.add(new Customer("DD", 1003));
		set.add(new Customer("CC", 1001));
		
		for(Object object : set){
			System.out.println(object);
		}
	}
	@Test
	public void test1(){
		Set set = new TreeSet();
		//当person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
		set.add(new Person("AA", 20));
		set.add(new Person("DD", 23));
		set.add(new Person("DD", 24));
		set.add(new Person("CC", 23));
		set.add(new Person("KK", 23));
		for(Object obj:set){
			System.out.println(obj);
		}
	}
	/*
	 * Set:存储的元素是无序的，不可重复的
	 * 1、无序性：无序性 ！=随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
	 * 2、不可重复性：当向set中添加进相同的元素的时候，后面的这个不能添加进去。
	 * 说明：要求添加进Set中元素所在的类，一定要重写equals（）和hashcode（）方法。
	 * 进而保证Set中元素的不可重复性。
	 * 
	 * Set集合中为了保证数据的不可重复存储采用了哈希算法。
	 * 当向Set中添加元素时，首先调用此对象的hashcode（）方法，计算此对象的hashcode（）值，此哈希值决定了对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存到这个位置；
	 * 若此位置已有对象存储，再通过equals（）方法比较这两个对象是否相同，如果相同，后一个对象就不能再添加进来。
	 */
	@Test
	public void test(){
		Set set = new HashSet();
		set.add(123);
		set.add(456);
		set.add("AA");
		set.add("BB");
		set.add(null);
		set.add(new Person("zhangyy", 20));
		set.add(new Person("zhangyy", 20));
		System.out.println(set.size());
		System.out.println(set);
	}
}

6、Map

/*
 * Map接口：
 * 	|--HashMap:Map的主要实现类,key使用Set来存储的，不可重复；value使用Collection来存储的，可重复的。
 * 		一个key—value对，是一个Entry。所有的Entry使用Set来存放的，也是不可重复的。
 * 		向hashMap中添加元素时，会调用key所在类的equals（）方法， 判断两个key是否相同，若相同，则只能添加进一个（是后一个添加进的元素）。
 * 	|--LinkedHashMap：使用链表维护添加进Map中的顺序，所以遍历Map时，是按照添加的顺序遍历的。
 *  |--TreeMap：按照添加进Map中元素的Key的指定属性进行排序。要求Key必须是同一个类对象！（key值排序方式与TreeSet中的排序类型一致：自然排序和定制排序）
 *  |--HashTable：古老的实现类，线程安全的，不建议使用。
 *  	|--Properties：常用来处理属性文件，键和值都是String类型。
 * 
 */
public class TestMap {
	/*
	 * 遍历map：
	 * Set keySet()
	 * Collection values()
	 * Set entrySet()
	 */	
	@Test
	public void test2(){
		Map map = new HashMap();
		//put:向map中添加一个元素
		map.put("AA", 123);
		map.put("BB", 456);
		map.put(null, null);
		map.put("CC", 789);
		map.put(123, "AA");		
		//遍历key集
		Set set =map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			//Object obj = map.get(iterator.next());
			System.out.println(iterator.next());
		}
		//遍历values
		Collection value = map.values();
		Iterator iterator2 = value.iterator();
		while(iterator2.hasNext()){
			System.out.println(iterator2.next());
		}
		//如何遍历key-value对：采用EntrySet
		Set set2 = map.entrySet();
		for(Object obj:set2){
			Entry entry = (Entry) obj;
			System.out.println(entry.getKey() +"--->"+entry.getValue());
		}	
	}
	@Test
	public void test1(){
		Map map = new HashMap();
		//put:向map中添加一个元素
		map.put("AA", 123);
		map.put("BB", 456);
		map.put("BB", "1111111111111");
		map.put("CC", 789);
		map.put(123, "AA");
		map.put(null, null);
		System.out.println(map.size());
		map.remove("BB");
		System.out.println(map);
		Object valueObject = map.get(123);
		System.out.println(valueObject);
		boolean b1 = map.containsKey(123);
		System.out.println(b1);
		boolean b2 = map.containsValue(123);
		System.out.println(b2);
	}
}