14.1 为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种
数组和集合类同事容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储
14.3 迭代器
迭代：就是取出集合中元素的一种方式
把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。那么取出方式就被定义成了内部类。而每个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，判断和取出，那么可以将共性内容进行抽取那么这些内部类都符合一个规则：该规则是Iterator.
如何获取集合的取出对象呢？
通过一个对外提供的方法：iterator();
14.4 集合框架-List集合共性方法
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引；
|--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢，线程不同步。
|--LinkedList:底层使用的是链表数据结构，特点：增删速度很快，查询稍慢。
|--Vector:底层是数组数据结构，线程同步。被ArrayList替代了。
|--Set:元素是无序的，元素不可以重复，因为该集合体系没有
List：
特有方法：凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator：列表迭代器
List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。
所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除等操作。如果要想其他的操作如添加，修改等，就需要使用其子接口：ListIterator该接口只能通过List集合的ListIterator方法获取。
14.5、集合框架-Vector中的枚举
枚举就是Vector特有的取出方式。发现枚举和迭代器很像，其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
14.6 LinkedList
LinkedList:特有方法：
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但元素被删除，如果集合中没有元素，会出现
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素，如果集合中没有元素，会返回null.
pollFirst();
pollLast();
获取元素，但是元素被删除，如果集合中没有元素，会返回null
i mport java.util.*;class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子
队列：先进先出 First in First out FIFO 如同一个水管。
14.7、集合框架-HashSet
|--Set:元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
|--TreeSet：
Set集合的功能和Collection是一致的。
15.1 集合框架—TreeSet
Set无序，不可以重复元素。
|--HashSet：数据结构式哈希表，县城市非同步的。
保证元素唯一性的原理：判断怨毒的hashcode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据机构是二叉树，保证元素唯一性的依据：
compareTo方法return 0；
TreeSet排序的第一种方式：让元素自身具备比较性；
元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的，
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式。
需求：
往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。
记住，排序时，当主要条件相同时，一定要判断一下次要条件。
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi001",20));
ts.add(new Student("lisi009",22));
ts.add(new Student("lisi004",23));
ts.add(new Student("lisi003",23));
ts.add(new Student("lisi007",25));
Iterator it = ts.iterator();
while(it.hasNext())
{
//System.out.println(it.next());
Studentstu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
thrownew RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"..compareTo..."+s.name);
if(this.age > s.age)
return1;
if(this.age==s.age)
{
returnthis.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
15.2、集合框架—二叉树
当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递个TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
集合框架—实现Comparator方式排序
定义一个类，实现Comparator接口，覆盖compare方法。
而在Comparable方式排序中，实现的是Comparable接口，覆盖的却是compareTo方法。
import java.util.*;
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
thrownew RuntimeException("非法学生对象");
Student s = (Student)obj;
if(this.age>s.age)
return1;
if(this.age==s.age)
{
returnthis.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class TreeSetDemo1
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi003",20));
ts.add(new Student("lisi005",22));
ts.add(new Student("lisi005",21));
ts.add(new Student("lisi04",21));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num =s1.getName().compareTo(s2.getName());
if(num==0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
/*
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()>s2.getAge())
return 0;
return-1;
*/
}
return num;
}
}
16.1、Map集合概述
接口Map<K,V>
类型参数：
K：此映射所维护的键的类型
V：映射值的类型
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
1.添加
put(K key, V value)
putAll(Map<? extends K,? extends V>m)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key)
size()
value()
16.2、Map子类对象特点
Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的，jdk1.0效率低
|--HashMap：底层是哈希表数据结构，允许存入null键null值。该集合线程不同步的，jdk1.2效率高。
|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于各map集合中的键进行排序。
map和Set很像，其实Set底层就是使用了Map集合。
Hashtable用作键的对象必须实现hashCode方法和equals方法。
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,如果出现相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
System.out.println("put:"+map.put("01","zhangsan01"));
System.out.println("put:"+map.put("01","wangwu"));
map.put("02","zhangsan02");
map.put("03","zhangsan03");
System.out.println("containsKey:"+map.containsKey("02"));
//System.out.println("remove:"+map.remove("02"));
map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
//获取Map集合中所有的值
Collection<String> coll =map.values();
System.out.println(coll);
System.out.println(map);
}
}
map集合的两种取出方式：
Set<k> keySet：将map中所有的键存入到Set集合，因为set具备迭代器，所以可以用迭代的方式取出所有的键，再根据get方法，获取每一个键所对应的值。
Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
16.4、Map-Entry
Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry
17.1集合框架的工具类
1、Collections-sort
Collections:此类完全由在collection上进行操作或返回collection的静态方法组成。它包含collection上操作的多态算法，即“包装器”，包装器返回由指定collection支持的心collection，以及少数其他内容。
如果为此类的方法锁提供的collection或类对象为null，则这些方法都抛出NullPointerException。
Collections-sort
Collections-max
根据指定比较器产生的顺序，返回给定collection 的最大元素。
2、Collections-替换反转
fill：将集合中的元素全部替换成指定元素
3、Collections-SynchronizedList
static<T> List<T>synchronizedList(List<T> list):返回指定列表支持的同步（线程安全）列表。
static void shuffle(List<?< list):使用默认随机源对指定列表进行置换。
4、Arrays
Arrays:用于操作数据的工具类，里面都是静态方法。
asList:将数组变成list集合。
把数组编程list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。否者会发生UnsupportedOperationException异常。
5、集合变数组
Collection接口中的toArray方法。
6、高级for循环
格式：
for(数据类型变量名 ： 被遍历的集合(Collection)或者数组){}
对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别？
高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标。
import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al)
{
System.out.println(s);
}
/*
Iterator it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
*/
int[] arr = {3,4,5};
for(int i:arr)
{
System.out.println("i:"+i);
}
<SPAN style="WHITE-SPACE: pre"> </SPAN>//由于Map集合不支持Collection集合中的方法，因此这里需要先将其转换成Set集合后，才能使用相关方法
HashMap<Integer,String> hm = newHashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
<SPAN style="WHITE-SPACE: pre"> </SPAN>//取出元素的第一种方法
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
}
//Set<Map.Entry<Integer,String>>entrySet = hm.entrySet();
//for(Map.Entry<Integer,String> me: entrySet)
<SPAN style="WHITE-SPACE: pre"> </SPAN>//取出元素的第二种方法
for(Map.Entry<Integer,String> me:hm.entrySet())
{
System.out.println(me.getKey()+"-----"+me.getValue());
}
}
}
7、可变参数
JDK1.5版本出现的新特性
方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。
8、staticimport 静态导入
当类名重名时，需要指定具体的包名；
当方法重名时，指定具备所属的对象或者类。
9、其他对象-System
1.getProperty
static Properties getProperty() 确定当前的系统属性
System:类中的方法和属性都是静态的。
out：标准输出，默认是控制台
in：标准输入，默认是键盘
描述系统一些信息，获取系统属性信息：Properties getProperties()
2.Runtime
public classRuntime extends Object 每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的Runtime类实例。
Runtime对象
该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的；发现该类中还有非静态方法，说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。该方法是static Runtime getRuntime();
由这个特点可以看出该类使用了单例设计模式，保证了对象的唯一性。
3.Date
4.Calendar日期类
5.Math-Random:随机数