学习文件流

文件流按照读取或写入的单位（字节数）大小来区分

字节型文件流（1字节）

FileInputStream/FileOutputStream

字符型文件流（2-字节–1字符）

FileReader/FileWriter

字节型文件输入流

了解一下继承关系 inputStream类 字节型输入流的父类

创建对象

调用一个带File类型的构造方法

调用一个带String类型的构造方法

常用的方法

int code = read(); 每次从流管道中读取一个字节 返回字节码的code码
int count = read(byte[] )每次从流管道中读取若干字节 存入数组内 返回有效元素
skip（long n）跳过几个字节 读取
多线程————————>利用几个线程同时读取文件
*close()   将流管道关闭---必须要做 最好放在fianlly里 注意代码的健壮性 严谨性

字节型文件输出流

FileOutput 将数据写入文件中

java.io

继承OutputStream 所有字节输出型的父类

创建对象

调用一个带file参数 还有file Boolean重载

调用一个带String参数 还有String boolean 重载

常用方法

writr(int code);将给定的code对应的字符写入文件“=”
write(byte[]) 将数组中的全部字节写入文集 getByte()
flush() 将管道内的字节推入(刷新)文件
close() 注意在finaly类中关闭

字符型文件流

FileReader FileWriter

只能操作存文本文件（右键打开方式 记事本打开 能看懂）.txt

FileReader

java.io包

继承 InputStreamReader Reader

构造方法

常用

read()

read(char[])

FileWriter

java.io包

继承OutputStreamWriter Writer

构造方法 带file参数 带file,boolean参数

                  带String参数 带String，boolean参数

常用方法

writer（int）
writer（char[]）
writer（String）
int count = read(char[]);
close() flush()

缓冲流

在管道中内增加缓存的数据

让我们使用流读取的文字更加流畅

高级流—–》创建通过低级流

BufferedInputStream/BufferedOutputStream
BufferedReader/BufferedWriter
BUfferedInPutStream
构建方式 使用低级流构建
基本上使用与低级流完全一致
read()skip()available()close() 
BufferedOutStream
构建方式 使用低级流构建 注意缓冲流构建的时候没有boolean类型的参数
基本使用与低级流的方法完全一致
read()skip()available()close()
BufferedOutputStream

对象流

对象的序列化/反序列化

为什么要有文件

文件永久保存信息    很多数据存入文件-----数据持久化

如果按照以行为单位写信息

好处在于每一行记录的信息都是相关的

信息我们可以读出来 直接看懂文件

不好在于第一不一定安全 直接看懂

不好在于只能记录String信息 不一定能记录一些动作（方法）

读取出来的信息 String——>Person

如果能将对象拆分成字节码直接写入文件

将对象直接存入文件中—–对象流

为什么要重写toString方法

toString 方法默认是打印对象和hashcode码

当输出为一个对象名的时候

重写toString方法可以打印对象的值

对象序列化与反序列化

对象的序列化指的是

将一个完整的对象 拆分成字节碎片 记录在文件中

对象的反序列化指的是

将文件中记录的对象随便 反过来组合一个完整的对象

如果想要将对象序列化到文件中

需要对象实现Serializable接口

是一个示意性的接口

如果要实现反序列化

需要给对象提供一个序列化的版本号 1.7版本—>String 1.8—>String

I/O相关 输入/输出 流（数据流动）

数据流动的方向 读数据(输入input) 写数据（输出output）

文件流 字符流 数组流 对象流 网络流

什么叫文件

一种电脑的存储形式

文件有不同的格式 .txt .doc .ppt .mp4 .rar …

文件夹—–目录路径

File—–>与电脑上的文件夹产生一一对应的映射关系

File是一个类

java.io包

文件或目录路径名的抽象形式

File与真实硬盘中的文件或文件夹 不是同一个东西

File是内存中的一个对象<—–映射—->磁盘上的文件或文件夹

File类中的常用方法

