---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
四、API
1，API：
ApplicationProgramming Interface，应用程序编程接口，是一些预定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组编程的能力，而且无需访问远吗，或理解内部工作机制的细节。
2，Java中的常用API
1. String类
对字符串进行操作通常我们使用String类，相关的还有StringBuffer和StringBuilder
2. 集合类
集合石一种容器，用来存取对象(Collection、Map)
3. 包装类
Java定义了一组包装类对基本数据类型进行了包装(Integer、Character、Double)
4. 时间对象
Java定义了一些类方便用于对时间、日期进行处理(Date、Calendar)
5. 系统类
Java定义了一些针对系统进行操作(System、Runtime)
6. IO流
Java定义了一些类对数据传输进行了封装(输入与输出流、File文件对象)
7. Socket
Java定义了一些方便用户进行网络编程(Socket、DatagramSocket)
3，String类
1. 字符串是一个特殊对象
2. 字符串一旦初始化就不可以被改变
3. 字符串在内存中有一个常量池，也就是一个数组，专门用于储存字符串数组也有对应的长度，但是它的length后没有括号；字符串也有长度，但是它是通过方法完成的，所以带括号，即length();
代码演示：
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";//s1是一个类类型变量，"abc"是一个对象。
//字符串最大特点：一旦被初始化就不可以被改变。
String s2 = new String("abc");
/*
s1和s2有什么区别？
s1在内存中有一个对象，s2在内存中有两个对象。
*/
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
//String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。
}
}4，String类常见功能
String类使用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。
1. 获取：
1) 获取字符串的长度：length()
2) 指定位置的字符：char charAt(int index);
3) 获取指定字符的位置，如果不存在返回-1，所以可以通过返回值-1来判断某一个字符不存在的情况。
int indexOf(int ch);//返回第一次找到的字符角标(索引)
int indexOf(int ch, intfromIndex);//返回从指定位置开始第一次找到的角标
int indexOf(String str);//返回第一次找到的字符串角标
int indexOf(String str, intfromIndex);
int lastIndexOf(int ch);
int lastIndexOf(int ch, intfromIndex);
int lastIndexOf(String str);
int lastIndexOf(String str, intfromIndex)
4) 获取子串
String substring(int start);//从start位开始，到length()-1结束
String substring(int start, intend);//从start开始到end为止，包含头，不包含尾
String substring(0,str.length());//获取整串
2. 判断：
1) 字符串中包含指定的字符串吗？
boolean contains(Stringsubstring);
2) 字符串是否已指定字符串开头？
boolean startsWith(String);
3) 字符串是否已指定字符串结尾？
boolean endsWith(String);
4) 判断字符串是否相同
boolean equals(String);//覆盖Object中的方法，判断字符串是否相同
5) 判断字符串内容是否相同，忽略大小写
boolean equalsIgnoreCase(String);
3. 转换
1) 通过构造函数可以将字符数组或者字节数组转成字符串
2) 可以通过字符串中的静态方法，将字符数组转成字符串
static String copyValueOf(char[]);
static String copyValueOf(char[],int offset, int count);
static String valueOf(char[]);
static String valueOf(char[], intoffset, int count);
3) 将基本数据类型或者对象转成字符串
static String valueOf(char);
static String valueOf(boolean);
static String valueOf(double);
static String valueOf(float);
static String valueOf(int);
static String valueOf(long);
static String valueOf(Object);
4) 将字符串转成大小写
String toLowerCase();
String toUpperCase();
5) 将字符串转成数组
char[] toCharArray();//转成字符数组
byte[] getBytes();//可以加入编码表，转成字节数组
6) 将字符串转成字符串数组，切割方法
String[] split(分割的规则-字符串);
7) 将字符串进行内容替换(注意：修改后变成新字符串，并不是将原字符串直接修改。)
String replace(oldChar,newChar);
String replace(oldstring,newstring);
8) 对字符串进行追加、去空格、比较
String concat(String);//对字符串进行追加，效率高
String trim();//去除字符串两端的空格
int compareTo();//如果参数字符串等于此字符串，则返回0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。
字符串练习：
//练习1：将一个字符串进行反转。将字符串中指定部分进行反转，”abcdefg”;”abfedcg”
class StringTest {
public static void sop(String str){
System.out.println(str);
}
public static void main(String[] args) {
String s =" ab cd ";
sop("("+s+")");
sop("("+reverseString(s,6,9)+")");
}
public static String reverseString(String s,int start,int end){
//将字符串变成数组
char[]chs = s.toCharArray();
//对数组进行反转
reverse(chs,start,end);
//将数组变成字符串
return new String(chs);
}
public static String reverseString(String s){
return reverse(s,0,s.length());
}
public static void reverse(char[] arr,int x,int y){
for(int start =x,end = y-1;start<end;start++,end--){
swap(arr,start,end);
}
}
public static void swap(char[] arr,int x,int y){
char temp= arr[x];
arr[x]= arr[y];
arr[y]= temp;
}
public static String myTrim(String str){
int start =0,end = str.length()-1;
while(start<=end&& str.charAt(start)==' ')
start++;
while(start<=end&& str.charAt(end)==' ')
end--;
return str.substring(start,end+1);//一定记得end+1操作，因为substring所获取的字符串包含头，不包含尾。
}
}//练习2：获取一个字符串在领一个字符串中出现的次数。"abkkcdkkdfkkskk"
class StringTest2{
//方式一
public static int getSubCount(String str,String key){
int count = 0;
int index = 0;
while((index= str.indexOf(key))!=-1){
sop("str="+str);
str= str.substring(index+key.length());
count++;
}
return count;
}
//方式二
public static int getSubCount_2(String str,String key){
int count = 0;
int index = 0;
while((index= str.indexOf(key,index))!=-1){
sop("index="+index);
index= index + key.length();
count++;
}
return count;
}
public static void main(String[] args) {
String str = "kkabkkcdkkdfkkskk";
//sop("count====="+str.split("kk").length);不建议使用，容易出错
sop("count="+getSubCount_2(str,"kk"));
}
public static void sop(Object obj){
System.out.println(obj);
}
}//3.获取两个字符串中最大相同子串。
class StringTest3{
public static String getMaxSubString(String s1,String s2){
String max = "",min = "";
max= (s1.length() > s2.length())? s1 : s2;
min= (max==s1)? s2 :s1;
sop("max="+max+"....min ="+min);
for(int x=0; x<s2.length(); x++){
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++){ //z是尾角标,-x是遍历字符串的
String temp = min.substring(y,z);
//sop(temp);
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
public static void main(String[] args) {
String s1 = "abcwerhelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s1,s2));
}
public static void sop(String str){
System.out.println(str);
}
} 5，StringBuffer字符串缓冲区
构造一个其中不带字符的字符串缓冲区，初始容量为16个字符
特点：C:create U:update R:read D:delete
1) 可以对字符串内容进行修改。
2) 是一个容器
3) 是可变长度的
4) 缓冲区中可以存储任意类型的数据
5) 最终需要编程字符串
StringBuffer容器通常具备一些固定的方法：
1. 添加
StringBuffer append(data);//在缓冲区中追加数据，追加到尾部
StringBuffer insert(index,data);//在指定位置插入数据
2. 删除
StringBuffer delete(start, end);//删除从start至end-1范围的元素
StringBufferdeleteCharAt(index);//删除指定位置的元素
sb.delete(0, sb.length());//清空缓冲区
3. 修改
StringBuffer replace(start, end, string);//将start至end-1替换成string
void setCharAt(index,char);//替换指定位置的字符
void setLength(len);//将字符串置为指定长度的字符串
4. 查找(查不到返回-1)
int indexOf(string);//返回指定子字符串在此字符串中第一次出现的索引
int indexOf(string , intfromIndex);//从指定位置开始查找字符串
int lastIndexOf(String);//返回指定字符串在此字符串中最右边出现的索引
int lastIndexOf(string, intfromIndex);//从指定的索引开始反向搜索
5. 获取子串
String substring(start);//返回start到结尾的子串
String substring(start,end);//返回start至end-1的子串
6. 反转
StringBuffer reverse();//字符串反转
6，StringBuilder字符串缓冲区
JDK1.5出现了StringBuilder；构造一个其中不带字符的字符串生成器，初始容量为16个字符。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被耽搁线程使用的时候(这种情况很普遍)，其中其方法和StringBuffer一样。
Java升级的三个特性：提高效率、简化书写、提高安全性。
1. StringBuffer和StringBuilder的区别：
StringBuffer：JDK1.0出现的，线程安全，并且线程同步，效率较低；
StringBuilder：JDK1.5出现的，线程不安全，线程不同步，效率高。
单线程操作，StringBuilder效率高；多线程操作，StringBuffer安全。
7，基本数据类型包装类
是按照面向对象思想将基本数据类型封装成了对象。
好处：
1) 可以通过对象中的属性和行为操作基本数据；
2) 可以实现基本数据类型和字符串之间的转换。
1. 基本数据类型对象包装类
基本数据类型 引用数据类型
byte Byte
short Short parseShort(numstring)
int Integer 静态方法:parseInt(numstring)
long Long
float Float
double Double
char Character
boolean Boolean
基本数据类型对象包装类都有Xxx parseXxx方法，只有一个类型没有parse方法：Character；
8，Integer对象
1. 数字格式的字符串转成基本数据类型的方法：
1) 将字符串封装成了Integer对象，并调用对象的方法intValue();
2) 使用Integer.parseInt(numString),不用建立对象，直接类名调用。
2. 将基本类型转成字符串：
1) Integer中的静态方法 String toString(int);
2) int +“”;
3. 将一个十进制证书转成其他进制：
1) 转成二进制：toBinaryString();
2) 转成八进制：toOctalString();
3) 转成十六进制: toHexString();
toString(int num, int radix);
将其他进制转换成十进制：
parseInt(string,radix);
9，基本数据类型的自动拆箱装箱
在JDK1.5版本后，对基本数据类型对象包装类进行升级。在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样进行运算。
Integer i = new Integer(4);//1.5之前的写法；
Integer I = 4;//1.5之后的写法，自动装箱；
i = i + 5;
//i对象不能直接和5相加，其实底层先将i转换成int类型，再和5相加。而转成int类型的操作时隐式的。
自动拆箱：拆箱原理就是i.intValue();i + 5运算完是一个int证书，如何赋值给引用类型i呢？其实有对结果进行装箱。
Integer c = 127;
Integer d = 127;
System.out.println(c == d);//true
//在装箱时，如果数值在byte范围之内(-128~127),那么数值相同，不会产生新的对象，也就是说多个数值相同的引用指向的是同一个对象。
10，Scanner对象
1. 创建对象
使用构造函数Scanner(InputStream)传入一个输入流，该Scanner就可以读取数据System.in
2. 读取各种类型的数据
nextInt() 可以读取一个int
nextLine() 读取一行字符串
3. 关闭问题
使用结束后要调用close()方法释放资源。
11，BigInteger对象
1. 创建对象
可以使用BigInteger(String)来创建一个很大的整数，精度可以无限大，值创建之后不会被改变(类似String)
2. 常用方法
BigIntegeradd(BigInteger val) //加
BigIntegersubtract(BigInteger val) //减
BigIntegermultiply(BigInteger val) //乘
BigIntegerdivide(BigInteger val) //除
BigIntegermod(BigInteger val) //模
BigIntegermax(BigInteger val) //两个数的最大值
BigIntegermin(BigInteger val) //两个数的最小值
12，BigDecimal对象
1. 创建对象
BigDecimal(double); //不建议使用，运算结果不精确
BigDecimal(String); //可以，但是每次都要传字符串给构造函数
staticBigDecimal valueOf(double) //可以，而且可以直接传double数
因为double数是不精确，是无限接近那个数，用BigDecimal这个类可以让其精确
2. 常用方法
BigDecimal add(BigDecimal augend)
BigDecimal subtract(BigDecimalsubtrahend)
BigDecimal multiply(BigDecimalmultiplicand)
BigDecimal divide(BigDecimal divisor)
五、集合框架
集合框架，用于存储数据的容器，
特点：
1) 对象封装数据，对象多了也需要存储，集合用于存储对象。
2) 对象的个数确定可以使用数组，但是不确定怎么办？可以使用集合，因为集合是可变长度的。
集合和数组的区别：
1) 数组是固定长度的，集合是可变长度的。
2) 数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3) 数组存储的元素必须是同一个数据类型，集合存储的对象可以是不同数据类型。
数据结构：就是容器中存储数据的方式。
对于集合容器，有很多种。因为每个容器的自身特点不同，其实原理在于买个容器的内部数据结构不同。集合容器在不断向上抽取过程中，出现了集合体系。在使用一个体系是，原则：参阅顶层内容，建立底层对象。
1，Collection接口
Collection：
|--List：有序(元素存入集合的顺序和去除的顺序一致)，元素都有索引，元素可以重复。
|--Set：无序(存入和去除顺序有可能不一致)，不可以存储重复元素，必须保证元素唯一性。
1. 添加
add(Object):添加一个元素
addAll(Collection): 添加一个集合中的所有元素
2. 删除
clear():将集合中的元素全部删除，清空集合
remove(obj):删除集合中指定的对象。注意：删除成功，集合的长度会改变
removeAll(collection): 删除部分元素，部分元素和传入Collection一致。
3. 判断
boolean contains(obj):集合中是否包含指定元素
boolean containsAll(Collection): 集合中是否包含指定的多个元素
boolean isEmpty(): 集合中是否有元素
4. 获取
int size():集合中有几个元素
5. 取交集
boolean retainAll(Collection):对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回false；如果retainAll修改了当前集合，返回true；
6. 获取集合中所有元素
Iterator iterator():迭代器
7. 将集合编程数组
toArray();
2，Iterator接口
迭代器：是一个接口，作用：用于取集合中的元素。
boolean hasNext():如果仍有元素可以迭代，则返回true；
E next(): 返回迭代的下一个元素。
void remove() : 从迭代器指向collection中移除迭代器返回的最后一个元素(可选操作)
每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。
也就是说，只要通过该接口就可以取出Collection集合中的元素，至于每一个集合的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。
Iterator it = coll.iterator();//获取容器中的迭代器对象，至于这个对象时什么不重要。这对象肯定副歌一个规则Iterator接口。
代码如下：
class Test {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc0");
coll.add("abc1");
coll.add("abc2");
//遍历集合的第一种方式
Iterator it= coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//遍历集合的第二种方式
for(Iterator it = coll.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}3，List接口
List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合的最大特点。
List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引，元素可以重复。
|--ArrayList：底层的数据结构是数组，线程不同步，ArrayList替代了Vector，查询元素的速度非常快。
|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。
|--Vector：底层的数据结构就是数组，线程同步的，Vector无论查询和增删都很慢。
1. 添加
add(index, element)：在指定的索引位插入元素
addAll(index, collection): 在指定的索引位插入一堆元素。
2. 删除
remove(index): 删除指定索引位的元素，返回被删的元素。
3. 获取
Objectget(index) : 通过索引获取指定元素
intindexOf(obj) : 获取指定元素第一次出现的索引位，如果该元素不存在返回-1；所以通过-1，可以判断一个元素是否存在。
intlastIndexOf(Object obj) : 反向索引指定元素的位置
ListsubList(start, end) : 获取子列表。
4. 修改
Object set(index, element) : 对指定索引位进行元素的修改。
5. 获取所有元素
ListIterator listIterator(): list集合的特有迭代器
List集合支持对元素的增、删、改、查
List集合因为角标有了自己获取元素的方式：遍历
for(intx=0; x<list.size(); x+){
System.out.println(“get”+ list.get(x));
}
在进行List列表元素迭代的时候，如果想要在迭代过程中，要对元素进行操作的时候，比如满足条件添加新元素，会发生ConcurrentModificationException并发修改异常。
导致的原因是：
集合引用和迭代器引用在同时操作元素，通过集合获取到对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器并不知道，所以会出现异常
如何解决呢？
既然是在迭代中对元素进行操作，找迭代器的方法最为合适。可是Iterator中只有hasNext，next和remove方法。通过查阅它的子接口，ListIterator，发现该列表迭代器接口具备了对元素的增、删、改、查等功能。
ListIterator是List集合特有的迭代器。
ListIterator it = list.listIterator();//取代Iteratorit = list.iterator();
| 方法摘要 | |
|
| |
|
| hasNext |
|
| hasPrevious |
| next | |
|
| nextIndex |
| previous | |
|
| previousIndex |
|
| remove |
|
| |
可变长度数组的原理：
当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再讲新的元素添加到新数组中。
ArrayList ：是按照原数组的50%延长，构造一个初始容量为10的空列表。
Vector：是按照原数组的100%延长。
注意：对于list集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的，所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。
LinkedList特有方法：
addFirst();
addLast();
getFirst():获取链表中的第一个元素。如果链表为空，抛出NoSuchElementException异常。
getLast();
removeFirst():获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，抛出NoSuchElementException异常
removeLast();
在JDK1.6以后就是：
offerFirst();
offerLast();
peekFirst(): 获取链表中的第一个元素，如果链表为空，返回null
peekLast();
pollFirst():获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，返回null。
pollLast();
练习：
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子
队列：先进先出 First in First out FIFO 如同一个水管。
import java.util.*;
class DuiLie{
private LinkedListlink;
DuiLie(){
link = newLinkedList();
}
public voidmyAdd(Object obj){
link.addFirst(obj);
}
public Object myGet(){
returnlink.removeLast();
}
public booleanisNull(){
returnlink.isEmpty();
}
}4，Set接口
Set接口中的方法和Collection中方法一致。Set接口取出元素方式只有一种：迭代器。
|--HashSet：底层数据结构是哈希表，线程时不同步的，无序，高效；
HashSet集合保证元素唯一性：通过元素的hashCode方法和equals方法完成。
当元素的hashCode值相同是，才继续判断元素的equals是否为true。
如果为true，那么视为相同元素，不存；如果为false，那么存储。
如果hashCode值不同，那么不判断equals，从而提高对象比较速度。
|--LinkedHashSet：有序，hashSet的子类。
|--TreeSet：对Set集合中的元素进行指定顺序的排序，不同步。TreeSet底层的数据结构就是二叉树
哈希表原理：
1) 对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法只，这个值成为哈希值。
2) 哈希值就是这个元素的位置。
3) 如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复；如果对象不同，就存储，在原来对象的哈希值基础上+1顺延。
4) 存储哈希值的结构，我们成为哈希表。
5) 既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。
对于ArrayList集合，判断元素是否存在或者删除元素底层依据都是equals方法。
对于HashSet集合，判断元素是否存在或者删除元素，底层依据的是hashCode方法和equals方法。
TreeSet：
用于对Set集合进行元素的指定顺序排序，排序需要的依据元素自身具备的比较性。如果元素不具备比较性，在运行时会发生ClassCastException异常。所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。
TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。
注意：在进行比较时，如果判断元素不唯一，比如同姓名、同年龄才视为一个人；在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。
TreeSet集合排序有两种方式，Comparable和Comparator区别：
1) 让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法
2) 让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。其中第二种方式较为灵活。
实现Comparable接口代码演示：
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))
throw new RuntimeException("非法学生对象");
Student s = (Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age){
return this.name.compareTo(s.name);
}
return -1;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
//主函数
class TreeSetDemo1 {
public static void main(String[] args) {
TreeSetts = 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())
return1;
if(s1.getAge()>s2.getAge())
return0;
return-1;
*/
}
return num;
}
}实现Comparator接口，并复写compareTo方法的代码演示：
class TreeSetTest {
public static void main(String[] args) {
TreeSett s = new TreeSet(new StrLenCompartor());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class StrLenCompartor implements Comparator{
public int compare(Object o1,Object o2){
String s1 = (String)o1;
String s2 = (String)o2;
/*
if(s1.length()>s2.length())
return1;
if(s1.length()==s2.length())
return0;
return-1;
*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}5，Map<K,V>集合
|--Hashtable：底层是哈希表数据结构，是线程同步的，不可以存储null键和null值。
|--HashMap: 底层是哈希表数据结构，是线程不同步的。可以存储null键，null值，替代了Hashtable。
|--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序
Map集合存储和Collection有着很大不同：
Collection一次存一个元素；Map集合一次存一对元素。
Collection是单列集合；Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
特点：要保证Map集合中键的唯一性。
1. 添加
put(key, value):当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null
void putAll(Map);
2. 删除
voidclear():清空
valueremove(key) : 删除指定键
3. 判断
boolean isEmpty();
boolean containsKey(key):是否包含key
boolean containsValue(value) :是否包含value
4. 取出
int size():返回长度
value get(key):通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存null键null值的。
Collection values():获取map集合中所有的值。
5. 想要获取map中的所有元素
原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，就可以使用迭代器了，之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用得就是map方法。
6. 把map集合转成set集合的方法：
Set keySet();和Set entrySet();//取得是键和值的映射关系
Entry就是Map接口中的内部接口；
为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。
1) 取出map集合中所有元素的方式一：keySet()方法。
可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()){
Object key = it.next();
Object value =map.get(key);
System.out.println(key +“=” + value);
}
2) 取出map集合中所有元素的方式二：entrySet()方法
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()){
Map.Entry me = (Map.Entry)it.next();
System.out.println(me.getKey() + “==” +me.getValue());
}
6，使用集合的技巧
1. 看到Array就是数组结构，有角标，查询速度很快。
2. 看到link就是链表结构：增删速度快，而且有特有方法：addFirst(),addLast(),removeFirst(),removeLast(),getFirst(),getLast().
3. 看到hash就是哈希表，就要想到哈希值，就要想到唯一性，就要想到存入到该结构中的元素必须覆盖hashcode()和equals()方法。
4. 看到tree就是二叉树，就要想到排序，就要想到用比较
比较的方式有两种：
1) 一个是Comparable：覆盖compareTo方法；
2) 一个是Comparator：覆盖compare方法。
5. LinkedSet，LinkedHashMap：这两个集合可以保证哈希表有存入顺序和去除顺序一致，保证哈希表有序。
6. 集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就是用Map集合。
7. 保证唯一，就用Set；不保证唯一，就用List。
7，Collections工具类
它的出现给集合操作提供了更多的功能，这个类不需要创建对象，内部提供的都是静态方法：
Collections.sort(list);//list集合进行元素的自然顺序排序
Collections.sort(list,newComparatorByLen());//按指定的比较器方法排序
class ComparatorByLen implements<String>{
public int compare(String s1, Strings2){
int temp = s1.length() –s2.length();
return temp == 0 ?s1.compareTo(s2) : temp;
}
}
Collections.max(list);//返回list中字典顺序最大的元素
intindex = Collections.binarySearch(list,”zz”);//二分查找，返回角标
Collections.reverseOrder();//逆向反转排序
Collections.shuffle(list);//随机对list中的元素进行位置的置换。
将非同步集合转成同步集合的方法：Collections中的XXX synchronizedXXX(XXX);
Listsynchronized(list);
MapsychronizedMap(map);
原理：定义一个类，将集合所有的方法加同一把锁后返回。
Collection和Collections的区别：
Collections是一个java.util下的类，是针对集合类的一个工具类，提供一系列静态方法，实现对集合的查找、排序、替换、线程安全化(将非同步的集合转换成同步的)等操作。
Collection是个java.util下的接口，它是各种集合集合结构的父接口，继承于它的接口主要有Set和List，提供了关于集合的一些操作，如插入、删除、判断一个元素是否其成员、遍历呢。
8，Arrays工具类：
用于操作数组对象的工具类，里面都是静态方法。
asList方法：将数组转换成list集合。
String[] arr ={“abc”,”kk”,”qq”};
List<String>list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合，有什么好处呢？用asList方法，将数组变成集合；
可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意(局限性)：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。(会报不支持操作异常UnsupportedOperationException)
如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方式操作。如果数组中存储的是基本数据类型，asList()会将数组实体作为集合元素存在。
集合变数组：用的是Collection接口中的方法：toArray();
如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定在创建一个该类型的数据，长度为集合的size。
如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，最好的方式就是指定的长度和size相等的数组。
将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。
六、其他类
1，API---java.lang.System:属性和行为都是静态的。
long currentTimeMillis();//返回当前时间毫秒值
exit();//退出虚拟机
Properties getProperties();//获取当前系统的属性信息
Properties prop = System.getProperties();//获取系统的属性信息，并将这些信息存储到Properties集合中。
System.setProperty(“myname”,”毕老师”);//给系统属性信息集添加具体的属性信息
//临时设置方式：运行jvm时，可以通过jvm的参数进行系统属性的临时设置，可以在java命令的后面加入-D<name>=<value>,用法：java –Dmyname=小明类名。
String name = System.getProperty(“os.name”);//获取指定属性的信息
想要知道该系统是否是该软件所支持的系统中的一个
Set<String> hs = new HashSet<String>();
hs.add(“Windows XP”);
hs.add(“Window 7”);
if(hs.contains(name))
System.out.println(“可以支持”);
else
System.out.println(“不支持”);
2，API---java.lang.Runtime:类中没有构造方法，不能创建对象。
但是有非静态方法，说明该类中应该定义好了对象，并可以通过一个static方法获取这个对象。用这个对象来调用非静态方法。这个方法就是static Runtime getRuntime();
这个Runtime其实使用单例设计模式进行设计。
class RuntimeDemo{
publicstatic void mian(String[] args) throws IOExcepiton{
Runtimer = Runtime.getRuntime();
Processp = r.exec(“notepad.exe ”);//运行指定的程序
Thread.sleep(4000);
p.destroy();//杀掉进程
}
}
3，API---java.util.Math:用于数学运算的工具类，属性和行为都是静态的，该类时final不允许继承。
staticdouble ceil(double a);//返回大于指定数值的最小整数
staticdouble floor(double a);//返回小于指定数值的最大整数
staticlong round(double a);//四舍五入成整数
staticdouble pow(double a,double b);//a的b次幂
staticdouble random();//返回0~1的伪随机数
代码演示：
publicstatic void main(String[] args){
Randomr = new Random();
for(intx=0; x<10; x++){
//doubled = Math.floor(Math.random() * 10 + 1);
//intd = (int)(Math.random() * 10 + 1);
intd = r.nextInt(10) + 1;
System.out.println(d);
}
}
4，API---java.util.Date:日期类，月份从0-11；
日期对象和毫秒值之间的转换
1) 日期对象转成毫秒值。Date类中的getTime()方法
2) 如何将获取到的毫秒值转成具体的日期呢？
Date类中的setTime方法，也可以通过构造函数。
//日期对象转成毫秒值
Date d = new Date();
long time1 = d.getTime();
long time2 = System.currentTimeMillis();//毫秒值
//毫秒值转成具体的日期
long time = 13227099213121;
Date d = new Date();
d.setTime(time);
//将日期字符串转换成日期对象：使用的就是DateFormat方法中的Date parse(String source)
public static void method() throws Exception{
String str_time= “2011/10/25”;
DateFormat df = newSimpleDateFormat(“yyyy/MM/dd”);//SimpleDateFormat作为可以指定用户自定义日期的格式来完成格式化
Data d =df.parse(str_time);
}
如果不需要使用特定的格式化风格，完全可以使用DateFormat类中的静态工厂方法获取具体的已经封装好风格的对象：getDateInstance()和getDateTimeInstance();
代码演示：
Date d = new Date();
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
df =DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String str_time = df.format(d);
将日期对象转换成字符串的方式：DateFormat类中的format方法
创建日期格式对象：
DateFormat df = new SimpleDateFormat();//该对象的建立内部会封装一个默认的日期格式
如果想要自定义日期格式的话。可使用SimpleDateFormat的构造函数。将具体的格式作为参数传入到构造函数中。如何表示日期中年的部分呢？可以必须要参与格式对象文档。
df = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
//调用DateFormat中的format方法。对已有的日期对象进行格式化
String str_time = df.format(d);
5，API---java.util.Calendar:日期类
查表法：建议数据的对应关系
最好是数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。
public static void method(){
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+ “年”+ (c.get(Calendar.MONTH) + 1) + “月” + getNum(c.get(Calendar.DAY_OF_MONTH)+ “日”+ “星期” + getWeek(c.get(Calendar.DAY_OF_WEEK))));
}
public static String getNum(int num){
return num >9 ? num+ “” : “0” + num;
}
public static String getWeek(int index){
String[] weeks ={“”,”日”,“一”,“二”,“三”,“四”,“五”,“六”};
returnweeks[index];
}
---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net
8361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
