java集合框架

一、集合和数组的区别

集合的特点：

1、类型不固定，可以随意存放任何数据。长度也不固定，可以根据元素的增长而增长。
2、集合只能存储引用数据类型（对象），集合存储基本数据类型会进行自动装箱，变成对象。
数组的特点：

1、类型固定，只能存储同一种类型的数据。长度固定，只能存储数组定义时，确定的长度。
2、数组可以存储引用数据类型，又可以存储基本数据类型，其中基本数据类型存储的是值，引用数据类型存储的是地址值。

二、Collection接口

          1.1 集合框架的顶级接口
          1.2 是Set和List的父接口
          1.3 但不是Map的父接口

         集合中只能添加引用类型数据

三、List接口

        2.1 特点：有序、对象可以重复
        2.2 遍历方式 
            2.2.1 下标
            2.2.2 foreach(>=jdk1.5)
            2.2.3 迭代器Iterator
        2.3 List优化
       初始容量10,负载因子0.5

指定初始容量

四、Set

 3.1 特点：无序、对象不能重复(eqauls)
      eqauls从Object继承，默认比较的内存地址
  3.2 遍历
    3.2.1 foreach
    3.2.2 迭代器   
  3.3 常用实现类
      HashSet
      TreeSet：根据某种(规则)对里面的元素进行排序
        规则1: java.lang.Comparable 
        规则2: java.util.Comparator
 

五、Map

 4.1 特点：无序、以键值对的形式添加元素，键不能重复，值可以重复，如果键相同，值会覆盖
            它没有继承Collection接口
  4.2 遍历
    3.2.1 先取出保存所有键的Set,再遍历Set即可(2种)
    3.2.2 先取出保存所有Entry的Set,再遍历此Set即可(快速遍历Map)

、Iterator(迭代器)

 5.1 Iterator(迭代器)：遍历集合List/Set
       hasNext
       next
       remove：在遍历集合，并同时需要删除集合中的元素时，建议使用
               Iterator.remove
   5.2 java.lang.Comparable：自然排序接口
   5.3 java.util.Comparator：比较器接口
   5.4 Collections：工具类，提供一组静态方法操作Collection集合
       Arrays：工具类，提供了一组静态方法操作数组

六、案例

6.1、子弹夹

public class Stack {
	static LinkedList ll = new LinkedList<>();
	
	//压
	public void push(Object o) {
		ll.addFirst(o);//增加第一个
	}
	//弹
	public Object pop() {
		Object first = ll.getFirst();//得到第一个
		ll.removeFirst();//移除第一个
		return first;
	}
	public static void main(String[] args) {
		Stack s = new Stack();
		//增加
		s.push("a");
		s.push("b");
		s.push("c");
		s.push("d");
		s.push("e");
		s.push("f");
		//取出来
		for (Object o : ll) {
			System.out.println(o);
		}
	}
}

6.2、用Comparator实现比大小

先定义一个类，实现Comparable接口

public class Student implements Comparable<Student>{
	private Integer age;
	private String name;
	
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public Student(Integer age, String sname) {
		super();
		this.age = age;
		this.name = sname;
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	@Override
	public int hashCode() {
		return this.age.hashCode()+this.name.hashCode();
	}
	@Override
	public int compareTo(Student s) {
		Integer n = this.age.hashCode()+this.name.hashCode();
		int is = s.hashCode();
		return n-is;
	}
}

测试

  public static void main(String[] args) {
        Teacher t = new Teacher();
		Student o1 = new Student();
		o1.setAge(10);
		o1.setName("张三");
		Student o2 = new Student();
		o2.setAge(10);
		o2.setName("李四");
		int i = t.compare(o1, o2);
		System.out.println(i);
}

6.3 使用map集合，完成一个猫舍里面放十只猫

public static void main(String[] args) {
		Map<String, List<Cat>> map = new HashMap<>();
		for (int i = 0; i < 10; i++) {
			List<Cat> myl = new ArrayList<Cat>();
			for (int j = 0; j < 10; j++) {
				Cat c = new Cat(j, (i+1)+"猫"+j+"号");
				myl.add(c);
			}
			map.put((i+1)+"", myl);
		}
		//取值
		Set<Entry<String,List<Cat>>> set = map.entrySet();
		Iterator<Entry<String, List<Cat>>> iterator = set.iterator();
		while(iterator.hasNext()) {
			Entry<String, List<Cat>> next = iterator.next();
			String key = next.getKey();
			List<Cat> value = next.getValue();
			for (Cat cat : value) {
				System.out.println("\t"+cat);
			}
			System.out.println(key+"，"+value);
		}
	}