canRead() canWrite() isHidden() isFile() isDirectory()
length() 获取文件中的字节数
lastModified()获取文件最后的修改时间---->毫秒值
*String path = getAbstractPath() 获取文件的绝对路径 D://test//Test.txt
绝对路径<--->相对路径
绝对路径可以通过完整字符串 定位盘符 文件夹 文件
相对路径没有盘符的写法 当前工程（项目）所在的位置寻找
              C：\Users\Administator\ideaProjects\TestFile\src
*String name = getName()获取文件名字 Test.txt
*creatNewFile() 创建新的文件
*mkdir 创建新的文件夹 外层没有 不能创建
*mkdirs 创建新的文件夹 外层没有 自动创建
String pname = getParent() 获取当前file的父亲file名字
*File file = getParent() 获取当前file父亲的对象
String[] names = list() 获取当前file所有儿子的名字
*File[]files = listFiles() 获取当前file所有儿子对象
*boolean = delete() 删除文件或空的文件及 不能删除带元素的文件夹

异常/错误

程序运行过程中，可能会发生一些不被期望的效果，肯定会阻止我们的程序按指令去执行

这种不被预期出现的效果，肯定需要抛出来告诉我们

在JAVA中有一个定义好的Throwable（可以抛出的）

Error错误

通常是一些物理性的，JVM虚拟机本身出现的问题，程序指令是处理不了的

Exception异常

是一种不正常的现象,通常是给定的指令程序产生了一些不合规范的事情

Throwable

Error（错误）

StackOverflowError

OutOfMemoryError

Exception(异常)

RuntimeException（运行时）

IOExceotion

异常的分支体系

运行时异常（非检查异常）

Error和RuntimeException都算作运行时异常
javac编译的时候，不会提示发现的
在程序编写的时候不要求必须做处理，如果我们愿意可以添加处理手段（try throws）
要求大家出现这样的异常的时候，知道怎么产生及如何修改
1.InputMisMatchExceotin  输入不匹配
        int value = input.nextInt();// abc
2.NumberFormatException  数字格式化
        int value = Integer.parseInt("123.45")
3.NegativeArraySizeException 数组长度负数
        int Array = new int[-2]
4.NullPointerException 空指针异常
        int[][] array = new int[3][];
        array[0][0] = 10;
        Person p = null;
        p.getName();
5.AirthmeticExceotion 数字异常
  10/0  整数不允许除0 infinity小数除0会产生无穷
6.ClassCastException 造型异常
       Person p = new Teacher();
       Student s = (Student) p;
7.ArrayIndexOutOfBoundsException 数组索引越界
       int[] array ={1,2,3};
       array[5];
8.StringIndexOutOfBoundsException 字符串越界
       String str = "abc";
       str.charAt(5);
9.IndexOutOfBoundsException 集合越界
       List家族
       ArrayList list = new ArrayList();
       list.add();list.add();ist.add();
       list.get(5);
10.IllegalArguementException 非法参数异常
       ArrayList list = new ArrayList(-1);

编译时异常（检查异常）

除了Error和RuntimeException以外的其他异常
javac编译的时候 强制要求我们必须为这样的异常处理（try或throws）
因为这样的异常在程序运行中可能会产生问题
异常产生后后续的所有执行就被停止啦
1.InterruptException
            try{
                 Thead.sleep(5000);
            }catch(Exception e){

            }

添加处理异常的手段

处理异常不是异常消失了

处理异常指的是 处理掉异常之后 后续的代码不会因为此异常停止执行

两种手段

try{}catch(){}{finally{}}

try不能单独出现

后面必须添加catch或finally

catch有一组括号（NullPointerException）目的是为了捕获一组异常

catch可以有多个存在

捕获的异常直接没有任何的继承关系
捕获的异常需要从小到大捕获

finally 不是必须存在的 若存在则必须执行

fianl fianlly fianlizae 区别

fianl 特征修饰符 修饰变量 属性 方法 类

