9、JAVA基础&集合框架

9、JAVA基础&集合框架

 

集合：

集合的由来：之前学过一些能封装数据的对象。但是当这样的数据多了之后怎么办呢，往什么地方存放这些对象呢？集合就产生了。

集合的特点：

      1、集合是一个容器  

   2、集合用于存放对象  

   3、集合的长度是可变的

集合和数组的不同：

1、集合定义时可以不用声明长度，即就是集合的长度可变。它是一个容器，可以存放对象，数组定义时的长度必须声明出来，即就是数组长度固定的。

2、数组存放的是同一类型的数据，集合存放的是对象，而对象可以是任意类型

3、集合只能存放对象，数组可以存放基本数据类型值。StringBuffer 也可以存放任意数据，但是必须以字符串形式来使用

数据结构：对数据存储和排放方式(结构)，每一种数据的存储方式都不一样，每一个容器因为自身数据结构不同，进行单独的描述，对象的封装，因为这些对象又有共性就进行了向上抽取，形成了集合框架。

学习体系：技巧：查阅顶层内容，建立底层对象。对集合不断的抽取就有Collection 接口 。接口中结合框架中的共性内容。

iterator 迭代器(其实就规则)：取出集合中的元素一种方法。

Collection 定义了集合框架的基本方法：集合框架中有增加、删除和查阅数据，唯独没有修改数据。

增加 

boolean add(object)   添加一个对象

boolean addAll(object)  添加全部对象

删除 

boolean remove(object)  删除一个对象

boolean removeAll(object)  删除一部分对象

void clear(); 清空   清空集合中的所有对象

判断

contains   包含某个元素

containsAll  包含部分对象

isEmpty   判断集合是否为空

size  判断容器大小

获取

Iterator    iterator();

迭代器：其实就是Collection集合的公共取出方法，因为每一个具体容器的数据结构不同，他们的取出方法不一样，要根据每一个容器的特点来定义特定的取出方式。而取出方式直接在访问容器中的元素，所以将取出方式定义到了容器的内部，是一个内部类，而对外提供了Iterator接口。这样可以通过该接口访问任意Collection容器中的元素。我们只要面对Iterator接口，并使用Iteratot接口即可，而具体的容器在做迭代器具体事项。

举例：抓娃娃机器

演示Collection接口中的共性方法

package ConllectionDemo;

import java.util.ArrayList;

import java.util.Collection;

public class ConllectionDemo1 {

public static void main(String[] args) {

Collection coll = new ArrayList();

Collection coll2 = new ArrayList();

Collection coll3 = new ArrayList();

method(coll);

method2(coll2,coll3);

}

public static void method2(Collection coll2,Collection coll3) {

//所有带All的方法  addAll  removeAll  containsAll retainAll

coll2.add("abc1");

coll2.add("abc2");

coll2.add("abc3");

coll2.add("abc4");

coll3.add("abc1");

coll3.add("abc5");

coll3.add("abc6");

System.out.println("coll2:"+coll2);

System.out.println("coll2:"+coll3);

coll2.addAll(coll3); //在coll2中添加coll3中的所有元素，重复也可以添加进去

System.out.println("coll2:"+coll2);

coll2.removeAll(coll3); //  在coll2中删除 coll3中的所有元素，coll2中有coll3中的重复元素也一起删除

System.out.println("coll2:"+coll2); 

coll2.addAll(coll3);

boolean b = coll2.containsAll(coll3); //判断coll2中是否包含coll3中的元素

System.out.println(b);

boolean b1 = coll2.retainAll(coll3); // 将coll2和coll3中相同的元素保留住在coll2中，删除coll2中其他元素

System.out.println(b1);

System.out.println(coll2);

}

public static void method(Collection coll){

//添加元素

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

System.out.println("size:"+coll.size());获取容器的大小

System.out.println(coll);

//删除元素

boolean b = coll.remove("abc3"); 删除成功返回true 否则返回false

System.out.println(b);

System.out.println("size:"+coll.size());

// 清空元素

coll.clear();  //元素被清空，但是集合本身仍然存在。也就是说集合中仍然可以存放数据

System.out.println("size:"+coll.size());

System.out.println(b);

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

// 判断对象存在

boolean b1 = coll.contains("abc3");  判断abc3是否包含在集合中

System.out.println(b1);

System.out.println("isEmpty:"+coll.isEmpty());//是空返回true  不是空返回false

}

}

