Java基础（二）

最新推荐文章于 2022-10-12 17:34:39 发布

C_yj223

最新推荐文章于 2022-10-12 17:34:39 发布

阅读量262

点赞数

文章标签：学习记录 Java

本文链接：https://blog.csdn.net/C_yj223/article/details/102638861

版权

三.多线程

Thread Runnable
Thread.start();
Thread.currentThread().getName()
setDaemon(true)
setPriority()
sleep()
yield()
join()
synchronized
wait()
notify()
notifyAll()

3.1 线程的创建

继承Thread类创建多线程

public class Main{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        while(true) {
            System.out.println("main()运行中");
        }
    }
}
class MyThread extends Thread {
    public void run() {
        while(true) {
            System.out.println("MyThread类的run()运行中");
        }
    }
}

实现Runnable接口创建多线程

public class Main{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
        while(true) {
            System.out.println("main()运行中");
        }
    }
}
class MyThread implements Runnable {
    public void run() {
        while (true) {
            System.out.println("MyTread类的run()运行中");
        }
    }
}

线程常用方法

Thread.currentThread()方法可以得到当前线程的实例对象；
线程对象.getName()可以获取线程对象的名称；
构造方法 Thread(Runnable target,String name) 在创建线程对象的同时制定线程的名称；
线程对象.setDaemon(true) 使当前线程变为后台线程（要在start之前使用），如果一个进程中只有后台线程运行，这个进程就会结束。

主线程默认名字"main",用户创建的线程默认名为"Thread-n" (n=0,1,2…)

打印当前线程的名称
System.out.println("这个线程是："+Thread.currentThread().getName());

3.2 线程的生命周期及状态转换

在这里插入图片描述
1.新建状态（New）
2.就绪状态（Runnable）
3.运行状态（Running）
4.阻塞状态（Blocked）
5.死亡状态（Terminated）
一旦进入死亡状态，线程将不再拥有运行的资格，也不能再转换到其他状态。

3.3 线程的调度

Java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称作线程的调度。
计算机中有分时调度模式和抢占式调度模式，Java虚拟机默认采用后者。

线程的优先级
优先级高的线程优先占用CPU，同优先级线程随机选择。线程的优先级用1~10之间的整数来表示还可以使用Thread类中的三个静态常量。
可以通过Thread类的setPriority(int newPriority)方法对其进行设置。

MAX_PRIORITY	MIN_PRIORITY	NORM_PRIORITY
10	1	5

线程休眠
静态方法sleep(long millis)方法可让当前线程休眠 millis 毫秒（该方法声明抛出InterruptedException异常）
结束后回到就绪状态，而不是立即开始运行

当前线程休眠2秒
Thread.sleep(2000);

线程让步
将线程转换为就绪状态

Thread.yield();

线程插队
在某个线程中调用替他线程的join()方法时，调用的线程被阻塞，直至jion()方法加入的线程执行完成后才会继续执行（该方法声明抛出InterruptedException异常）

main线程中{
	Thread t=new Thread();
	t.join();
	此时main线程被阻塞，t线程执行
}

3.4 多线程同步

同步代码块
多个线程使用同一个共享资源时，可以将处理共享资源的代码放在同步代码块中，用synchronized修饰

synchronized(lock){
    操作共享资源代码
}

lock为一个锁对象，默认情况下标志位为1，此时线程执行同步代码块，同时将标志位设为0。当新线程执行到此同步代码块时，由于锁对象的标志位为0，新线程发生阻塞，等待当前线程执行完同步代码块后，锁对象的标志位被置位1.

*锁对象可以是任意类型的对象，但多个线程共享的锁对象必须是唯一的。

public class Main{
    public static void main(String[] args) {
        SaleThread saleThread=new SaleThread();
        new Thread(saleThread,"线程一").start();
        new Thread(saleThread,"线程二").start();
        new Thread(saleThread,"线程三").start();
        new Thread(saleThread,"线程四").start();
    }
}
class SaleThread implements Runnable{
    private int tickets =5;
    Object lock=new Object();		//定义任意一个对象，用作同步代码块的锁
    public void run() {
        while(true){
            synchronized (lock) {	//定义同步代码块
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(tickets>0){
                    System.out.println(Thread.currentThread().getName()+"卖出票"+(tickets--));
                }else {
                    break;
                }
            }
        }
    }
}

