昨天，猿人君已经教会你搞对象了。听说——
由于文字篇幅有限，讲得不明白的地方，大家关注公主号猿人工厂，或者加入qq群765605694，猿人工厂君，手把手的免费教你！
恭喜你，从此开始一段新的人生——跨越上和大海，抽象人山人海
在过去的几天里，你已经学会了一些java的语言特性以及面向对象思想，今天猿人工厂君，要带你完成一个华丽的转身变成一个——
真正理解和使用一门语言，了解的不仅仅是一些语言特性，还需要了解常用的API.更重要的是要学会和实践鲁迅先生的那句名言——拿来主义。
很多倒在了从入门到放弃路上的人，其实都是倒在了拿来主义的路上——不会使用别人写的程序。今天我们就一起来看看怎样使用别人写的程序，学会java提供的一些常用工具。比如说
java.lang.String 类代表字符串。用双引号””表示，双引号内的内容就是字符串的内容。在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。我们可以看看String类的部分源码。
Strig有一个成员变量 char[] value,实际上String是一个字符数组成”123”某种程度上等效于char value={‘1’,’2’,’3’};
String对象是不可变的，一旦创建了 String 对象，那它的值就无法改变了。
因为String对象是不可变的，所以它们可以被共享。
String类是final类不能被继承
public String() ：创建一个空字符串
public String(Stringoriginal)：支持使用字符串入参创建字符串
public String(char[] value) ：支持使用char[]创建字符串。
public String(byte ascii[],int hibyte) ：支持btyte[]创建字符串
下面这段代码免费拿走不，分分钟学会String的使用：
public static void main(String args[]){
String str="This is a statement , How are you";
char[] bcd={'b','c','d'};
String str1="bcd";
String str2="bcd";
String str3=new String("bcd");
String str4=new String(bcd);
System.out.println(str1==str2);//==比较是地址比较这str1==str2是因为str1和str2共享了地址
System.out.println(str1==str3);//str3使用了关键字 new 重新开辟了内存空间 str3的地址和str1不再 相同所以返回false
System.out.println(str1==str4);
System.out.println(str1.equals(str3));//比较字符串用equals
System.out.println(str.length());//获取字符串长度，注意时length()方法噢，和数组不同噢
String upperStrng=str.toUpperCase();
System.out.println(upperStrng);
String lowerString=str.toLowerCase();
System.out.println(lowerString);
System.out.println(upperStrng.equalsIgnoreCase(lowerString));//equalsIgnoreCase忽略大小写比较字符串
char c=str.charAt(0);//根据索引返回字符从0开始，顺序从左往右
System.out.println(c);
System.out.println(str.indexOf('T'));//返回某个字符第一次出现的索引位置，从0开始
System.out.println(str.lastIndexOf('T'));//返回某个字符最后一次出现的索引位置，从0开始
System.out.println(str.substring(1));//使用索引截取字符串，从左往右，索引从0开始算
System.out.println(str.substring(1,str.length()-1));//使用索引1-索引2之间的字符串，索引从0开始算，顺序从左往右
System.out.println(str.replace("This", "There"));//使用某个字符串替换字符串，被替换的字符串再前
System.out.println(str.substring(1));
System.out.println(str.startsWith("This"));//判断字符串是否拥有某个前缀
System.out.println(str.startsWith("is"));//判断字符串是否拥有某个前缀
System.out.println(str.endsWith("you"));//判断字符串是否拥有某个后缀
System.out.println(str.endsWith("u"));//判断字符串是否拥有某个后缀
System.out.println(str.endsWith("are"));//判断字符串是否拥有某个后缀
System.out.println(str.contains("statement"));//判断字符串是否包含某个字符串
//split 将一个字符串按某个分隔符号（分隔符好也是字符串）拆分为多个字符串返回数组，使用时最好做非空判断
String[] strs=str.split(",");
if (null!= strs) {
for (Strings : strs) {
System.out.println(s);
}
}
}
办法还是有的，可以使用static！static是java提供的关键字，用于修饰类的成员变量和方法是静态的意思。当一个类的成员变量和方法使用了static修饰，那么我们在使用这个类的时候就不用先创建对象了:
算了，还是告诉你吧：
静态变量只要改变一次，这个类以及这个类创建的所有对象的相应变量都会被改变。
静态代码块会在类随类的而执行一次,也只会执行一次，会优先于main方法和构造方法的调用。
java.util.Calendar是日历类，出现在Date类以后，JAVA推荐使用Calendar替换Date的使用，因为Calendar类替换了很多Date的方法。下面是一些常规的用法：
Java的数据类型分为基本类型和引用类型。针对每一种基本类型提供的引用类型，被称作包装类型。基本类型和包装类型之间的转换被称作装箱和拆箱。从基本类型转换为对应的包装类对象叫做装箱。从包装类对象转换为对应的基本类型叫做拆箱。
String和包装类型的转化要复杂一些使用对应包装类的parseXXX方法即可。这个不要你敲了，送你个点福利吧：
String numStr="123";
int num=Integer.parseInt(numStr);我们先看看下面这段代码：
Integer a =10;
Long b=20L;
Object obj =(Object)a;
System.out.println(obj);
obj =(Object)b;
System.out. println(obj);
Object obj2 =new Object();
System.out.println(obj2);编译无问题，代码能运行。因为在java中任何一个类其实都隐藏的继承了Object类。由于Object类是根类，所以还免费给每个对象赠送了两个方法:
public String toString()：返回该对象的字符串表示。默认返回的是：对象类型@+内存地址值Integer类型和Long类型能够返回具体的值，是因为重写了toString()方法。由于Object类是根类，也就是说所有的类都这个方法。
public boolean equals(Object obj)：判断两个对象是否“相等”，这里的相等是比较两个对象的内存地址，如果一个对象有自己认为相等的方式，就需要重写这个方法，以后遇到实际问题再给你讲。
java.lang.StringBuilder 提供了一个可变的字符序列，能够动态的调整序列的长度和能容，它提供了一个字符串缓冲区，使用字符数组来存放内容，当字符串进行拼接时，动态的扩容数组，并且放入新的内容，从而解决+号连接字符串的内存浪费问题（默认时16个字符空间）。
我们都知道数组是固定长度的，我们在使用数组的时候需要明确的知道数组能存放多少个标签，这样很麻烦，java为我们提供了一个容器类java.util.ArrayList, java.util.ArrayList的长度是可变的，在ArrayList中不断增加标签，ArrayList的大小也不断增加，在在ArrayList中不断删除标签，ArrayList的大小也随之减少。这样我们可以更便捷的存储和操作对象数据。
ArrayList的基本操作主要体现在——增、删、查三个方面。常用的方法有：
public int size()：返回ArrayList中标签的个数，可以用来控制遍历时的循环次数,防止越界。抛出java.lang.IndexOutOfBoundsException
public boolean add(E e) ：将指定的标签添加到此集合的尾部，注意这个E代表泛型，即任意类型，但是有一个前提，就是必须和声明时的类型一致。
List<Person>list = new ArrayList<Person>();
我们声明时指定了泛型的类型是Person类，所以这里也只能是Person类型的对象。
public Eremove(int index) ：移除此集合中指定位置上的标签并返回被删除的标签。
public Eget(int index) ：返回此集合中指定位置上的标签。index和数组下标一样从0开始。
java.util.Arrays类提供了一些操作数组的静态方法，比如排序、查找、复制。
还有很多好玩的，就不一一说了，暂时嘛，够用就好。
刚刚学了ArrayList,你就飘了， AyyayList只是一种容器，装东西的都叫容器！集合就是容器的统称，用来存放多个数据的数据结构都可以统称为集合。既然是统称呢，那就由共性，抽象为接口比较好一点，为此，java定义了java.util.Collection：
集合是一种接口，ArrayList等集合类实现了这个接口，所以所有实现了这个类的接口都能用Collection的接口变量操作，下面就是集合的主要功能：
public boolean add(E e)：添加对象到集合中。
public void clear() :清空集合中的标签。
public boolean remove(E e): 删除集合中的指定标签。
public boolean contains(E e): 判断集合中是否包含指定对象。
public boolean isEmpty(): 判断集合是否是空集合，即没有标签。
public int size(): 获取集合中标签的个数。
public Object[] toArray(): 把集合中的标签存储到数组中。
Iterator<E> iterator()：返回迭代器
等等Iterator是个什么鬼？迭代就是先判断结合里有没有标签，如果有就取出来，然后再判断有没有，一直到把集合里所有的标签取出来为止。这种方式就叫迭代。
Iterator就是迭代器，迭代器是一个接口，一个用于迭代访问的接口。迭代就两个常用方法：
public E next():返回迭代的下一个标签。
public booleanhasNext():如果还存在标签，返回 true。
Iterator<Integer> it = collection2.iterator();
while(it.hasNext()){
Integer value=it.next();
System.out.println(value);
}上面的代码送你了，拿走不谢。
我们都知道集合能存入任意类型得数据，但是如果数据类型不一致，访问起来是由风险的。
我们看下面的代码：
List list = newArrayList();
list.add(1);
list.add("1");
for(int i=0;i<list.size();i++){
Integer j =(Integer) list.get(i);
}
编译时没问题，但是run起来，java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
为了解决这一问题，java在JDK5中提出了泛型，在编译时期解决这个问题，给类或者方法预先指定一个未知的类型，在使用前在指定具体的类型。
java.util.List接口继承了Collection接口，也就是说List拥Collection接口所有的方法，在此基础上还进行了扩展，list常用的方法如下：
public boolean add(E e)：添加对象到集合中。
public void clear() :清空集合中的对象。
public boolean remove(int index): 删除集合中的指定位置的对象。
public boolean contains(E e): 判断集合中是否包含指定对象。
public boolean isEmpty(): 判断集合是否是空集合，即没有对象。
public Eget(int index) :返回集合中指定位置的对象。
public Eset(int index, E element) :用指定对象替换集合中指定位置的对象,并且返回被替换的对象。
public int size(): 获取集合中标签的个数。
List中存放的元素有一下特点：
1.标签顺序存储，比如按照1，2，3的顺序加入标签，那么标签的存放顺序就是1，2，3。
2.List可以通过索引（下标）进行访问，可以根据索引直接获取标签。
3.List中的标签可以重复，判断一个对象是否在list中是否存在，需要对应的类重写equals方法。
java.util.ArrayList 我们之前已经讲过了，是最常用的List的子类，之前已经说过了，这里就不多说了。
Set是一种新的数据结构,类似于数组,但是成员的值都是唯一的,没有重复的值。java.util.Set 接口也同样继承了Collection 接口，也具备了Collection接口的能力法基本一致，Set并没有对Collection 接口的基础上扩展新功能，Set 接口中的对象是无序的，并且保证不会出现重复的对象。Set接口可以通过迭代器和For in语句遍历。
java.util.HashSet 实现了Set接口，是set最常用的一个实现类，它所存储的标签是无序(即存取顺序不一致)且不重复的，我们经常使用它来给数据去重。
Set<String> set = new HashSet<String>();
char a='A';
for(int i=0;i<10;i++){
set.add(a+""+i);
set.add(a+""+i);
}
for(String str:set){
System.out.println(str);
}运行程序，只有10行记录，说明数据唯一，输出结果和加入顺序不一致，说明标签无序。
Map是一种容器，提供了键值对（key /value）的访问方式。什么是键值对？比如周xx又叫9527，我们一提9527就想到了周xx。那么9527和周xx就是一个键值对。Map是一个接口，但是它并没有继承或者实现Collcetion接口，也就是说，map并不具备Collcetion接口的相关功能。但是，map也是一种集合，是键值对的集合。Map中的key是要保证唯一的，不重复的，需要重写key的hashCode和equals方法。
以下是Map的常用方法如下：
public Vput(K key, V value) : 通过指定的key将value对象添加到map中,并返回value对象。
public Vremove(Object key) : 通过指定的key删除对象,并返回被删除的对象。
public Vget(Object key) 通过指定的key，获取对象。
publicSet<K> keySet() : 以Set的方式返回map中所有的key对象。
publicSet<Map.Entry<K,V>> entrySet() : 以Set的方式返回map中所有的value对象。
HashMap实现了Map接口，是最常用的Map的实现类，LinkedHashMap也是HashMap的子类，能够保证数据的有序存放。
下面是map的使用例子：
Map<Integer, Person> map = new HashMap<Integer, Person>();
for (Integer i = 0; i < 10; i++) {
Person person = new Person();
person.setName("张" + i);
map.put(i, person);
map.put(i, person);//试试看能多加一倍的对象吗
}
showMapByKey(map);System.out.println("==下面是直接遍历访问值==");showMapValues(map);
System.out.println("==下面是map的get访问==");System.out.println(map.get(1).getName());System.out.println(map.remove(1));System.out.println(map.containsKey(1));System.out.println(map.containsKey(2));System.out.println(map.size());map.clear();System.out.println(map.isEmpty());Java为集合操作还提供了工具类，java.utils.Collections——提供了一些方法来操作集合数据：
public static <T> booleanaddAll(Collection<T> c, T... elements) :往集合中添加一些数据。
T... elements是可变参数，一个方法传递多个相同类型的参数时，这样编写，JDK5新特性。
public static <T> voidsort(List<T> list) :将集合中标签按照默认规则排序。
public static <T> voidsort(List<T> list，Comparator<? super T> ) :将集合中标签按照Comparator用于指定的规则排序。
Comparable接口，需要在类中实现，需要实现compareTo方法，由于是定义在类中，如果要修改类的排序方式就需要修改类，相对来说不灵活。
而Comparator接口可以在调用排序方法，比如Collections.sort或Arrays.sort方法时，再去实现，可以相对精确的按照自己的意愿来指定排序方式。相对灵活。
当然我们再调用Collections.sort或Arrays.sort方法的无Comparator入参的方法时，其实使用的是默认排序的方式。
List<Person> list = new ArrayList<Person>();
for (int i = 0; i < 10; i++) {
Person person = new Person();
person.setName("张" + i);
list.add(person);
}
showList(list);System.out.println("==下面是Comparator排序==");//注意匿名内部类的用法噢Collections.sort(list, new Comparator<Object>() {//匿名内部类了解下
@Override
public int compare(Object o1, Object o2) {
Person p1 = (Person) o1;
Person p2 = (Person) o2;
if (p1.getName().equals(((Person) o2).name)) {
return -1;
} else {
return 1;
}
}
});showList(list);List<Integer> nums = new ArrayList<Integer>();//注意可变参数的用法Collections.addAll(nums, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);showNumList(nums);定义一个学生类，给定一切你想给定的属性，加到list然后按你想要的方式排序玩耍吧。