黑马程序员——Java API

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

  JavaAPI：Java应用程序接口，也是java已经定义好的功能，给我们直接使用。

一、String类
   String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。字符串最大的特点是一旦被初始化就不会在改变。
   String类覆写写了Object类中的equals方法，该方法用于判断字符串是否相同。
  （一）字符串的常见操作
      1、获取
        1.1获取字符串中所含字符的个数，也就是字符串的长度。方法：int length（）；
        1.2根据指定位置获取该位置上的字符。方法：char charAt（int index）；
        1.3根据字符获取该字符在字符串中的位置。方法：
          int indexOf（int ch）；返回的是ch在字符串中第一出现的位置。
          int indexOf（int ch，int fromindex）；从fromindex指定的位置开始获取ch在字符串中出现的位置。
          int indexOf（String str）；返回的是str在字符串中第一出现的位置。
          int indexOf（String str，int fromindex）；从fromindex指定的位置开始获取str在字符串中出现的位置。
         1.4反向索引 lastIndexOf（）
class  StringMethodDemo
{
 public static void Method_get()
 {
  String str="abcdebf";
  sop(str.length());//字符串的长度
  //根据索引获取字符
  sop(str.charAt(3));//当访问到字符串中不存在的角标时，
                          //就会发生StringIndexOutOfBoundsException

  //根据字符获取索引
  sop(str.indexOf('b'));//当所找字符在字符串中不存在时，就返回-1.
  sop(str.indexOf('b',3));
  //反向索引一个字符出现的位置
  sop(str.lastIndexOf("c"));
  
 }
 public static void main(String[] args)
 {
  Method_get();
 
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

      2、判断
       2.1字符串中是否包含某一个子串
                      boolean contains（str）
           特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1，表示str不在字符串中存在。所以，也可以用来判断一个字符串中是否包含指定字符串。而且该方法既可以判断是否存在即，也可以得到出现的位置。
       2.2字符串中是否有内容
                      boolean isEmpty（）
       2.3字符串是否是以指定内容开头
                      boolean startWith（str）
       2.4字符串是否是以指定内容结尾
                      boolean endsWith（str）
       2.5判断字符串内容是否相同
                      boolean equals（str）
        2.6判断内容是否相同，并忽略大小写
                       boolean equalsIgnoreCase（）
        3、转换
            3.1将字符数组转成字符串
                  构造函数：String（char[]）
                           String(char[],offset,count)将字符数组中的一部分转成字符串
                   静态方法：static String ccopyValueOf(charp[])
                        static String copyValueOf(char[] data,int offset,int count)
                        static String valueOf(char[])

            3.2将字符串转成字符数组
                  char[] toCharArray();
            3.3将字节数组转成字符串
                    String(byte[])
                     String(byte[],offset,count);//将字节数组的一部分转换成字符串

            3.4将字符串转成字节数组
                         byte[] getBytes();
            3.5将基本数据类型转换成字符串
                   static String valueOf()
                //3+""//String.valueOf(3)
         4.替换
              String replace（char oldchar，char newchar）//返回来的是一个新的字符串如果替换的字符串不存在，则返回原来的字符串
          5.切割
             String[] split(regex);//
          6.子串 获取字符串中一部分
              String substring（begin）//从指定位置开始到结尾
              String substring（begin，end）//包含头不包含尾
           7、转换、去除空格、比较
              7.1 将字符串转成大写或者小写
                     String toUpperCase（）；
                     String tolowerCase();
               7.2 将字符串两端的多个空格去除
                     String trim();
                7.3 对两个字符串进行自然顺序的比较
                     int compareTo（String）

二、StringBuffer
    StringBuffer可以对字符串内容进行增删；它是一个容器，有很多方法与String相通，StringBuffer是可变长度的，而且可以操作多个数据类型。最终通过toString方法变成字符串。
     1、存储
           StringBuffer append（）；//将指定数据作为参数添加到已有数据的结尾处。
           Stringbuffer insert（index，data）//可以将数据插入到index指定的位置。
     2、删除
           StringBuffer delete（start，end）//删除缓冲区中的数据，包含start不包含end
            StringBuffer deleteCharAt（index）//删除指定位置的字符。
     3、获取
            char charAt（index）
            int indexOf（String str）
            int lastIndexOf（String str）
            int length（）
            String subString(int start,int end)                                    
     4、修改
          StringBuffer replace（start，end，String）
          void setCharAt（int index，char ch）
      5、反转
            StringBuffer reverse（）
      6、将缓冲区中指定数据存储到指定字符数组中的指定位置
          void getChars（int srcBegin，int srcEnd，char[] dst，int dstBegin）
class StringBufferDemo
{
 public static void main(String[] args)
 {
                  StringBuffer sb = new StringBuffer();
                    //添加返回的新对象任然指向原对象，

   sb.append("abc").append(true).append("code");
                     //从始至终程序中就只要有一个容器。
                                  
   sb.insert(3,"not");
    sop(sb.toString());
 }
 public static void sop(String str)
 {
  System.out.println(str);
 }
}

三、StringBuilder
    是JDK1.5的一个新特性，一个可变的字符序列，此类提供一个与Stringbuffer兼容的API，但不保证同步。该类设计用作Stringbuffer的一个简易替换。
四、基本数据类型对象包装类
    基本数据类型包装类的最常见作用：就是用于在基本数据类型和字符串类型之间转换。
    1、基本数据类型转成字符串，方法两种：
       第一种：基本数据类型+"";第二种：基本数据类型.toString（基本数据类型），如
        integer.toString(34);//将整数34转成"34".
    2、字符串转成基本数据类型，方法
       例如转换integer：int parseInt（字符串）；//
         例如：int num = integer.parseInt（"34"）;//将字符串34转成整数类型34
    3、十进制转成其他进制
         toBinarySting（）；//十进制转二进制
         toHexString（）；//十进制转十六进制
         toOctalString（）；//十进制转成八进制
    4、其它进制转十进制
          parseInt（String，radix）//如：integer.parseInt("110",10);结果为6.
     5、新特性演示
class  IntegerDemo
{
 public static void main(String[] args)
 {
  //Integer x= new Integer(4);
  Integer x=4;//1.5后的自动装箱
  x=x+2;//x进行了自动拆箱变成int类型后和2运算后，又自动装箱后赋给x
  Integer m=128;
  Integer n=128;
  sop("m==m"+m==n);//false
  Integer a=127;
  Integer b=127;
  sop("a==b"+a==b);//true，因为a和b指向了同一个Integer对象。
      //因为当数值在byte范围内（-128-127），对于新特性，如果该数值已经存在，
   //                                      则不会再开辟新的空间了。
  method();
 }
 public static void method()
 {
  Integer x = new Integer("123");
  Integer y = new Integer(123);
  sop((x==y)+"");//false,x和y指向两个不同的对象
  //添加“”是为了将基本数据类型转成字符串，比较的是数值是否相同所以为true
  sop((x.equals(y))+"");//true
 }
 public static void sop(String str)
 {
  System.out.println(str);
 }
}

五、集合类
   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对象进行存储。集合就是存储对象最常用的一种方式。数组虽然也可以存储对象，但长度是固定的，而集合的长度是可变的；数组中可以存储基本类型数据，集合只存储对象。
    总结：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。集合中存储的都是对象的地址。
     （一）集合框架
        1、共性方法演示
import java.util.*;
class  CollectionDemo
{
 public static void methodBase()
 {
  //创建一个集合容器，使用Collection接口的子类
  ArrayList al = new ArrayList();
  //添加元素
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java04");
  //获取集合的长度
  sop(al.size());
  //打印集合
  sop(al);
  //删除集合元素
  al.remove("java02");
  //清空集合
  al.clear();
  //判断元素
  sop(al.contains("java02"));
  //判断是否为空
  sop(al.isEmpty());
 }
 public static void main(String[] args)
 {
  method_2();
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void method_2()
 {
  ArrayList al1 = new ArrayList();
  //添加元素
  al1.add("java01");
  al1.add("java02");
  al1.add("java03");
  al1.add("java04");

  ArrayList al2 = new ArrayList();
  al2.add("java01");
  al2.add("java02");
  al2.add("java05");
  al2.add("java06");
  //al1.retainAll(al2);//取交集，把交集存放到al1中。al2中的元素不变。
  al1.removeAll(al2);//在al1中删除和al2中相同的元素。al2中的元素不变。
  sop("al1"+al1);
  sop("al2"+al2);
 }
}
       

         2、迭代器（Iterator）
             迭代器就是取出  集合中元素的方式。取出方式是定义在集合的内部，这样就可以直接访问集合内的元素了。那么取出方式就被定义成了内部类。而每一个容器的数据不同，所以取出的具体细节也不一样，但是都有共性的内容：判断和取出，那么可以将共性抽取，这样就形成了一个Iterator接口。获取集合的取出方式是通过一个对外提供的iterator()方法完成
public static void method_get()
 {
  ArrayList al1 = new ArrayList();
  //添加元素
  al1.add("java01");
  al1.add("java02");
  al1.add("java03");
  al1.add("java04");
  Iterator it = al1.iterator();//获取迭代器，用于输出集合中的元素
  while(it.hasNext())//集合中如果还有下个元素就返回true，否则返回false
  {
   sop(it.next());//取出下一个元素
  }
 }

         3、Collection的子接口List接口
             在List中元素是有序的，元素可以重复，因为该集合体系有索引。List中特有的方法：凡是可以操作角标的方法都是该体系中的特有方法：
      增：add（index，element）；
          addAll（index，Collection）；

      删：remove（index）；

      改：set（index，element）；

      查：get（index）；
          subList（from，to）；

import java.util.*;
class ListDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();
  //添加元素
  al.add("java01");
        al.add("java02");
        al.add("java03");
  //在指定位置添加元素
  al.add(1,"java00");
  //删除指定位置的元素
  al.remove(1);
  //修改指定位置的元素
  al.set(2,"java04");
  //通过角标获取元素
  sop(al.get(1));
  //通过循环获取所有元素
  for (int x=0;x<al.size();x++ )
  {
   System.out.println(al.get(x));
  }
         //使用迭代器
   //Iterator it= al.iterator();
   for (Iterator it= al.iterator();it.hasNext(); )
   {
    sop(it.next());
   }
   //通过indexOf获取对象的位置
   sop("index="+al.indexOf("java02"));

   List sub=al.subList(0,2);
   sop(sub);

 }

}