同步方法

synchronized 返回值类型 方法名(){}

被synchronized修饰的方法同一时间只允许一个线程访问（同步方法的锁对象是当前调用该方法的对象，也就是this指向的对象）
*Java中静态方法的锁是该方法所在类的class对象，该对象可用“类名.class”获取

死锁问题

3.5 多线程通信

方法声明	功能描述
void wait()	使当前线程放弃同步锁并进入等待，直到其他线程进入此同步锁，调用notify()或notifyAll()唤醒该线程为止
void notify()	唤醒此同步锁上第一个调用wait()的线程
void notifyAll()	唤醒此同步锁上所有调用wait()的线程

这三个方法的调用者都应该是同步锁对象（在同步方法中只能是this），如果调用者不是同步锁对象，Java虚拟机会抛出 IllegalMonitorStateException 异常

四.常用API（应用程序编程接口）

4.1 String类和StringBuffer类

String类（常量，不可更改）
String类的初始化：

String str1="abc";
此字符串创建在常量池中，str1指向常量池中"abc"的地址
再用一个变量赋值"abc"时，两变量指向相同地址

String类构造方法
String()
String(char[] value)
String(String value)

String类的常用方法：

int indexOf(int ch) 				 返回ch字符在此字符串中第一次出现处的索引
int lastIndexOf(int ch) 			 返回ch字符在此字符串中最后一次出现处的索引
char charAt(int index)				 返回字符串中index处的字符
boolean endsWith(String suffix)		 判断此字符串是否以suffix结尾
int length() 						 返回此字符串长度
boolean equals(Object anObject) 	 判断此字符串与anObject是否相同
boolean isEmpty() 				 	 当且仅当字符串长度为0时返回true
boolean startsWith(String prefix)	 判断此字符串是否以prefix开始
boolean contains(CharSequence cs)	 判断此字符串中是否包含指定的字符序列
String toLowerCase() 				 所有字符转换为小写
String toUpperCase()				 所有字符转换为大写
String valueOf(int i)				 返回i的字符串形式
char[] toCharArray() 				 将此字符串装换为字符数组
String replace(CharSequence oldstr,CharSequence newstr)		将字符串中所有的oldstr换为newstr
String[] split(String regex) 		 根据regex将原字符串分割为若干个子字符串
String substring(int beginIndex)	 返回beginIndex后所有字符组成的字符串
String substring(int beginIndex,int endIndex)				返回[beginIndex,endIndex)组成的字符串
String trim() 						 返回去除源字符串收尾空格后的字符串

equals()对父类Object中的方法进行了重写，用来判断字符串内容是否相等。
==用来判断两个字符串对象的地址是否相同。

String[] split(String regex)

public class Main{
    public static void main(String[] args) {
        String[] a="010200300040".split("0");
        for (int i = 0; i < a.length; i++) {
            if(a[i].equals(""))
                System.out.printf("-");
            else
                System.out.printf("%s",a[i]);
        }
    }
}
-12-3--4

StringBuffer类
StringBuffer与String最大的区别在于它的内容和长度都是可变的。
StringBuffer类没有重写equals()方法；String类对象可以用+进行连接，而StringBuffer类对象不能。

StringBuffer类常用方法

StringBuffer append(type c)	将c添加到对象末尾(append有多个重载方法,type可为String,char,int,double等)
StringBuffer insert(int offset,String str)		将str插入到原穿offset处
StringBuffer deleteCharAt(int index)			删除index处字符
StringBuffer delete(int start,int end)			删除[start,end)字符
StringBuffer replace(int start,int end,String s)用s替换[start,end)
void setCharAt(int index,char ch)				修改index处为ch
String toString()								返回StringBuffer缓冲区的字符串
StringBuffer reverse()							将此字符序列反转

4.2 System类与Runtime类

System类

System类常用方法

static void exit(int status)	终止当前正在运行的虚拟机，status代表状态码，若非0，则表示异常终止
static long gc()				运行垃圾回收器
static long currentTimeMillis()	返回以毫秒为单位的当前时间
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
将dest中以destPos开始length长度个字符，覆盖src中以srcPos开始的length个字符
static Properties getProperties()		去的当前的系统属性
static String getProperty(String key)	获取指定键描述的系统属性