iterator 先判断有没有元素 ，有然后再去数值，取完在判断，然后再去，直到取完。

Iterator it = coll.iterator(); 获取到了集合的迭代器对象。

whie(it.hasNext()) 判断有没有这个元素

{

sop(it.next());  取出这个元素  在循环里面进制写多个next

}

建议 写迭代用for循环

for( Iterator it = coll.iterator() ; it.hasNext() ;  )

{

sop(it.next());

}

package ConllectionDemo;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class IteratorDemo {

public static void main(String[] args) {

Collection coll = new ArrayList();

}

public static void getElements(Collection  c){

c.add("abcd1");

c.add("abcd2");

c.add("abcd3");

c.add("abcd4");

Iterator it = c.iterator();  // 获取到了集合的迭代器

while( it.hasNext() ){

System.out.println(it.next()); // next只能出现一次，避免问题的发生

}

for( Iterator it2 = c.iterator() ; it2.hasNext() ;  ){  // 开发用for循环，当循环结束定义的变量就不用了

System.out.println(it2.next());

}

}

}

集合的细节：

1、直接存储基本类型值也是可以的，因为JDK1.5后，有自动装箱技术，会将基本数据类转换成数据对象。JDK1.4绝对不行，因为集合中存放的对象的引用，当直接存放基本类型值的时候，会将这个基本类型值变成一个对象。

2、集合对象中存储的其实都是元素对象的引用

3、add方法的参数是object类型可以接受所有类型的对象。但会出现向上转型，取出元素时的类型还是object，不能使用具体对象的特有内容，想要是有特有内容，必须向下转型。集合框架中存放的都是对象的地址。当我们想用对象的特有方法的时候必须向下转型。

当我们想直接打印一个集合，其实是调用了这个对象的toString方法，当我们要打印一个对象的长度的时候，首先我们会想到length方法。但是由于我们添加数据的时候用的add方法，而add方法的参数类型是object，也就说把存进去的数据向上转型了。但是我们都知道object是没有length方法，此时无法使用length方法。那么就要向下转型才可以。

public class IteratorDemo {

public static void main(String[] args) {

Collection coll = new ArrayList();

}

public static void getElements(Collection  c){

c.add("abcd1");

c.add("abcd2");

c.add("abcd3");

c.add("abcd4");

for( Iterator it2 = c.iterator() ; it2.hasNext() ;  ){

String  s = (String)it2.next();

System.out.println(s.length());

}

}

}

Collection 有很多子接口，那么常用的子接口有两个 Set 和 List

|--List(列表) 有序(存储的顺序和取出的顺序一致)，因为该子体系中的元素都有索引(角标)。是可以存储重复元素的。

|--Set(集) 存储的元素不可以重复，必须要保证集合中的元素的唯一性。无序的(存储的顺序和取出的顺序有可能不一样).

List 子体系中的特有方法：(List 继承了Collection中的所有方法)

1、增加

void add(index element)

2、删除

object remove(index); 删除指定索引上的元素，并返回该元素

3、获取(查)

object get(index); 获取指定角标上的元素但不删除

int  indexOf(object);获取元素的索引，如果元素存在返回索引，不存在返回-1。从而这个方法可以判断当前这个元素是否存在

int  lastIndexOf(object);

List  subList(forIndex,toIndex); 获取集合中的一部分。 获取从指定位置到指定位置的元素，包头不包尾

4、修改

object set(index,objec); 替换当前位置上的元素，并返回被替换的元素

记住：只有 List 集合支持增删改查。

