java 自学日志【十二】---工具类

于 2013-05-08 19:08:10 发布
阅读量581 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yutengfei2006/article/details/8901798
版权
集合框架工具类 Collections
Collections是一个集合工具类，它没有构造方法，所有的成员方法都是静态的。利用它可以实现对集合的一些特殊操作，如排序、二分查找、取最值、反转等。
1、  对List集合进行排序
Collections.sort(list)，Collections.sort( list, comparator)。
2、  获取集合的最大值
Collections.Max(collection)，Collections.Max(collection，comparator)。
3、  二分查找
binarySearch(List<? extends Comparable<? super T>> list, T key)
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
4、  填充
fill（list，obj），将集合所有元素都换成obj
5、  替换
replaceAll(List<T> list, T oldVal, T newVal)，将集合中出现的所有的某一个值，替换为另一个。
6、  反转
reverse(List<?> list)，头变尾，尾变头。
7、随机排列
         shuffle(list)，应用：洗牌、掷色子。
重点掌握的下边三个方法
1、  reverseOrder：强行逆转比较器的自然顺序或元素的自然顺序。
2、  将集合由线程不安全转为线程安全的
synchronizedCollection(Collection<T>c)
synchronizedList(List<T>list)
synchronizedMap(Map<K,V>m)
synchronizedSet(Set<T>s)
其原理是：内部封装一个容器，然后定义一个锁，使用该锁同步并封装该容器的所有方法。
 
import java.util.*;  
class  CollectionsDemo  
{  
  
    public static void main(String[] args)   
    {  
        sortDemo();  
    }  
  
    public static  void sortDemo()  
    {  
        List <String> list = new ArrayList<String>();  
        list.add("abcdd");  
        list.add("asdfas");  
        list.add("saa");  
        list.add("bbb");  
        list.add("qt");  
        list.add("bbb");  
  
  
  
        sop(list);  
        //排序演示，要排序的元素继承comparable类或者新建一个比较器。  
        Collections.sort(list,new StrLenComparator());  
        sop(list);  
        sop("----------sort");  
  
        //取最大值演示：要排序的元素继承comparable类或者新建一个比较器。  
        String max = Collections.max(list,new StrLenComparator());  
        sop(max);  
        sop("----------max");  
          
        //二分查找：必须先是有序集合，前后排序的比较规需要相同，是自然顺序都是自然顺序，是比较器都是比较器。  
        int index = Collections.binarySearch(list,"kkkk");  
        //int index = halfSearch(list,"aaaa");  
        sop(index);  
        sop("----------binarySearch");  
        /* 
        我的问题：如果前边排序是用比较器，后来查找的时候没有加比较器，返回值如何？ 
        */  
          
        //reverse：将集合中的元素反转。  
        Collections.reverse(list);  
        sop(list);  
        sop("----------reverse");  
  
        //swap():交换集合中两个元素的位置  
        Collections.swap(list,2,5);  
        sop(list);  
        sop("----------swap");  
  
        //shufle:使用默认随机源对指定列表进行置换(如洗牌动作、色子)  
        Collections.shuffle(list);  
        sop(list);  
        sop("----------shuffle");  
  
        //fill方法：可以将list集合中的所有元素替换成指定元素，  
        //练习：将list集合中的部分元素替换成指定元素。  
        sop(list);  
        Collections.fill(list,"yyyy");  
        sop(list);  
        sop("----------fill");  
        //repalceAll:将集合中的所有的指定元素替换成新元素  
        Collections.replaceAll(list,"yyyy","00");//其实封装了list.set(index,"00");  
        sop(list);  
        sop("----------repalceAll");  
          
  
  
    }  
  
    //二分法原理。  
    public static int halfSearch(List<String> list,String key/*,Comparator cmp*/)  
    {  
        int max,min,mid;  
        max =list.size()-1;  
        min = 0;  
  
        while(min<max)  
        {  
            mid =(max+min)>>1;  
            String str = list.get(mid);  
            int num = str.compareTo(key);//int num = cmp.compare(s1,s2);  
            if(num>0)  
                max =mid -1;  
            else if(num<0)  
                min =mid + 1;  
            else  
                return mid;  
        }  
  
        return min;//-min-1;  
    }  
    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);  
    }  
}