修饰变量 基本类型 值不能改变 引用类型 地址不能改变（如果变量没有初值 给一次赋初值的机会）

修饰属性 特点与修饰变量相似（要求必须给属性赋初值 否则编译报错）

修饰方法 不能被子类重写

修饰类 不能被其他子类继承

fianlly 处理异常的手段的一部分

try()catch(){}后面的一个部分

这个部分可有可无 如果只能含有一部分 且必须执行

finalize 是Object类中的一个protected方法

对象没有任何引用指向的时候—-会被GC回收

当对象回收的时候 默认调用finalize方法

若想看到回收的效果 可以重写 public void finalize(){}

处理异常放在方法内部可能还会有小问题

如果在方法内部含有返回值

不管返回值return关键字在哪里 finally一定会执行完毕

返回值的具体结果 看情况

throws 抛出

异常只能在方法上抛出 属性是不能处理异常的

方法 构造

方法 可以抛出不止一个异常，通过，隔开

抛出的异常与多个catch类似 要么没关系 要么先抛出小异常

Map 映射

通过某一个key键可以直接定位到一个Value值

存储方式以 键值对 存储 Key-Value

key无序还是一样,指的是存入顺序与取得顺序不一致

key无重复当然指的是 元素不能一致

Map基本使用

HashMap

TreeMap

Properties

HashMap

包 java.util

如何创建对象

基本方法

增删改查
增put(key,value)   存放一组映射关系 key-value
          1.key存储的顺序与取得的顺序不同
          2.不同的key可以存储相同的value
          3.key若有相同的 则将原有的key覆盖而不是拒绝存入(跟Set刚好相反)
删 E = remove(key);
改 put = (key,value1) put（key,value2）
  replace（key,newValue）
查 E = get(key)
遍历Map集合   key不一定什么样
//获取map集合的全部key
Set<Integer> it = map.keySet();
//通过迭代器遍历
Iterator<Integer> it = keys.iterator();
while(it.hashNext()){
   Integer key = it.next;
   String value = map.get(key);
   System.out.println(key+"-"value);
}

API提供的其他方法

char containsKey(key) containsValue(value)
getOrDfault(key.defaultValue)如果key存在就返回对象对应的Value 若没有找到则返回默认返回值
isEmpty()
putAll(map)
putlfAbsent(key.value);//如果key不存在才向集合添加 如果key值不存在就不添加了

HashMap在什么情形下用?

想要存一组元素

数组 or 集合 如果存储的元素以后长度不变用数组 如果数组长度以后不确定用集合

如果发现长度以后不确定——————>集合

List Set Map
List家族有序的  存储有顺序用这个
       ArrayList       更适合遍历轮循
       LinkList        更适合插入删除
       Stack          LIFO      
Set家族无重复   存储元素希望自动去掉重复元用这个
       Hash            性能更高
       Tree            希望存进去的元素自动去重复 同时还自动排序按(A-Z)字典顺序

Map家族k-v      通过唯一的K快速找寻v用这个
       Hash            性能更高
       Tree            希望存进去的元素能自动排序

Hash底层的数据结构

散列表形式      数组加链表
Person对象存入HashMap中  可以
HashCode方法   —>不同的对象可以产生相同的hashCode码
不同的hashCode码  不同的对象
//hashcode码
static fial int hash(Object obj){
  int h;
  return(key == null)?0:(h = key.hashCode())^(h >>>16);
}
数组：对象的hashCode码
    发现hashCode码一致
    当前数组后面串一个Node

    先扫描数组(位置 )
    继续扫描链表
    数组中存储的是hash值
    （key+value）包装成一个对象Entry
    Map.entry

Collection

以value形式存在

Set

无序无重复

具体实现的类

HashSet

TreeSet

基本的使用

无序 无重复

无序 ： 我们使用的集合存放元素的顺序 集合内取出来的顺序不一致 （不是集合本身是否有序 Tree自然有序）

无重复 ：添加的元素不能一致（如果出现重复元素 只存第一个 不再存入）

