API(持续更新)

曾经终败给现在 2023-10-16 11:31 50阅读 0赞

#### 文章目录 ####

*   *  API
 *  Object类
 *   *  toString
     *  equals
 *  Arrays类
 *   *  equals 方法
     *  binarySearch(二分查找法)
     *  Copyof(数组复制)
     *  sort(排序)
 *  基本数据类型的包装类
 *   *  Integer
     *   *   *  声明
             *  调用非静态方法
             *   *  int compareTo();
                 *  boolean equals();
             *  调用静态方法
             *   *  Integer valueOf
                 *  int compare(int a,int b)
     *  装箱和拆箱
 *  String类
 *   *  字符串创建的两种方式
     *  \*\*构造方法\*\*
     *  \*\*成员方法(常用)\*\*
     *   *  判断功能
         *   *  boolean equals(String str);
             *  boolean equalsIgnoreCase(String str);
             *  \*oolean contains(String str)
             *  \*\*boolean isEmpty()\*\*
         *  获取功能
         *   *  \*\*byte\[\] getBytes()\*\*
             *  char\[\] toCharArray()
             *  int length();
             *  char charAt(int index)
             *  int indexOf(int ch)
             *  int indexOf(String str)
             *  int index(int ch/String str,int fromIndex)
             *  String substring(int start);
             *  String substring(int start,int end);
         *  转化功能
         *   *  byte\[\] getByte();
             *  char\[\] toCharArray();
             *  static String valueOf(char\[\] chs)
             *  String toLowerCase();
             *  String toUpperCase();
             *  String concat(String str);
             *  String\[\] split(分割符)
             *  String replace(char old,char new);
             *  String replace(String old,String new);
             *  String replaceAll(String regex, String replacement);
             *  replaceFirst(String regex, String replacement);
             *  public class StringUtil(自己定义工具类)
 *  Random类
 *   *  构造方法
     *   *  public Random()无参构造
         *  public Random(long seed)无参构造
     *  方法
     *   *  public int nextInt()获取随机整数
         *  public boolean nextBoolean()
         *  public double nextDouble()
         *  public long nextLong()
         *  .....
 *  Date类
 *   *  getYear()
     *  getDay()
     *  getMonth()
     *  getDate()
     *  getTime()
     *  ......
 *  Calendar类
 *   *  get(Calendar.XXX);
     *   *  get(Calendar.Year)
         *  get(Calendar.MONTH)
         *  get(Calendar.DAY\_OF\_MONTH)
         *  get(Calendar.DAY\_OF\_WEEK)
         *  get(Calender.WEEK\_OF\_YEAR)
         *  get(Calender.HOUR\_OF\_DAY)
         *  ......
     *  set(年,月,日)
 *  SimpleDateFormat类
 *   *  Format(Date类型)方法
     *  parse(String 类型)
 *  BigInteger类
 *   *  运算方法add()，subtract()，multiply()，divide()
     *   *  add()
         *  subtract()减法
         *  multiply()乘法
         *  divide()除法
 *  BigDecimal()类
 *  StringBuffer类
 *   *  构造方法
     *   *  public StringBuffer(); 无参构造
         *  public StringBuffer( String ); 有参构造,初始化字符串
         *  public StringBuffer( int );有参构造,初始化缓冲区大小,即底层数组大小
     *  方法
     *   *  public StringBuffer append (String str);
         *  public StringBuffer insert(int i , String str/int i/char/...)
         *  public StringBuffer delete(int start , int end);
         *  public StringBuffer deleteCharAt(int index);
         *  public synchronized StringBuffer replace(int start, int end, String str)
         *  public synchronized StringBuffer reverse()
         *  public synchronized String substring(int start)
         *  public synchronized String substring(int start, int end)
 *  StringBuilder类
 *  StringBuffer与StringBuilder共同点与区别
 *   *  共同点
     *  区别
 *  ArrayList类(对List接口的实现,底层由数组实现)
 *   *  构造方法
     *  方法
     *   *  public boolean add(E e)
         *  public void add(int index , E element)
         *  public boolean remove(Object O)
         *  public E remove( int index)
         *  public boolean contains(Object O)
         *  public E get (int index)
         *  public int indexOf(Object O)
         *  public int lastIndexOf(Object O)
         *  public boolean isEmpty()
         *  public int size()
         *  public void clear()
 *  Vector类(对List接口的实现,底层由数组实现)
 *   *  构造方法
     *  方法
     *   *  public synchronized boolean add(E e)
         *  public synchronized void add(int index , E element)
         *  public synchronized boolean remove(Object O)
         *  public synchronized E remove( int index)
         *  public synchronized boolean contains(Object O)
         *  public synchronized E get (int index)
         *  public synchronized int indexOf(Object O)
         *  public synchronized int lastIndexOf(Object O)
         *  public synchronized boolean isEmpty()
         *  public synchronized int size()
         *  public synchronized void clear()
 *  LInkedList类(对List接口的实现,底层是链表)
 *   *  构造方法
     *  方法
     *   *  public boolean add(E e)
         *  public void add(int index , E element)
         *  public boolean remove(Object O)
         *  public E remove( int index)
         *  public boolean contains(Object O)
         *  public E get (int index)
         *  public int indexOf(Object O)
         *  public int lastIndexOf(Object O)
         *  public boolean isEmpty()
         *  public int size()
         *  public void clear()
         *  public synchronized E remove( int index)
         *  public synchronized boolean contains(Object O)
         *  public synchronized E get (int index)
         *  public synchronized int indexOf(Object O)
         *  public synchronized int lastIndexOf(Object O)
         *  public synchronized boolean isEmpty()
         *  public synchronized int size()
         *  public synchronized void clear()
 *  LInkedList类(对List接口的实现,底层是链表)
 *   *  构造方法
     *  方法
     *   *  public boolean add(E e)
         *  public void add(int index , E element)
         *  public boolean remove(Object O)
         *  public E remove( int index)
         *  public boolean contains(Object O)
         *  public E get (int index)
         *  public int indexOf(Object O)
         *  public int lastIndexOf(Object O)
         *  public boolean isEmpty()
         *  public int size()
         *  public void clear()

