Java06-集合框架

(1)Collection接口

1.该接口将对象集中放在一起简称集合，与数组类似。但是数组不能改变大小且只能存放相同对象，和数组不同，集合允许添加任何类型的对象，并且不强制指定初始大小；

2.该接口有许多抽象方法

        1.add             可以添加元素；

        2.addAll         添加另一个Collection类的对象的成员

        3.clear           删除所有成员

        4.size            获取集合中元素的数量

        5.isEmpty      判断集合中是否包含元素

        6.toArray       将元素移动到数组里

（2）List类和ArrayList类

其中List是Collection的子接口(所以它继承并覆盖了接口的方法)，而ArrayList是List的通用实现类(基类)

    import java.util.ArrayList;
    import java.util.List;

    public class Easy {

	    public static void main(String[] args) {
	    	List myList = new ArrayList();
	    	String s1="Hello";
		    String s2="World";
		    myList.add(100);
		    myList.add(s1);
		    myList.add(s2);
		    myList.add(s2);
		    myList.add(3,"emm");
		    myList.add(4,"kmm");//在指定位置添加元素 在原来位置上的元素会替换到下一个位置上
	    	myList.set(4,"easy");//替换指定位置的元素
	    	myList.add(null);
		    System.out.println(myList.size());//7 有7个的对象证明null也算是对象
		    for(Object object : myList) {
		    	System.out.println(object);
		    }		
	    }
    }
            
            //100
            //Hello
            //World
            //emm
            //easy
            //World
            //null

1.固定大小的集合 - 用Arrays.asList()功能传入元素

	    public static void main(String[] args) {
		    List myList = Arrays.asList("Hello","World");//向集合中放入固定的两个对象
		    //myList.add("123");  写入这行代码编译器不会报错，但是在运行时会抛出错误
		    System.out.println(myList.size());//2				
	    }

2.java.util.Collections类

该类是一个辅助类，它提供了静态方法操作Collection或List集合

    public class Easy {

	    public static void main(String[] args) {
		    List myList = Arrays.asList(7,-9,10,3,20);
		    Collections.sort(myList);//在集合中只存在数字元素的情况下将数字从大到小排序
		    System.out.println(myList);//[-9, 3, 7, 10, 20]	以数组的形式返回		
	    }
    }

（3）利用增强for循环迭代集合(遍历)

    public class Easy {

	    public static void main(String[] args) {
		    List myList = Arrays.asList(7,-9,10,3,20);
		    for(Object object : myList) {
			    System.out.println(object);//7 -9 10 3 20
		    }		
	    }
    }

事实上该for循环会被编译器翻译成用Iterator处理过的语句 

1.Iterator类使用了一个内部指针，调用方法可以使指针移动并且返回被指向的元素 注意该指针开始指向第一个元素

    public class Easy {

	    public static void main(String[] args) {
		    List myList = Arrays.asList(7,-9,10,3,20);		
		    for(Iterator a = myList.iterator();a.hasNext();) {//hasNext会判断被指针指向的元素 
                                                     //后面还有没有元素存在 有返回1 没有返回2
			    int b = (int) a.next();//调用指针指向下一个元素并且返回该元素
			    System.out.println(b);
		    }		
	    }
    }

不过还是十分推荐使用增强for循环，不仅简洁，而且还不用判断赋值类型。

（4）Set和HashSet

Set集合和List不同，该集合不允许有相同的元素存在，如果在集合中添加一个相同的元素那么它将返回false。同样HashSet是Set的通用实现类(基类)

    public class Easy {

	    public static void main(String[] args) {				
	    	Set set = new HashSet();
		    set.add("Hello");
		    System.out.println(set.add("Hello"));
	    }
    }

（5）Queue和LinkedList

Queue同样是Collection的扩展，但是添加到它集合的元素只支持先进先出的原则，不像List那样可以在任意下标下添加或者替换元素了

1.offer        可以像add一样添加元素,但是如果不能添加元素，比如说达到上限了那么将返回                    false, 而不是像add一样抛出异常

2.remove   删除头元素并返回 如果头元素为空则抛出异常

3.poll         类似remove方法但是头元素为空则返回false

4.element 返回头元素，如果为空则抛出异常

5.peek      返回头元素，如果为空返回false

    public static void main(String[] args) {				
	    	Queue queue = new LinkedList();
	    	queue.add("1");
	    	queue.add("2");
		    System.out.println(queue.remove());//1
		    System.out.println(queue.remove());//2
	    }

（6）集合转换

因为每个集合的通用实现类的构造方法都是接收一个Collection的对象，所以这使得集合之间能够互相转换

    public class Easy {

	    public static void main(String[] args) {				
		    List myList = new ArrayList();
		    myList.add("1");
		    myList.add("2");
		    Queue queue = new LinkedList(myList);//进行集合转换
		    for(Object object : queue) {
		    	System.out.println(object);// 1 2
		    }		
	    }
    }

(7)Map和HashMap

Map集合中可以保存键/值对，其中键和值不能是基础类型。并且每个键最多映射一个值。

1.put()        该方法传入键和值

2.remove   可以通过传递键将映射（值）删除

3.get          通过输入键来获取对应的键值

4.KeysSet  返回集合中所有键的Set

5.values     返回集合中所有的值 Collection

6.entrySet  返回一个包含Map.Entry对象的Set,每一个Entry表示一个键/值对

    public class Easy {

	    public static void main(String[] args) {				
	    	Map map = new HashMap();
		    map.put("1", "one");
	    	map.put("2", "two");
            System.out.println(map.get("1"));//one
		    System.out.println(map.keySet());//[1, 2]
		    System.out.println(map.values());//[one, two]
		    Set Keys = map.keySet();// 
	    }		
    }

(8) java.lang.Comparable

实战

因为Arrys.sort是需要数组所以要对对象进行打包的操作(非常重要)。

对象数组之间的比较是通过Arrys.sort调用对象中的compareTo()方法进行return的int 值进行比较的，也就是说对象之间怎么进行比较可以由自己定义。 

就比如我下列代码中将return值的结果调换一下的话那么排序的结果将是重量比较重的在前,年龄大的在前。或者将判断年龄的代码放到前面那么排序结果就又不一样了。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Dog implements Comparable<Dog>{
	public float weight;//重量
	public int age;//年龄
	public Dog(float weight,int age) {//构造方法
		this.weight=weight;
		this.age=age;
	}
	public int compareTo(Dog a) {
		
		if(this.weight > a.weight) {
			return 1;
		}else if(this.weight<a.weight) {
			return -1;
		}else {
			if(this.weight > a.weight) {
				return 1;
			}else if(this.weight<a.weight) {
				return -1;
			}
		}	
		return 0;//if外面一定要有个return
	}	
}
public class Easy {

	public static void main(String[] args) {				
		Dog dog1 = new Dog(20,10);//初始化
		Dog dog2 = new Dog(25,17);
		Dog dog3 = new Dog(20,12);
		Dog[] dogs = new Dog[3];//打包
		dogs[0] = dog1;//打包过程
		dogs[1] = dog2;
		dogs[2] = dog3;
		Arrays.sort(dogs);//交给sort调用compareTo方法排序
		for(Dog dog : dogs) {
			System.out.println(dog.weight+":"+dog.age);//输出排好的顺序
		}
		
	}		
}
	//20.0:10
	//20.0:12
	//25.0:17