JAVA基础知识★集合工具类及常用工具类的使用

# Collections
## Collections概述
Collections是对集合框架的一个工具类。并未封装特有数据，里边的方法都是静态的，可以直接用类名调用而不需要创建对象
              
在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等

## Collections和Collection的区别
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

Collections是集合框架中的一个工具类。提供了很多已经封装好的可以对集合进行操作的方法

## Collections常用方法
1、排序

void sort(List<T> list)：根据元素的自然顺序对指定列表进行升序排序

void sort(List<T> list,Comparator<? super T> c)：根据指定比较器对指定列表进行升序排序

2、查找

int binarySearch(List<? extends Comparable<? super T>> list,T key)：二分查找返回key的角标

T max(Collection<? extends T> coll)：根据元素的自然顺序返回集合的最大值

T max(Collection<? extends T> coll,Comparator<? super T> comp)：根据指定比较器的顺序返回集合的最大值

T min(Collection<? extends T> coll)：根据元素的自然顺序返回集合的最小值

T min(Collection<? extends T> coll,Comparator<? super T> comp):根据指定比较器的顺序返回集合的最小值

3、替换

void fill(List<? super T> list,T obj)：将列表的所有元素得值变成obj

boolean replaceAll(List<T> list,T oldVal,T newVal)：用newVal替换集合中的oldVal

void swap(List<?> list,int i,int j)：将集合中i和j角标位置上的元素互换

4、反转

void reverse(List<?> list)：将给定集合反转

Comparator<T> reverseOrder()：返回一个比较器，强行逆转了Comparable接口的子类的对象的自然顺序

Comparator<T> reverseOrder(Comparator<T> cmp)：返回一个比较器，强行逆转指定比较器的顺序

5、返回同步集合

为提高效率，常用的集合都是线程不安全的。如果多线程操作这些集合时，可以通过工具类中的同步方法，将集合转换成安全的集合返回。

List<T> synchronizedList(List<T> list)：返回支持同步（线程安全）的List列表

Map<K,V> synchronizedMap(Map<K,V> m)：返回支持同步（线程安全）的Map列表

## 练习
需求：使用Collections中的方法fill对List集合中的部分元素进行替换
```java
/*
思路：1、将List集合中要替换的部分元素取出,并存入另一集合中
      2、将原集合中的要替换元素移除
      3、用fill将要替换的元素进行替换
      4、将取出的部分增加进集合
*/
import java.util.*;
class  FillTest
{
    public static void main(String[] args) 
    {
        List<String> list = new ArrayList<String>();
 
        list.add("abc");
        list.add("ab");
        list.add("abcd");
        list.add("a");
        list.add("abcde");
 
        try
        {
            fillSome(list,1,5,"shenma");
        }
        catch (InputException e)
        {
            System.out.println(e.toString());
        }
        System.out.println(list);
    }
    //替换部分元素方法
    public static void fillSome(List<String> list,int start,int end,String s)throws InputException
    {
        if(start>=end)
            throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常
 
        //定义一个新集合
        List<String> li=new ArrayList<String>();
 
        //因为每移除一次，后面的元素就会补上，所以这里用y来控制次数
        for (int x=start,y=start;y<end ; y++)
        {
            li.add(list.get(x));//将需要替换的元素增加到新集合
            list.remove(x);//移除需要替换的元素
        }
         
        Collections.fill(li,s);//替换成需要的元素s
         
        list.addAll(start,li);//将替换的部分增加进原集合
    }
 
}
 
//自定义异常
class InputException extends Exception
{
    InputException(String Massage)
    {
        super(Massage);
    }
}
```

# Arrays
## Arrays概述
Arrays是操作数组的一个工具类。并未封装特有数据，里边的方法都是静态的，可以直接用类名调用而不需要创建对象。

## Arrays常用方法
1、数组转换为集合

ListasList(T... a)：将数组转换成固定大小的List集合

注意：

a、将数组转换成集合，不能用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException异常。

b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。

c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

2、查找、替换、排序等方法

binarySearch()：二分查找

fill()：替换方法

sort()：排序方法