Runtime类

Runtime类用于表示虚拟机运行时的状态，用于封装JVM虚拟机进程。采用单例模式。

Runtime run=Runtime.getRuntime(); 获取实例对象

run.availableProcessors();	返回处理器个数
run.freeMemory();			返回空闲内存数量(B)
run.maxMemory();			返回最大可用内存数量(B)

Runtime类提供了一个exec()方法，用于执行一个dos命令，和在命令行窗口中输入命令效果相同。
该方法返回一个Process对象，该对象表示操作系统的一个进程，可以对产生的新进程进行管理。关闭此进程可调用destroy()方法。

4.3 Math类与Random类

Math类

Math.abs(a);		绝对值
Math.ceil(a);		向上取整
Math.floor(a);		向下取整
Math.round(a);		四舍五入
Math.max(a,b);		两者较大值
Math.min(a,b);		两者较小值
Math.random();		生成[0.0,1.0)的随机数
round返回 int     ceil，floor返回 double

Random类

构造方法

Random()			
Random(long seed)	使用seed种子创建随机数生成器

常用方法

boolean nextBoolean()
double nextDouble()		返回0.0和1.0之间的值
float nextFloat()
int nextInt()
int nextInt(int n)		返回[0,n)之间的值
long nextLong()

4.4 包装类

除了 Integer 和 Character 类，其他包装类名称为基本数据类型名称首字母改为大写

装箱：
int a=6;
Integer in = new Integer(a);

拆箱：
int b=in.intValue();

其他常用函数:
valueOf(int i)返回一个表示i的Integer对象
valueOf(String s)返回一个表示s的Integer对象
parseInt(String s)返回s转换成的有符号的十进制整数
这三个函数都是静态函数

包装类都重写了toString()方法，以字符串的形式返回被包装的基本数据类型的值
除了Character外，包装类都有valueOf(String s)静态方法，可以根据String类型的参数创建包装类对象，但s不能为null，切字符串必须可解析为相应的数据类型
除了Character外，包装类都有parseXXX(String s)静态方法，将字符串转换为对应的基本类型的数据。

*JDK5.0 新特性—自动拆箱和装箱（自动进行基本数据类型和包装类对象之间的转换）

4.5 Date类、Calendar类与DateFormat类

针对日期类型的操作类
java.util.Date
java.util.Calendar
java.text.DateFormat

Date类

Date t1=new Date();				创建表示当前时间的Date对象
Date t2=new Date(1111111111);	创建表示时间戳的Date对象

时间戳：1970年1月1日00：00：00（称为历元）以来的毫秒数
2. Calendar类

Calendar是一个抽象类，通过调用静态方法getInstance()得到一个实例对象

Calendar calendar=Calendar.getInstance();
获取表示当前时间的Calendar对象

通过静态方法得到抽象类的实例对象：

public class Main{
    public static void main(String[] args) {
        AA a=AA.getAA();
        System.out.println(a.geti());
    }
}
abstract class AA{
    public static BB getAA() {
        return new BB();
    }
    public abstract int geti();
}
class BB extends AA{
    int i=777;
    public int geti() {
        return i;
    }
}

Calendar的常用方法

int get(int field)						返回指定日历字段的值
void add(int field,int amount)			为指定日历字段增加或减去指定的时间量
void set(int field,int value)			为指定日历字段设置指定值
void set(int year,int month,int date)	设置年、月、日三个字段的值
void set(int year,int month,int date,int hourOfDay,int minute,int second)设置年、月、日、时、分、秒的值

Date getTime()			返回一个表示Calendar时间值的Date对象
void setTime(Date a)	用Date对象的时间来设置Calendar

参数field接收Calendar类中定义的常量值
Calendar.YEAR 	年
Calendar.MONTH	月
Calendar.DATE	日
Calendar.HOUR	时
Calendar.MINUTE	分
Calendar.SECOND	秒

*注：月份的初始值是从0开始

