黑马程序员——java学习10（毕17）——工具类

1、字符串排序

考虑一个空格和多个空格的限定

转化时记得对象间比较实用compareTo

package learn;

import java.util.Arrays;

/*对一个字符串进行从小到大排序
 * 20 78 9 -7 88 36 29
 * 思路
 * 1、排序，多用int
 * 2、如何获取到这个字符串中的这些需要排序的数值？
 * 发现这个字符串中其实都是空格来对数值进行分隔的
 * 所以就想到用字符串对象的切割方法将大串变成多个小串
 * 3、数值最终变成小字符串，怎么变成一个int数
 * 字符串到基本类型可以使用包装类
 * 
 * */
public class WrapperDemo {
    private static final String SPACE_SEPARATER = " ";
    public static void main(String[] args) {
//        int num = 4;
//        num=num+5;
//        Integer i =4;//new Integeger(4)自动装箱 简化书写
//        i=i+6;
        String numStr="20 78 9 -7 88 36 29";
        System.out.println(numStr);
        numStr=sortStringNumber(numStr);
        System.out.println(numStr);
    }
    //用方法将步骤与主函数分开
    public static String sortStringNumber(String numStr)
    {
        //1、将字符串变成字符串数组
//        String [] str_arr = numStr.split(" ");
        String[] str_arr = stringToArray(numStr);
        
        //2、将字符串数组变成int数组
        int[] num_arr = toIntArray(str_arr);
        
        
        //3、对int数组排序
        mySortArray(num_arr);
        
        //4、将排序后的int数组变成字符串
        String temp = arrayToString(num_arr);
        
        return temp;
    }
    //1
    public static String[] stringToArray(String numStr) {
        //按照一个空格来吧一个字符串划分成一个个字符串，装入数组str_arr中
        String [] str_arr = numStr.split(SPACE_SEPARATER);
        return str_arr;
    }
    //2
    private static int[] toIntArray(String[] str_arr) {
        //字符串数组与整型数组差距就是数据内容，长度一致，所以先给出长度
        //如果直接int[] = String[]的话只是地址间的传递
        int[] arr = new int[str_arr.length];
        for(int i=0;i<arr.length; i++)
        {
            //核心：通过parseInt将字符串转换成整型
            arr[i] = Integer.parseInt(str_arr[i]);
        }
        return arr;
    }
    //3
    private static void mySortArray(int[] num_arr) {
        //排序sort
        Arrays.sort(num_arr);
    }
    //4
    private static String arrayToString(int[] num_arr) {
        //结果要的是字符串，所以再转成字符串
        //调用StringBuilder类的append方法，把一个个数组内容输入，再调用toString方法返回字符串
        StringBuilder sb = new StringBuilder();
        for(int x = 0; x<num_arr.length; x++)
        {
            if(x!=num_arr.length-1)
                sb.append(num_arr[x]+SPACE_SEPARATER);
            else
                sb.append(num_arr[x]);            
        }
        return sb.toString();
    }
}

 运行结果

2、集合框架的工具类

2.1、sort,max,binarySearch

static<T> void sort(List<T>list) 根据指定比较器产生的顺序对指定列表进行排序

static<T> max(Collection<?extends T>coll,Comparator<?super T>comp)根据指定比较器缠身过的顺序获取最大元素

static<T> int binarySearch(List<? extends comparator <? super T>>list, T key,)二分法查找指定对象

可以通过改写比较器方法写出指定比较规则

package learn;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * 集合框架的工具类
 * 对象比大小，不是compareTo就是compare
 * Collections: 
 * */

public class CollectionDemo {
    public static void main(String[] args) {
//        sortDemo();
//        maxDemo();
        binarySearchDemo();
    }
    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");
        Collections.sort(list);
        
        sop(list);
        
//        int index = Collections.binarySearch(list,"aaaa");
        int index = halfSearch(list,"aaaa");
        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);
            //compareTo比较两个对象
            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 void maxDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        Collections.sort(list);
        sop(list);
        //max方法
        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");
        sop(list);
        
