集合框架,Math,System,Runtime,Scanner

1:集合框架
	A:集合:存储对象的容器。
		对象数组：String[],Student[]
	B:集合和数组的区别
		集合:
			长度可变
			可以存储不同的对象数据
			只能存储对象
		数组:
			长度固定
			可以存储基本数据类型，也可以存储引用类型
			只能存储同一种数据类型的数据
	C:由于数据结构不同，所以就会有很多的集合类。
	  而这多种集合类都是可以存储数据的，以及遍历数据的。那么，我们不断的向上抽取，
	  抽象共性的功能，最终形成了集合体系结构。
	D:集合的体系结构
		Collection: add,size,remove,iterator
			|--List
				元素有序,可重复。
				get,set,listIterator
				|--ArrayList
					底层数据结构是数组，查询快，增删慢。
					线程不安全，效率高。
				|--LinkedList
					底层数据结构式链表，查询慢，增删快。
					线程不安全，效率高。
				|--Vector
					底层数据结构是数组，查询快，增删慢。
					线程安全，效率低。
			|--Set
				元素无序,唯一。
				|--HashSet
					底层数据结构是哈希表。
					如何保证元素的唯一性的呢？
						重写hashCode()和equals()方法。
						先执行hashCode()，
							如果不同，就直接存储元素
							如果相同，在执行equals()方法
								如果返回true,说明元素重复。
								如果返回false,直接存储元素。
					|--LinkedHashSet
						底层数据结构是链表和哈希表。
						元素有序,唯一。
				|--TreeSet
					底层数据结构是二叉树。
					如何保证元素的唯一性的呢？
						根据两种方式实现。如果返回值是0，就认为元素重复。
					方式1：对象具备比较性
						自定义对象实现Comparable接口
					方式2：集合具备比较性
						集合的构造方法接收Comparator接口的子类对象
		Map: put,get,size,keySet,entrySet,values
			在Map中，它的数据结构式针对键而言。
			|--HashMap
				底层数据结构是哈希表。
				线程不安全的
			|--Hashtable
				底层数据结构是哈希表。
				线程安全的
				|--Properties
					在IO中我会讲到。
			|--TreeMap
				底层数据结构是二叉树。
				线程不安全的
	E:集合要掌握什么呢？
		能够使用不同的集合添加元素，在把元素从集合中遍历出来。

		操作集合的步骤：
			创建集合对象
			创建元素对象
			把元素添加到集合中
			遍历集合
				迭代器是依赖于集合存在的。
				通过集合对象的.iterator()方法返回一个迭代器对象
				调用迭代器对象hasNext()方法判断是否有元素
				调用迭代器的next()方法获取元素

		用ArrayList存储Person(name,age)对象.

		//创建集合对象
		ArrayList<Person> array = new ArrayList<Person>();

		//创建元素对象
		Person p1 = new Person("张飞",38);
		Person p2 = new person("赵云",35);
		Person p3 = new Person("马超",37);
		Person p4 = new Person("关羽",40);
		Person p5 = new Person("黄忠",60);

		//把元素添加到集合中
		array.add(p1);
		array.add(p2);
		array.add(p3);
		array.add(p4);
		array.add(p5);

		//遍历集合
		//通过集合对象的.iterator()方法返回一个迭代器对象
		Iterator<Person> it = array.iterator();
		//调用迭代器对象hasNext()方法判断是否有元素
		while(it.hasNext())
		{	
			//调用迭代器的next()方法获取元素
			Person p = it.next();
			//System.out.println(p); //需要重写toString()方法
			System.out.println(p.getName()+"***"+p.getAge());
		}
	F:List,Set,Map
		List的遍历方式：(假如array这个集合存在)	
			迭代器：
				Iterator<Person> it = array.iterator();
				while(it.hasNext())
				{
					Person p = it.next();
					//操作
				}
			增强for：
				for(Person p : array) //内部封装了判断和获取功能
				{
					//操作
				}
			普通for：
				for(int x=0; x<array.size(); x++)
				{
					Person p = array.get(x);
					//操作
				}
		Set的遍历方式：(假如hs这个集合存在)
			迭代器：
				Iterator<Person> it = hs.iterator();
				while(it.hasNext())
				{
					Person p = it.next();
					//操作
				}
			增强for：
				for(Person p : hs) //内部封装了判断和获取功能
				{
					//操作
				}
		Map的遍历方式：
			Map是一个键值对集合。把Map看成是一个夫妻对。
			HashMap<String,String> hm;

			方式1：keySet()
				我通过Map获取所有的丈夫的集合。keySet()
				遍历丈夫集合,获取每一个丈夫。iterator()
				根据丈夫找妻子。hm.get(key)

			Set<String> set = hm.keySet();
			Iterator<String> it = set.iterator();
			while(it.hasNext())
			{
				String key = it.next();
				String value = hm.get(key);
				System.out.println(key+"***"+value);
			}


			方式2：entrySet()
				我拿到结婚证集合。entrySet()
				遍历结婚证集合,获取每一个结婚证。iterator()
				根据结婚证获取丈夫和妻子。getkey(),getValue()

			Set<Map.Entry<String,String>> set = hm.entrySet();
			Iterator<Map.Entry<String,String>> it = set.iterator();
			while(it.hasNext())
			{
				Map.Entry<String,String> me = it.next();
				String key = me.getKey();
				String value = me.getValue();
				System.out.println(key+"***"+value);
			}
	G:作业
		假如我现在有一个Person类存在。这个类结构如下：
			public class Person {
				private String name;
				private int age;

				public Person() {
				}

				public Person(String name, int age) {
					this.name = name;
					this.age = age;
				}

				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;
				}

			}
		请选择下面三道题目的任意两道实现；
		1：使用ArrayList存储3个Person，并遍历。(必做题)
		2：使用HashSet存储5个Person对象，要求保证元素唯一。
			需求是：同姓名同年龄的人即为同一个人。
		3：使用HashMap存储Person对象，以编号(字符串类型)做键，以Person对象做值。
		   存储3个对象，并遍历。

		要求按照集合操作步骤实现。遍历方式任选。



		//创建集合对象
		HashSet<Person> hs = new HashSet<Person>();
		//创建元素对象
		Person p1 = new Person("刘德华",50);
		Person p2 = new Person("张学友",49);
		Person p3 = new Person("郭富城",48);
		Person p4 = new Person("黎明",47);
		Person p5 = new Person("刘德华",50);
		//把元素添加到集合中
		hs.add(p1);
		hs.add(p2);
		hs.add(p3);
		hs.add(p4);
		hs.add(p5);

		//通过集合对象的.iterator()方法返回一个迭代器对象
		Iterator<Person> it = hs.iterator();
		//调用迭代器对象hasNext()方法判断是否有元素
		while(it.hasNext())
		{
			//调用迭代器的next()方法获取元素
			Person p = it.next();
			System.out.println(p.getName()+"***"+p.getAge());
		}

		重写：
		public int hashCode()
		{
			return this.name.hashCode()+this.age*13;
		}

		public boolean equals(Object obj)
		{
			Person p = (Person)obj;
			return this.name.equals(p.name) && this.age==p.age;
		}

		
		//创建集合对象
		HashMap<String,Person> hm = new HashMap<String,Person>();
		//创建元素对象
		Person p1 = new Person("林青霞",25);
		Person p2 = new Person("王祖贤",18);
		Person p3 = new Person("张曼玉",22);
		//添加
		hm.put("it001",p1);
		hm.put("it002",p2);
		hm.put("it003",p3);
		//遍历
		Set<String> set = hm.keySet();
		Iterator<String> it = set.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			Person value = hm.get(key);
			System.out.println(key+"***"+value.getName()+"***"+value.getAge());
		}