          4、listIterator（）；
        List集合特有的迭代器ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断、取出、删除的操作。如果要想使用其他的操作如添加、修改等，就需要使用其子接口：ListIterator。该接口只能通过List集合的listIterator方法获取。
 
import java.util.*;
class ListDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  method();
         }
  
 public static void method()
 {
  //演示列表迭代器
  ArrayList al = new ArrayList();
  //添加元素
  al.add("java01");
        al.add("java02");
        al.add("java03");
  //获取List集合的迭代器
  ListIterator li=al.listIterator();
  while(li.hasNext())
  {
   Object obj = li.next();
   if(obj.equals("java01"))
    li.set("java00");//添加
  }
  //sop("hasNext="+li.hasNext());
  //sop("hasPrevious="+li.hasPrevious());
  while(li.hasPrevious())//对集合反向遍历
  {
   sop(li.previous());
  }
 }

}
        6、List下的三个常用集合
          （1）ArrayList：底层的数据结构是数组结构，特点：查询速度很快，但增删稍， 线程不同步。
           （2）LinkedList：底层使用的数据结构是链表结构，特点：增删速度快，但查询稍 慢。
import java.util.*;
/*
LinkedList 中特有的方法：
     addFist();
  addFist();
  获取元素，但不删除
     getFist（）；
  getLast（）；
  能获取元素，但把取出的元素删除，如果集合中没有元素，会出现NoSuchElementException
  removeFist（）；
  removeLast（）；
在JDK1.6中出现了替代方法：
  添加头、尾
     offerFist（）；
  offerLast();
  获取头、尾，但不删除，如果集合中没有元素，返回null。
     peekFist（）；
  peekLast（）；
  获取头、尾，并在集合中删除，如果集合中没有元素，返回null
   pollFist（）；
   pollLast（）；
*/
class LinkedListDemo
{
 public static void main(String[] args)
 {
  LinkedList link = new LinkedList();
  link.addFist("java1");
  link.addFist("java2");
  link.addFist("java3");
  link.addFist("java4");
  sop(link);
  sop(link.getFist());
  while(!link.isEmpty())
  {
   sop(link.removeFist());
  }
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

           （3）vector：底层是用的数据结构是数组结构，线程同步。被ArrayList代替。
 Vector特有方法：枚举的演示

import java.util.*;

class VectorDemo
{
 public static void main(String[] args)
 {
  Vector vt = new Vector();
  vt.add("java01");
  vt.add("java02");
  vt.add("java03");

        vt.add("java04");
  /*
  枚举是Vector特有的取出方式。其实枚举和迭代器是一样的，只是枚举的名称过长，被迭代器替代。
         */
  Enumeration en=vt.elements();//枚举
  while(en.hasMoreElements())
  {
   System.out.println(en.nextElement());
  }

 }
}

           
          7、Collection的子接口Set接口
           在Set集合中元素是无序的（存入和取出的元素不一致），元素不可以重复。Set集合的更能和Collection是一致的。Set框架下的两个常用集合：HashSet和TreeSet。

        8、HashSet保证元素唯一性的依据是：是通过元素的两个方法，hashCode和equals来完成的。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，则不会调用equals注意：对与判断元素是否存在和删除元素，依赖的方法都是hashCode和equals方法。
      而在ArrayList中只依赖equals方法。
import java.util.*;
class HashSetDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  HashSet hs = new HashSet();
  hs.add("java01");
  hs.add("java01");
  hs.add("java02");
  hs.add("java02");
  hs.add("java03");
  hs.add("java04");
  Iterator it=hs.iterator();
  while(it.hasNext())
  {
   sop(it.next());//无序、不可重复
  }
 }
}
     9、TreeSet可以对Set集合中的元素进行排序。底层数据结构是二叉树，保证元素唯一性的依据是compareTo方法return 0.TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然顺序，或者默认顺序。
TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需的要的。这时就需要让集合自身具备比较性。
         （1）Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序这种排序被称为自然排序，类的compareTo方法被称为它的自然比较方法。

import java.util.*;
class TreeSetDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  TreeSet ts = new TreeSet();
  ts.add("java01");
  ts.add("java06");
  ts.add("java00");
  ts.add("java04");
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   sop(it.next());//按照ASCII码的自然顺序排序
  }
 }
}

        （2）自定义对象的排序
import java.util.*;
/*
记住当主要条件相同时，要比较次要条件
TreeSet集合存储自定义对象时的步骤
1、自定义类要实现Comparable接口
2、再定义类中覆写compareTo方法，自定义排序方式
3、其他步骤都一样
*/
class TreeSetTest
{
 
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet();
  ts.add(new Person("zhangsan01",10));
  ts.add(new Person("zhangsan02",20));
  ts.add(new Person("zhangsan02",20));
  ts.add(new Person("zhangsan04",40));
  Iterator it = ts.iterator();
  while(it.hasNext())
  {
   Person p = (Person)it.next();
   System.out.println(p.getName()+"........"+p.getAge());
  }
 }
}
class Person implements Comparable//实现该接口，该接口强行让人具备比较性
 {
  private String name;
  private int age;
  Person(String name,int age)
  {
   this.name=name;
   this.age=age;
  }
  public String getName()
  {
   return name;
  }
  public int getAge()
  {
   return age;

  }
  public int compareTo(Object obj)
  {
   if (!(obj instanceof Person))
    throw new RuntimeException("类不匹配");
   Person s = (Person)obj;
   if(this.age>s.age)
    return 1;
   if(this.age==s.age)//主要方面相等时，要比较次要方面
    {
     return this.name.compareTo(s.name);
    }
   return -1;
  }
 }

  注意：TreeSet底层的数据结构是二叉树，而HashSet的底层数据结构是hash表。
         （3）自定义比较器事例

 