package ConllectionDemo;

import java.util.ArrayList;

import java.util.List;

public class ListDemo {

public static void main(){

List<String> l = new ArrayList<String>();

method(l);

}

public static void method( List<String> l ){

l.add("abcd1");

l.add("abcd2");

l.add("abcd3");

l.add("abcd4");

System.out.println(l);

l.add(1,"bcde7"); //添加指定角标上的元素，当前角标上的元素顺延下一位

System.out.println(l);

Object obj = l.remove(2); // 删除指定角标上的元素，并返回被删除的这个元素

System.out.println(l);

System.out.println(obj);

Object obj1= l.get(3); // 获取指定角标上的元素，但这个元素不被删除

System.out.println(obj1);

int index = l.indexOf("abcd2"); // 获取指定元素的索引，如果这个元素存在返回元素的索引，若不存在返回-1,这个方法还可判断当前这个元素是否存在

System.out.println(index);

List news = l.subList(0,2); // 获取从指定位置到到下一个指定位置的元素(包起不包尾)

System.out.println(news);

Object s = l.set(1, "ABCD1");// 修改指定位置上的元素，并把修改之前的元素返回

System.out.println(s);

}

}

list 集合继承了Collection接口，那么它也有了通用的取元素方法

for( Iterator it2 = c.iterator() ; it2.hasNext() ;  ){

System.out.println(it2.next());

}

list 集合特有的取出方式，通过角标遍历

for (int x=0;x<list.size() ;x++ )

{

sop("next:"+it.next());

}

package ConllectionDemo;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ListDemo2 {

public static void main(String[] args) {

List list = new ArrayList();

List list2 = new ArrayList();

method(list);

method2(list2);

}

public static void method(List list) {

list.add("abcd1");

list.add("abcd2");

list.add("abcd3");

list.add("abcd4");

// 取出数据通用方法迭代器

for (Iterator it = list.iterator(); it.hasNext();) {

System.out.println(it.next());

}

// list集合特有的取值方法，通过角标遍历

for (int x = 0; x < list.size(); x++)

System.out.println(list.get(x));

}

public static void method2(List list2) {

list2.add("abcd11");

list2.add("abcd22");

list2.add("abcd33");

list2.add("abcd44");

Iterator it = list2.iterator(); //迭代器在这里已经知道了集合中具体有多少个元素

while (it.hasNext()) {

Object obj = it.next();

if ("abcd22".equals(obj))  

list2.remove(obj); // 在这里删除会导致集合的长度变小，而迭代器开始知道集合的数据，而此时元素被删除，迭代器并不知道，所以会导致并发修改异常的发生

else

System.out.println(it.next());

}

}

}

在 List 取出元素的时候如果我们同时删除元素，就会发生异常

想要在迭代的过程中进行元素的增删改查动作，Iterator 就不行，可以使用其子接口ListIterator，而且该接口的对象只有通过List集合的listIterator方法获取，是List集合特有的取出元素方式。在迭代过程中，列表迭代器可以实现增删改查的动作。

public static void method2(List list2) {

list2.add("abcd11");

list2.add("abcd22");

list2.add("abcd33");

list2.add("abcd44");

ListIterator it = list2.listIterator();

while (it.hasNext()) {

Object obj = it.next();

if ("abcd22".equals(obj))  

it.add("hahaheihei"); 

else

System.out.println(it.next());

}

System.out.println(list2);

}

public static void method2(List list2) {

list2.add("abcd11");

list2.add("abcd22");

list2.add("abcd33");

list2.add("abcd44");

ListIterator it = list2.listIterator(); //迭代器在这里已经知道了集合中具体有多少个元素

while (it.hasNext()) {

System.out.println(it.next());

}

while(it.hasPrevious()){

System.out.println(it.previous());

}

}

List 集合

|--Vector:底层数据结构是可变数组长度结构。是同步的。 延长是原来的100% 无论什么都慢

支持枚举接口 Enumeration 但是该接口因为名称过长，被 Iterator 代替

