API:
接口概念：
API(Application Programming Interface),应用程序编程接口，Java API是一本程序员的字典。是JDK中提供给我们使用的类的说明文档。
API是jdk提供的各种功能的java类。
这些类将底层的代码实现封装了起来，我们呢不需要这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可通过查询API的方式，来学习Java提供的类，并得知如果使用它们。
API的使用步骤：
- 打开帮助文档（jdk帮助文档_汉化版）
- 点击显示，找到索引，看到输入框
- 你要找谁？再输入框里输入，然后回车。
- 看包。java.lang下的类不需要导包，其他需要。
- 看类的解释说明。
- 学习构造方法。
- 使用成员方法。
所谓的API就是好多类好多方法，jdk提供了一些现成的类，可以直接俄拿过来使用，这些类是现成提供给我们，直接拿来使用的类，他们都叫做API。
API文档：告诉我们到底只有哪些类是现成的，到底有哪些方法具有各自怎样的功能，这个样的一份说明说就叫做API文档。
提示： string 关键字都是小写的， String是一个类，这个是jdk的作者写的。
API:String、StringBuilder的学习
String、StringBuffer、StringBuilder
首先，三者的区别：
String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
?简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
?而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
?String S1 = “This is only a” + “ simple” + “ test”;
?StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
?你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
?String S1 = “This is only a” + “ simple” + “test”; 其实就是：
?String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做
在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer
java.lang.StringBuilder
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。
其次，单独介绍：
String：
概念：
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例
也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。
特殊点：
字符串不可变，它们的值在创建后不能被更改。
虽然 String 的值是不可变的，但是它们可以被共享，字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )。
特点：
1、通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但地址值不同。
2、以“”方式给出的字符串，只要字符序列相同（顺序和大小），无论在程序代码中出现几次，JVM都只会创建一个String对象，并在字符串池中进行维护。
? ??
注意：面试考点
?如何理解String类的值不可变但可以共享？
string说的不可变是其值不可变，比如String str = "abc"，不可变值得是abc不可变，当我们str = “abcde”时，abc没有被销毁，仍然存放在常量池中，只不过是让str指向了“abcde”的内存地址。所以就算不停的赋值，改变的也只是str引用的地址问题，右边的值是不改变的。
所以会产生冗余问题，占据大量内存空间，且无用。
而共享，共享是指你在声明一个具体内容的数据类型String时，如果你定义一个string name= "tttt "，它将自己生成一个字符串池，其他的字符串类型，如果内容相同，将直接访问字符串池，而不会再生成新的内存。它将使用串池里原来的那个内存，而不会重新分配内存，也就是说，string saname= "tttt ",将会指向同一块内存，变量名不同毫无关系。
String的常用方法：
1、indexOf(“字符”)：查询指定的字符串是否存在，返回的是字符串的位置，不存在返回-1；
2、substring(int begIndex,int endIndex)：截取字符串；
3、CharAt(值)：拿到指定位置的字符；
4、length()：返回字符串的长度；
5、equals()：比较两个字符串是否相等；
6、toLowerCase()：将字符串转换为小写字母；
7、toUpperCase()：将字符串转换为大写字母；
8、equalsIgnoreCase(String)：忽略大小写比较两个值是否相等；
9、spilt（）：将此字符串拆分为给定的 regular expression的匹配。
10、replace（）：返回从替换所有出现的导致一个字符串 oldChar ，在这个字符串 newChar 。
11、compareTo（）：按字典顺序比较两个字符串。
12、startsWith()：判断当前字符串的前缀是否和指定的字符串一致。
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
StringBuilder
概念：
StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器。
这里的可变指的是 StringBuilder 对象中的内容是可变的。
String 和 StringBuilder 的区别：
?? ?String ：内容是不可变的
StringBuilder：内容是可变的
构造方法：
添加和反转方法：
?? ?
? ? ? ??
?代码例子：
添加：
?反转：
StringBuilder 和 String 相互转化：
?? ?1. StringBuilder 转换为 String
? ? ? ? public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
?? ??? ?
?? ?2. String 转换为 StringBuilder
? ? ? ? public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
特殊方法拓展：
line=line.toLowerCase();//字符串中的字母都转为小写
**toUpperCase()**：将字符串转换为大写字母；
line.equalsIgnoreCase(code)//忽视大小写比较。
**CharAt(值)**：拿到指定位置的字符；
**equals()**：比较两个字符串是否相等；
查找字符串（indexOf），截取字符串（substring（int begIndex,int endIndex））
? ? 例子：
String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
? ? ? ? String tar = "Java";?
?? ? int count = 0;
? ? ? ? // 定义索引变量，表示每次找到子串出现的索引
? ? ? ? int index = -1;
? ? ? ? // 定义循环，判断条件为在字符串中找到了目标子串
? ? ? ? while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
? ? ? ? ? ? // 次数累加
? ? ? ? ? ? count++;
? ? ? ? ? ? // 把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取。
? ? ? ? ? ? str = str.substring(index + tar.length());
? ? ? ? }
? ? ? ? return count;
String.intern() 方法可以使得所有含相同内容的字符串都共享同一个内存对象，可以节省内存空间。
spilt方法：public String[] split(String regex)； //根据给定正则表达式的匹配拆分此字符串。
该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。
例如，字符串 “boo:and:foo” 使用这些表达式可生成以下结果：
Regex 结果
{ “boo”, “and”, “foo” }
o { “b”, “”, “:and:f” }
?
Arrays.sort(变量)：冒泡排序的方法。
toCharArray()：包含一切字符均转换成相应的字符数组。
?
?
?ArrayList
集合概述：
概念：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变。
特点：底层是数组实现的，长度可以变化。
ArrayList<E>：?可调整大小的数组实现，?<E>:是一种特殊的数据类型，泛型。
?? ?怎么用呢?
?? ??? ?在出现E的地方我们使用引用数据类型替换即可。
?? ?举例：ArrayList<String>,ArrayList<Student>
构造方法：
?代码例子：
添加方法：
?代码例子：
public boolean remove(Object o),删除指定元素的方法应用
假如我要删除我在集合中添加的一种水果，请看以下：
Scanner sc=new Scanner(System.in);
System.out.println("请输入您要删除的水果编号");
String str=sc.nextLine();
for (int i = 0; i < list.size(); i++) {
if(list.get(i).getNum().equalsIgnoreCase(str)){
System.out.println("你确定要删除该水果吗？（y/n）");
String atr=sc.nextLine();
if(atr.equalsIgnoreCase("y")){
list.remove(list.get(i));
}
}
}
System.out.println("水果信息删除完毕！");public E set(int index,E element);
假如我要修改我在集合中添加的一种水果，请看以下代码：
这是修改集合中一组录入的信息：
Scanner sc=new Scanner(System.in);
System.out.println("请输入您要修改信息的水果编号：");
String str=sc.nextLine();
System.out.println("请输入新的水果编号：");
String newstr=sc.nextLine();
System.out.println("请输入新的水果名称：");
String atr=sc.nextLine();
System.out.println("请输入新的水果单价：");
double ner=sc.nextDouble();
Pro02 p5=new Pro02();
p5.setNum(newstr);
p5.setName(atr);
p5.setPrice(ner);
for (int i = 0; i < list.size(); i++) {
if(list.get(i).getNum().equals(str)){
list.set(i,p5);
}
}
System.out.println("水果信息更新完毕！");而修改集合中录入一组信息中某一个位置的信息，看以下代码：
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要修改的商品编号");
int sid = sc.nextInt();
System.out.println("请输入您要修改的库存数量");
int proNum = sc.nextInt();
// 第一种方法：
// System.out.println(array.get(sid.charAt(0) - 49).getProNum());
// array.get(sid.charAt(0) - 49).setProNum(proNum);
//
Pro pro1 = array.get(sid-1);//找到集合里面的下标sid-1（sid从1开始），就找到了集合里面的元素。
pro1.setProNum(proNum);//把修改的proNum调用到新对象pro1
array.set(sid-1,pro1);//array.set(index索引，元素element);修改指定位置的元素
}这就是修改单一元素的方法，找到索引位置，然后修改的元素信息覆盖旧的信息。
public E get(int index);
获取或者是说返回具体索引位置的方法：大多数用于获取某一个元素，或者某一个位置上的元素。通过遍历的方式找到。
例如：
ArrayList<Customer_2> cust=new ArrayList<Customer_2>();
for (int i = 0; i < list.size(); i++) {
cust.add(list.get(i));
}
return cust;其中，list是集合，list.get（i），就是遍历获取每一个元素。
?? ??? ?