import java.util.*;
//按字符串长度排序
class TreeSetTest2
{
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet(new StringLengthComparator());
  ts.add("abc");
  ts.add("ace");
  ts.add("abcd");
  ts.add("abcdef");
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
}
class StringLengthComparator implements Comparator
{
 public int compare(Object o1,Object o2)
 {
  String s1=(String)o1;
  String s2=(String)o2;
  //比较主要条件
 int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
  if(num==0)
  {
   //比较次要条件
   return s1.compareTo(s2);
  }
  return num;
 }
}

六、泛型概述
    JDK1.5版本之后出现的新特性，用于解决安全问题，是提高安全性的。使用泛型的好处有：
     1、将运行时期出现的ClassCastException转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全。
     2、避免了强制转换麻烦。
     3、泛型的格式：通过一对<>来定义泛型。
import java.util.*;
class GenericDemo
{

 public static void main(String[] args)
 {
  TreeSet<String>ts= new TreeSet<String>(new MyComparator());
  ts.add("adg");
  ts.add("frhhrhe");
  ts.add("fgeg");
  ts.add("rfhrhr");
  Iterator<String> it=ts.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }

 }
}
class MyComparator implements Comparator<String>
{
 public int compare(String o1,String o2)
 {
 int num=new Integer(o1.length()).compareTo (new Integer(o2.length()));
  if(num==0)
  {
   return o1.compareTo(o2);
  }
  return num;
 }
}
       5、泛型类的定义
        当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
     class tool<type>
         {
            private type q;
            pbulic void set(type q)
               {
                   this.q=q;
                }
             public type get()
                {
                    return q;
                }
          }
         6、泛型方法定义
            泛型类定义的泛型，在整个类中有效，如果要使用泛型类中的方法，则泛型类的对象要明确操作的具体类型后，所有操作的类型都已近固定了。为了让不同的方法可以操作不同的类型，而且类型换不固定，那么可以将泛型定义在方法上。
       class  GenericDemo2
{
 public static void main(String[] args)
 {
  GenericMethod ge = new GenericMethod();
  ge.show(4);
  ge.print("fanxingfangfa");
 }
}
class GenericMethod
{
    public <T> void show(T s)//泛型定义在方法上，而且泛型符号要放在返回值类型之前
 {
  System.out.println("show"+s);
 }
 public<T>void print(T a)
 {
  System.out.println("print"+a);
 }
}
        7、静态方法泛型
          静态方法不可以访问类上定义的泛型，如果静态方法操作的数据不确定，可以将泛型定义在方法上。