### API ###

**常用类:java系统中提供的一些使用频率较高的类**

**API(Application Programming Interface)应用程序接口**

*  java系统中所提供的一系列类和接口

API文档:官方给广大开发者学习者提供对类和接口功能的说明文档

## Object类 ##

java.lang.Object 是java类体系的最顶级,万类之祖

### toString ###

当我们输出一个对象时,会默认调用toString()方法,把对象以字符串形式输出

public class A extends Object{
        
        private String name;
    
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        @Override
        public String toString() {
        //相当于把Object的toString方法重写
            return name;
        }
    }
    class test{
        
        public static void main(String[] args) {
        
            A a=new A();
            a.setName("崔渭阳");
            System.out.println(a);//默认调用toString();方法
        }
    }

类中如果没有toString(),那么父类会调用(Object)中的toString();

public String toString(){
        
    		Object类中的默认输出类的名字和对象在内存中的地址(10进制转化6进制)
    		return get getClass().getName+"@"+Integer.toHexString(hashCode());
    }

### equals ###

**String类中equals()用来比较字符串内容是否相等**

**Object 中equals()用来表示两对象地址是否相等,可以通过方法的重写修改来比较对象中的内容是否相等**

public class A extends Object{
        
        private String name;
        private int age;
    
        public A(String name,int age){
        
            this.name=name;
            this.age=age;
        }
    
        @Override
        public boolean equals(Object obj) {
        
            if(obj==null){
        
                return false;
            }
            if(this==obj){
        
                return true;
            }
            if(obj instanceof A){
        
                A a=(A)obj;
            return this.name.equals(a.name)&&age==age;
            }
            return false;
        }
        class test{
        
        public static void main(String[] args) {
        
            A a=new A("张三",18);
            A b=new A("张三",18);
            System.out.println(a.equals(b));
        }
    }
        结果:ture;

== 用于基本类型代表数值是否相等,在引用类型中代表地址是否相等\*\*

## Arrays类 ##

### equals 方法 ###

**比较两个数组中的元素内容是否相等**

import java.util.Arrays;
    