集合本身是有自己的算法排布顺序 hash算法

HashSet——->（HashMap（数组+链表）散列表 邻接表）

java.util包

如何创建对象

无参数

有参数

集合容器的基本使用

增删改差
boolean = add(value) addAll(collection c) retainAll removeAll
boolean = remove(Object)
没有修改方法
size()

关于迭代器iterator

//获取一个迭代器对象 通过set集合获取
Iterator <String> it = set.iterator();// Iterator 接口 多态效果 父类引用子类对象
//判断下一个位置是否有元素
if（it.hashNext）{
 String value = it.next();
 System.out.println(Value);
}

无重复原则

首先通过String类和Person类型存储
大概猜测 无重复原则 利用equals方法进行比较
如果我们让Person对象的name一致 认为是同一个对象
我们可以重写equals方法
重写了equals方法 发现还没有产生无重复的效果
证明可能原则不止equals方法这么简单
还有另一个规则同时起着作用 hashcode方法

为什么要重写equals（）方法？

  因为默认equals在比较两个对象时，是看他们是否指向同一个地址的。但有时，我们需要两个不同对象只要是某些属性相同就认为它们equals（）的结果为true。比如：

 person p1 = new person(1,"name");
 person p2 = new person(1,"name");
 如果不重写equals的话，他们是不相同的，所以我们要重些equals，判断只要他们的id和名字相同equals就为true，在一些集合里有时也这样用，集合里的contain也是用equals来比较

   先来看Object关于equals()的源码：

   public boolean equals(Object obj) {
   return (this == obj);
   }


 //String 就重写了equals方法
public boolean equals(Object obj){
    if(this==obj){
        return true;
    }
    if(obj instanceof Question) {
        Question anotherQuestion = (Question)obj;
       //this.title 按照？截取 与anotherQuestion.title截取之前的部分比较
        if(this.title.equals(anotherQuestion.title)){
            return true;
        }
    }
    return false;
}

当重写equals方法时，同时也要重写hashCode方法。

//修改equals 方法一定要修改hashcode方法 因为底层用hashCode比较
public int hash(){
   return this.title.hashCode();
}

TreeSet—–>（TreeMap 二叉树利用Node（Left item right））

无序无重复 java.util

无参构造方法 带Collection构造方法

基本常用方法

add(E e)  iterator() remove(E e) 没有修改 size()

无序无重复规则是如何实现的

treeSet集合本身是有顺序的  我们指的无序是存入和取出不一致
CompaerTo------>String类 按照字母的自然顺序排列
//如果想让Person对象存入TeeSet集合内  必须实现Comapareable接口 重写这个方法
piublic int compareTo（o.name）{//当前对象name与另一个对象CompareTo结果
return this.name.compareTo(o.name);//当前对象name和另一对象name的CompareTO结果
}

List

Vector 类

java.util包

是ArrayList集合 早期版本

(StringBuffer类早期 Stringbuilder后来)
 vector底层也是用动态数组来存储
 vector是线程同步的 安全性高 效率低

扩容方式与ArrayList不同

默认是扩容两倍  可以通过构造方法创建对象时修改这一机制

Stack类 栈

java.util包

构造方法只有一个无参数

只有几个特殊的方法

push(E e)将某个元素压入栈顶（add()）
E = pop()将某一个元素从栈顶取出并删掉(E = remove())
E = peek()将某一个元素从栈顶取出并删除掉(E = remove())
boolean = empty()判断栈顶元素是否为空(isEmpty)
int = search()查找给定元素在栈中的位置(indexof())

中国象棋 悔棋

栈中存储每一次的操作步骤
撤销功能

Queue接口

java.util

通常子类 Linklist ArrayQueque

通常用无参构造方法实现

一般方法

add()
element()----->get()
remove()
boolean = offer(E e);//相当于add  不会抛出异常
E = peek();//相当于element方法
E =poll; 剪短//相当于remove()

