Java基础--工具类（Collections、Arrays）及其他常用类

时间：2023-02-24 23:16:41

工具类

集合工具类Collections

  1. Collections类中的方法可对集合进行操作，该类中的方法都是静态的，调用该类的方法时，不需要建立Collections对象，直接调用；
  2. Collections类中的常用方法：
方法 功能描述
sort(List< T> list) 根据自然顺序对指定列表排序，用法：参数中传入集合
sort(List< T> list,Comparator< ? super T> c) list-集合;c比较器；按指定比较器c为list排序。
max(Collection< ? extends T> coll) 根据自然顺序排序，返回collection的最大元素；
max(collection< ? extends T>,Comparator< ? super T>com) 根据指定比较器排序，返回Collection的最大元素；
binarySearch(List<>list,T key) 根据二分法搜索指定列表，获取指定对象；list-集合；key-指定对象；
binarySearch(List list,T key,Comparator comp) 二分法搜索指定列表，获取指定对象，list-集合，key-指定对象，comp-指定比较器；
fill(List list,T obj) 使用指定元素替换指定列表中的所有元素；obj-指定元素，list-指定集合
replaceAll(List list,T oldValue,T newVaule) 使用一个新值替换指定列表中的旧值
reverse(List list) 反转指定列表中元素的顺序，反转比较器；
reverseOlder() 返回一个比较器，它强行逆转Comparable接口的对象collection的自然顺序，该方法自身可作为一个比较器传入集合的对象中；
reverseOlder(Comparator< T> comp) 返回一个比较器，它强行逆转了指定比较器的顺序，comp-指定比较器
synchronizedList(List list) 返回由指定集合支持的同步的集合
SynchronizedSet(Set< T> s) 返回由指定集合支持的同步的集合
SynchronizedMap(Map< k,v>m) 返回由指定集合支持的同步的集合
shuffle(List list) 使用默认随机源对指定列表进行置换
shuffle(List list,Random rnd) 使用指定的随机源对指定列表进行置换

集合工具类示例代码：

import java.util.*;
class CollectionsDemo{
public static void main(String[] args) {
        sortDemo();
    }
public static void binarySearchDemo(){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
        Collections.sort(list,new StrLenComparator());
        sop(list);
//int index = Collections.binarySearch(list,"aaaa");
//int index = halfSearch(list,"cc");
        int index = halfSearch2(list,"aaaa",new StrLenComparator());
        sop("index="+index);
    }
public static int halfSearch(List<String> list,String key){
        int max,min,mid;
        max = list.size()-1;
        min = 0;
while(min<=max){
            mid = (max+min)>>1;// /2;
            String str = list.get(mid);
            int num = str.compareTo(key);
if(num>0)
                max = mid -1;
else if(num<0)
                min = mid + 1;
else
return mid;
        }
return -min-1;
    }
public static int halfSearch2(List<String> list,String key,Comparator<String> cmp){
        int max,min,mid;
        max = list.size()-1;
        min = 0;
while(min<=max){
            mid = (max+min)>>1;// /2;
            String str = list.get(mid);
            int num = cmp.compare(str,key);
if(num>0)
                max = mid -1;
else if(num<0)
                min = mid + 1;
else
return mid;
        }
return -min-1;
    }
public static void maxDemo(){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
        Collections.sort(list);
        sop(list);
        String max = Collections.max(list/*,new StrLenComparator()*/);
        sop("max="+max);
    }
public static void sortDemo(){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");  
        sop(list);
//Collections.sort(list);
        Collections.sort(list,new StrLenComparator());
//Collections.swap(list,1,2);
        sop(list);  
    }
public static void sop(Object obj){
        System.out.println(obj);
    }
}
class StrLenComparator implements Comparator<String>{
public int compare(String s1,String s2){
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
    }
}

数组工具类

  1. Arrays：数组工具类用于操作数组的工具类，里面都是静态方法，不用建立对象可直接使用：Arrays.方法名()；的方式调用；
  2. Arrays类中的常用方法