    public class ArraysEQuals {
        
        public static void main(String[] args) {
        
            int[]a={
        1,2,3,4,5,6};
            int[]b={
        1,2,3,4,5,6};
            System.out.println(a.equals(b));//直接用的是Object类,因为数组也是对象
            System.out.println(Arrays.equals(a,b));//调用Arrays类中的equals,比较两个数组元素内容
        }
    }

### binarySearch(二分查找法) ###

**必须是有序数组，若找到返回脚码(索引)，若没找到返回负数**

import java.util.Arrays;
    
    public class ArraysBinarySearch {
        
    
        public static void main(String[] args) {
        
            int[]a={
        1,2,3,4,5,6,7};//必须有序数组
            int index= Arrays.binarySearch(a,2);
            System.out.println(index);
        }
    
    }
    结果：
    	1

*  也支持区间查找Arrays.binarySearch(数组,起始区间,结束区间,目标元素);//检索范围包含起始，不包含结尾

index=Arrays.binarySearch(a,0,4,2);
            System.out.println(index);
    结果
    	1

### Copyof(数组复制) ###

解决了不能改变数组长度的弊端

**将原来数组内容和新定义的newLength返回个新数组**

public class ArraysCopyof {
        
        public static void main(String[] args) {
        
            int[] a={
        1,2,3,4,5};
            System.out.println(Arrays.toString(a));
            a= Arrays.copyOf(a,20);
            System.out.println(Arrays.toString(a));//自己延长自己
            //Arrays.toString(a);遍历数组
            
        }
    }

### sort(排序) ###

*  对数组(基本数据,引用数据类型)排序 **引用数据排序需要实现**
 *  还可以对数组区间排序(包含起始不包含末端)
 *  还可以定义排序方法
 *  **默认升序排序**

package arraysdemos;
    
    import java.util.Arrays;
    
    public class ArraysSort {
        
        public static void main(String[] args) {
        
            int []a={
        1,2,7,9,9,0,3};
            Arrays.sort(a);
            System.out.println(Arrays.toString(a));
        }
    }
    结果:
    [0, 1, 2, 3, 7, 9, 9]

import java.util.Arrays;
    
    public class ArraysSort {
        
        public static void main(String[] args) {
        
            int []b={
        1,2,7,9,9,0,3};      
            Arrays.sort(b,0,4);
            System.out.println(Arrays.toString(b));
        }
    }
    结果:[1, 2, 7, 9, 9, 0, 3]

**对对象某个属性进行排序**

package arraysdemos;
    
    import java.util.Arrays;
    
    class Student implements Comparable<Student>{
        //需要实现Comparable接口
        private String name;
        private String id;
    
        public Student(String name,String id) {
        
            this.name=name;
            this.id=id;
        }
    
        @Override
        public String toString() {
        
            return this.name+this.id;
        }
    
        @Override
        public int compareTo(Student o) {
        
            return this.id.compareTo(o.id);
        }
    }
    class ArraysSort {
        
