黑马程序员——java第十七天：集合框架（Collections和其他对象）

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

Collections

Collections工具类下的方法都是静态的，他是专对集合操作的工具类。

sort

 

public static <T extends Comparable<? super T>> void sort(List<T> list)

根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2)不得抛出 ClassCastException）。

package bijicaogao;

 

import java.util.*;

publicclassCllectionsDemo{

   publicstaticvoid main(String[] args){

      sortDemo();

   }

   privatestaticvoid sortDemo() {

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq");

      sop(list);

      Collections.sort(list);

      sop(list);

   }

 

   privatestaticvoid sop(List<String>list) {

      System.out.println(list);

      

   }

}

 

 

public static <T> void sort(List<T> list,Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较（也就是说，对于列表中的任意 e1 和 e2 元素，c.compare(e1,e2) 不得抛出 ClassCastException）。

package bijicaogao;

 

import java.util.*;

publicclassCllectionsDemo{

   publicstaticvoid main(String[] args){

      sortDemo();

   }

   privatestaticvoid sortDemo() {

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq");

      sop(list);

      Collections.sort(list,new StrLenComparator());

      sop(list);

   }

 

   privatestaticvoid sop(List<String>list) {

      System.out.println(list);

      

   }

}

class StrLenComparator implements Comparator<String>{

 

   @Override

   publicint compare(String o1,String o2) {

      if(o1.length()>o2.length())

         return 1;

      if(o1.length()<o2.length())

         return -1;

      return o1.compareTo(o2);

   }

   

}

 

 

max

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定collection 的最大元素。collection 中的所有元素都必须实现Comparable接口。此外，collection 中的所有元素都必须是可相互比较的（也就是说，对于 collection 中的任意e1和e2元素，e1.compareTo(e2)不得抛出ClassCastException）。

 

 

package bijicaogao;

 

import java.util.*;

publicclassCllectionsDemo{

   publicstaticvoid main(String[] args){

      //sortDemo();

      maxDemo();

   }

   privatestaticvoid maxDemo() {

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq");

      //Collections.sort(list);

      //sop(list);

      Stringmax=Collections.max(list);

      sop("max"+max);

   }

   privatestaticvoid sop(Object obj) {

      System.out.println(obj);

      

   }

}

class StrLenComparator implements Comparator<String>{

 

   @Override

   publicint compare(String o1,String o2) {

      if(o1.length()>o2.length())

         return 1;

      if(o1.length()<o2.length())

         return -1;

      return o1.compareTo(o2);

   }

   

}

 

 

public static <T> T max(Collection<? extends T> coll,

                       Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器相互比较（也就是说，对于 collection 中的任意 e1 和 e2 元素，comp.compare(e1, e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与collection 的大小成正比。

package bijicaogao;

 

import java.util.*;

publicclassCllectionsDemo{

   publicstaticvoid main(String[] args){

      //sortDemo();

      maxDemo();

   }

   privatestaticvoid maxDemo() {

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq");

      Stringmax=Collections.max(list,new StrLenComparator());

      sop("max"+max);

   }

   privatestaticvoid sop(Object obj) {

      System.out.println(obj);

      

   }

}

class StrLenComparator implements Comparator<String>{

 

   @Override

   publicint compare(String o1,String o2) {

      if(o1.length()>o2.length())

         return 1;

      if(o1.length()<o2.length())

         return -1;

      return o1.compareTo(o2);

   }

}

 

 

 

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过sort(List)方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

import java.util.*;

publicclassCllectionsDemo<T>{

   publicstaticvoid main(String[] args){

      //sortDemo();

      //maxDemo();

      int index=binarySearchDemo();

      sop(index);

   }

   privatestaticint binarySearchDemo(){

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq"); 

      sop(list);

      Collections.sort(list);

      sop(list);

      return Collections.binarySearch(list,"z");

   }

}

 

 

 

binarySearch

public static <T> int binarySearch(List<? extends T> list,

                                   T key,

                                   Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过sort(List, Comparator)方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

package bijicaogao;

 

import java.util.*;

publicclassCllectionsDemo<T>{

   publicstaticvoid main(String[] args){

      List<String>list=newArrayList<String>();

      list.add("abcd");

      list.add("aaa");

      list.add("aaa");

      list.add("z");

      list.add("kkk");

      list.add("qq");

      

      sop("排序前"+list);

      

//    sortDemo(list);

//    sop("排序后"+list);

      

//    Stringmax=maxDemo(list);

//    sop("最大"+max);

      int index=binarySearchDemo(list);

      sop(index);

   }

   privatestaticintbinarySearchDemo(List<String> list){

      Collections.sort(list,new StrLenComparator());

      sop("binarySearchDemo排序"+list);

      return Collections.binarySearch(list,"z",new StrLenComparator());

   }

   

   privatestatic String maxDemo(List<String>list) {

      Stringmax=Collections.max(list,new StrLenComparator());

      return max;

   }

   

   privatestaticvoid sortDemo(List<String>list) {    

      Collections.sort(list,new StrLenComparator());

   }

 

   privatestatic <T> void sop(T obj) {

      System.out.println(obj);    

   }

}

class StrLenComparator implements Comparator<String>{

 

   

   publicint compare(String o1,String o2) {

      if(o1.length()>o2.length())

         return 1;

      if(o1.length()<o2.length())

         return -1;

      return o1.compareTo(o2);

   }

   

}

 

 

 

static <T> void	fill(List<? super T> list, T obj)             使用指定元素替换指定列表中的所有元素。
static <T> boolean	replaceAll(List<T> list, T oldVal, T newVal)             使用另一个值替换列表中出现的所有某一指定值。
static void	reverse(List<?> list)             反转指定列表中元素的顺序。
static <T> Comparator<T>	reverseOrder()             返回一个比较器，它强行逆转实现了Comparable接口的对象 collection 的自然顺序。
static <T> Comparator<T>	reverseOrder(Comparator<T> cmp)             返回一个比较器，它强行逆转指定比较器的顺序。
static void	swap(List<?> list, int i, int j)             在指定列表的指定位置处交换元素。
static void	shuffle(List<?> list)             使用默认随机源对指定列表进行置换。
static <T> Collection<T>	synchronizedCollection(Collection<T> c)             返回指定 collection 支持的同步（线程安全的）collection。

 

\

Arrays类

Arrays：用于操作数组的工具类。里面都是静态方法

1)数组变集合：

static <T> List<T>

asList(T... a)             返回一个受指定数组支持的固定大小的列表。

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

注意：

1、数组变成集合不可使用集合的增删方法，如果增上会出现异常。

       2、如果数组中的元素都是对象，那么变成集合时数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存在，才在集合中的是数组地址值。想要把基本数据直接专场集合中的元素可以用其对应的封装类。

Collection类中的toArray（）

用于集合转数组：

问题：指定类型的数组到底要定义多长呢？

         当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的长度为集合size的数组；当指定类型的数组长度大于集合的size，那么该方法内部不会创建一个新的长度为集合size的数组，但数组中空缺的位置就会赋默认值null；所以建立一个刚好的数组最优——String[] arr=al.toArray(new String[al.size()]);

为题：为什么要将集合变数组呢？

         为了限定对元素的操作。

 

增强for循环

for(声明循环变量：数组的名字) {

…

}

其中，声明的循环变量的类型必须和数组的类型相同。

这种形式的for语句类似自然语言中的“for each”语句，

为了便于理解上述for语句，可以将这种形式的for语句中翻译成

“对于循环变量依次取数组的每一个元素的值”。

 

格式：

         for（数据类型变量名：被遍历的集合）{

}

例如：一个集合对象：ArrayList al=new ArrayList();

                   添加元素：     al.add(“…”);…….

for(String s:al){

         System.out.println(s);

}

注意：用增强for对于集合遍历只能获取集合元素，但是不能对集合进行操作。

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

 

传统for与增强for的区别？

高级for有一个局限性必须有被遍历的目标。

建议遍历数组数组时用传统for，因为可以操作角标。

 

可变参数

其实不用每一才都手动创建数组对象，只要将要操作的元素作为参数传递即可，隐式的将这些参数封装成了数组。

例如：

show(2,3,4,5);

}

public void show(int… arr){

         System.out.println(arr.length);

}

这样就把2,3,4,5这几个数封装在了以arr为数组名的数组中了。

方法的可变参数：

在使用是注意：课变参数一定定义在参数列表的最后面。例如：

show(“哈哈”，2,3,4,5);

}

public void show(String str，int… arr){

         System.out.println(arr.length);

}

静态导入

import static java.util.Arrays*；//导入的是Arrays类中的所有静态成员。

当类名重名时需要指定具体的包名；当方法重名时指定具体所属的对象或者类。

import static java.lang.System*；//导入了System类中的所有静态成员。

其他对象

System类：

System类中的成员都是静态的。

static PrintStream	err              “标准”错误输出流。
static InputStream	in              “标准”输入流。
static PrintStream	out              “标准”输出流。

 

 

static void	arraycopy(Object src, int srcPos, Object dest, int destPos, int length)             从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
static long	currentTimeMillis()             返回以毫秒为单位的当前时间。
static void	exit(int status)             终止当前正在运行的 Java 虚拟机。
static void	gc()             运行垃圾回收器。

类 Properties

Properties是Hashtable的子类,也就是Map集合的一个子类对象，那么可以通过map的方法取出该集合中的元素。该集合中存储的都是字符串，没有泛型定义。

String

getProperty(String key)             用指定的键在此属性列表中搜索属性。

 

 

import java.util.*; 

import java.text.*;

public class ThreadDemo 

{

         publicstatic void main(String[] args) 

         {

                   Propertiesprop=System.getProperties();

                   for(Objectobj:prop.keySet()){

                            Stringvalue=(String)prop.get(obj);

                            System.out.println(obj+"==="+value);

                   }

         }

}

 

 

Object

setProperty(String key, String value)             调用Hashtable的方法put，设置属性值。

动态加载命令——java –Dhaha=QQ SystemDemo.

 

Runtime类

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

由此特点可以看出该类使用了单例

 

Process

exec(String command)             在单独的进程中执行指定的字符串命令。打开一个程序

Process类中的

abstract  void

destroy()             杀掉子进程。

 

public class RuntimDemo {

   publicstaticvoid main(String[] args)throws Exception {

      Runtimer=Runtime.getRuntime();

      Processp=r.exec("C:\\软件 (x86)\\yy\\YY.exe");

      Thread.sleep(6000);

      p.destroy();

   }

}

 

 

 

二、

 

publicclassRuntimDemo {

   publicstaticvoid main(String[] args)throws Exception {

      Runtimer=Runtime.getRuntime();

      Processp=r.exec("C:\\软件 (x86)\\QvodPlayer\\QvodPlayer.exe D:\\娱乐\\电影\\优酷视频\\三星创意广告 - Allshare star - DJ Spider! 高清.mp4");

      Thread.sleep(30000);

      p.destroy();

   }

 

}

 

 

 

Date对象

publicclassThreadDemo 

{

   publicstaticvoid main(String[] args) 

   {

      Date d=new Date();

      SimpleDateFormatsdf=new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");//将时间格式化

      Stringtime=sdf.format(d);调用format方法封装对象

      System.out.println(time);

}

}

 

 

SimpleDateFormat类在java.text文件包中

Calendar对象

Calendar是抽象类；

getInstance()使用默认时区和语言环境获取一个日历。

 

import java.util.Calendar;

publicclassThreadDemo 

{

   publicstaticvoid main(String[] args) 

   {

      Calendarc=Calendar.getInstance();

      String[]mons={"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};

      String[]weak={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};      

      sop(c.get(Calendar.YEAR)+"年");

      sop(mons[c.get(Calendar.MONTH)]);

      sop(c.get(Calendar.DAY_OF_MONTH)+"日");

      sop(weak[c.get(Calendar.DAY_OF_WEEK)]);

      

   }

   publicstatic <T> void sop(T t){

      System.out.println(t);

   }

}

 

 

注意：c.get(Calendar.MONTH)是是从0开始的。

 

完善几个方法：

 

import java.util.Calendar;

publicclassThreadDemo 

{

   publicstaticvoid main(String[] args) 

   {

      Calendarc=Calendar.getInstance();

      String[]mons={"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};

      String[]weak={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};      

      sop(c.get(Calendar.YEAR)+"年");

      sop(mons[c.get(Calendar.MONTH)]);

      sop(c.get(Calendar.DAY_OF_MONTH)+"日");

      sop(weak[c.get(Calendar.DAY_OF_WEEK)]);

      c.add(Calendar.YEAR, 2014);//在原先获取年的基础上添加2014年。

      sop(c.get(Calendar.YEAR)+"年");

      c.set(Calendar.MONTH, 10);//在原先获取月的基础上改为11月。

//c.set(2014,4,5);

      sop(mons[c.get(Calendar.MONTH)]);

   }

   publicstatic <T> void sop(T t){

      System.out.println(t);

   }

}

 

 

 

Math  & Random

Math类中方法是静态的；

方法：

         abs(doublea);返回double值的绝对值。

         ceil(doublea);返回大于指定数据的最小整数。

         floor(doublea); 返回小于指定数据的最大整数。

         round（double a）；返回四舍五入后的数

         pow(doublea,double b);返回第一个数的第二个数次幂的值。

         random（）；返回带正好的double值，该值大于等于0.0且小于1.0；

 

Random类：Random r=new Random();

                   int d=r.nexInt（10）+1；

------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net