双十一秒杀

所有进入秒杀系统的人存入队列

ArrayList

Linklist类

java.util包

自己封装过LinkBox 内部类Node<T>对象（节点 prev item next）

底层就是使用双向链表的数据结构形式来存储

适合插入或删除不适合遍历轮循

构建对象

无参构造方法 带参数的构造方法（collection）

常用的方法

增删改查 add() remove() set() get() size()
手册中提供其他常用方法
addAll() addFirst() clear() contains()
element() getFirst() getLast() indexOf() lastindex()
....

集合相关

变量–容器

存取一个元素

数组–容器

一组具有某种特性的数据存放在一起
       存储一组元素（数据类型一致）  长度固定

集合–容器

与数组类似 集合的长度存储之后还能改变
集合用来存储一组元素

Collection

存的都是value

List

有序可重复

Set

无序无重复

Map

存储的是以key-value形式存在
key无序无重复  value无序可重复

序：顺序

添加进去的元素 取得元素的顺序一致 注意指的不是集合自己的顺序

重复：两个对象一致

List集合

1.ArrayList 2.LinkList 3.Vector

ArrayList——-底层就是一个数组

所属的包 java.util

如何创建对象

无参数构造方法 带默认参数的都构造方法 带collection参数的构造方法

常用的方法 —小容器

   存 add
   取 get
   删 remove
   改
   个数 size

add(E e) add(int index,E e)
addAll(Collection c); add(int index,Collection c)
clear();将集合内的元素全部清除
boolean = contains(Object);找寻一个给定元素集合中是否拥有
ensureCapacity(int minCapacity);
E = get(int index);
int = indexOf(Object obj); lastindexOf();
isEmpty();
iterator;//迭代器 1.5之后增强for
removeAll 差集 retainAll()交集
addAll()并集
E = set(int index,E value)
int size();
List = subList(int index,E value)
toArray();集合变成数组
toArray(T[]);
trimToSize();//变成有效元素个数那么长

arryList底层是一个Object[]

什么类型都可以存进去
取出来的时候多态效果 需要自己造型 显得用起来非常麻烦

JDK1.5之后—->泛型

用来规定数据类型的,定义的时候用一个符号代替某种类型
在使用的时候具体的数据类型 将定义的那个符号替换掉
ArrayBox<T>

泛型可以用在哪里？

泛型类

类定义的时候描述某种数据类型 集合就是这样使用

泛型接口

与泛型类的使用基本一致 子类实现接口时必须添加泛型
public interface Text<X>{
     public X value;
}
public class Son<X>implements Test<X>

泛型方法

方法调用时传参数 方法的泛型与类无关 带有泛型的方法可以不放在带有泛型的类中

正则表达式 regex

Regualar有规律的   Expression表达式
匹配字符串格式的

正则表达式通常的作用如下

字符串格式的校验

String类中提供的方法 boolean = str.match("regex");

字符串的拆分及替换

String类中提供的方法 replace split

字符串的查找

pattern模式 Matcher匹配器
[abc]       abc中的一个
[^abc]      不能是abc中的一个 其他都可以
[a-zA-Z]     表示必须是这两个范围内的
[a-z&&[^bc]]  表示a-z其中的一个但不能是b和c
.代表任意一个字符
\d digit [0-9]
\D 非数字[^0-9]
\S 非留白
\w word单词 [0-9A-Za-z]数字或字母都可以

所有字符串中寻找如下规则的信息 邮政编码

String str = "123456abc123456abc123456abc"