|--ArrayList:底层数据结构可变数组长度结构。是不同步的，替代了 Vector. 当在多线程中，我们可以使用其他方法给他加锁。延长是原来的50%

|--LinkedList:底层数据结构是链表数据结构。不同步的。

ArrayList 查询元素的速度很快。增删较慢。LinkedList 增删效率快。查询较慢。建议使用ArrayList，因为开发后期我们使用对数据的查询还是多余增删。

LinkedList  底层是链表结构存储数据。

LinkedList 中常用的特有方法

1、添加元素  

void addFirst(obj) 在链表的第一个位置插入元素

void addLast(obj)  在链表的末尾插入元素

在JDK1.6 有了替代方法

boolean offerFirst ()  在此列表的开头插入指定的元素

boolean offerLast()   在此列表末尾插入指定的元素

2、取出元素(获取对象，但不删除)

object getLast() 获取链表最后一个元素返回，但是不删除当前这个元素

如果集合中没有元素，会抛出 NoSuchElementException

object getFirst() 获取链表第一个元素返回，但是不删除当前这个元素

在JDK1.6 有了替代方法

peekFirst 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null

peekLast  获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

3、获取对象，但会删除当前对象

object removeFirst() 获取链表第一个元素返回，并从链表中删除这个元素

object removeLast() 获取链表最后元素返回，并从链表中删除这个元素

package MapDemo;

import java.util.Iterator;

import java.util.LinkedList;

public class LinkedListDemo {

public static void main(String[] args) {

LinkedList link = new LinkedList();

link.add("abcd1");

// 添加元素 addFirst addLast

link.addFirst("bcde1"); // 永远都是在第一个位置插入

link.addFirst("bcde2");

link.addFirst("bcde3");

link.addLast("bcde4"); // 永远都是在末尾插入

Iterator it = link.iterator();

while (it.hasNext()) {

System.out.println("link:" + it.next());

}

System.out.println("getLast:" + link.getLast()); // 获取最后一个元素

Object obj = link.remove();  // 没有指定元素，会删除第一个元素，并返回这个元素

System.out.println(obj);

Object obj1 = link.removeLast();  // 没有指定元素，会删除最后一个元素，并返回这个元素

System.out.println(obj1);

}

}

面试 ：用LinkedList 来模拟常见的两种数据结构。

堆栈结构： 先进后出   first in last out  FILO

队列结构： 先进先出   first in first out  FIFO

这样的题，是让做一个容器出来，具备队列或者堆栈这种结构特点。方便调用者使用队列结构添加和删除是相反的。

package MapDemo;

import java.util.LinkedList;

public class LinkedListTest {

public static void main(String[] args) {

MoNiDuiLie dl = new MoNiDuiLie();

dl.myAdd("abcd1");

dl.myAdd("abcd2");

dl.myAdd("abcd3");

dl.myAdd("abcd4");

while (!dl.isNull()) {

System.out.println(dl.myGet());

}

}

}

class MoNiDuiLie {

private LinkedList link;

MoNiDuiLie() { // 在对象初始化的时候就把link初始化

link = new LinkedList();

}

/**

 * 对外提供一个添加元素的方法

 */

public void myAdd(Object obj) {

link.addFirst(obj);

}

/**

 * 对外提供一个获取元素的方法

 */

public Object myGet() {

return link.removeLast();

}

/**

 * 判断集合是否为空

 */

public boolean isNull() {

return link.isEmpty();

}

}

练习给集合中存储自定义元素。

删除ArrayList中的重复元素：有没有重复元素集合最清楚，而集合里面有一个方法就是contains

import java.util.ArrayList;

import java.util.Iterator;