toString()：将数组转换成字符串

以上方法根据重载接受不同类型的数组，根据指定参数的类型返回相应要查询的值，具体可查API文档

上述方法示例：
```java
import java.util.*;
class  ArraysDemo
{
    public static void main(String[] args) 
    {
        int[] arr = {2,4,5};
        System.out.println(Arrays.toString(arr));//转换为字符串形式
         
        String[] arr = {"abc","cc","kkkk"};//字符串数组
         
        List<String> list = Arrays.asList(arr);
        sop("contains:"+list.contains("cc"));//判断是否存在"cc"这个元素
 
        Integer[] nums = {2,4,5};
        List<Integer> li = Arrays.asList(nums);
        sop("asList--Integer[]转集合:" + li);  
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```

# System类
## System类概述
1、System是描述系统一些信息的类，类中的属性和方法都是静态的。不能被实例化，没有提供构造函数。
2、字段摘要
out：标准输出流。默认是控制台
in：标准输入流。默认是键盘

## 方法
1、Properties getProperties()：获取系统的属性信息
说明
1）此方法返回值是双列集合，即键值对。因为Properties是Hashtable的子类，那么通过Map方法取出该集合中的元素。
2）该集合存储的都是字符串，没有泛型定义
2、String getProperty(String key)：获取指定键指示的系统属性
3、String setProperty(String key,String value)：设置指定键指示的系统属性，如键不存在，则在系统属性信息中存入该键值对
4、如何在jvm启动时，加载一些属性信息
通过命令：java -D<name>=<value>可以设置特有的系统属性信息
方法示例：
```java
import java.util.*;
class SystemDemo 
{
    public static void main(String[] args) 
    {
        Properties p=System.getProperties();//获取当前的系统属性
        sop(p);
 
        String value=System.getProperty("os.name");//获取指定键指示的系统属性
        sop("os.name="+value);
 
        System.setProperty("wode","My_PC");//设置指定键指示的系统属性信息
        sop(p);
         
        String s= System.getProperty("woshi");//当系统中没有该键值，返回null
        sop(s);
 
    }
 
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```

# Runtime类
## Runtime类概述
1、每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的
2、该类中并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。查阅API文档发现，该类中还有非静态方法。说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型
3、由以上特点可以看出该类使用了单例设计模式完成
## 方法
1、Runtime getRuntime()：获取本类对象
2、Process exec(String command)：在单独的进程中执行指定字符串命令
3、void destroy()：在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束

代码示例
```java
class RuntimeDemo 
{
    public static void main(String[] args)throws Exception
    {
        Runtime r=Runtime.getRuntime();//获取本类对象
 
        Process p=r.exec("notepad.exe");//执行记事本程序
        r.exec("notepad.exe  RuntimeDemo.java");//用记事本打开指定文件
 
        Thread.sleep(3000);//让线程等待3秒
        p.destroy();//杀掉指定进程
    }
}
```

# Date类
## Date类概述
Date类表示特定的瞬间，精确到毫秒。

java中的默认显示格式为英文样式

## 自定义格式
默认的格式不一定满足每个人的需求，那么就需要自定义格式化模式。因为Date类中的大部分方法已过时，所以只能找其子类来实现。子类DateFormat中有format方法可以实现，但是DateFormat是抽象类，不能实例化。但是其下有个SimpleDateFormat子类，可以定义时间模式。

具体步骤：

1）创建Date对象

2）将时间模式封装到SimpleDateFormat对象中

3）调用format方法让格式化模式指定Date对象

代码如下：
```java
import java.util.*;
import java.text.*;
class DateDemo 
{
    public static void main(String[] args) 
    {
        Date d=new Date();//创建Date对象
 
        //将模式封装到SimpleDateformat对象中。
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");
        //调用format方法让模式格式化指定Date对象。
        String time=sdf.format(d);
        sop(time);
    }
 
    public static void sop(Object ojb)
    {
        System.out.println(ojb);
    }
}
```

# Carendar类
## Carendar类概述
1.Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。

2.Calendar可以对年月日等时间进行获取。并提供了相应的子段值。可参阅API文档。