        public static void main(String[] args) {
        
            Student [] stu=new Student[4];
            Student people=new Student("张一","1314521");
            stu[0]=people;
            stu[1]=new Student("张二","1314523");
            stu[2]=new Student("张四","1314522");
            stu[3]=new Student("张三","1314524");
            Arrays.sort(stu);
            System.out.println(Arrays.toString(stu));
        }
    }
    结果
    [张一1314521, 张四1314522, 张二1314523, 张三1314524]

## 基本数据类型的包装类 ##

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面  
向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设  
计类时为**每个基本数据类型设计了一个对应的类进表示，这样八个和基  
本数据类型对应的类统称为包装类**

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类(包裹类型)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ｂｙtｅ</td> 
   <td>Ｂｙｔｅ</td> 
  </tr> 
  <tr> 
   <td>ｓｈｏｒｔ</td> 
   <td>Ｓｈｏｒｔ</td> 
  </tr> 
  <tr> 
   <td>ｃｈａｒ</td> 
   <td>Ｃｈａｒａｃｔｅｒ</td> 
  </tr> 
  <tr> 
   <td>ｉｎｔ</td> 
   <td>I ｎｔｅｇｅｒ</td> 
  </tr> 
  <tr> 
   <td>ｌｏｎｇ</td> 
   <td>Ｌｏｎｇ</td> 
  </tr> 
  <tr> 
   <td>ｆｌｏａｔ</td> 
   <td>Ｆｌｏａｔ</td> 
  </tr> 
  <tr> 
   <td>ｄｏｕｂｌｅ</td> 
   <td>Ｄｏｕｂｌｅ</td> 
  </tr> 
  <tr> 
   <td>ｂｏｏｌｅａｎ</td> 
   <td>Ｂｏｏｌｅａｎ</td> 
  </tr> 
 </tbody> 
</table>

### Integer ###

##### 声明 #####

Integer a=new Integer(12);
            Integer b=new Integer(10);

##### 调用非静态方法 #####

###### int compareTo(); ######

###### boolean equals(); ######

//调用非静态方法
            System.out.println(a.compareTo(b));//前面大返回1,后面大返回-1,一样大返回0;
            System.out.println(a.equals(b));//比较a与b内容是否相同 与"=="要区分 返回一个boolean类型
            System.out.println(a==b);//比较a与b是否指向一个内容
            //.....

##### 调用静态方法 #####

###### Integer valueOf ######

###### int compare(int a,int b) ######

//调用静态方法
    		Integer c=Integer.valueOf(12);//调用静态方法,返回一个Integer类型变量给C
            Integer d=Integer.valueOf("10");//调用静态方法,把字符串类型(必须是数字)转换为Integer返回一个Integer类型变量
            System.out.println(Integer.compare(13,10));//前面大返回1,后面大返回-1,一样大返回0;
            System.out.println(Integer.max(13,10));//返回较大的数值
            System.out.println(Integer.valueOf(10));//返回的时引用类型

### 装箱和拆箱 ###

*  装箱:

将基本类型可以自动转换为包装类型

Integer a=10;//默认调用Integer.valueOf(a)把10转化为引用类型即Integer类型

*  拆箱:.

将包装类型转化为基本类型

int c=a.intValue();//拆箱
    int c=a;//自动拆箱

源码: 
    public static Integer valueOf(int i) {
        //low:-128;high:127
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);    
        }

Integer a=10;//默认调用Integer.valueOf(a)
            Integer a=10;
            Integer b=10;
            System.out.println(a.equals(b));//结果为true
    		System.out.println(a==b);//结果也为true
    		Integer c=128;
            Integer d=128;
            System.out.println(c==d);//结果为false
            System.out.println(c.equals(d));//结果为true

**有源代码可知,当在方法内部对 -128~127之间进行缓存(数组),在此期间的自动装箱,不会创建新的Integer对象,直接从中获得,(因为a与b传过去对应i的参数都为10,则返回的是同一个对象地址的引用),而超出此区间的每次都会返回新的对象(所以c和d虽然值相等但是返回的都是一个新的对象地址,所有c==d结果为false)**

## String类 ##

*  java中使用\*\*" "\*\*括起来的,都是String类的实例(对象)
 *  字符串的值是不可以被修改的,一旦字符串对象被创建,值就不能被改变

String s="abc";
    s+="aaa";
    s+="bbb";
    s+="ccc";
    System.out.println(s);//结果为abcaaabbbccc
    //实际上每次的字符串连接都是创建新的对象病赋值给s;s+="aaa"表示abcaaa这个新对象然后赋值给s,依次类推....;

**底层存储字符串内容的是数组,是被final修饰的,必须在创建之初由构造方法对其赋值**

### 字符串创建的两种方式 ###

*  方式1：

String s = "abc";

String s1 = "abc";
    String s2 = "abc";
    在第一此创建s1变量时，会去内(堆内存)中有一个叫字符常量池的空间检索,有没有与内容相同的字符串对象,如果没有就会在字符串常量池中创建一个字符串对象,把对象的地址赋值给s1,在第二次创建s2这个变量时,继续会去字符串常量池去检索,如果有,直接把之前的字符串内容的对象赋值给s2
    System.out.println(s1==s2);//结果为true

