Javaj基础—集合

集合：

Collection接口：
Collection的常用方法：

@Test
		public void testCollection1(){
			Collection coll=new ArrayList();
			//1.size():返回集合中元素的个数
			System.out.println(coll.size());
			
			//2.addAll(Collection coll)将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
			Collection coll1=Arrays.asList(1,2,3,4);
			coll.addAll(coll1);
			
			//3.add(Object obj):向集合中添加一个元素
			coll.add(123);
			coll.add("AA");
			coll.add(new Date());
			coll.add("BB");
			//4.ArrayList重写了toString()方法
			System.out.println(coll);
			System.out.println(coll.size());
			
			//5.isEmpty():判断集合是否为空
			System.out.println(coll.isEmpty());
			
			//5.clear():清空集合元素
			coll.clear();
			System.out.println(coll.isEmpty());
			
		}
		
		
			@Test
		public void testCollection2(){
			Collection coll=new ArrayList();
			//3.add(Object obj):向集合中添加一个元素
			coll.add(123);
			coll.add("AA");
			coll.add(new Date());
			coll.add("BB");
			
			//6.contains(Object obj):判断集合中是否包含指定的obj元素
			Boolean boolean1=coll.contains("AA");
			System.out.println(boolean1);
			
			//7.containsAll(Collection coll):判断当前集合是否包含coll中所有元素
			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.retainAll(coll1);
			System.out.println(coll);
			
			//9.remove(Object obj)
			boolean b1=coll.remove("AA");
			System.out.println(b1);
			
			//10.remoeAll():从当前集合中包含在coll中的元素
			coll.removeAll(coll1);
			System.out.println(coll);
			
			//11.equals(Object obj):判断两个集合中的元素是否完全相同
			Collection coll3=new ArrayList();
			coll3.add(123);
			coll3.add(new String("AA"));
			System.out.println(coll1.equals(coll3));
			
			
			//12.toArray():将集合转换成数组
			Object[] obj=coll3.toArray();
			for(int i=0;i<obj.length;i++){
				System.out.println(obj[i]);
			}
			
			//iterator():可以实现集合的遍历
			System.out.println("aaaa");
			Iterator iterator=coll3.iterator();
			while(iterator.hasNext()){
				System.out.println(iterator.next());
			}	
		}

两种遍历集合的方法:

	第一种：
			Iterator iterator=set.iterator();
				while(iterator.hasNext()){
					System.out.println(iterator.next());
				}
	第二种：
			for(Object str:set){
			System.out.println(str);
		}

List接口： 存储有序的，可以重复的元素
>新增的方法：删除remove(int index) 修改set(int index,Object obj) 获取get(int index)插入add(int index,Object obj)
添加进List集合中的元素（或对象）所在的类一定要重写equals（）方法
ArrayList(主要的实现类)
LinkedList(更适用于频繁的插入删除操作)
Vector(古老的实现类、线程安全的)

Set接口: 存储无序的，不可重复的元素
>添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致。
HashSet(主要的实现类)
LinkHashSet(是HashSet的子类，频繁的遍历，较少的添加使用此类)
TreeSet(可以按照添加进集合的元素指定属性进行排序)

两种排序方式：

自然排序：
①要求添加进TreeSet中的元素所在的类implements Comparable接口
②重写compareTo(Object obj)，在此方法内指明按照元素的哪个属性进行排序
③向TreeSet中添加元素即可。若不实现此接口，会报运行时异常

定制排序：
①创建一个实现Comparator接口的实现类的对象。在实现类中重写Comparator的compare(Object o1,Object o2)方法
②在此compare()方法中指明按照元素所在类的哪个属性进行排序
③将此实现Comparator接口的实现类的对象作为形参传递给TreeSet的构造器中
④向TreeSet中添加元素即可。若不实现此接口，会报运行时异常

Comparable和Comparator区别比较
Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。

如何对一个类对象进行排序：

定制排序：


	@Test
	public void test5(){
		//1.创建一个实现了Comparater接口的类对象
				Comparator comparator=new Comparator(){
					//向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer的哪个属性排序的。
					@Override
					public int compare(Object o1, Object o2) {
						if(o1 instanceof Customer&&o2 instanceof Customer){
							Customer c1=(Customer) o1;
							Customer c2=(Customer) o2;
							return  c1.getId().compareTo(c2.getId());
						}
						return 0;
					}
					
				};
				TreeMap map=new TreeMap(comparator);
				map.put(new Customer("AA",1001), 123);
				map.put(new Customer("CC",1005), 456);
				map.put(new Customer("dd",1008),234);
				map.put(new Customer("tt",1002), 567);
				
				Set set1=map.keySet();
				for(Object obj:set1){
					System.out.println(obj+"--->"+map.get(obj));
				}
				
	}

