看懂今天这个！你就是个真正的javaer!

恭喜你，从此开始一段新的人生——跨越上和大海，抽象人山人海

在过去的几天里，你已经学会了一些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然后按你想要的方式排序玩耍吧。