*  方法2：

String s1 = new String("abc");
    String s2 = new String("abc");
    这种方法每次都会创建新的字符串对象
    System.out.println(s1==s2);//结果为false

### **构造方法** ###

*  无参构造:

String s1=new String();//无参构造,相当于this.value = "".value;
    //        public String() {
        
    //            this.value = "".value;
    //        }源码

*  有参构造

String s2=new String("abc123");//有参构造

### **成员方法(常用)** ###

#### 判断功能 ####

##### boolean equals(String str); #####

*  判断俩个字符串内容是否相等

String s4="abcd";
            System.out.println(s4.equals("abcD"));//false

##### boolean equalsIgnoreCase(String str); #####

*  判断两个字符串内容是否相等**不区分大小写**

System.out.println(s4.equalsIgnoreCase("ABcD"));//true

##### \*oolean contains(String str) #####

*  判断str是否为子串(**字符串必须连续**)

System.out.println(s4.contains("ab"));//true
    		System.out.println(s4.contains("ad"));//false

##### **boolean isEmpty()** #####

*  判断字符串是否为空字符串
    
    **注:“”–>指空字符串,而null–>指的是空地址并不能进行使用,否则会报错**

String s5="";
    		System.out.println(s4.isEmpty());//true

#### 获取功能 ####

##### **byte\[\] getBytes()** #####

*  //将字符串转化为编码,存在byte数组中并返回数组首地址

String s2=new String("abc123");//有参构造
            //把字符串处理为编码返回给byte数组;
            byte []bytes=s2.getBytes();
            System.out.println(Arrays.toString(bytes));
    结果:[97, 98, 99, 49, 50, 51]

**当然也可以通过有参构造方法将byte数组的编码转化为字符串new String(byte\[\]);**

//把编码转化为字符串可以使用 new String(byte[]);
            s2=new String(bytes);

##### char\[\] toCharArray() #####

*  将字符串转化为字符数组,并把字符数组的首地址返回

String s3=new String("qwertyuiopasdfghjklzxcvbnm");
            //toCharArray()方法可以将字符串转化为字符数组
            char[] chars=s3.toCharArray();

**当然也可以通过有参构造的方法将字符数组转化为字符串**

Arrays.sort(chars);//这里对字符数组进行了排序处理
            //new String(char[]);
            s3=new String(chars);
            System.out.println(s3);
    结果:abcdefghijklmnopqrstuvwxyz

String s="abcdefg";

先定义一个字符串

##### int length(); #####

*  获取字符串长度

System.out.println(s.length());//结果为7

##### char charAt(int index) #####

*  获取index位置上的字符

System.out.println(s.charAt(2));//结果为c

**在java没有输入字符的方法,我们可以节约这个方法来实现字符的输入**

Scanner in=new Scanner(System.in);
    String str= in.next;
    char c=str.charAt(0);//读取字符串第一个

##### int indexOf(int ch) #####

*  查找ch字符,如果查到返回索引,如果未查到,返回一个负数

System.out.println(s.indexOf('a'));//结果为0

##### int indexOf(String str) #####

*  查找str字符串,如果查到返回首字母的索引,如果未查到返回一个负数

System.out.println(s.indexOf("cd"));//结果为2

##### int index(int ch/String str,int fromIndex) #####

*  查找字符ch或字符串str,从fromIndex位置开始查找,返回

System.out.println(s.indexOf("ef", s.indexOf('e')));//结果为4

##### String substring(int start); #####

*  表示从start处截取字符串,将这个新的字符串地址作为返回值

System.out.println(s.substring(2));//结果edefg

##### String substring(int start,int end); #####

*  表示从start开始,end结束之间的截取,不包括结尾

System.out.println(s.substring(0,2));//结果ab

#### 转化功能 ####

##### byte\[\] getByte(); #####

*  把字符串返回成编码数组//

##### char\[\] toCharArray(); #####

*  把字符串返回成字符数组,返回新的字符串,不改变原来字符串

String s5="abcdef";
            char[] chars1=s5.toCharArray();

##### static String valueOf(char\[\] chs) #####