//        Collections.sort(list);
        //sort方法的，根据制定比较器，将list集合排序
        Collections.sort(list, new StrLenComparator());
        sop(list);
    }
    //输出方法简写
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

//比较器
class StrLenComparator implements Comparator<String>
{
    //重写compare方法，定义自己的规则
    public int compare(String s1,String s2)
    {
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;
        //调用lang包里Comparable接口的compareTo方法，与compare类似，操作对象为对象
        return s1.compareTo(s2);
    }
}

 运行结果

2.2、fill, replaceAll, reverseOrder

static<T> void fill(List<?super T> list ,T obj)  用指定元素替换指定列表中的所有元素

static<T> boolean replaceAll(List<T>list, T oldVal, T newVal) 使用另一个值，替换列表中所有某一指定值

static<T> Comparator<T>reverseOrder() 返回一个比较器，它强行逆转实现了comparable接口对象的自然顺序

注意reverse可以在不用重写方法的情况下实现反比较器规则

package learn;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

//定义比较器类
class StrComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        
//        int num = s1.compareTo(s2);
//        if(num>0)
//            return -1;
//        if(num<0)
//            return 1;
//        return num;    
        return s2.compareTo(s1);
    }
}

public class CollectionsDemo2 {
    public static void main(String[] args) {
        orderDemo();
    }
    public static void orderDemo()
    {
        //将比较器里的规则倒叙，再调用
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
        ts.add("abcde");
        ts.add("aaa");
        ts.add("kkk");
        ts.add("ccc");
        //迭代器
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    
    //替换指定
    public static void replaceAllDemo()
    {        
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        sop(list);
        //替换
        Collections.replaceAll(list, "aaa", "pp");
        sop(list);
        //反转，头和尾交换
        Collections.reverse(list);
        sop(list);    
    }
    /*
     * fill方法可以将list集合中的所有元素替换成制定元素
     * 将list集合中部分元素替换成指定元素
     * */
    //替换全部
    public static void fillDemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        Collections.sort(list);
        sop(list);
        //将集合中的元素全部替换成pp
        Collections.fill(list, "pp");
        sop(list);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

 运行结果

2.3、数组变集合 asList

java.util.Arrays

static<T>List<T> asList(T...a)返回一个受指定数组支持的固定大小的数组

注意基本数据类型的数组变集合时，数组作为集合中的一个元素存在。

package learn;

import java.util.Arrays;
import java.util.List;

/*
 * Arrays: 用于操作数组的工具类
 * 里面都是静态方法
 * 
 * asList: 将数组变成List集合
 * */
public class ArraysDemo {
    public static void main(String[] args) {
//        int []arr = {2,4,5};
//        System.out.println(Arrays.toString(arr));
        
        //如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
        String [] arr = {"abc", "cc", "kkk"};
        //把数组变成集合的好处
        /*
         * 可以使用集合的思想和方法来操作数组中的元素
         * 数组变成集合，不可以使用集合的增删方法
24          * */
        List<String> list = Arrays.asList(arr);
        System.out.println("contains:"+list.contains("cc"));
//        list.add("qq");//UnsupportedOperationException不支持操作异常
        System.out.println(list);
        //如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
//        int [] nums = {2,4,5};
//        List/*<int []>*/ li = Arrays.asList(nums);
        
        Integer [] nums = {2,4,5};
        List<Integer> li = Arrays.asList(nums);
        System.out.println(li);//输出一个数组的哈希值
    }
}

 运行结果

2.4、集合变数组

java.util.Collection

<T>T[] toArray(T[] a) 返回包含此collection中所有元素的数组

防止对集合进行增删操作

package learn;

import java.util.ArrayList;
import java.util.Arrays;

/*
 * 集合变数组
 * Collection接口中的toArray方法
 * 
 * */
public class CollectionsToArray {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        /*
         * 1、指定类型的数组要定义多少
         * 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
         * 当指定类型的数组长度大于了集合的size,那不会新创建了数组，而是使用传递进来的数组
         * 所以创建一个刚刚好的数组最优。
         * 
         * 2、为何要将集合变数组
         * 为了限定对元素的操作，不需要进行增删
         * 
         * */
        String[] arr =al.toArray(new String[al.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

 运行结果

2.5、增强for循环

局限：必须由被遍历的目标

for(数据类型 变量名 ：被遍历的集合（Collection）或者数组)
{

}

package learn;
/*
 * 高级for循环
 * 格式:
 * for(数据类型 变量名 ：被遍历的集合（Collection）或者数组)
 * {
 * 
 * }
 * 对集合进行遍历
 * 只能获取集合元素，但是不能对集合进行操作 
 * 迭代器除了遍历，还可进行remove操作
 * 若使用ListIterator,还可以在遍历过程中进行增删改查
 * 
 * 传统for循环和高级区别
 * 高级for局限性：必须有被遍历的目标
 * 
 * */
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {
    public static void main(String[] args) {
        
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        //若无泛型的定义String则为Object s
        for(String s :al)//只能对集合中元素取出，不能修改，迭代器都有remove,列表迭代器都可以增删改查
        {
            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  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());
        }
        
    }
}

运行结果

 字符串形式的原集合，整型的数组的输出，不加/加泛型后的增强for输出

2.6、方法的可变参数

可变参数放在参数列表的最后，以防参数不一致

package learn;
/*
 * JDK1.5新特性
 * 方法的可变参数
 * 使用时注意：可变参数一定要定义在参数列表的最后
 * */
public class ParamMethodDemo {
    public static void main(String[] args) {
//        show(3,4);
        //要定义3,4,5,6、、、、个参数的show方法时，重载方法要多个，数组法需要重新定义数组
//        int []arr = {2,3};
//        show(arr);
//        int[] arr1 = {2,3,4};
//        show(arr);
        //可变参数，其实就是数组参数的简写方式，不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可
        //隐式将这些参数封装成了数组。
        show("haha",2,3,4,5);
        
    }
    public static void show(String str,int...arr)
    {
        System.out.println(arr.length);
    }
//    public static void show(int a,int b)
//    {
//        System.out.println(a+" "+b);
//    }
//    public static void show(int []arr)
//    {
//        System.out.println();
//    }
    
    
}

运行结果 

调用方法时传递的参数个数

2.7、静态导入

import static java.util.Arrays.*的导入，导入了类中的静态成员，可以节省Arrays.

不过，如toString方法都是继承Object，而它的toString方法无参

故，注意是否会引起冲突

package learn;
/*
 * 静态导入
 * 当类名重名时，需要指定具体包名。
 * 当放大重名时，指定具备所属的对象或者类
 * */
import java.util.Arrays;
//导入的是类中的静态成员
import static java.util.Arrays.*;

public class StaticImport {
    public static void main(String[] args) {
        int [] arr = {3,1,5};
        Arrays.sort(arr);
        int index = Arrays.binarySearch(arr, 1);
        System.out.println(Arrays.toString(arr));
        System.out.println("index:"+index);
    }
}

运行结果

 

2.8、System类

java.lang.System

因为安装的java的版本，老版java将vista之后的版本一律判定为vista

故

String value = System.getProperty("os.name");
         System.out.println("value:"+value);
得到的是操作系统是vista，
java7可以正确显示

package learn;

import java.util.Properties;

/*
 * System中的方法和属性都是静态的
 * out: 标准输出，默认是控制台
 * in : 标准输入，默认键盘
 * 描述系统的一些信息
 * 获取系统属性信息Properties getProperties();
 * */
public 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);
        
        //可不可以在虚拟机启动时动态加载信息
        //java命令查出，  -D<name>-<value> 再+class文件名即可
        
        //获取所有属性信息
//        for(Object obj:prop.keySet())
//        {
//            String value = (String)prop.get(obj);
//            System.out.println(obj+"..."+value);
//        }
//        
    }
}

运行结果：

2.9、Runtime类

java.lang.Runtime

通过java来执行制定程序，关闭指定线程

Process exec(String command)  在单独的进程中执行指定的字符串命令

注意：文件路径涉及文件夹使用\分隔

　　　　如果只写文件名，则会从环境变量里设置的默认路径中去查找

package learn;
/*
 * Runtime对象
 * 该类并没有提供构造函数
 * 说明不可以new对象，那么会直接想到该类中的方法都是静态的
 * 发现该类中还有非静态方法，
 * 说明该类肯定会提供一个方法，获取本类对象，且该方法静态，返回值类型是本类类型
 * 
 * 由此看出，该类使用了单例设计模式完成
 * 保证了对象的唯一性
 * 该方法是static Runtime getRuntime()
 * 
 * */
public class RuntimeDemo {
    public static void main(String[] args) throws Exception
    {
        Runtime r = Runtime.getRuntime();
        //用记事本打开指定文件名的程序
        Process p = r.exec("notepad.exe");
//        Process p = r.exec("notepad.exe SystemDemo.java");
//        Process p = r.exec("D:\Program Files (x86)\Tencent\QQ\QQProtect\Bin\QQProtect.exe");
        //4s
//        Thread.sleep(4000);
        //进程一启动就被杀了,只能杀自己写的启动过的，不能隔空杀进程管理器里的
//        p.destroy();
        //文件夹之间使用\连接
        //如果只写文件名，则会去环境变量里找
//        r.exec("D:\Program Files (x86)\Tencent\QQ\QQProtect\Bin\QQProtect.exe");
    }
}

运行结果

2.10、Date

java.util.date

StringBuffer format(Date date,StringBuffer toAppendTo,FieldPosition pos)

将给定的Date格式化为日期/时间字符串，并将结果添加到给定的StringBuffer

星期本地化，无需加"星期"

package learn;

import java.text.SimpleDateFormat;
import java.util.Date;



public class DateDemo {
    public static void main(String[] args) {
        Date d= new Date();
        System.out.println(d);//结果看不懂
        //将模式封装在SimpleDateFormat对象中
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日Ehh:mm:ss");
        String time = sdf.format(d);
        System.out.println("time:"+time);
    }
}

运行结果

2.11、Calendar

java.util.calendar

通过查表法，将数量较多的月份，星期几与表内元素下标对应，来简化输出

java.text.SimpleDateFormat 通过yyyy等获取

package learn;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        String[] mons = {"一月","二月","三月","四月",
                        "五月","六月","七月","八月",
                        "九月","十月","十一月","十二月"};
        //前面多了一个因为数字是从0开始，去掉0角标
        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]);