日历字段模式
lenient模式（默认模式）和non-lenient模式。
当Calendar处于lenient模式下时，他的字段值可超过允许范围，调用get方法获取某个字段时，会重新计算所有字段的值。
调用Calendar对象的 setLenient(false) 方法变为non-lenient模式时，超出允许范围会抛出异常。

DateFormat类

用于将日期格式化为字符串或者将用特定格式显示的日期字符串转化为一个Date对象
抽象类，通过静态方法获取实例对象

静态方法获得实例对象
static DateFormat getDateInstance()
static DateFormat getDateInstance(int style)						 日期格式器
static DateFormat getDateTimeInstance()
static DateFormat getDateTimeInstance(int dateSytle,int timeSytle)	 日期/时间格式器

String format(Date date)	将一个Date格式化为日期/时间字符串
Date parse(String source)	将给定字符串解析成一个日期，抛出异常ParseException

在DateFormat中定义了四个常量来表示日期格式器的输出格式
FULL 完整格式
LONG 长格式
MEDIUM 普通格式
SHORT 短格式

public class Main{
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();
        //Date calendar = new Date();
        DateFormat mediumFormat=DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
        System.out.println(mediumFormat.format(calendar.getTime()));
    }
}
2019-10-20 16:08:21

SimpleDateFormat

是DateFormat的子类，在java.text包中

public class Main{
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat df1=new SimpleDateFormat(
                "Gyyyy年MM月dd日：今天是yyyy年的第D天，E");
        System.out.println(df1.format(new Date()));
        SimpleDateFormat df2=new SimpleDateFormat("yyyy/MMM/dd");
        String dt="2012/八月/03";
        System.out.println(df2.parse(dt));
    }
}
公元2019年10月20日：今天是2019年的第293天，星期日
Fri Aug 03 00:00:00 CST 2012

五.集合类

5.1 概述

详细介绍：https://blog.csdn.net/zhangqunshuai/article/details/80660974

储存任意类型的对象，且长度可变，统称为集合。都位于java.util包中
在这里插入图片描述

5.2 Collection接口

方法声明	功能
boolean add(Object o)	向集合中添加一个元素
boolean addAll(Collection c)	将c中的所有元素添加到集合中
void clear()	清空集合
boolean remove(Object o)	删除指定元素
boolean removeAll(Collection c)	删除此集合中包含在c中的元素
boolean isEmpty()	判断是否为空
boolean contains(Object o)	判断是否包含o元素
boolean containsAll(Collection c)	判断是否包含c中所有元素
Iterator iterator()	返回迭代器
int size()	返回元素个数

5.3 List接口

List集合常用方法

方法声明	功能
void add(int index,Object element)	将element插入在LIst集合的index处
boolean addAll(int index,Collection c)	将c所有元素插入到List集合index处
Object get(int index)	返回集合index处的元素
Object remove(int index)	删除index处元素
Object set(int index,Object element)	将index处元素替换为element
int indexOf(Object o)	返回o在集合中出现的位置下标
int lastIndexOf(Object o)	返回o最后出现的位置下标
List subList(int fromIndex,int toIndex)	返回[fromIndex,toIndex)组成的子集合
ListIterator listIterator(int index)	返回反向迭代器，以index为起始位置

ArrayList集合
长度可变的数组，当元素超过数组长度时，ArrayList在内存中重新分配一个更大的数组来存储元素。
*底层用数组保存元素，适用于查找元素
LinkedList集合
双向循环链表，增删元素效率较高

针对增删操作定义的特有方法

方法声明	功能
void add(int index,E element)	在index处插入element
void addFirst(Objcet o)	插入到开头
void addLast(Objcet o)	插入到结尾
Objcet getFirst()	返回首元素
Objcet getLast()	返回尾元素
Object removeFirst()	删除首元素
Object removeLast()	删除尾元素

foreach循环–JDK5.0新特性
用于遍历数组或集合中的元素

for(容器中元素类型 临时变量 : 容器变量) {
	执行语句
}

(1).只能访问，不能修改（foreach中访问元素的变量为临时变量，与实际元素无关）
(2).在用Iterator迭代器进行迭代时，不能调用集合对象的remove()方法删除元素。