*  把字符数组转化为字符串类型返回的是字符串首地址

String strings= String.valueOf(chars1);//把字符数组转化为字符串类
            System.out.println(strings);//结果为abcdef

##### String toLowerCase(); #####

*  把字符串改为小写,返回新的字符串,不改变原来字符串

String s6="ABCD";
    System.out.println(s6.toLowerCase());//结果:abcd

##### String toUpperCase(); #####

*  把字符串改为大写,返回新的字符串,不改变原来字符串

String s7="abcd"
    System.out.println(s7.toUpperCase());//结果ABCD

##### String concat(String str); #####

*  把字符串str连接到对象字符串,返回新的字符串,不改变原来字符串

String s8="abc";
    System.out.println(s8.concat("def"));//结果abcdef

##### String\[\] split(分割符) #####

*  (分割符)

String s9="ab;cd;efg";
     String []strings1 =s9.split(";");
     System.out.println(Arrays.toString(strings1));//结果[ab,cd,efg]

##### String replace(char old,char new); #####

*  old字符被new字符替换,返回新的字符串,不改变原来字符串

String s10="abcDEF";
    System.out.println(s10.replace('a', 'A'));
    System.out.println(s10);//结果:AbcDEF;

##### String replace(String old,String new); #####

*  old字符串被new字符串替换,返回新的字符串,不改变原来字符串

System.out.println(s10.replace("ab", "AB"));//若无法匹配到目标字符串则不会替换

##### String replaceAll(String regex, String replacement); #####

*  基本功能类似于String replace(String old,String new);

##### replaceFirst(String regex, String replacement); #####

*  替换第一个目标字符串

##### public class StringUtil(自己定义工具类) #####

通过自己编写方法,便于后续使用

## Random类 ##

### 构造方法 ###

#### public Random()无参构造 ####

Random r =new Random();

#### public Random(long seed)无参构造 ####

Random r1 = new Random(1l);

### 方法 ###

#### public int nextInt()获取随机整数 ####

int num1 = r.nextInt();
    //可以使用取余方式来获得想要的随机数

#### public boolean nextBoolean() ####

#### public double nextDouble() ####

#### public long nextLong() ####

**用法与上面类似**

#### … ####

## Date类 ##

*  **Date类**
 *  使用Date类代表当前系统时间
 *      Date d = new Date();
        Date d = new Date(long d);

### getYear() ###

**获取从1900年到今天的年数**

*  如果要显示年份可以
    
        date.getYear()+1900

### getDay() ###

**星期从0开始,周日为0**

*      date.getDay();

### getMonth() ###

**月份,从0开始**

*      date.getMonth();

### getDate() ###

**日期 一月中的几号**

*      date.getDate();

### getTime() ###

**返回毫秒值,获取的是 1970 1.1 00:00:00起的时间差**

*      date.getTime();

也可以使用Date的有参构造,将一个毫秒的时间封装成一个对象,Date会自动将毫秒转化为时间

*      Date d = new Date(1694588952086L);//注意里面必须是long类型
        
        //Wed Sep 13 15:09:12 CST 2023

### … ###

## Calendar类 ##

*  **Calendar类**
 *  是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用**getInstance**方法创建即可
 *      Calendar c1 = Calendar.getInstance();
        Calendar c1 = new GregorianCalendar();

### get(Calendar.XXX); ###

#### get(Calendar.Year) ####

*  获取年份

#### get(Calendar.MONTH) ####

*  获取月份
 *  **切记月份是从0开始的**

#### get(Calendar.DAY\_OF\_MONTH) ####

*  获取今天是月份的第几天

#### get(Calendar.DAY\_OF\_WEEK) ####

*  获取今天是一周的第几天
 *  **切记1是周日,从周日开始算**

#### get(Calender.WEEK\_OF\_YEAR) ####

*  获取这周是今年的第几周(注意:国外是从星期日开始的)

#### get(Calender.HOUR\_OF\_DAY) ####

*  此时是今天的第几个小时

#### … ####

### set(年,月,日) ###

*  设置日期,改变get获得的日期

## SimpleDateFormat类 ##

