第九天集合框架与常用的其它类

1:集合框架
A:集合:存储对象的容器。
对象数组：String[],Student[]
B:集合和数组的区别
集合:
长度可变
可以存储不同的对象数据
只能存储对象
数组:
长度固定
可以存储基本数据类型，也可以存储引用类型
只能存储同一种数据类型的数据
C:由于数据结构不同，所以就会有很多的集合类。
 而这多种集合类都是可以存储数据的，以及遍历数据的。那么，我们不断的向上抽取，
 抽象共性的功能，最终形成了集合体系结构。
D:集合的体系结构
Collection: add,size,remove,iterator
|--List
元素有序,可重复。

|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
|--LinkedList
底层数据结构式链表，查询慢，增删快。
线程不安全，效率高。
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
|--Set
元素无序,唯一。
|--HashSet
底层数据结构是哈希表。
如何保证元素的唯一性的呢？
重写hashCode()和equals()方法。
先执行hashCode()，
如果不同，就直接存储元素
如果相同，在执行equals()方法
如果返回true,说明元素重复。
如果返回false,直接存储元素。
|--LinkedHashSet
底层数据结构是链表和哈希表。
元素有序,唯一。
|--TreeSet
底层数据结构是二叉树。
如何保证元素的唯一性的呢？
根据两种方式实现。如果返回值是0，就认为元素重复。
方式1：对象具备比较性
自定义对象实现Coomparable接口
方式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()
我通过set集合获取所有的丈夫的集合。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，并遍历。(必做题)
ArrayList<Person> list=new ArrayList<Person>();
Person p1=new Person("张一",35);
Person p2=new Person("张二",35);
Person p3=new Person("张三",23);
list.add(p1);
list.add(p2);
list.add(p3);
for(ArrayList al: list){
System.out.println(list);
}
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接口的子类对象


4API查找方法。
建议使用带索引搜索的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: 比任何其他值都更接近 e（即自然对数的底数）的 double 值。
PI: 比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。
                abs: 返回一个double类型的绝对值。
Ceil:返回一个大于等于该参数的最小double类型整数值。
Floor：返回一个小于等于该参数的最大double类型整数值。
Max：返回两个数中值较大的。返回值的类型可以是float,double,int,long
Min：返回两个数中值较小的。返回值的类型可以是float,double,int,long
Sqrt： 返回一个double类型,四舍五入后的正平方根。
Random：返回大于等于 0.0 且小于 1.0 的伪随机 double 值。


Round：返回一个四舍五入后long/int类型数值。


6:System类
A:系统类,提供了静态方法供我们使用。
B:要掌握的方法：
退出jvm：exit  终止当前正在运行的 Java 虚拟机
获取当前时间的毫秒值:currentTimeMillis    返回以毫秒为单位的当前时间，返回值类型为long.


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


8:Scanner类
可以获取键盘录入数据。
需要注意特殊情况：
A:输入了数据后，直接获取字符串会有问题。
B:当数据不匹配的时候，Scanner对象本身失效。
9.Date类：日期类，用于获取或者设置时间
      long getTime():Date--->long毫秒值。
      Date(long date):long毫秒值---->Date
      setTime(long time):设置毫秒值。


10.DateFormat类：对日期对象进行格式化的类。
      A：常用功能：
格式化：Date--->Strng:  format();
解析：String---->parse();
      B：注意问题：1.创建格式化对象的时候，自已一定要注意模式的编写。
            2.解析的时候，要指定模式，并且和字符串的关系要一一对应。
      C：simpleDateFormat:是一个以语言环境有关的方式来格式化和解析日斯 的具体类。


11.Calendar类：日历类，把时间分解成一个个单独的日历字段。
         方法：Calendar getInstance():返回一个子类实例对象。
常用功能：
get():获取时间,返回指定日历字段的值。
         set(int year,int moth,int date): 设置时间
add(int field,int amount):根据指定的日历字段，增加或者减少值。