方法 功能描述
binarySearch(int[] a,int key) 使用二分法搜索指定的基本数据类型数组，以获得指定的值，a-数组；key-值
deepEquals(Object[]a1,Object[] a2) 深度比较，如果两数组是深层次相等的，则返回true；
deepHashCode(Object[] a) 返回指定数组的深层内容的哈希值
deepToString(Object[] a) 返回指定数组深层内容的字符串表示形式
equals(int[] a,int[] a1) 如果两个指定的基本数据类型数组相等返回true
fill(int[] a,int[] val) 将指定的基本数据类型值分配给指定数组的所有元素
fill(int[] a,int fromIndex,int toIndex,int val) 将指定的基本数据类型值分配给基本数据类型数组中指定范围的每个元素
hashCode(int[] a) 返回指定数组a的哈希码
sort(int[] a) 对指定的基本数据类型数组按升序排列
sort(int[] a,int fromIndex,int toIndex) 对指定的基本数据类型数组的指定范围按升序排列
toString(int[] a) 返回指定基本数据类型数组内容的字符串表示形式
asList(T… a) 返回一个集合，该方法可以将数组转换成List集合，a-支持列表的数组，将数组转成集合后可使用集合的思想和方法操作数组的元素；（注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的；如果数组中的元素都是引用类型，那么变成集合时，数组中的元素就直接转成集合中的元素，如果数组中元素都是基本数据类型，那么会将数组作为集合中的元素存储）
toArray(T[] a) 返回一个指定类型的数组，该数组中包含collection中所有元素，a-指定数组；1.当指定数组a的长度小于集合的size，则该方法内部会创建一个新的数组，长度为集合的size，当指定类型的数组长度大于集合的size，则不会创建而是使用传递进来的数组，多余的位置为null，所以创建一个集合.size()长度的数组最优；2.集合变数组是为了限定对元素的操作，不需要进行增删；

数组工具类示例代码：

import java.util.*;
class  ArraysDemo{
public static void main(String[] args) {
        String[] arr = {"abc","cc","kkkk"};
//把数组变成list集合有什么好处？
/*
 可以使用集合的思想和方法来操作数组中的元素。
 注意：将数组变成集合，不可以使用集合的增删方法。
 因为数组的长度是固定。
 contains。
 get
 indexOf()
 subList();
 如果你增删。那么会反生UnsupportedOperationException,
 */
        List<String> list = Arrays.asList(arr);
//sop("contains:"+list.contains("cc"));
//list.add("qq");//UnsupportedOperationException,
//sop(list);
//int[] nums = {2,4,5};
        Integer[] nums = {2,4,5};   
        List<Integer> li = Arrays.asList(nums);
/*
 如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
 */
        sop(li);
    }
public static boolean myContains(String[] arr,String key){
for(int x=0;x<arr.length; x++){
if(arr[x].equals(key))
return true;
        }
return false;
    }
public static void sop(Object obj){
        System.out.println(obj);
    }
}
//集合变数组；
import java.util.*;
class  CollectionToArray
{
public static void main(String[] args) 
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        String[] arr = al.toArray(new String[al.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

高级for循环

  1. 格式：
for(数据类型  变量名:被遍历的集合(Collection)或数组)
{
 执行语句；
}
  1. 对集合进行遍历，只能获取集合元素，但是不能对集合进行操作，迭代器除了遍历，还可以进行remove集合中元素的动作，如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作；
  2. 与传动for的区别：高级for有一个局限性，必须有被遍历的目标，建议在遍历数组的时候，还是使用传统for，因为传统for可以定义角标；

示例代码：

import java.util.*;
class ForEachDemo {
    public static void main(String[] args) {    
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        for(String s : al){
            //s = "kk";
            System.out.println(s);
        }
        System.out.println(al);
/*
 Iterator<String> it = al.iterator();
 while(it.hasNext()){
 System.out.println(it.next());
 }
 */
        int[] arr = {3,5,1};
        for(int x=0; x<arr.length; x++){
            System.out.println(arr[x]);
        }
        for(int i : arr){
            System.out.println("i:"+i);
        }
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"a");
        hm.put(2,"b");
        hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
        for(Integer i : keySet){
            System.out.println(i+"::"+hm.get(i));
        }
//      Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
//      for(Map.Entry<Integer,String> me : entrySet)
        for(Map.Entry<Integer,String> me : hm.entrySet()){
            System.out.println(me.getKey()+"------"+me.getValue());
        }
    }
}

可变参数

  1. 概述：可变参数是函数的另一种表现形式，传递的参数个数可变；
  2. 格式：
返回值类型  函数名(参数类型...形式参数)
{
    执行语句；
}
  1. 可变参数其实接收的是一个数组，可以指定实际参数个数；
  2. 可变参数一定要定义在参数列表最后面，因为当传入的参数有多种类型时，会将前面的先匹配完，剩下的参数封装成数组，如果在前面将会出现类型匹配异常；
    例：定义一个函数
public static void show(String str,int... arr)
{
    语句；
}

调用show函数：
show(“hahaha”,2,3,4,5…);该函数在调用时,第一个参数为String类型(只能有一个，因为形式参数String只有一个)匹配给str，后面的2，3,4,5…为int类型自动封装为数组传递给arr，因为arr为可变参数的，所以函数调用传递时int形式参数不固定，传多少就是多少，注：可变参数必须是同一数据类型，有形参类型决定；

静态导入

  1. 当import后边跟static的时候，导入的是某一个类中的所有的静态成员，故：当某一类中的方法都是静态的时候可以使用静态导入该类，那么在调用该类中的方法时就不用再在前面加上“类名.”了；
  2. 静态导入可简化书写；
  3. 静态导入的格式：
    import static java.包名.类名.*；
    例：导入Arrays类中的所有静态成员；
    import static java.util.Arrays.*;
  4. 注意：
    • 当类名重名时，需要指定具体的包名；
    • 当方法重名时，指定具备所属的对象或者类；
      例：toString()方法，所有类中都有，使用时需注明类名或对象；
  5. 常用如：Collections，Arrays，System类都可使用静态导入方式简化书写；

静态导入示例代码：

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
import static  java.lang.System.*;//导入了System类中所有静态成员。
class StaticImport //extends Object{
public static void main(String[] args) {
        out.println("haha");
int[] arr = {3,1,5};
        sort(arr);
int index = binarySearch(arr,1);
        out.println(Arrays.toString(arr));
        System.out.println("Index="+index);
        ArrayList al = new ArrayList();
        al.add(1);
        al.add(3);
        al.add(2);
        out.println(al);
        sort(al);
        out.println(al);
    }
}

其他对象

System类