//1.利用pattern模式创建一个模式 理解为一个正则表达式对象
Pattern pattern = Pattern.compile（"\\d{6}"）;//邮编
//2.需要提供一个字符串
//3.利用pattern模式对象创建一个匹配器
Matcher matcher = pattern.matcher(str);
//4.找寻字符串中出现满足上述格式的字串
   while(matcher.find()){
    System.out.println(matcher.group());//找到满足字符串格式的那一串文字

如下所有都用来描述字符出现的次数

？ 0-1次 [0-9]?
*  0-n次 
+  1-n次
{n} 固定n次
{n,}至少出现n次
{m,n}m-n次

StringBuffer/StringBuilder

所属的包

java.lang包

String

Serializable,CharSequence,Comparable
非常特殊的类 可以像常量一样创建对象
String str = "abc";
内存存储 "abc"对象 char[] value
String的不可变特性   private fianl char[] value
频繁的修改内容的时候 性能不是很好

默认继承

obJect 实现接口Serialzable,CharSequence,Appendable
StringBuffer/StringBuilder 没有compare To方法
StringBuffer/StringBuilder 含有一个String没有的方法 append();拼接

特性

可变字符串 char[] value;动态扩容

对象的构建

无参数构造方法
有参数构造方法
//无参数构造方法 构建一个默认长度16个对象空间 char[]
 StringBuilder builder = new StringBuilder();
//利用给定的参数 构建有一个自定义长度空间的对象 char[]
 StringBuilder builder = new StringBuilder(20);
//利用带String参数的构造方法,默认数组字符长度字符串+16个长度
 StringBuilder builder = new StringBuilder("abc");

StringBuilder中的常用方法

最主要的方法 append() 频繁的拼接字符串时候使用此方法 提高性能
capcacity();字符串底层char[]的容量
length();字符串有效元素个数（长度）
char = charAt(int index);
int = codePointAt(int index);
String = substring(int start,[int end]);
        注意需要接收返回值 看见取出来的字符串效果
delete(int start,[int end]);
        String Builder类中独有的方法String类没有
        将Start到end之间的字符串删掉 不用接收返回值就看到效果啦
int = indexOf(String str,[int fromindex]);
int = lastindexof（String str,[int fromIndex]）
        找寻给定的str字符串中第一次出现的索引位置 带重载 则从某一个位置开始找
StringBuilder = deleteCharAt(int Index)
        String类中没有的方法
        将给定inde位置的某一字符串删除
insert(int index,value);
        将给定的value插入在index上
replace(int start，int end，string str);
        将start和end之间的部分替换成str
        builder.replace(2.5,"zzt")
setCharAt(int index,char value);
        将index位置的字符改成给定字符的value
toString()
        将StringBuilder对象 构建成一个string对象 返回
trimToSize()
        将数组无用的容量去掉 变成length长度的数组

知识总结

StringBuilder类不一定需要

是为了避免String频繁拼接修改字符串信息时才使用的 底层是数组是可变的 提高了性能

常用方法

与String类不同独有的方法
append() lnsert() delete() deleteCharAt() reverse()
与String类相同的方法
charAt() codePointAt() indexOf() lastindexOf() replace() 名字相同 用法不一致
不是很常用的方法
ensureCapacity() capacity() SetLength() trimToSize() setCharAt();

String家族笔试中经常考察的知识点

String所属的包 继承关系 实现接口

java.lang包 继承Object 实现接口Serializable,CharSequence,Comparable

String构建方式

常量 构造方法

String对象内存结构

字符串常量区 new堆内存对象
= = equals()区别
"a" +"b"+"c"

String不可不变特性

长度及内容

String类常用的方法—-与StringBuilder的区别

concat(); toUpperCase();

String和StringBuilder区别|String和StringBuffer区别

String不可变字符串
        有一个接口Comparable
        不可变体现在长度及内容
        有一些方法StringBuilder没有 没有concat compareTo toUpperCase
StringBuilder可变字符串
        JDK1.5
        有一个接口Appendable
        可变字符串 没有final修饰 底层可以进行数组扩容
        有一些方法string没有 append() insert() delete() reverse()

StringBuffer和StringBuild的不同

stringBuffer早期版本1.0
StringBuilder后来的版本1.5
方法使用几乎一致
早期版本 线程同步  安全性比较高 执行效率相对较低
后期版本 线程非同步 安全性能比较低 执行效率相对较高

字符串相关

String类—->引用类型 java.lang包

常见的String笔试题

==  equals方法和区别
             ==可以比较基本类型 也可以比较引用类型
             比较基本类型只比较值 比较引用类型比较地址
             equals只能比较引用类型（方法）
             默认比较地址this == obj
             如果想要修改比较规则可以重写equals方法
             通常重写equals方法会伴随重写hashcode方法
String的不可变特性
             长度及内容
String与StringBuffer区别
StringBuffer与StringBuilder区别
String对象的存储
             "abc"----->字符串常量池
             new String（"abc"）--->堆内存

*string中的常用方法

存在哪 java.lang包

没有任何继承关系  实现三个接口Serializable,CharSequence,Comparable

如何构建对象

String str = "abc"; //直接将字符串常量赋值给str （字符串常量池）
String str = new String();//无参函数构造方法创建空的对象
String str = new String("abc");//带参String构造方法创建对象
String str = new String(byte[]);//将数组中的每一个元素转化成对应的char 组合成str
String str = new String(char[]);//将数组中的每一个char元素拼接成最终的String

String的不可变特性

体现在两个地方 长度及内容
长度----->final修饰的数组  数组长度不变 final修饰素组的地址不变
内容----->private修饰的属性 不能再类外访问
在String类中包含一个 数组
private fianl char[] value;//存储String中的每一个字符
fianl最终是不可改变的---->地址不让改变 数组的长度本身不可变
private私有的当前类中---->数组中的内容也不能改变

*4.常用方法

booean = equals(Obj obj);
     //继承自Object类 重写啦 比较两个字符串的字面值是否相等
int = hashCode();
     //继承自object类 重写啦 将当前字符串的每一个char元素拆开 乘以31求和
int = CompareTo(String str);
    //实现Comparable接口 实现啦 按照字典（Unicode编码）索引的顺序比较
String = toString();
    //继承自Object 重写啦 不在输出@hashCode 字符串中的字面值

char = charAt(int index);

返回给定index位置对应的字符
int = codePointAt(int index);
返回给定index位置对应字符的code码

int = length();

返回字符串的长度 （其实就是底层 char[] value属性的长度）
注意：区别数组length是属性 String的length()方法  集合size()方法

.String = concat(String str);

将给定的str拼接在当前String对象的后面
注意：方法执行完毕需要接受返回值 String的不可变特性
      concat方法与 + 拼接性能的问题
      开发中若遇到频繁拼接字符串----->通常使用stringBuilder/stringBuffer

boolean = contains（”s”）;

判断给定的s在字符串中是否存在

statsWith(String prefix）;
   endWith（String suffix）;

判断此字符串是否已XX开头/结尾

byte[] = getBytes();—->getBytes(String charsetName); char[] = toCharArray[];

将当前字符串转化为数组 “我爱你中国”“我”“爱”“你”“中”“国”

int index = indexOf(int/String str,[int fromindex]);

四个方法重载，找寻给定元素在字符串第一次出现的索引位置 若不存在返回-1
lastIndexOf(int/String str,[int fromindex]);
找寻给定元素在字符串最后一次出现的索引位置 若不存在返回-1

boolean = isEmpty();

判断当前字符串是否为空字符串（length是否为0）
注意与null之间的区别

replace(); replaceAll(); replaceFirst();

将给定字符串替换成另一个字符串

String[] = split（String regex, [int limit限度界限]）;

按照正则表达式将原来的字符串拆开
   String str="a-b-c-d";
   String[] value = str.split("-",3);
   for(String v:value){
     System.out.println(v);
   }  

String = substring(int beginIndex),[int endIndex]);

将当前字符串截取一部分
从beginIndex开始至endIndex结束[beginIndex，endIndex)
若endIndex不写 则默认到字符串最后

String = toUpperCase();
String = toLowerCase();

将全部字母转换成大写/小写

String = trim();

去掉字符串前后多余的空格