黑马程序员-Java API-day17

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

集合框架的工具类

1、Collections-sort

Collections:此类完全由在collection上进行操作或返回collection的静态方法组成。它包含collection上操作的多态算法，即“包装器”，包装器返回由指定collection支持的心collection，以及少数其他内容。

如果为此类的方法锁提供的collection或类对象为null，则这些方法都抛出NullPointerException。

Collections-sort

Collections-max

static<T>T max(Collection<? extends T> coll, Comparator<? super T> comp)
          根据指定比较器产生的顺序，返回给定collection 的最大元素。

import java.util.*;class CollectionsDemo{       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("z");              list.add("kkkkk");              list.add("qq");              list.add("zz");              sop(list);               Collections.sort(list);              int index =Collections.binarySearch(list,"aaa");              sop("index="+index);       }       public static void maxDemo()       {              List<String> list = new ArrayList<String>();              list.add("abcd");              list.add("aaa");              list.add("z");              list.add("kkkkk");              list.add("qq");              list.add("zz");                           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("z");              list.add("kkkkk");              list.add("qq");               sop(list);               //Collections.sort(list);              Collections.sort(list,new StrLenComparator());               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);       }}

2、Collections-替换反转

fill：将集合中的元素全部替换成指定元素

import java.util.*;class StrComparator implements Comparator<String>{       public int compare(String s1,String s2)       {              return s2.compareTo(s1);              /*              int num = s1.compareTo(s2);              if(num>0)                     return -1;              if(num<0)                     return 1;              return num;              */       }}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)       {              //fillDemo();              //replaceAll();              orderDemo();       }       public static void orderDemo()//倒序       {              TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));//传递一个反向比较器              ts.add("abcd");              ts.add("aaa");              ts.add("kk");              ts.add("c");               Iterator it = ts.iterator();              while(it.hasNext())              {                     sop(it.next());              }       }       public static void replaceAll()//替换       {              List<String> list = new ArrayList<String>();              list.add("abcd");              list.add("aaa");              list.add("zz");              list.add("kkkkk");               sop(list);              Collections.replaceAll(list,"aaa","pp");              sop(list);              Collections.reverse(list);               sop(list);       }       public static void fillDemo()//全部替换       {              List<String> list = new ArrayList<String>();              list.add("abcd");              list.add("aaa");              list.add("zz");              list.add("kkkkk");               sop(list);              Collections.fill(list,"pp");              sop(list);       }       public static void sop(Object obj)       {              System.out.println(obj);       }}

小结：

reverseOrder：返回一个比较器，它强行逆转实现了Comparable接口的对象collection的自然顺序。

3、Collections-SynchronizedList

static<T> List<T>synchronizedList(List<T> list):返回指定列表支持的同步（线程安全）列表。

static void shuffle(List<?< list):使用默认随机源对指定列表进行置换。

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集合有什么好处？              可以使用集合的思想和方法来操作数组中的元素。              注意：将数组变成集合，不可以使用集合的增删方法，              因为数组的长度是固定的。              contains,get,indexOf(),subList()              如果有增删操作，就会发生UnsupportedOperationException(不支持异常)              */              List<String> list =Arrays.asList(arr);              //sop("contains:"+list.contains("cc"));              //list.add("qq");//UnsupportedOperationException              //int[] nums = {2,4,5};              Integer[] nums = {2,4,5};               List<Integer> li =Arrays.asList(nums);              /*              如果数组中的元素师对象，那么变成集合时，数组中的元素就会直接转成集合中的元素；              如果数组中的元素是基本数据类型，那么会将该数组作为集合中的元素存在。              */              sop(li);       }       public static void sop(Object obj)       {              System.out.println(obj);       }}

4、Arrays

Arrays:用于操作数据的工具类，里面都是静态方法。

asList:将数组变成list集合。

import java.util.*;class ArraysDemo{       public static void sop(Object obj)       {              System.out.println(obj);       }       public static void main(String[] args)       {              String[] arr ={"abc","cc","kkkk"};               List<String> list =Arrays.asList(arr);              //sop("contains:"+list.contains("cc"));              //sop(list);               //int[] nums = {2,4,5};              Integer[] nums = {2,4,5};               List<Integer> li =Arrays.asList(nums);               /*              如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素；              如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。              */              sop(li);       }}

小结：

把数组编程list集合有什么好处？

       可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。否者会发生UnsupportedOperationException异常。

5、集合变数组

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));       }}

