黑马程序员_Java基础_常用工具类

------- android培训、 java培训、期待与您交流！ ----------



常用的工具类有：
1.集合工具类：Collections 用于对Collection接口子类进行操作，它包含在 collection 上操作的多态算法，即“包装器”
当我们的程序是多线程的操作集合框架的时候，通常使用这个类的synchronized保证线程操作集合的安全性，
还可以通过 使用Collections类的sort方法对集合进行排序。
使用集合产生线程不安全时，我们可以通过使用Collections类中提供的方法是集合线程同步：
 Collections常用方法:
 shuffle(List list) 使用默认随机源对指定列表进行置换(洗牌)
rotate(List list, int distance) 根据指定的距离轮换指定列表中的元素（旋转链表中的数据）
reverse(List list) 反转指定列表中元素的顺序
synchronizedList(List list)  返回指定列表支持的同步（线程安全的）列表
synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全的）映射
synchronizedSet(Set<T> s) 返回指定 set 支持的同步（线程安全的）set

2.Arrays类
用来操作数组的各种方法。（比如排序和搜索）
此类还包含一个允许将数组作为列表来查看的静态工厂。 
Arrays常用方法：(大部分都是静态方法)
static List asList(T... a)   静态方法，返回一个受指定数组支持的固定大小的列表
 binarySearch(byte[] a, byte key) 二分搜索法来搜索指定的 byte 型数组，以获得指定的值


boolean equals(boolean[] a, boolean[] a2)  如果两个指定的 boolean 型数组彼此相等

sort(byte[] a)   对指定的 byte 型数组按数字升序进行排序

例子1：

public class CollectionsDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("ges");
        list.add("h");
        list.add("eih");
        list.add("apsp");
        System.out.println("默认：" + list);
        // 按照元素默认的compareTo方法进行排序，我们可以自定义一个类实现Comparator类
        Collections.sort(list); // 结果
        System.out.println("自然排序：" + list);
        
        //使用二分搜索法搜索指定列表，以获得指定对象
        int index = Collections.binarySearch(list, "b",new StrLenComparator());
        System.out.println("index:" + index);
        
        Collections.sort(list, new StrLenComparator());
        System.out.println("自定义长度排序：" + list);
        
        // 获取最大元素
        String max = Collections.max(list);
        String max_ = Collections.max(list, new StrLenComparator());
        System.out.println("max:" + max + ",max_:" + max_);
    }
}

例子2：

class StrLengthComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if (num == 0) {
            return o1.compareTo(o2);
        }
        return num;
    }
}
public class CollectionsDemo2 {
    public static void main(String[] args) {
//      revOrderDemo();
//      utilMethod();
        shuffleDemo();
    }
    
    public static void revOrderDemo() {
        // 反序排序,我们可以自定义比较器，将比较器作为参数放入Collections.reverseOrder（）中进行反序；
        TreeSet<String> ts = new TreeSet<String>(
                Collections.reverseOrder(new StrLengthComparator()));
        ts.add("abd");
        ts.add("geddss");
        ts.add("gkug");
        ts.add("aaa");
        sop(ts);
    }
    public static void utilMethod() {
        List<String> list = new ArrayList<String>();
        list.add("ges");
        list.add("h");
        list.add("eih");
        list.add("apsp");
        System.out.println(list);
        //指定位置交换元素
        Collections.swap(list, 1, 2);
        System.out.println("交换元素："+list);
        
        // 翻转list元素
        Collections.reverse(list);
        System.out.println(list);
        // 选择替换新值
        Collections.replaceAll(list, "h", "z");
        System.out.println(list);
        // 替换全部元素
        Collections.fill(list, "1111");
        System.out.println(list);
        
    }
    public static void shuffleDemo(){
        List<String> list = new ArrayList<String>();
        list.add("ges");
        list.add("h");
        list.add("eih");
        list.add("apsp");
        System.out.println("原牌："+list);
        
        //洗牌，，可以使用于骰子   扑克的随机洗牌
        Collections.shuffle(list);
        System.out.println("洗牌："+list);
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

  1.指定类型的数组到底要定义多长？
   当指定类型的数组长度小于了集合size，那么该方法内部会创建一个新的数组，长度为集合的size.
   当指定类型的数组长度大于了集合size,就不会新创建了数组，而是使用传递进来的数组
   所以创建一个刚刚好的数组最优
   
   2.为什么要将集合变数组？
   为了限制对元素的操作，不需要进行增删了

例子3： 

 将集合放到数组中 ArrayList.toArray();

public class ArraysDemo {
    public static void main(String[] args) {
        intArr();
        
        String[] str = {"agve","gra","htryr"};
        
        //将数组转变成集合
        List<String> list = Arrays.asList(str);
//      list.add("aaa");    注意：如果进行增删操作，这里会出现unsupportedOperationException异常
        
        print(list);
        
        //将数组进行排序，然后转变成集合打印
        Arrays.sort(str);
        List<String> list01 = Arrays.asList(str);
        print(list01);
        
        //可以利用集合的思想来判断数组是否存在关键字
        print("gra contains:" + list01.contains("gra"));
    }
    
    public static void intArr(){
        /*
         * 如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
         * 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
         * 
         */
        Integer[] num = {1,2,3};
        List<Integer> list = Arrays.asList(num);
        print(list);
        
        int[] num1 = {1,2,3};
        List<int[]> list1 = Arrays.asList(num1);
        print(list1);
        
        
    }
    public static void print(Object obj){
        System.out.println(obj);
    }
}

高级for循环
对集合进行遍历：
只能获取集合元素，但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作

传统for和高级for有什么区别呢？
高级for有一个局限性，必须有遍历的目标
建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义角标
 例子5：

public class ForEachDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("fj");
        list.add("gkf");
        list.add("rreh");
        
        for(String str : list){
            System.out.println(str);
        }
        
//      Iterator<String> it = list.iterator();
//      while(it.hasNext()){
//          System.out.println(it.next());
//      }
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1, "sdeoi");
        hm.put(2, "kudsfe");
        hm.put(3, "feadd");
        