## 方法
基本获取时间
获取年份：Calendar.YEAR

获取月份：Calendar.MONTH

获取日期：Calendar.DAY_OF_MONTH

获取星期：Calendar.DAY_OF_WEEK

获取小时：Calendar.HOUR_OF_DAY

获取分钟：Calendar.MINUTE

获取秒数：Calendar.SECOND

设置时间
void add(int field,int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量

int get(int field)：获取指定的日历字段对应的时间值

void set(int field,int value)：将给定的日历字段设置为给定值

void set(int year,int month,int date)：设置字段年月日的值

代码示例
```java
import java.util.*;
class  CalendarDemo
{
    public static void main(String[] args) 
    {
        Calendar c=Calendar.getInstance();
        sop(pattern(c));//显示今天日期和当前时间       
        c.add(Calendar.YEAR,3);//年份变为3年后
        sop(pattern(c));//显示指定日期和时间
    }
    //获取指定日期和时间
    public static String pattern(Calendar c)
    {
        String s=year(c)+month(c)+day(c)+week(c)+" "+time(c);
        return s;
    }
     
    //获取年份
    public static int year(Calendar c)
    {
        return c.get(Calendar.YEAR);
    }
    //获取月份
    public static String month(Calendar c)
    {
        String[] yue={"一月","二月","三月","四月",
                    "五月","六月","七月","八月",
                    "九月","十月","十一月","十二月"};
        return yue[c.get(Calendar.MONTH)];
    }
    //获取日期
    public static int day(Calendar c)
    {
        return c.get(Calendar.DAY_OF_MONTH);
    }
    //获取星期
    public static String week(Calendar c)
    {
        String[] day={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return day[c.get(Calendar.DAY_OF_WEEK)];
    }
    //获取时间，格式为时：分：秒
    public static String time(Calendar c)
    {
        String s=c.get(Calendar.HOUR_OF_DAY)+":"+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND);
        return s;
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```
## 练习
### 获取任意年的二月有多少天
```java
import java.util.*;
/*
思路：
根据指定年设置一个时间就是 
c.set(year,2,1)//某一年的3月1日。
c.add(Calenar.DAY_OF_MONTH,-1);//3月1日，往前推一天，就是2月最后一天。
*/
class  Test
{
    public static void main(String[] args) 
    {
         
        System.out.println("2012年二月份有"+numOfFeb(2012)+"天");
    }
 
    public static int numOfFeb(int year)
    {
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);
        c.add(Calendar.DAY_OF_MONTH,-1);
        return c.get(Calendar.DAY_OF_MONTH);
    }
}
```
### 获取前一天的现在这个时刻
```java
import java.util.*;
//思路：c.add(Calenar.DAY_OF_MONTH,-1);
class  OtherClassTest
{
    public static void main(String[] args) 
    {
 
        System.out.println("昨天的现在这个时刻："+lastNowTime());
 
    }
    public static String lastNowTime()
    {
        Calendar c=Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH,-1);
        return pattern(c);
    }
}
```

# Math类
## Math类概述
Math 类包含用于执行基本数学运算的方法，该类全为静态方法。

## 方法
abs()：接受整数或者浮点数，返回该数的绝对值

double pow(double a,double b)：返回a的b次方

double ceil(double a)：返回大于参数的最小整数

double floor(double a)：返回小于参数的最大整数

long round(double a)：返回参数的四舍五入值

double random()：返回带正号的 double 值，是一个大于等于0.0且小于1.0的伪随机数

## Random类
这是java.util中的一个单独的类，该类对象用于获取随机数。与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。

如：intnextInt(int n);//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。

练习：给定一个小数，保留该小数的后2位
```java
import java.util.*;
/*
思路：
1、先把给定小数乘以100，四舍五入保留整数部分 
2、再把该整数除以100
*/
class MathTest 
{
    public static void main(String[] args) 
    {
        demo(1.455965);
    }
    public static void demo(Double d)
    {
        d *= 100.0;
        double i  = Math.rint(d);
        i/=100;
        System.out.println(i);
    }
}
```
-separator-