Collections.reverseOrder()命令：反转自然顺序或比较器； 
import java.util.*;  
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);  
    }  
}  
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);  
    }  
}  
  
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("adsdf");  
        ts.add("afasdf");  
        ts.add("efsf");  
        ts.add("bc");  
        ts.add("e");  
  
        Iterator<String> it = ts.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next());  
        }  
    }   
}
Arrays 数组工具类：
binarySearch：二分查找数组中的元素。
copyOf：复制数组
copyOfRange：复制数组内的某一段
equals：判断两个数组是否相等。
deeEquals：如果两个指定数组彼此是深层相等的，则返回true。
deeHashCode：基于指定数组的“深层内容”返回哈希码。
deeToString: 返回指定数组“深层内容”的字符串表示形式。
fill：将指定的值分配给指定数组的每个元素。
hashCode：基于指定数组的内容返回哈希码。
sort: 对数组元素进行排序
toString:把数组的元素转化成字符串


重点：Arrays有个asList(T… t)方法，可以把数组转换为List集合,它与Collection接口中的toArray一起，构成了数组API和集合API之间的桥梁。
1.指定类型的数组到底要定义多长？ 
        当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，数组的长度为集合的size 
        当指定类型的数组长度大于了集合的size，就不会新创建数组，而是用传递进来的数组。 
 
        所以创建一个刚刚好的数组最优。 
2.为什么要将集合变数组？ 
        为了限定对元素的操作。（如返回数据时，将数据变成数组） 

把数组编程List集合有什么好处？  
        可以使用集合的思想和方法来操作数组中的元素。（如判断是否包含：如果是数组，需要进行循环判断））。否则需要自己封装多种方法。 
 
注意：将数组变成集合，不可以使用集合的增删方法(add,remove)，因为数组的长度是固定的。 
 
如果增删了，那么会发生UnsupportedOperationException ；

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。 
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存储。 
 
/* 
集合变数组。 
Collection接口中的toArray方法。 
*/  
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));  
  
    }  
}

class ArraysDemo   
{  
    public static void main(String[] args)   
    {  
//      int[] arr =new int[]{2,5,7};  
//      System.out.println(Arrays.toString(arr));  
          
        String [] arr ={"abc","cc","kkk"};  
                 
        List<String>  list = Arrays.asList(arr);  
        //list.add(0,"k");//UnsupportedOperationException  
        System.out.println(list);  
             
        int [] nums ={2,5,9};  
        List<int[]> li = Arrays.asList(nums);  
          
        sop(li);  
        Integer [] nums1 ={2,5,9};  
        List<Integer> lis = Arrays.asList(nums1);  
        sop(lis);  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}

System:类中的方法和属性都是静态的。 
out：标准输出，默认是控制台 
in：标准输入流，默认是键盘。 
 
描述系统的一些信息。 
 
获取系统属性信息：Properties getProperties();  
import java.util.*;    
class SystemDemo   
{  
    static{  
        System.setProperty("hah", "win7");  
    }  
    public static void main(String[] args)   
    {  
        Properties prop = System.getProperties();  
        //因为Propertiess是Hashtable的子类，也就是Map集合的一个子类对象。  
        //所以可以通过Map的方法去除该集合的元素。  
        //该集合中存储的都是字符串，没有定义泛型。  
  
        //如何在系统中自定义一些特有信息。  
        System.setProperty("mykey","myvalue");  
  
        //获取指定属性信息  
        String value = System.getProperty("os.name");  
        System.out.println("value="+value);  
        /* 
         可不可以动态给系统增加一些信息？ 
         1.通过java -D 命令； 
         2.静态代码块。 
         */  
        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对象： 
该类中没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的，发现该类中还有非静态方法。 
说明该类肯定会提供了方法获取本类对象，而且该方法是静态的，并且返回值类型是本类类型。 
由这个特点可以看出该类使用了单例设计模式完成。该方式是static Runtime getRuntime();  
class  RuntimeDemo  
{  
    public static void main(String[] args)  throws Exception  
    {  
        Runtime r = Runtime.getRuntime();  
        //Process p =r.exec("C:\\Program Files (x86)\\JCreator Pro\\JCreator_cn.exe");//通过该方式可以打开机子上的任意一个文件。  
        Process p =r.exec("notepad.exe SystemDemo.java");//它会启动一个线程，在path环境变量中找执行程序。  
        //Thread.sleep(4000);  
        //p.destroy();//结束线程  
    }  
}
Date与Calendar 
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);  
    }  
}
两个练习： 
1.获取任意年的二月有多少天。 
 