        for(Map.Entry<Integer, String> me : hm.entrySet()){
            System.out.println(me.getKey()+":"+me.getValue());
        }
        
    }
}

JDK1.5版本出现的新特性：

 方法的可以变参数。
 在使用时注意：可变参数一定要定义在参数链表最后面
例子6： 

public class ParamMethodDemo {
    public static void main(String[] args) {
        show("aaa", 1, 2, 3);
    }
    /*可变参数传入方法时：格式：
      T... arr
     */
    
    public static void show(String str, int... arr) {
        for (int i : arr) {
            System.out.println(str + ":" + i);
        }
    }
}

 JDK1.5版本出现的新特性：
 
 StaticImport   静态导入。
 
 当类名重名时，需要指定具体的包名
 当方法重名时，指定具体所属的对象或者类；
例子7：

import static java.lang.System.*;  //导入System类中所有静态成员
import java.util.Arrays;
public class StaticImportDemo {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        sort(arr);    //使用Arrays静态成员进行排序操作
        int index = binarySearch(arr, 2);
        out.println(Arrays.toString(arr));
        System.out.println("Index:"+index);
    }
}

System：类中的方法和属性都是静态的

out:标准输出，默认是控制台

in:标准输入，默认是键盘

描述系统中的依稀信息。

获取习哦他能够属性信息： Properties getProperties();

例子8：

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

   Runtime对象

 该类并没有提供构造函数

 说明不可以new对象，那么会直接想到该类中的方法都是静态的

 发现该类中还有非静态的方法

 说明该类肯定会提供了方法获取本类对象，  而且该方法是静态的，并返回值类型是本类类型

 有这个特点可以看出该类使用了单例设计模式

 该方法是static Runtime getRuntime();
例子9：
 

 

public class RuntimeDemo {
    public static void main(String[] args) {
        Runtime r = Runtime.getRuntime();
        try {
            // 启动记事本文件
            Process p = r.exec("notepad.exe");
            
            
            try {
                //5秒后杀死进程
                Thread.sleep(5000);
                p.destroy();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

Date类：（用于对日期的操作，通常和SimpleDateFormat一起使用，但是好多方法都过时了）
分配 Date 对象并初始化此对象，以表示分配它的时间
例子10：

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日E HH:mm:ss");
        
        //调用format方法让模式格式化指定Daet对象
        String date = sdf.format(d);
        System.out.println("格式化后时间："+date);
    }
}

 Calendar类
它 能够生成为特定语言和日历风格实现日期-时间格式化所需的所有日历字段值  

时间格式操作的工具类
例子11：

 

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        
        printCalendar(c);
        
        //可以设置时间
        c.set(2012, 2,23);
        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);
        System.out.println(c.get(Calendar.YEAR) + "年");
        System.out.println(mons[index]);
        System.out.println(c.get(Calendar.DAY_OF_MONTH) + "日");
        System.out.println(weeks[index1]);
    }
}

 

  Math类：
它 包含用于执行基本数学运算的方法，
如初等指数、对数、平方根和三角函数

常用方法：（大多是静态方法）
abs(int a)  返回  int  值的绝对值
max(double a, double b)   返回两个  double  值中较大的一个
min(int a, int b)   返回两个  int  值中较小的一个
pow(double a, double b)  返回第一个参数的第二个参数次幂的值
double random()     返回带正号的  double  值，该值大于等于  0.0  且小于  1.0(最常用到)

例子12：

<pre name="code" class="html">public class MathDemo {
    public static void main(String[] args) {
        //随机数方式一：
        for(int i=0; i<10 ; i++){
            int j = (int)(Math.random()*10+1);
            System.out.print(j+" ");
        }
        //方式二：
        Random r = new Random();
        for(int i=0; i<10 ; i++){
            int d = r.nextInt(10)+1;
            System.out.print(d+" ");
        }
//      show();
    }
    public static void show(){
        //ceil返回大于指定数据的最小整数
        double d = Math.ceil(16.34);
        print(d);   //输出：17
        
        //floor返回小于指定数据的最大整数
        double d1 = Math.floor(12.56);  
        print(d1);  //输出：12
        
        //四舍五入
        long l = Math.round(12.54);
        print(l);
        
        //2的3次幂
        double d2 = Math.pow(2, 3);
        print(d2);
        
    }
    public static void print(Object obj){
        System.out.println(obj);
    }
}