//        Date d = new Date();
//        System.out.println(d);
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
//        String year = sdf.format(d);
//        System.out.println(year);
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    
}

2.12、结合2.11后的改写

Calendar提供了add方法，给指定的数值加或减

abstract void add(int field,int amount)为给定字段添加指定的时间量

常用YEAR, MONTH,DAY_OF_MONTH, DAY_OF_WEEK等

package learn;

import java.util.Calendar;

public class CalendarDemo2 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
//        c.set(2012,2,23);//输出3月，自+1
        //指定数字加
        c.add(Calendar.YEAR,4);
//        c.add(Calendar.DAY_OF_MONTH, -18);

        printCalendar(c);
    }
    public static void printCalendar(Calendar c)
    {
        String[] mons = {"一月","二月","三月","四月",
                        "五月","六月","七月","八月",
                        "九月","十月","十一月","十二月"};
        //前面多了一个因为数字是从0开始，去掉0角标
        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);
    }
    
}

2.13、Math

java.lang.math

static double ceil(double a) 返回大于指定数据的最小整数

static double floor(double a) 返回小于指定数据的最大整数

static int round(double a) 四舍五入

package learn;

import java.util.Random;

public 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);
        }
    }
    public static void show()
    {
        double d = Math.ceil(-16.24);//ceil返回大于指定数据的最小整数
        double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数
        long l = Math.round(12.34);//四舍五入
        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);
    }
}