如需删除特定一个元素，可使用集合对象的remove()删除元素后break;退出迭代；
或使用迭代器本身的删除方法：迭代器对象.remove()删除next或previous返回的最后一个元素

*5. Iterator接口

集合对象.iterator();得到迭代器对象
hasNext()
next()

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        Iterator<Integer> it=list.iterator();   //通过Collection的iterator()方法得到迭代器对象
        while(it.hasNext()) {                   //判断list集合中是否存在下一个对象
            Object obj = it.next();            //取出元素，并使迭代器指向下一元素
            System.out.println(obj);
        }
    }
}

ListIterator接口
集合对象.listIterator(int index) 得到反向迭代器
void add(Object o)
boolean hasPrevious()
Object previous()
void remove()
*只能用于List集合
Enumeration接口
Vector集合：List接口的一个实现类，用法与ArrayList相同
Vector提供了一个elements()方法返回Enumeration对象（与Iterator类似）
hasMoreElements()
nextElements()

5.4 Set接口

HashSet：根据哈希值确定存储位置，具有良好的存取和查找性能；
TreeSet：以平衡二叉树存储元素，对集合中的元素排序
使用迭代器Iterator遍历

HashSet集合
添加元素时，首先调用该对象的 hashCode() 方法确定存储位置，如果该位置没有元素，则直接将元素存入，如果该位置有元素，则调用对象的 equals() 方法让当前存入的元素依次和该位置上的元素进行比较，如果为true就舍弃该元素，如果返回false则将该元素存入集合。

用HashSet存储自定义类时，要重写该类的hashCode()和equals()方法

class Student{
    private String id;
    private String name;
    public Student(String id,String name){
        this.id=id;
        this.name=name;
    }
    public String toString(){
        return id+":"+name;
    }
    public int hashCode() {
        return id.hashCode();			//返回id哈希值
    }
    public boolean equals(Object obj){
        if(this==obj){					//如果是同一对象，返回true
            return true;
        }
        if(!(obj instanceof Student)){	//如果对象不是Student类型，返回false
            return false;
        }
        Student stu=(Student)obj;
        return this.id.equals(stu.id);	//判断id值是否相同
    }
}

TreeSet集合
自定义类，实现 Comparable<T> 接口的 int compareTo(T o) 方法
自定义比较器类，实现 Comparator<T> 接口的 int compare(T o1, T o2) 方法，在TreeSet的构造方法传入自定义比较器的实例对象

（1）集合中的元素进行比较时，会调用compareTo方法，该方法是Comparable接口中定义的。

class A implements Comparator<T>{
    public int compareTo(T o){}
}
该方法返回值大于0时，this排序靠后
没有使用泛型时，compareTo参数为Object

（2）自定义比较器进行比较

class MyComparator implements Comparator<String> {
    public int compare(String s1,String s2) {
        return s1.length()-s2.length();
    }
}
该方法返回值大于0时，s1排序靠后
在创建TreeSet集合时指定比较器
TreeSet ts=new TreeSet(new MyComparator());

5.5 Map接口

存储键值对，每个元素都包含一个键对象Key和一个值对象Value，键值存在一种对应关系，称为映射。
Map中键唯一，如果存储了相同的键，值会被后存储的值覆盖。

Map集合常用方法

方法声明	功能
void put(Object key,Object value)	向集合中添加键值对
Object get(Object key)	返回key所映射的值；如果不存在key的映射，则返回null
boolean containsKey(Object Key)	判断是否包含key的映射关系
boolean containsValue(Object value)	判断是否有映射到value的映射关系
Set keySet()	返回包含键的Set集合
Collection<V> values()	返回包含值的Collection集合
Set<Map.Entry<K,V>> entrySet()	返回包含映射关系的，Set集合

put，get 用来存取元素；
containsKey，containsValue 用来判断Map中是否包含某个指定的键或值；
keySet，values 用来获取Map中所有的键和值。