小结：

              1.制定类型的数组到底要定义多长呢？

              当制定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size.

              当制定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组。

              所以创建一个刚刚好的数组最优。

 

              2.为什么要将集合变数组？

              为了限定对元素的操作，不需要进行增删了。

6、高级for循环

格式：

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

对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级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)              {                     System.out.println(s);              }              /*              Iterator it = al.iterator();              while(it.hasNext())              {                     System.out.println(it.next());              }              */               int[] arr = {3,4,5};              for(int i:arr)              {                     System.out.println("i:"+i);              } //由于Map集合不支持Collection集合中的方法，因此这里需要先将其转换成Set集合后，才能使用相关方法              HashMap<Integer,String> hm = newHashMap<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());              }       }}

7、可变参数

JDK1.5版本出现的新特性

方法的可变参数。

在使用时注意：可变参数一定要定义在参数列表最后面。

class ParamMethodDemo{       public static void main(String[] args)       {              /*              虽然少定义了多个方法，但是每次都要定义一个数组，作为实际参数。              int[] arr = {3,4};              show(arr);               可变参数：              其实就是上一中数组参数的简写形式，不用么一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。              隐式将这些参数封装成了数组。              */              show("hah",2,3,4,5,6);              show(2,3,4,5,5,6,7,8);        }       public static void show(String str,int... arr)//可变参数       {              System.out.println(arr.length);       }}

8、staticimport 静态导入

当类名重名时，需要指定具体的包名；

当方法重名时，指定具备所属的对象或者类。

import java.util.*;import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员import static java.lang.System.*;//导入了System类中所有静态成员class StaticImport{       public static void main(String[] args)       {              out.println("hah");              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);       }}

9、其他对象-System

1.getProperty

static Properties getProperty()       确定当前的系统属性

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

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

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

描述系统一些信息，获取系统属性信息：Properties getProperties()

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);              //步骤：在dos命令行下首先编译程序，其次在运行的时候，具体代码如下：java -Dhaha=qqqq SystemDemo              /*              //获取所有属性信息              for(Object obj :prop.keySet())              {                     String value = (String)prop.get(obj);                     System.out.println(obj+"::"+value);              }              */       }}

2.Runtime

public classRuntime extends Object  每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的Runtime类实例。

Runtime对象

该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的；发现该类中还有非静态方法，说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。该方法是static Runtime getRuntime();

由这个特点可以看出该类使用了单例设计模式，保证了对象的唯一性。

class  RuntimeDemo{       public static void main(String[] args)throws Exception       {              Runtimer = Runtime.getRuntime();              Processp = r.exec("notepad.txt");              Thread.sleep(4000);              p.destroy();//杀掉进程       }}

3.Date

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);       }}

4.Calendar日期类

import java.util.*;import java.text.*;class CalendarDemo{       public static void main(String[] args)       {              Calendar c = Calendar.getInstance();              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]);               /*              Date d = new Date();              SimpleDateFormat sdf = newSimpleDateFormat("yyyy");              String year = sdf.format(d);               System.out.println("year:"+year);              */       }       public static void sop(Object obj)       {              System.out.println(obj);       }}

import java.util.*;class CalendarDemo2{       public static void main(String[] args)       {              Calendar c = Calendar.getInstance();              //c.set(2013,04,04);//月份是实际月份+1得到的结果              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(mons[index]);              sop(c.get(Calendar.DAY_OF_MONTH)+"日");              sop(weeks[index1]);        }       public static void sop(Object obj)       {              System.out.println(obj);       }}

5.Math-Random:随机数

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);              }       }       public static void show()       {              double d = Math.ceil(-12.34);//ceil返回大于指定数据的最小整数。              double d1 = Math.floor(-12.34);//ceil返回小于指定数据的最大整数。              long l = Math.round(12.50);//round四舍五入               sop("d="+d);//-13.0              sop("d1="+d1);//-12.0              sop("l="+l);//13       double d2 = Math.pow(2,3);      sop(“d2=”+d2);       }       public static void sop(Object obj)       {              System.out.println(obj);       }}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net