自然排序：

1.创建一个Employee类，实现Comparable接口，重写他的compareTo方法

2.定义属性,重写hashCode和equals方法，提供toString方法

3.通过name进行排序
@Override
	public int compareTo(Object o) {
		if(o instanceof Employee){
			Employee e=(Employee) o;
			return this.name.compareTo(e.name);
		}
		return 0;
	}


4.创建测试类
public  void test1(){
			Employee e1=new Employee("刘德华", 60, new MyDate(4,12,1965));
			Employee e2=new Employee("张哥", 50, new MyDate(4,12,1965));
			Employee e3=new Employee("大姐姐", 33, new MyDate(4,12,1965));
			Employee e4=new Employee("是否", 54, new MyDate(4,12,1965));
			Employee e5=new Employee("就是", 78, new MyDate(4,12,1965));
			
			TreeSet<Employee> set=new TreeSet<Employee>();
			set.add(e1);
			set.add(e2);
			set.add(e3);
			set.add(e4);
			set.add(e5);
			
			Iterator<Employee> iterator=set.iterator();
			while(iterator.hasNext()){
				System.out.println(iterator.next());
			}
			
		}

Map接口：存储“键-值”对的数据 key是不可重复的，使用Set存放。value可以重复的，使用Collection来存放的。一个key-value对构成一个entry(Map.Entry)，entry使用Set来存放。
keySet() 获取建
values() 获取值
entrySet() 获取键值

Map常用的方法：

Object put(Object key,Object value):向Map中添加一个元素
- Object remove(Object key):按照指定的Key，删除此key-value对
- void putAll(Map t)
- void clear():清空
- Object get(Object key)：获取指定的key的value值,若无此key，返回null
- boolean containsKey(Object key)
- boolean containsValue(Object value)
- int size():返回map的长度
- boolean isEmpty():是否为空
- boolean equals(Object obj):是否
|-----HashMap：主要的实现类，可以添加null键，null值
|-----LinkedHashMap：是HashMap的子类，可以按照添加进Map的顺序实现遍历
|-----TreeMap：需要按照key所在类的指定属性进行排序。要求key是同一个类的对象。对key考虑使用自然排序或定制排序
|-----Hashtable：是一个古老的实现类，线程安全的，不可以添加null键，null值不建议使用。
|-----子类：Properties：常用来处理属性文件

Iterator接口：用来遍历集合Collection元素

遍历Map的三个方法：
		set keySet()
		Collection values()
		Set entrySet()

如何遍历Map

	@Test
	public void test2(){
		Map map=new HashMap();
		map.put("AA", 123);
		map.put("BB", 456);
		map.put(123, "CC");
		map.put(null, null);
		//1.遍历key集
		Set set=map.keySet();
		for(Object obj:set){
			System.out.println(obj);
		}
		//2.如何来遍历所有的value
		Collection values=map.values();
		Iterator iterator=values.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		//3.如何遍历key-value对  
				//方式一
				Set set1=map.keySet();
				for(Object obj:set1){
					System.out.println(obj+"--->"+map.get(obj));
				}
				
				//方式二
				Set set2=map.entrySet();
				for(Object obj:set2){
					Map.Entry entry=(Entry) obj;
					System.out.println(entry);
				}
	}

Properties类：

	//使用Properties处理属性文件
	@Test
	public void test6() throws FileNotFoundException, IOException{
		Properties pro=new Properties();
		pro.load(new FileInputStream(new File("jdbc.properties")));
		String user=pro.getProperty("user");
		String password=pro.getProperty("password");
		System.out.println("user="+user);
		System.out.println("password="+password);
	}

操作Collection、Map的工具类：Collections
面试题; 区分Collection与Collections
Collections是操作Collection和Map的一个工具类

方法：
reverse(List)：反转List中元素的顺序
shuffle(List)；对List集合元素进行随机排序
sort(List):根据元素的自然顺序对指定List集合元素按升序排序
sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
swap(List,int,int)：指定list集合中的i处元素和j处元素进行交换
Object max(Collection):找到最大元素
Object min(Collection):找到最小元素
int frequency(Collection,Object):返回集合中指定元素出现的次数
void copy(List dest,List src):将src中的内容复制到dest中

集合：

猜你喜欢