Map类的遍历

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("3","A");
        map.put("1","B");
        map.put("2","C");
        //方法一
        Set keySet=map.keySet();			//获取键的集合
        Iterator it1=keySet.iterator();		//迭代键的集合
        while (it1.hasNext()) {
            Object key=it1.next();
            Object value=map.get(key);      //获取键所对应的值
            System.out.println(key+":"+value);
        }
        //方法二
        Set entrySet=map.entrySet();                //获取映射关系的集合
        Iterator it2=entrySet.iterator();
        while (it2.hasNext()) {
            Map.Entry entry=(Map.Entry) itr2.next();//获取集合中键值对映射关系
            Object key=entry.getKey();              //获取Entry中的键
            Object value=entry.getValue();          //获取Entry中的值
            System.out.println(key+":"+value);
        }
        //方法三
        Collection values=map.values();		//获取值的集合
        Iterator it3=values.iterator();
        while (it3.hasNext()) {
        	Object value=it.next();
        	System.out.println(value);
        }
    }
}

Map接口的实现类
HashMap
LinkedHashMap：是HashMap的子类，使用双向链表维护，使Map元素迭代的顺序与存入顺序一致
TreeMap：可用new TreeMap(new MyComparator())传入自定义比较器，通过key排序
Properties：Map接口实现类Hashtable的子类，主要用来存储字符串类型的键和值。

//Properties用法
import java.util.Enumeration;
import java.util.Properties;
public class Main {
    public static void main(String[] args) {
        Properties p=new Properties();
        p.setProperty("name","Npc");	//将键值对添加到集合
        p.setProperty("age","18");
        p.setProperty("type","man");
        Enumeration names=p.propertyNames();			//得到一个包含所有键的Enumeration对象
        while (names.hasMoreElements()) {
            String key=(String) names.nextElement();	//得到键
            String value=p.getProperty(key);			//得到对应键的值
            System.out.println(key+":"+value);
        }
    }
}

5.6 泛型–JDK5.0

在定义集合类时，使用<参数化类型>的方式制定该类中方法操作的数据类型
在定义方法时使用<T>，<>要在返回值前

ArrayList<参数化类型> list = new ArrayList<参数化类型>();
限定了list中只能存储<>中指定类型的数据

public <T> String getType (T x) {
    return x.getClass().getName();
}
范式定义要在返回值前

自定义泛型：

在定义一个类时使用<>声明参数类型，可有多个

class Test <A,B> {
    private A a;
    private B b;
    public void setA(A a) {
        this.a = a;
    }
    public void setB(B b) {
        this.b = b;
    }
    public void show (){
        System.out.println(a+":"+b);
    }
}
public class Main {
    public static void main(String[] args) {
        Test<Integer,String> test = new Test<Integer, String>();
        test.setA(1);
        test.setB("aaa");
        test.show();
    }
}

5.7 Collections工具类

java.util.Collections
操作集合

排序

方法声明	功能
static <T> boolean addAll(Collection<? super T> c, T… elements)	将所有指定元素添加到单列集合c中
static void reverse(List list)	反转list中元素顺序
static void shuffle(List list)	对list中元素进行随机排序（“洗牌”）
static void sort(List list)	根据元素的自然顺序对list排序
static void swap(List list)	将list中i，j处元素交换

import java.util.*;
public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Collections.addAll(list,1,2,3,4);
        System.out.println(list+"排序前");
        Collections.reverse(list);
        System.out.println(list+"反转后");
        Collections.shuffle(list);
        System.out.println(list+"洗牌后");
        Collections.sort(list);
        System.out.println(list+"按自然顺序排序后");
    }
}

查找、替换

方法声明	功能
static int binarySearch(List list,Object key)	二分法查找key在list中的下标，查找的List集合必须有序
static Object max(Collection col)	返回自然顺序的最大元素
static Object min(Collection col)	返回自然顺序的最小元素
static boolean replace All(List list,Object oldVal,Object newVal)	用newVal替换list中所有的oldVal

5.8 Arrays工具类

java.util.Arrays
提供了大量静态方法操作数组

方法声明	功能
void sort(Object[] s)	对s进行排序
int binarySearch(Object[] a,Object key)	返回a中key的下标，若没有则返回负数
<T> T[] copyOfRange(T[] original, int from, int to)	返回包含original数组[from,to)的数组（from>original.length时会出现异常,返回的数组长度为to-from,不足的补默认值）
void fill(Object[] a,Object val)	用val填充数组a
String toString(Object[] arr)	返回指定数组的字符串形式