2:集合类的使用总结。
	数据是否是键值对形式的：
		是：Map
			键是否需要排序
				是：TreeMap
				不是：HashMap
			如果不知道，就使用HashMap。

		不是：Collection
			数据是否唯一
				是：Set
					数据是否需要排序
						是：TreeSet
						不是：HashSet
					如果不知道，使用HashSet

				不是：List
					是否考虑线程安全：
						是：Vector，但是一般也不用。用Collections里面额方法。
							ArrayList array = Collections.synchronizedList(new ArrayList());
						不是：
							看查询多：ArrayList
							还是增删多：LinkedList
					如果不知道，使用ArrayList

3:数据结构规律总结
	数据结构：组织数据的方式
	ArrayXxx:底层数据结构是数组,查询快,增删慢
	LinkXxx:底层数据结构是链表,查询慢,增删快
	HashXxx:底层数据结构是哈希表。可能需要重写hashCode()和equals()
	TreeXxx:底层数据结构是二叉树。
		对象实现：Comparable接口
		集合接收：Comparator接口的子类对象

	数据结构与算法。
		面试大企业可能需要。

4:学会使用API
	建议使用带索引搜索的API。

	A：看包
		java.lang 
			类 String
	B：看类的声明结构
		public final class Stringextends Objectimplements Serializable, Comparable<String>, CharSequence
	C：看看解释与说明
	D：一个类中可能有三个内容：字段，构造方法，方法
	   他们其实就是对应于类中的：成员变量，构造方法，成员方法。
	E：我们学习一个类，目的就是为了使用这个类的功能。
		看这个类中的功能是否都是静态的。如果是，就不需要创建对象了。
		如果不是，就需要创建对象，也就是我们需要学习构造方法。
	F：构造方法
		如果一个类没有构造方法
			可能是所有成员都是静态的。
			可能是以单例模式返回了该类对象。
			可能是以一个静态方法返回了该类对象。
	G：使用功能
		注意看左边和右边。
		想想返回值类型，和方法名及参数。

5:Math(掌握)
	A:Math 类包含用于执行基本数学运算的方法
	B:Math类的特点：没有构造方法。原因：它的成员都是静态的。
	C:要掌握的成员变量和成员方法：(请补齐中文意思)
		E:最接近的自然对数的底数的double值
		PI:最接近π(即圆周长与直径之比)的double值

		abs:获取绝对值
		ceil:ceil(double a)返回最接近参数并大于等于参数的double型的整数值
		floor:floor(double a)返回最接近参数并小于等于参数的double型的整数
		max:返回两个数中较大的一个
		min:返回两个数中较小的一个
		sqrt:返回正确舍入的 double 值的正平方根
		random:返回带正号的随机 double 值，该值大于等于 0.0 且小于 1.0
		round:1,round(double a)返回最接近参数的 long。
		      2,round(float a)返回最接近参数的 int。

6:System(掌握)
	A:系统类,提供了静态方法供我们使用。
	B:要掌握的方法：(请补齐方法名)
		退出jvm：System.exit(0);
		获取当前时间的毫秒值:currentTimemillis()

7:Runtime(理解)
	A:运行时类。作用：可以运行path路径中的exe文件
	B:它是单例设计模式的一种体现
	C:获取对象的方式:
		Runtime r = Runtime.getRuntime();
	D:掌握的功能
		exec(String name)

8:Scanner(理解)
	可以获取键盘录入数据。
	需要注意特殊情况：
		A:输入了数据后，直接获取字符串会有问题。
		B:当数据不匹配的时候，Scanner对象本身失效。