2.获取昨天的现在的这个时间 
import java.util.*;
class CalendarDemo2   
{  
    public static void main(String[] args)   
    {  
        Calendar c = Calendar.getInstance();  
        printCalendar(c);  
        //c.set(2013,2,15);/这里的2表示3月，MONTH字段是从0开始的，即0代表一月。  
        c.add(Calendar.MONTH,-1);  
        printCalendar(c);  
        test1(2013);  
        test2();  
          
    }  
      
    //打印日期  
    public static void printCalendar(Calendar c)  
    {         
        String[] mons = {"一月","二月","三月","四月",  
                         "五月","六月","七月","八月",  
                         "九月","十月","十一月","十二月"};  
        String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};//1代表星期日，所以0角标元素为“”。  
        int indexOfMon = c.get(Calendar.MONTH);  
        int indexOfWeek = c.get(Calendar.DAY_OF_WEEK);  
  
          
          
        sop(c.get(Calendar.YEAR)+"年"+mons[indexOfMon]+  
            c.get(Calendar.DAY_OF_MONTH)+"日"+weeks[indexOfWeek]+"  "+  
            c.get(Calendar.HOUR_OF_DAY)+":"+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND));  
    }  
      
    //1.获取任意年的二月有多少天。  
    public static void test1(int year)  
    {  
        Calendar c = Calendar.getInstance();  
        c.set(year,2,1);  
        c.add(Calendar.DAY_OF_MONTH,-1);  
        sop("练习一------"+year+"年2月有"+c.get(Calendar.DAY_OF_MONTH)+"天");  
    }  
    //获取昨天现在这个时刻。  
    public static void test2()  
    {  
        Calendar c = Calendar.getInstance();  
        //Calendar类的add方法必须要掌握，给指定的字段添加或减去指定的时间量。  
        c.add(Calendar.DAY_OF_MONTH,-1);//给当前时间减去一个月的时间量。  
        System.out.print("练习二-------昨天现在的时间是：");  
        printCalendar(c);  
  
    }  
  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}

Math与Random 
import java.util.*;  
  
class MathDemo   
{  
    public static void main(String[] args)   
    {  
        //show();  
        generateRandomNum1();  
    }  
      
    //产生一组随机数，可能重复  
    public static void generateRandomNum() {  
        //随机数对象  
        Random r = new Random();  
        //产生十个随机数。  
        for(int x =0;x<10;x++)  
        {  
            //int d = (int)(Math.random()*10+1);//random方法返回一个包括0但不包括1的伪随机数，集合中随机排列方法底层就是调用了这个方法。  
            int d =r.nextInt();  
            sop(d);  
        }         
    }  
      
    //产生一组随机数，不重复  
    public static void generateRandomNum1() {  
        //随机数对象  
        Random r = new Random();  
        Set<Integer> hs=new HashSet<Integer>();  
        //产生十个随机数。  
        while(hs.size()<5){  
            hs.add(r.nextInt(10)+1);  
        }  
        sop(hs);  
    }  
  
    public static void show()  
    {  
        double d  = Math.ceil(-12.34);//ceil返回大于指定数据的最小整数。  
        double d1  = Math.floor(-12.74);//floor返回小于指定数据的最大整数  
        long l =Math.round(-12.34);//四舍五入,  
        double d2 = Math.pow(12,2);//12的2次幂，幂数计算。  
        sop("d="+d);  
        sop("d1="+d1);  
        sop("l="+l);  
        sop("d2="+d2);  
  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}




yutengfei2006
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值