class  GenericDemo2
{
 public static void main(String[] args)
 {
  GenericMethod<Integer> ge = new GenericMethod<Integer>();
  ge.show(4);
  ge.print("fanxingfangfa");
  ge.method("jingtaifanxingfangfa");
  ge.method(4);
 }
}
class GenericMethod<T>
{
 public  void show(T s)
 {
  System.out.println("show"+s);
 }
 public<T>void print(T a)
 {
  System.out.println("print"+a);
 }
 //泛型定义在方法上，而且泛型符号要放在返回值类型之前,修饰符之后。
 public static <E>void method(E e)
 {
  System.out.println("method"+e);
 }
}
          8、泛型限定
            ？叫做通配符，也可以理解为占位符。泛型限定的两种方式：
            ？extends E：可以接收E类型，或者E的子类型。上限。
             ？super E：可以接收E类型或者E的父类型。下限。
import java.util.*;
class Person
{
 private String name;
 Person(String name)
 {
  this.name=name;

 }
 public String getName()
 {
  return name;
 }
}
class Student extends Person
{
 Student(String name)
 {
  super(name);
 }
}
class GenericDemo3
{
 public static void main(String[] args)
 {
  ArrayList<Person> al = new ArrayList<Person>();
  al.add(new Person("feifei"));
  al.add(new Person("feifei1"));
  al.add(new Person("feifei2"));
  
  ArrayList<Student> al1=new ArrayList<Student>();
  al1.add(new Student("fei"));
  al1.add(new Student("fei1"));
  al1.add(new Student("fei2"));
  printCollection(al);
  printCollection(al1);
 }
 public static void printCollection(ArrayList<? extends Person> al)//泛型限定
 {
  Iterator <? extends Person>it = al.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next().getName());
  }
 }
}

七、Map集合：Map<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）；
               isEmptty（）；
          4、获取
              get（Object key）；
              size（）；
              values（）；
              entrySet（）；
              keySet（）；
通用方法事例：
import java.util.*;
class MapDemo
{
 public static void main(String[] args)
 {
  Map<String,String> map=new HashMap<String,String>();
 //添加元素,如果出现添加相同键时，那么后添加的值会覆盖键对应的原有值，
  map.put("01","zhangsan1");//put方法会返回这个键对应的原来的那个值，
  map.put("02","zhangsan2");         // 如果是第一次添加，则返回null。
  map.put("03","zhangsan3");
  map.put("04","zhangsan4");
  //判断是否包含指定键的元素

  System.out.println("containsKey"+map.containsKey("03"));
  //删除指定键的元素
  System.out.println("remove:"+map.remove("02"));
  //打印集合
  System.out.println(map);
  //获取键对应的值
  System.out.println("get:"+map.get("04"));
  //获取Map集合中所有的值
  Collection<String> coll=map.values();
  System.out.println("values:"+coll);

 }
}
            5、Map集合两种取出方式：
              Set<k> keySet：将Map中所有的键存入到Set集合中，因为Set集合有迭代器，所 以可以通过迭代的方式取出所有的键，再用Map集合的get方法获取每个键对应的 值。
 import java.util.*;