public class ArrayListDemo {

public static void main(String[] args) {

ArrayList al = new ArrayList();

al.add("abcd1");

al.add("abcd2");

al.add("abcd3");

al.add("abcd2");

al.add("abcd3");

al.add("abcd4");

al = getSingleElement(al);

Iterator it = al.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

}

public static ArrayList getSingleElement(ArrayList al) {

ArrayList temp = new ArrayList();

Iterator it = al.iterator();

while(it.hasNext()){

Object obj = it.next();

if(!temp.contains(obj)) //contains方法依赖于对象的equals方法来判断是否相同。相同即包含。

temp.add(obj);

}

return temp;

}

}

思路：既然姓名和年龄等信息都是Person的属性，所以封装到Person对象中，应该先对Person进行描述

同姓名同年龄视为同一个人。视为重复元素。Person类中的equals继承Object。判断相同的依据是Person对象的地址值。 为了按照指定的条件来判断Person对象是否相同。必须覆盖equals方法。

比如Person，有年龄和姓名

import java.util.ArrayList;

import java.util.Iterator;

public class ArrayListPerson {

public static void main(String[] args) {

ArrayList al = new ArrayList();

al.add(new Person("张三",32));

al.add(new Person("李四",33));

al.add(new Person("王五",27));

al.add(new Person("赵六",26));

al.add(new Person("田七",33));

al.add(new Person("周八",27));

        al.add(new Person("田七",33));

al.add(new Person("周八",27));

al = getSingleElement(al);

Iterator it = al.iterator();

while(it.hasNext()){

Person p = (Person)it.next();

System.out.println(p.getName()+"..."+p.getAge());

}

}

public static ArrayList getSingleElement(ArrayList al) {

ArrayList temp = new ArrayList();

Iterator it = al.iterator();

while(it.hasNext()){

Object obj = it.next();

if(!temp.contains(obj)) 

temp.add(obj);

}

return temp;

}

}

public class Person {

private String name;

private int 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;

}

public boolean equals(Object obj) {

if(!(obj instanceof Person))

throw new ClassCastException("类型错误");

Person p = (Person)obj;

return this.name.equals(p.name) && this.name==p.name;

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

}

练习中发现：ArrayList中的contains 方法，remove 方法 最终使用的都是元素对象自身的equals 方法。复写equals 方法，其实是建立对象自身特有的判断对象是否相同的数据

Set 集合：无序，不重复。该接口中的方法和Collection接口中的方法一致

|--HashSet: 底层是哈希表数据结构。线程不同步的。它保证元素的唯一性是根据元素的两个方法来完成，一个是hashCode方法，一个是equals方法。只有当hashCode方法算出的哈希值相同，会再次判断两个元素的equals方法是否为true。如果是true，就不存放自此。所以往HashSet集合中存储自定义对象时，要覆盖hashCode 和 equals方法。通过自定义对象自身具备的特有数据来定义hashCode和equals的具体实现

|--TreeSet: 用于给Set集合中的元素按照指定的顺序进行排序。底层是二叉树数据结构。线程是不同步的，如何保证元素唯一性呢？就是通过元素对象的比较方法返回值来确定的，如果为0 视两个元素为相同元素，不存放这个值。

排序方式一：

让元素自身具备比较功能，就是强制让元素去实现Compareable接口，覆盖compareTo方法。这是元素具备的自然排序。可是如果元素自身不具备比较功能，获取具备的比较功能不是所需要的，这是排序方式一就用不了了。

排序方式二：

让集合自身具备表功能。需要定义比较器，其实就是将实现了Comparator接口的子类对象作为参数传递给TreeSet集合的构造函数。让TreeSet集合一创建就具备了比较功能。该子类必须要覆盖compare方法。

基本数据比较用比较运算符，对象比较用compareTo方法。要想具备compareTo方法该对象必须实现 Comparable查阅集合的技巧：

List

|--Vector

|--ArrayList

|--LinkedList

Set

|--HashSet

|--TreeSet

在jdk1.2集合框架出现后，名称的阅读性非常强。通过名称就可以识别.，明确所述的子体系：只要看后缀名。