### Format(Date类型)方法 ###

*  **日期格式化**
 *      SimpleDateFormat sdf = new SimpleDateFormat("制定格式")
            
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月");
 *  **调用format方法格式化上面格式日期**
 *      System.out.println(sdf.(date));//结果是四位数字的年,两位数字的月份
        
        2023年09月
    
    )

### parse(String 类型) ###

*  **把字符串日期转化为Date类型**
 *      String str = "2004-07-10";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        Date date2 = sdf2.parse(str);
        System.out.println(date2);
        
        结果:
        Sat Jul 10 00:00:00 CST 2004

## BigInteger类 ##

*  **BigInteger 支持任意精度的整数,可以准确的表达任何大小的整数而不丢失精准度**
 *  BigInteger 位于 java.math包中
 *  **BigInteger()括号里必须是字符串**
 *      BigInteger a = new BigInteger("8888888888888888");
        BigInteger b = new BigInteger("9999999999999999");

### 运算方法add()，subtract()，multiply()，divide() ###

*  **注意:divide方法里默认无限小数会报错,所以必须使用divide方法规定小数位数**

#### add() ####

a.add(b);

#### subtract()减法 ####

a.subtract(b);

#### multiply()乘法 ####

a.multiply(b);

#### divide()除法 ####

a.divide(b,3,BigDecimal.ROUND_DOWN);
    
    取三位小数,第三个是取整方式

## BigDecimal()类 ##

*  **由于Double类型运算有精度损失,所以需要使用BigDecimal类来运算,BigDecimal类运算浮点不会有精度损失,但必须传入String类型**
 *  **运算方法与BigInteger一样**

## StringBuffer类 ##

*  **由于String类型创建字符串每次改变后都会创建新的对象,旧的对象地址不会及时的被Java垃圾回收机制回收,造成内存的浪费**
 *  \*\*所以我们可以引用StringBuffer类来处理字符串,StringBuffer类 带缓冲区,弥补了String不可改变字符串的缺点,char\[\] value是StringBuffer类中的数组,默认16长度,装满16元素后会进行数组扩容(数组长度\*2+2) \*\*

### 构造方法 ###

#### public StringBuffer(); 无参构造 ####

#### public StringBuffer( String ); 有参构造,初始化字符串 ####

#### public StringBuffer( int );有参构造,初始化缓冲区大小,即底层数组大小 ####

### 方法 ###

StringBuffer stringBuffer = new StringBuffer();//无参构造
    StringBuffer stringBuffer1 = new StringBuffer("abc");//有参构造
    StringBuffer stringBuffer2 = new StringBuffer(123);//有参构造指定数组长度

#### public StringBuffer append (String str); ####

stringBuffer.append("abc");
    //结果:拼接字符串 相当于String中的'+';

#### public StringBuffer insert(int i , String str/int i/char/…) ####

stringBuffer.insert(1,"123");
    //从指定位置,插入字符串/整数/字符...

#### public StringBuffer delete(int start , int end); ####

stringBuffer.delete(1, 3);
    //删除指定片段,包含开始位置,不包含结束位置

#### public StringBuffer deleteCharAt(int index); ####

stringBuffer.deleteCharAt(0);
    //删除指定位置;

#### public synchronized StringBuffer replace(int start, int end, String str) ####

stringBuffer.replace(0,stringBuffer.length(), "123");
    //替换指定区域字符串;

#### public synchronized StringBuffer reverse() ####

stringBuffer.reverse();
    //翻转字符串

#### public synchronized String substring(int start) ####

String str1 = stringBuffer.substring(1);
     //从某一位置开始截取字符串,返回String类型,注意:不会改变原来类里面的字符串

#### public synchronized String substring(int start, int end) ####

String str2 = stringBuffer.substring(1,2)
    //截取某一区域的字符串,不包含结束位置,返回值为String,不会改变原来的字符串

## StringBuilder类 ##

**方法与StringBuffer类似,区别是StringBuffer的方法被synchronized修饰,而StringBuilder方法没有被修饰**

## StringBuffer与StringBuilder共同点与区别 ##

### 共同点 ###

