集合 （基础）

Iterable (迭代器)

Collection (集合)

• List
  底层使用连续的数组存储
  优点：遍历元素和随机访问元素的效率比较高，List添加的顺序和访问的顺序是一致的，List能添加重复元素
  缺点：添加和删除需要大量移动元素效率底，按照内容查找效率底

private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "姓名：" + name + ",年龄：" + age ;
	}

List list = new ArrayList();
		list.add(new Student("张三", 5));
		list.add(new Student("李四", 7));
		print(list);

• LinkedList
  底层使用链表存储，不是连续的
  优点：插入、删除元素时效率比较高，排序但是需要重写equals方法。
  缺点：遍历和随机访问元素效率低下

private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "姓名：" + name + ", 年龄：" + age ;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj==null)return false;
		if(obj instanceof Student){
			Student s=(Student) obj;
			//return s.age==age&&s.name==name;
			//重写了toString方法才可以这样用
			return s.toString().equals(toString());
		}
		return false;
	}

List list=new LinkedList();
		list.add(new Student("张三", 10));
		list.add(new Student("李四", 20));
		list.add(new Student("王五", 30));
		print(list);

用增强for循环遍历

private static void print(List list) {
		for(Object o:list){
			System.out.println(o);
		}
		
	}

结果

姓名：张三, 年龄：10
姓名：李四, 年龄：20
姓名：王五, 年龄：30

Set

• HashSet
  底层使用数组（hash算法）+链表实现
  相等对象必须具有相等的哈希码
  优点：添加速度快，查询速度快，删除速度快，无序
  重写equals方法，必须重写Hashcode方法，有去重的功能

Set set = new HashSet();
		set.add("abc");
		set.add("asd");
		set.add("qwe");
		print(set);

增强for

private static void print(Set set) {
		for(Object o:set){
			System.out.println(o);
		}

• TreeSet
  底层采用二叉树（红黑树）的存储结构
  优点：有序（排序后的升序）查询速度比List快（按照内容查询）
  缺点：查询速度没有HashSet快
  需要实现Comparable或者new Set(Compartor)才可以排序

private String name;
	private int age;
	private boolean sex;
	public Student(String name, int age, boolean sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isSex() {
		return sex;
	}
	public void setSex(boolean sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "名字：" + name + ", 年龄：" + age + ",性别：" + sex ;
	}

//用compartor   去重   必须实现
Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				 return o1.toString().compareTo(o2.toString());
//				int c = o1.getAge() - o2.getAge();
//				if (c != 0) {
//					return c;
//				}
//				c = o1.getName().compareTo(o2.getName());
//				if (c != 0) {
//					return c;
//				}
//				return new Boolean(o1.isSex()).compareTo(o2.isSex());
				 
			}
		});
		set.add(new Student("asda", 10, true));
		set.add(new Student("张三", 10, true));
		set.add(new Student("李四", 20, false));
		set.add(new Student("张三", 20, false));
		set.add(new Student("张三", 10, true));
		set.add(new Student("李四", 20, false));
		print(set);

	}

	private static void print(Set set) {
		for (Object o : set) {
			System.out.println(o);
		}

	}

排序可以用

return o1.toString().compareTo(o2.toString());

也可以用

int c = o1.getAge() - o2.getAge();
				if (c != 0) {
					return c;
				}
				c = o1.getName().compareTo(o2.getName());
				if (c != 0) {
					return c;
				}
				return new Boolean(o1.isSex()).compareTo(o2.isSex());
				 
			}
		});

同样用增强for

Map

• HashMap
  允许使用null键null值

Map map=new HashMap();
map.put("a", "asd");
		map.put("c", "asdasf");
		map.put("d", "asfssdf");
		map.put("b", "agsdfsd");
		print(map);
		增强for遍历

• Hashtable
  不允许使用null键null值

Map map=new Hashtable();
		map.put(null, null);
		空指针异常

• TreeMap
  key必须实现Comparable，根据key排序。

Map map=new TreeMap<>();
		map.put("b", "asdasd");
		map.put("a", "fsdf");
		map.put("d", "fdsfs");
		map.put("c", "adada");
		print(map);
		System.out.println("----------->");
		map.put("a", "fsdfsad");
		map.remove("b");
		print(map);
	}

	private static void print(Map map) {
		Set keyset=map.keySet();
		for(Object o:keyset){
			System.out.println(o+"--------->"+map.get(o));
		}
		
	}

泛型

解决数据类型操作不统一产生的异常
给类定义泛型,类名后面
给静态方法定义泛型
两个泛型参数(也可以写一个，前面的后面的都可以)