class  MapDemo2
{
 public static void main(String[] args)
 {
  Map<String,String> map=new HashMap<String,String>();
  map.put("01","zhangsan1");//put方法会返回这个键对应的原来的那个值，
  map.put("02","zhangsan2");         // 如果是第一次添加，则返回null。
  map.put("03","zhangsan3");
  map.put("04","zhangsan4");
  //先通过Map集合中俄keySet（）方法获取Map集合中所有的键值
  Set<String> keySet=map.keySet();
  //有了Set集合可以获取其迭代器，
  Iterator<String> it=keySet.iterator();
  //通过迭代，取出所有的键值
  while(it.hasNext())
  {
   String key=it.next();
   String values=map.get(key);
   System.out.println("key="+key+";values="+values);
  }
 }
}

              Set<Map.Entry<k,v>>entrySet：将Map集合中映射关系存入到了Set集合，而这关系的数据类型就是Map.Entry。
import java.util.*;
class MapDemo3
{
 public static void main(String[] args)
 {
  Map<String,String> map=new HashMap<String,String>();
  map.put("01","feifei01");
  map.put("02","feifei02");
  map.put("03","feifei03");
  map.put("04","feifei04");

  //将Map集合中的映射关系取出，存入到Set集合中
  Set<Map.Entry<String,String>> entrySet = map.entrySet();
  //创建Set集合的迭代器
  Iterator<Map.Entry<String,String>> it = entrySet.iterator();
  while(it.hasNext())
  {
   //取出Set集合中的元素
   Map.Entry<String,String>me=it.next();
   String key = me.getKey();
   String value=me.getValue();
   System.out.println("key"+key+":value"+value);
  }
 }
}

       （二）Map集合中常见的三个子类
           1、Hashtable
              此类实现了一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以 用做键和值。为了成功的在哈希表中存储和获取对象，用做键的对象必须实现           hashCode方法和equals方法。该集合是线程同步的。
           2、HashMap
              底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。
           3、TreeMap
                底层是二叉树数据结构，可以用于给Map集合中的键进行排序。线程是不同步 的。
  
八、集合框架下的工具类Utilities

     （一）Collections工具类
          此类完全由在Collection上进行操作或返回collection的静态方法组成。它包含在collection上操作的多态算法。即“包装器”，包装器返回collection支持新collection以及少数其他内容。如果为此类的方法提供的collection或类对象为null，则这些方法都抛出NullPointerException。
      （二）Arrays工具类：是对数组操作的工具类，里面都是静态方法。
          1、asList：将数组变成List集合。把数组变成集合的好处就是：可以使用集合的思想和方法来操作数组。注意：将数组变成集合不可以使用集合的增删方法，因为数组长度是固定的。
        如果数组中的元素都是对象，那么变成集合时，数组中的元素直接转成集合中的元素。如果数组中的元素是基本数据类型，那么会将该数组作为集合中元素存在。
          2、将集合变数组：用的是Collection接口中的toArray方法，
例如：String[] arr=al.toArray(new String(al.size()));将集合变数组的好处是限定了对集合元素的操作。不需要进行增删了。

九、JDK1.5新特性
     （一）增强for循环
           1、 for（数据类型 变量名：被遍历的集合（Collection）或数组 ）
               {
                }
import java.util.*;
class  ForEachDemo
{
 public static void main(String[] args)
 {
  List<String> list = new ArrayList<String>();
  list.add("adf");
  list.add("aergef");
  list.add("def");
  for (String s: list )
  {
   System.out.println(s);
  }
 } 
}
           2、增强for循环和迭代器的区别
             for循环，只能遍历集合，获取集合元素，不能对集合进行操作。迭代器Iterator除了遍历集合外，还可以进行remove集合中元素的操作。如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
   （二）可变参数
         使用方法的可变参数时，可变参数要放在参数列表的最后。
class  ParamMethodDemo
{
 public static void main(String[] args)
 {
  show(1,3,4,4);
  show(4);
  show();
 }
 public static void show(int... arr)//可变参数的格式
 {
  System.out.println(arr.length);
 }
}
     （三）静态导入
import java.util.*;
import static java.util.Arrays.*;//静态导入，导入类中的所有静态方法
import static java.lang.System.*;
class  StaticImport
{
 public static void main(String[] args)
 {
  out.println("静态导入");
  int[] arr = {3,3,4};
  sort(arr);
 System.out.println(Arrays.toString(arr));//当两个类中有相同的方法时，
                                    //  调用时应该用类名区分。
 }
}

           

---------------------- android培训、java培训、期待与您交流！ ----------------------