*  **字符串是可以改变的,不会创建对象,变的只是底层的数组在改变**

### 区别 ###

*  **由于StringBuffer的方法是被synchronized修饰的,表示一次只允许一个请求进入方法,适合多线程场景**
 *  **StringBuilder 不是加锁的(即它的方法不被synchronized修饰),一次可以允许多个请求进入方法适合单用户操作**

## ArrayList类(对List接口的实现,底层由数组实现) ##

### 构造方法 ###

ArrayList arrayList = new ArrayList();//默认为Object类,可以存储任意类型
    
    //ArrayList<E>  E为泛型
    ArrayList<String> stringArrayList = new ArrayList<>();//定义String类型
    ArrayList<Integer> integerArrayList = new ArrayList<>();//定义Integer类型集合

### 方法 ###

#### public boolean add(E e) ####

integerArrayList.add(10);//自动装箱,10自动转为Integer类型,自动添加内容
    		stringArrayList.add("0");
            stringArrayList.add("1");
            stringArrayList.add("2");
            stringArrayList.add("3");
            stringArrayList.add("4");
    
    返回值为boolean类型,添加成功-true 失败-false

#### public void add(int index , E element) ####

stringArrayList.add(1,"0");
    //在指定位置Index插入数据,不能对没有使用的位置进行插入操作(从0到size(集合元素个数))

#### public boolean remove(Object O) ####

stringArrayList.remove("1");
    //删除指定元素,并自动进行排序,返回值为boolean类型,如果匹配到对应元素删除成功返回-true 找不到-false

#### public E remove( int index) ####

stringArrayList.remove(1);
    //删除指定位置(index)元素并返回该元素,并对剩余元素进行排序,并返回该元素

#### public boolean contains(Object O) ####

boolean b = stringArrayList.contains("1");
    //判断是否包含该元素,返回boolean类型数据

#### public E get (int index) ####

stringArrayList.get(2);
    //获取指定位置上的元素

#### public int indexOf(Object O) ####

stringArrayList.indexOf("1");
    //查找指定位置元素,并返回该元素位置
    //查找方式:从头查找

#### public int lastIndexOf(Object O) ####

stringArrayList.lastIndexOf("1");
    //查找指定位置元素,并返回该元素位置
    //查找方式:从末尾开始查找

#### public boolean isEmpty() ####

stringArrayList.isEmpty();
    //判断该集合是否为空,, 是-true 否-false

#### public int size() ####

stringArrayList.size();
    //返回集合元素个数(即长度)

#### public void clear() ####

stringArrayList.clear();
    //清空元素个数

## Vector类(对List接口的实现,底层由数组实现) ##

### 构造方法 ###

Vector<Integer> vector = new Vector<>();

### 方法 ###

#### public synchronized boolean add(E e) ####

#### public synchronized void add(int index , E element) ####

#### public synchronized boolean remove(Object O) ####

#### public synchronized E remove( int index) ####

#### public synchronized boolean contains(Object O) ####

#### public synchronized E get (int index) ####

#### public synchronized int indexOf(Object O) ####

#### public synchronized int lastIndexOf(Object O) ####

#### public synchronized boolean isEmpty() ####

#### public synchronized int size() ####

#### public synchronized void clear() ####

**用法和ArrayList类方法一样,区别是,Vector类方法被synchronized关键字修饰,当多线程运行时,只允许一个请求调用方法,相比ArrayList是安全的**

## LInkedList类(对List接口的实现,底层是链表) ##

### 构造方法 ###

//1.
    LinkedList linkedList = new LinkedList();//可以存储任意类型
    
    //2.
    LInkedList<String(可以是任意类型)> stringLinkedList = new LinkedList<>();
    //可以存储<>里对应的类型

### 方法 ###

#### public boolean add(E e) ####

#### public void add(int index , E element) ####

#### public boolean remove(Object O) ####

#### public E remove( int index) ####

#### public boolean contains(Object O) ####

#### public E get (int index) ####

#### public int indexOf(Object O) ####

#### public int lastIndexOf(Object O) ####

#### public boolean isEmpty() ####

#### public int size() ####

#### public void clear() ####