  1. System类中的方法和属性都是静态的；
    • out：标准输出，默认是控制台；
    • in：标准输入，默认是键盘；
  2. System类中一些常用方法：
方法 功能描述
getProperties() 获取系统属性信息，返回一个Properties类型的集合，Properties是Hashtable的子类，故可以通过Map的方法对其操作，该集合中都是字符串，没有泛型定义
getProperty(String key) 获取指定键指示的系统属性，没有返回null
setProperty(String key,String value) 设置系统属性（自定义）
currentTimeMillis() 返回以毫秒为单位的当前时间
exit(int status) 退出JVM虚拟机，status退出状态
gc() 运行垃圾回收器

3. JVM启动时可动态加载一些属性信息：
格式：java -D属性名称=属性值 类文件；

示例代码：

import java.util.*;
class SystemDemo {
public static void main(String[] args) {
        Properties prop = System.getProperties();   
//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
//那么可以通过map的方法取出该集合中的元素。
//该集合中存储都是字符串。没有泛型定义。 
//如何在系统中自定义一些特有信息呢？
        System.setProperty("mykey","myvalue");
//获取指定属性信息。
        String value = System.getProperty("os.name");
        System.out.println("value="+value);
//可不可以在jvm启动时，动态加载一些属性信息呢？
        String v = System.getProperty("haha");
        System.out.println("v="+v);
/*//获取所有属性信息。
 for(Object obj : prop.keySet())
 {
 String value = (String)prop.get(obj);

 System.out.println(obj+"::"+value);
 }
 */
    }
}

Runtime类

1.Runtime类没有提供构造函数(构造函数被私有化)，不能创建对象，每个Java程序都有一个Runtime类实例，可通过getRuntime()方法获取：
static Runtime getRuntime()；//该方法返回本类对象；要想使用该类中的方法，可先调用该方法，获取对象；
2. 常用方法：

  • exec(String command)在单独的进程中执行指定的字符串命令，该方法可启动pc中的应用程序，command-程序名；
    • exec方法返回一个类型为Process的实例，该类有一个方法可以杀掉exec启动的程序，该方法为：
      destory()；杀掉子进程//Process类方法，谁调用杀谁；
  • exce(String command file)可由command程序打开file文件，command为打开程序，file为可由command程序打开的文件；
    例：Runtime r=Runtime.getRuntime()；//返回本类对象；
    Process p=r.exce(“notepad **.txt”)//用记事本打开**.txt文件；
    p.destroy();//杀掉notepad进程；

示例代码：

class  RuntimeDemo{
public static void main(String[] args) throws Exception{
        Runtime r = Runtime.getRuntime();
        Process p = r.exec("notepad.exe SystemDemo.java"); 
//Thread.sleep(4000);
//p.destroy();
    }
}

Date类（时间、日期）

  1. 创建一个Date类对象，打印可显示当前时间，通过SimpleDateFormat类的对象可设置指定格式，调用该父类中的format()方法并将时间对象传递，可按指定的模式格式化时间（将时间模式作为字符串传入SDF的构造函数，不传则为默认格式）；