到底具体这个集合是什么结构，有什么特点：只要看前缀名即可。看到array：数组结构，就必须想到角标，有序，可重复。查询快。看到link：链表结构，想要增删快，同时可以明确 操作first last的方法。看到hash：哈希表结构，就想要到无序，不可以重复，必须要想到元素是依靠hashcode,equals方法来保证唯一性的。看到tree：二叉树结构，就想要比较功能和排序，必须要想到两个接口，Comparable-compareTo Comparator-compare.

通常集合中常用的集合对象都是不同步的。

泛型

在jdk1.4版本之前，定义容器可以存储任意类型的对象，但是取出时，如果使用了具体元素的方法，需要向下转型的动作。因为元素类型的不一致，会导致运行时， ClassCastException 类型转换异常。问题原因是，在定义集合时，并没有明确集合中的元素的具体类型。借鉴数组的定义方式就可以避免这个问题。所以jdk1.5版本以后，出现了一个解决机制，就在定义容器时，直接明确容器的元素类型。ArrayList<String> a = new ArrayList<String>();

这是就是泛型的表现，通过<>格式来使用，其实泛型就是使用到了带有<>的类和接口时，传递需要操作的对象的类型即可，其实就传递类型参数。

什么时候写泛型

最简单一种体现，只要使用了带有<>的类的接口，就是指定具体对象类型。

泛型的好处：

1、将运行时出现的 ClassCastException 问题，在编译时期给解决了，运行就安全了

2、避免了强制转换的麻烦了。

所以泛型就是jdk1.5后出现了一个安全机制。

泛型是编译时期的安全机制

泛型的擦除：

编译时，通过泛型机制，编译器多了对元素类型进行检查的步骤。如果检查通过，产生的class文件是不带有的泛型的：泛型的擦除。

泛型的补偿：

在对元素存储的时候，可以完成类型的判断。可是在对元素取出的时候，怎么用指定的类型来接收呢？jvm在运行时，会获取元素的类型，并用该类型对元素进行转换即可。

泛型在表现上的特点：

泛型类：

将泛型定义在自定义类上，这个类称为泛型类。

所以泛型替代了Object的同时在编译时期更安全，省去了强转的麻烦。

什么时候使用泛型类呢？

当类中的要操作的引用数据类型不确定的时候，以前使用的共性类型Object，现在可以使用泛型来解决。

泛型方法：

类中的方法操作的类型不确定时，可以将泛型定义在方法上。

什么时候使用泛型方法？

当方法操作的引用数据类型不确定的时候，就使用泛型方法。

*.如果方法是静态的，是无法访问类上定义的泛型的，如果该方法还需要泛型，必须将泛型定义在方法上。

泛型通配符：

当打印集合中的元素的类型是不确定的，无法明确，可以使用泛型中的通配符来完成，该通配符用 ？来表示。

如果要对操作的类型进行限定，只操作一部分类型时，可以使用泛型的高级功能。

泛型的限定：

? extends E 可以接收E类型和E的子类型。

？super E 可以接收E类型或者E的父类型。

什么时候使用这种高级功能？

一般在存储具体引用类型时，使用这种情况，因为存储E类型或者E类型的子类型，在取出的时候都可以使用E类型操作操作这些元素。这时可以保证类型是安全的。

下限什么时候用？

从集合中取出对象进行操作时，就可以使用下限。比如：比较器，无论集合中的元素对象的类型是什么，只要比较器的指定类型可以接收这些对象完成比较，就可以了。所以比较器的类型，可以是集合中的当前元素或者是元素的父类型。

定义泛型时，左右两边一定要一致。

如果不一致。。。。

简单理解：

？：Object，只能使用Object的方法。

？extends E

？super E

把它们当成E。

Map集合

特点：

1.它也是集合框架中的顶层。

2.它一次存储一对元素，键、值，也就是键值对。

Collection一次存一个，称为单列集合。

Map一次存一对，称为双列集合。

3.Map集合中必须保证键的唯一性。

4.如果存储键值对时，键出现重复，新值覆盖旧值。

其实Map集合中存储的都是映射关系。

Map集合常见的方法：

