黑马程序员-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