  2. 设置时间模式定义了模式字母，常用的如：

    字符 字符含义
    y 年
    M 年中的月份
    d 月份中的天数
    E 星期中的天数
    h am/pm中的小时数(1-12)
    H 一天中的小时数(0-23)
    m 小时中的分钟数
    s 分钟的秒数
    S 毫秒数

  3. 模式封装传入的是字符串：

//例：
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E hh：mm：ss");
String time=sdf.format(d);//该format(d)方法调用的是父类DateFormat中的方法，返回String；

示例代码：

import java.util.*;
import java.text.*;
class DateDemo {
public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);//打印的时间看不懂，希望有些格式。
//将模式封装到SimpleDateformat对象中。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");   
//调用format方法让模式格式化指定Date对象。
        String time = sdf.format(d);
        System.out.println("time="+time);
long l = System.currentTimeMillis();
        Date d1 = new Date(l);
        System.out.println("d1:"+d1);
    }
}

注：SimpleDateForat类属Java.text包；该类继承DateFormat（抽象的）也属于Java.text包；

Calendar类

  1. 为操作日历字段提供了一些方法；
  2. 该类常用方法示例：
    • getInstance();以获得此类型的一个通用的对象，该方法返回一个Calendar对象；
      Calendar c=Calendar.getInstance();
      不传参数则使用默认时区和语言环境获得一个日历；
    • get(int field);通过调用该方法返回给定日历字段的值。例：
      c.get(Calendar.MONTH);
    • set(int year,int month,int date)；设置日历字段YEAR.MONTH和DAY_OF_MONTH的值。例：
      c.set(2012,2,23);
    • add(int field,int amount);根据日历的规则，为给定的日历字段添加或减去指定的时间量，例：
      c.add(MONTH,2)//当前月份+2个月；
      c.add(DAY_OF_MONTH,10)//当前日期+10天；
      参数：field-日历字段；amount-偏移量；
      常用字段：
字段 字段含义
YEAR 年
MONTH 月(0-11)
DAY_OF_MONTH 月中的某天
DAY_OF_WEEK 星期中的某天(0-6)
HOUR 时
MINUTE 分
SECOND 秒

示例代码：

class  CalendarDemo2{
public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
//c.set(2012,2,23);
        c.add(Calendar.DAY_OF_MONTH,-18);   
        printCalendar(c);
    }
public static void printCalendar(Calendar c){
        String[] mons = {"一月","二月","三月","四月"
                    ,"五月","六月","七月","八月"
                    ,"九月","十月","十一月","十二月"};
        String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};        
int index = c.get(Calendar.MONTH);
int index1 = c.get(Calendar.DAY_OF_WEEK);
        sop(c.get(Calendar.YEAR)+"年");
//sop((c.get(Calendar.MONTH)+1)+"月");
        sop(mons[index]);
        sop(c.get(Calendar.DAY_OF_MONTH)+"日");
//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
        sop(weeks[index1]);
    }
public static void sop(Object obj){
        System.out.println(obj);
    }
}

Math类

  1. Math类中的包含用于执行基本数学运算的方法（全都是静态方法）；
  2. 常用方法：
方法 功能描述
ceil(double a) 返回大于指定数据的最小整数，类型double
floor(double a) 返回小于指定数据的最大整数，返回类型为double
round(float a) 四舍五入
pow(double a,double b) 返回a的b次幂的值，返回类型double
ranom() 返回一个0~1之间的随机数，返回类型为double 
import java.util.*;
class  MathDemo{
public static void main(String[] args) {        
/*Random r = new Random();
 for(int x=0; x<10; x++){
 //int d = (int)(Math.random()*10+1);
 int d = r.nextInt(10)+1;
 sop(d);
 }*/
        saveTwo(12.3456,3,true);//12.34
    }
public static void saveTwo(double d,int scale,boolean isRound){ 
double base = Math.pow(10,scale);
double num = isRound?Math.round(d*base)/base:((int)(d*base))/base;
        sop("num="+num);
/*
 double d1 = d*100;
 sop("d1="+d1);
 d1 = d1+0.5;
 double d2 = (int)d1;
 sop("d2="+d2);
 double d3 = d2/100;
 sop("d3="+d3);
 */
    }
public static void show(){
double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。
long l = Math.round(12.54);//四舍五入
        sop("d="+d);
        sop("d1="+d1);
        sop("l="+l);
double d2 = Math.pow(2,3);
        sop("d2="+d2);
    }
public static void sop(Object obj){ 
        System.out.println(obj);
    }
}
标签：

相关文章