1.添加

value put(key,value);

void putAll(Map);

2.删除

value remove(key);

void clear();

3.判断

boolean containsKey(key);

boolean containsValue(value);

isEmpty();

4.获取

int size();

value get(key);如果获取返回的值为null，可以视为指定键不存在。可以用于判断Map集合是否有指定键的存在。

Collection values();获取Map集合中所有的值。

5.获取Map集合中所有的键值对。

第一种取出方式：

set<key> keySet();返回Map集合中所有的键的set集合。之所以返回set，是因为键有

唯一性。

其实Map中没有迭代器，只要将Map转成set，就可以使用迭代器了。(set集合底层使用

的就是map集合。)

第二种取出方式：

取出Map结合中的所有的映射关系，存储到set集合中。映射关系对象(如同结婚证)的数

据类型，很特殊：Map.Entry类型。它里面既包含着键又包含真值。

Map.Entry：其实Entry就是Map接口中的一个内部静态接口。

Set<Map.Entry<Integer,String>>  entrySet();返回Map集合中所有的映射关系对象，

并存储到Set集合中。

Map

|--Hashtable:底层结构就是哈希表，不允许null作为键与值。同步。

|--HashMap：底层结构是哈希表，允许null作为键，允许null作为值。不同步。

取代了Hashtable。

|--TreeMap：底层结构是二叉树结构。可以Map集合中的键进行排序。不同步。

Map集合什么时候用？

只要在分析问题时，出现了对应关系(映射关系)，就要先想到Map集合。

注意：

对应关系的不同情况：

⑴如果映射关系中，一方是数字，并且是有序的编号，另一方是数据，它们存在对应关

系。这时可以使用数组，别忘了长度是固定的。

⑵如果映射关系中，没有这样的编号特点，或者映射关系的数量不确定。这时要使用

Map集合来完成存储。

别忘了，Map集合一样适用于查表法。

集合框架的工具类

Collections

|--

Arrays

JDK1.5版本的特点：

|--foreach语句(增强for循环)

|--格式

|--与传统for循环的区别

|--与迭代器的区别

|--使用注意

|--可变参数(T... t)

其他对象

System类：

Runtime类：

Math类：

Collections类：

负责给集合提供工具方法的工具类。

而且该工具类中的方法都是静态的。

了解一下常用的一些工具方法。

Arrays类：

asList()；如果数组中存储的都是对象，转成集合时，会将数组中的元素作为集合中的元素存在；如果数组中存储的都是基本数据类型值，转成集合时，该数组会作为集合中的元素存在。

foreach语句

增强for循环：

for(数据类型 变量名 ： 数组或Collection集合)

{

}

1.传统for循环和增强for的区别？

传统for循环可以通过增量完成循环的动作，让指定代码多次运行。

增强for循环，遍历必须有目标，而且目标只能是数组和Collection单例集合。

2.增强for循环和迭代器的区别？

通常增强for循环只用于遍历目标。在遍历过程中少有对元素的操作。

而迭代器在遍历元素的过程中，可以对遍历的元素进行操作比如remove。

建议遍历数组可以是增强for循环，也可以传统for循环。

只为遍历可以增强for循环简化书写，一旦要对元素有其他操作时，要使用传统for循环。

3.用增强for循环可以遍历map集合吗？

不可以，但是可以将Map集合转成Set集合。

Date 类，日期：

Date date = new Date();

sop(date);

日期对象和毫秒值之间的转换：

毫秒-->日期对象

使用 构造函数完成  new Date(long);

还可以使用setTime(long);

为什么要做这样的转换呢

将一个long型的值变成日期对象，就可以使用日期对象的方法获取其中

的具体的日期和时间。这样操作起来简单便捷

日期-->毫秒值

使用Date对象的getTime方法

什么时候用呢？当要对日期进行运算时，最好是将日期

转成基本数据类型long型值，就可以进行基本运算了。

将日期对象转成指定格式的字符串

使用的Dateformat类中的format方法