关闭

黑马程序员——集合(二) .

97人阅读 评论(0) 收藏 举报

黑马程序员--集合(二)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

一、泛型

1、定义
泛型(generic):一般的。JDK1.5版本以后出现的新特性。用于解决安全问题,是一个类型安全机制。
格式:通过<>来定义要操作的引用数据类型。<>就是用来接收类型的。

PS:
由来:借鉴数组的定义和操作。
JDK1.5之前定义Object来完成扩展(存在强制问题),现在定义泛型来完成扩展。
2、好处:
2.1 将运行时期出现问题,转移到了编译时期。方便于程序员解决问题,让运行时期问题减少,安全。
2.2 避免了强制转换麻烦。

一般方法:

  1. import java.util.*;  
  2. class GenericDemo1  
  3. {  
  4.     public static void main(String[] args)  
  5.     {  
  6.         ArrayList al = new ArrayList();  
  7.   
  8.         al.add("abc01");  
  9.         al.add("abc0234");  
  10.         al.add("abc012");  
  11.   
  12.         //同时存入字符串和数字时,存在类型转换异常。   
  13.         al.add(4);  
  14.   
  15.         for(Iterator it = al.iterator();it.hasNext();)  
  16.         {  
  17.             //向下转型。使用自定义内容。   
  18.             String s = (String)it.next();  
  19.             System.out.println(s+".."+s.length());  
  20.         }  
  21.     }  
  22. }  
运行结果:

泛型方法:

  1. import java.util.*;  
  2. class GenericDemo  
  3. {  
  4.     public static void main(String[] args)  
  5.     {  
  6.         /* 
  7.         在集合定义时就定义数据类型,这样就把不同类型的数据区分开,防止类型转换异常。 
  8.         这样的做法借鉴了数组格式。有利于将运行时期出现问题,转移到编译时期。 
  9.         */  
  10.         ArrayList<String> al = new ArrayList<String>();  
  11.   
  12.         al.add("abc01");  
  13.         al.add("abc0234");  
  14.         al.add("abc012");  
  15.   
  16.         //同时存入字符串和数字时,存在类型转换异常。   
  17.         al.add(4);//al.add(new Integer(4));   
  18.   
  19.         //指定迭代器类型,避免强转问题。   
  20.         for(Iterator<String> it = al.iterator();it.hasNext();)  
  21.         {  
  22.             String s = it.next();  
  23.   
  24.             System.out.println(s+".."+s.length());  
  25.         }  
  26.     }  
  27. }  
运行结果:

3、应用:
3.1 定义在集合框架中。通常在集合框架中很常见。只要见到<>就要定义泛型。
3.2 定义在接口上
3.3 定义在类中。当类中要操作的引用数据类型不确定的时候(注意:基本数据不确定无法自定义)。
3.3.1 泛型类存在局限性。因为方法接收的对象类型依据是对象定义的类型,所以一旦对象定义好类型,
方法接收的对象类型也将被固定。
3.3.2 泛型定义在方法上:可操作不同数据类型。它可以避免泛型类的局限性。
格式:放在返回值类型前、修饰符后。
3.3.3 静态方法不可以访问类上定义的泛型。因为它优先于对象加载。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。

  1. //泛型类。适用于当类中要操作的引用数据类型不确定的时候(注意:基本数据不确定无法自定义)。   
  2. class Demo<T>   
  3. {  
  4.     public void show(T t)  
  5.     {  
  6.         System.out.println("show:"+t);  
  7.     }  
  8.     //方法上定义泛型:可操作不同数据类型。   
  9.     public <Q> void print(Q q)  
  10.     {  
  11.         System.out.println("print:"+q);  
  12.     }  
  13.     //将泛型定义在静态方法上   
  14.     public static <W> void method(W t)  
  15.     {  
  16.         System.out.println("method:"+t);  
  17.     }  
  18. }  
  19. class GenericDemo2  
  20. {  
  21.     public static void main(String[] args)  
  22.     {  
  23.         Demo<Integer> d = new Demo<Integer>();  
  24.         //泛型类的局限性   
  25.         //d.show("hah");   
  26.         d.show(4);  
  27.   
  28.         d.print("hehe");  
  29.         d.print(4);  
  30.       
  31.         //调用静态方法   
  32.         Demo.method("dhdh");  
  33.     }  
  34. }  
运行结果:

3.4 ? 通配符。可理解为占位符。它用于定义泛型未明确的类型。
3.4.1泛型的高级应用
泛型限定 作用:用于功能扩展。
? extends E:可接收E类型或E的子类型。 上限。
? super E:可接收E类型或E的父类型。 下限。

  1. //泛型限定   
  2. import java.util.*;  
  3. class Person  
  4. {  
  5.     private String name;  
  6.     Person(String name)  
  7.     {  
  8.         this.name = name;  
  9.     }  
  10.     public String getName()  
  11.     {  
  12.         return name;  
  13.     }  
  14. }   
  15. class Student extends Person  
  16. {  
  17.     Student(String name)  
  18.     {  
  19.         super(name);  
  20.     }      
  21. }  
  22. //泛型下限应用,扩展了数据类型   
  23. class Comp implements Comparator<Person>//<? super E>   
  24. {  
  25.     public int compare(Person s1,Person s2)  
  26.     {  
  27.         return s1.getName().compareTo(s2.getName());  
  28.     }  
  29. }  
  30. class GenericDemo3  
  31. {  
  32.     public static void main(String[] args)  
  33.     {  
  34.         ArrayList<Person> al = new ArrayList<Person>();  
  35.   
  36.         al.add(new Person("abc1"));  
  37.         al.add(new Person("abc2"));  
  38.         al.add(new Person("abc3"));  
  39.   
  40.         //printColl(al);   
  41.   
  42.         ArrayList<Student> al1 = new ArrayList<Student>();  
  43.   
  44.         al1.add(new Student("abc---1"));  
  45.         al1.add(new Student("abc---2"));  
  46.         al1.add(new Student("abc---3"));  
  47.   
  48.         printColl(al1);   
  49.   
  50.         TreeSet<Student> ts = new TreeSet<Student>(new Comp());  
  51.         ts.add(new Student("abc1"));  
  52.         ts.add(new Student("abc2"));  
  53.         ts.add(new Student("abc3"));  
  54.   
  55.         //下限-->只接受Student及其父类。   
  56.         for(Iterator<? super Student> it = ts.iterator();it.hasNext();)  
  57.         {  
  58.             System.out.println(it.next());  
  59.         }  
  60.     }  
  61.     //上限-->只接受Person及其子类。   
  62.     public static void printColl(ArrayList<? extends Person> al)  
  63.     {  
  64.         for(Iterator<? extends Person> it = al.iterator();it.hasNext();)  
  65.         {  
  66.             System.out.println(it.next().getName());  
  67.         }  
  68.     }  
  69. }  
运行结果:

二、Map集合


1、Map集合:双列集合,该集合存储键值对。必须保证键的唯一性。Collection单列集合,一次添加一个元素。
2、常用方法:
2.1 添加
value put(key,value):返回前一个和key关联的值,如果没有返回null。
putAll(Map<? extends K,? extends V> m)
2.2 删除
void clear():清空集合。
value remove(Object key):根据指定的key删除这个键值对。
2.3 判断
boolean containsValue(Object value);
boolean containsKey(Object key);
boolean isEmpty();
2.4 获取
value get(Object key):通过获取值,如果没有该键返回null。
int size():获取键值对个数。

Collection<> Values():返回键值对值。

  1. //Map集合常见用法:   
  2. import java.util.*;  
  3. class MapDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         Map<String,String> map = new HashMap<String,String>();  
  8.   
  9.         //put()返回值为V,add()返回值为boolean。添加相同的键时,后添加的值会覆盖并返回   
  10.   
  11. 原有键对应值。  
  12.         sop("put:"+map.put("01","dou"));  
  13.         sop("put:"+map.put("01","bi"));  
  14.         map.put("02","ni");  
  15.         map.put("03","zhen");  
  16.         map.put("04","dour");  
  17.           
  18.         //删除   
  19.         sop("remove:"+map.remove("01"));  
  20.         sop("map:"+map);  
  21.   
  22.         //判读键是否存在   
  23.         sop("containsKey:"+map.containsKey("022"));  
  24.         //判读值是否存在   
  25.         sop("containsValue:"+map.containsValue("ni"));  
  26.   
  27.         //获取键对应的值   
  28.         sop("get:"+map.get("02"));  
  29.   
  30.         //可通过get方法的返回值判断键是否存在。一次取一个值。   
  31.         map.put("0192",null);  
  32.         sop("get:"+map.get("0192"));          
  33.           
  34.         //获取map集合中所有的值。   
  35.         Collection<String> coll = map.values();  
  36.   
  37.         sop(coll);  
  38.         sop("map:"+map);  
  39.     }  
  40.     public static void sop(Object obj)  
  41.     {  
  42.         System.out.println(obj);  
  43.     }  
  44. }  
运行结果:

Map集合的两种取出方式:
Set<K> keySet:将Map中所有的键存入到Set集合。一次可取出多个值。
Set<Map.Entry<k,v>> entrySet:将Map集合中的映射关系存入到set集合中,而这个关系的数据类型就是:Map.Entry。
Entry是Map接口的一个内部接口。
  1. /* 
  2. 每一个学生都有对应的归属地。 
  3. 学生Student,地址String. 
  4. 学生属性:姓名,年龄。 
  5. 注意:姓名和年龄相同的视为同一个学生。 
  6. 保证学生的唯一性。 
  7.  
  8. 思路: 
  9. 1. 描述学生。//描述事物时,系统默认比较哈希地址值。所以要注意按元素自身条件判断唯一性。 
  10.         //具体做法:复写hashCode、equals方法。 
  11.         //同时需要注意数据排序,这可以方便数据多时的整理。 
  12.     总结:数据多时,必须做:实现、覆盖两方法。 
  13. 2. 定义map容器。将学生作为键,地址作为值存入。 
  14. 3. 获取map集合中的元素。 
  15. */  
  16. import java.util.*;  
  17. //同时创建多个对象备用时,实现和复写必须要进行。   
  18. class Student implements Comparable<Student>  
  19. {  
  20.     private String name;  
  21.     private int age;  
  22.     Student(String name,int age)  
  23.     {  
  24.         this.name = name;  
  25.         this.age = age;  
  26.     }  
  27.     public int compareTo(Student s)  
  28.     {  
  29.         int num = new Integer(this.age).compareTo(new Integer(s.age));  
  30.   
  31.         if(num==0)  
  32.             return this.name.compareTo(s.name);  
  33.         return num;  
  34.     }  
  35.   
  36.     public int hashCode()  
  37.     {  
  38.         return name.hashCode()+age*23;  
  39.     }  
  40.     public boolean equals(Object obj)  
  41.     {  
  42.         if(!(obj instanceof Student))  
  43.             throw new ClassCastException("类型不匹配");  
  44.   
  45.         Student s = (Student)obj;  
  46.   
  47.         return this.name.equals(s.name) && this.age == s.age;  
  48.     }  
  49.     public String getName()  
  50.     {  
  51.         return name;  
  52.     }  
  53.     public int getAge()  
  54.     {  
  55.         return age;  
  56.     }  
  57.     public String toString()  
  58.     {  
  59.         return name+":"+age;  
  60.     }  
  61. }  
  62. class MapTest  
  63. {  
  64.     public static void main(String[] args)  
  65.     {  
  66.         HashMap<Student,String> hm = new HashMap<Student,String>();  
  67.   
  68.         hm.put(new Student("lisi1",21),"beijing");  
  69.         hm.put(new Student("lisi2",22),"nanjing");  
  70.         hm.put(new Student("lisi3",23),"tianjin");  
  71.         hm.put(new Student("lisi4",24),"shanghai");  
  72.   
  73.         //第一种取出方式 keySet       
  74.         Set<Student> keySet = hm.keySet();  
  75.   
  76.         for(Iterator<Student> it = keySet.iterator();it.hasNext();)  
  77.         {  
  78.             Student stu = it.next();  
  79.             String addr = hm.get(stu);  
  80.             System.out.println("学生信息:"+stu+",地址"+addr);  
  81.         }  
  82.   
  83.         //第二种取出方式 entrySet   
  84.         Set<Map.Entry<Student,String>> entrySet = hm.entrySet();  
  85.   
  86.         for(Iterator<Map.Entry<Student,String>> it = entrySet.iterator();it.hasNext();)  
  87.         {  
  88.             Map.Entry<Student,String> me = it.next();  
  89.             Student stu = me.getKey();  
  90.             String addr = me.getValue();  
  91.             System.out.println(stu+"........"+addr);  
  92.         }  
  93.     }  
  94. }  
运行结果:

PS:
1、Map和Set很像,因为Set底层使用了Map集合。
2、Map集合的取出原理:将Map集合转成set集合,再通过迭代器取出。

三、工具类

1、Collections类
Collections: 是集合框架的工具类,它的方法都是静态的。无对外提供构造函数,不需要封装对象。
sort(List<?> list):根据元素的自然顺序 对指定列表按升序进行排序。
max():获取对象中最大元素。 
binarySearch():二分搜索法。必须是有序集合。包含索引键,返回索引;不含,返回“插入点-1”。
replaceAll(List<T> list,T oldVal,T newVal):使用另一个值替换列表中出现的所有某一指定值。
swap(List<?> list,i,j):在指定列表的指定位置处交换元素。
shuffle(List<?> list):随机重置元素位置。
reverse(List<?> list):反转指定列表中元素的顺序。

fill(List<? super T> list,T obj):使用指定元素替换指定列表中的所有元素。

  1. //Collections: 集合工具类   
  2. import java.util.*;  
  3. class CollectionsDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         collsDemo();  
  8.     }  
  9.     public static void collsDemo()  
  10.     {  
  11.         List<String> list = new ArrayList<String>();  
  12.   
  13.         list.add("adss");  
  14.         list.add("sdfd");  
  15.         list.add("sfd");  
  16.         list.add("cc");  
  17.         list.add("w");  
  18.         list.add("sfd");  
  19.   
  20.         sop(list);  
  21.   
  22.         //1、sort 接收自定义比较器,按长度比较。只能给List排序。   
  23.         Collections.sort(list,new StrLenComparator());  
  24.         sop("sort1:"+list);  
  25.         //自然排序   
  26.         Collections.sort(list);  
  27.         sop("sort2:"+list);  
  28.   
  29.         //2、max 获取最大元素   
  30.         String max = Collections.max(list);   
  31.         sop("max="+max);  
  32.   
  33.         //3、binarySearch 二分查找,必须是自然排序   
  34.         int index = Collections.binarySearch(list,"cc");  
  35.         sop("index="+index);  
  36.   
  37.         //4、replaceAll 替换指定元素。等效于list.set(index,"pp");   
  38.         Collections.replaceAll(list,"cc","pp");  
  39.         sop("replaceAll:"+list);  
  40.   
  41.         //5、swap 置换指定位置元素   
  42.         Collections.swap(list,1,2);  
  43.         sop("swap:"+list);  
  44.   
  45.         //6、shuffle 随机排序(验证码)   
  46.         Collections.shuffle(list);  
  47.         sop("shuffle:"+list);  
  48.   
  49.         //7、reverse 反转   
  50.         Collections.reverse(list);  
  51.         sop("reverse:"+list);  
  52.   
  53.         //8、fill 把集合中值全换成pp。   
  54.         Collections.fill(list,"pp");  
  55.         sop("fill:"+list);  
  56.     }  
  57.     public static void sop(Object obj)  
  58.     {  
  59.         System.out.println(obj);  
  60.     }  
  61. }  
  62. //自定义比较器   
  63. class StrLenComparator implements Comparator<String>  
  64. {  
  65.     public int compare(String s1,String s2)  
  66.     {  
  67.         if(s1.length()>s2.length())  
  68.             return 1;  
  69.         if(s1.length()<s2.length())  
  70.             return -1;  
  71.         return s1.compareTo(s2);  
  72.     }  
  73. }  
运行结果:

PS:
SynchronizedList(List<T> list):返回指定列表支持的同步(线程安全的)列表。存在线程不安全问题是集合的共同特点。
2、Arrays类
Arrays:用于操作数组的工具类。里面都是静态方法。
equals():比较两个数组中内容是否相同。
deepEquals():比较两个数组及其内部内容是否相同。
2.1 List asList:将数组变成list集合。
优点:可以使用集合的思想和方法来操作数组中的元素,更加便捷。
缺点:集合不可以增删数组内容,因为数组的长度固定。否则发生UnsupportedOperationException。
如果数组中的元素都是对象,那么变成集合时,"数组中的元素"就直接转成集合中的元素。
如果数组中的元素都是基本数据类型,那么会将"该数组"作为集合中的元素存在。
2.2 集合变数组
操作:使用Collection接口中的toArray方法。可对集合中的元素操作的方法进行限定,不允许对其增删。
指定类型的数组到底要定义多长?
如果长度小于集合的size,那么该方法内部会创建一个新的数组。
如果长度大于集合的size,就不会创建一个新的数组。使用传递进来的数组,其他位置默认为null。
所以创建一个刚刚好的数组内存处置最优。
  1. //Arrays:用于操作数组的工具类。   
  2. import java.util.*;  
  3. class ArraysDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         int[] arr1 = {2,4,5};  
  8.   
  9.         System.out.println(Arrays.toString(arr1));  
  10.   
  11.         String[] arr2 = {"abc","cc","kkkk"};  
  12.   
  13.         List<String> list = Arrays.asList(arr2);  
  14.         sop("contains:"+list.contains("cc"));  
  15.         //注意打印的是list,不是arr.   
  16.         sop(list);  
  17.   
  18.         //将数组中的对象转成集合   
  19.         Integer[] nums1 = {2,4,5};  
  20.         List<Integer> list1 = Arrays.asList(nums1);  
  21.         sop("数组对象:"+list1);  
  22.   
  23.         //基本数据类型转成集合   
  24.         int[] nums2 = {2,4,5};  
  25.         List<int[]> list2 =Arrays.asList(nums2);  
  26.         sop("基本数据类型:"+list2);  
  27.           
  28.         List<String> list3 = new ArrayList<String>();  
  29.         list3.add("abc1");  
  30.         list3.add("abc2");  
  31.         list3.add("abc3");  
  32.   
  33.         //集合转数组   
  34.         String[] arr = list3.toArray(new String[2]);  
  35.         sop(Arrays.toString(arr));  
  36.     }  
  37.     public static void sop(Object obj)  
  38.     {  
  39.         System.out.println(obj);  
  40.     }  
  41. }  
运行结果:

3、System类

System类中的方法和属性都是静态的。out:标准输出,默认是控制台。in:标准输入,默认是键盘。
常见方法:
long currentTimeMillis():获取当前时间的毫秒值。作用:检测程序的执行时间。
Properties getProperties():获取系统属性信息。Properties集合中存储的都是String类型的键和值。
最好使用它自己的存储和取出的方法来完成元素的操作。
Windows系统中换行为\r\n两个转义字符,Linux只有一个\n。

  1. //System:类中的方法和属性都是静态的。   
  2. import java.util.*;  
  3. class SystemDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         long l1 = System.currentTimeMillis();  
  8.         sop("计时开始:"+l1);  
  9.         Properties prop = System.getProperties();  
  10.   
  11.         //因为Properties是Hashtable的子类,也就是Map集合的一个子类对象。   
  12.         //那么可以通过map的方法取出该集合中的元素。   
  13.         //该集合中存储都是字符串,没有泛型定义。   
  14.   
  15.         //获取指定属性信息   
  16.         String value = System.getProperty("os.name");  
  17.         sop("value="+value);  
  18.   
  19.         sop("转义字符\r\n:"+"hello-\r\n world");  
  20.         //定义跨系统信息   
  21.         final String LINE_SEPARATOR = System.getProperty("line.separator");  
  22.         sop("hello"+LINE_SEPARATOR+"java");  
  23.   
  24.         long l2 = System.currentTimeMillis();  
  25.         sop("共用时:"+(l2-l1));      
  26.     }  
  27.     public static void sop(Object obj)  
  28.     {  
  29.         System.out.println(obj);  
  30.     }  
  31. }  
运行结果:

4、Runtime类

每个Java应用程序都有一个Runtime类实例,使应用程序能和其运行的环境相连接。应用程序不能创建自己的Runtime类实例。
该类并没有提供构造函数。说明不可以创建对象。那么该类中的方法应该都是静态的。但发现该类中还有非静态方法。
说明该类肯定会提供静态方法获取本类对象。而且只有一个,说明该类使用了单例设计模式。
static Runtime  getRuntime():获取Runtime类。
  1. //Runtime对象        
  2. class RuntimeDemo  
  3. {  
  4.     public static void main(String[] args) throws Exception  
  5.     {  
  6.         Runtime r = Runtime.getRuntime();  
  7.   
  8.         //exec:在单独的进程中执行指定的字符串命令。   
  9.         Process p = r.exec("notepad.exe StaticImport.java");  
  10.   
  11.         Thread.sleep(4000);  
  12.         //杀进程   
  13.         p.destroy();  
  14.     }  
  15. }  

5、Math类

该类提供了静态的操作数学运算的方法。
常用方法:
ceil():返回大于参数的最小整数。
floor():返回小于参数的最大整数。
round():返回四舍五入的整数。
pow(a,b):a的b次方。
  1. //Math类   
  2. import java.util.*;  
  3. class MathDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         show();  
  8.         //返回大于或等于 0.0 但小于 1.0 的伪随机 double 值。   
  9.         Random r = new Random();  
  10.         for(int x=0; x<10;x++)  
  11.         {  
  12.             //强转成int类型数值   
  13.             int d = (int)(Math.random()*10+1);  
  14.             System.out.print(d+" ");  
  15.         }  
  16.         System.out.println();  
  17.   
  18.         for(int x=0; x<10;x++)  
  19.         {  
  20.             int d1 = r.nextInt(10)+1;  
  21.             System.out.print(d1+" ");  
  22.         }  
  23.         System.out.println();  
  24.     }  
  25.     public static void show()  
  26.     {  
  27.         //ceil返回大于指定数据的最小整数。   
  28.         double d = Math.ceil(16.34);  
  29.   
  30.         //floor返回小于指定数据的最大整数。   
  31.         double d1 = Math.floor(14.78);  
  32.       
  33.         //四舍五入   
  34.         long l = Math.round(12.5);  
  35.         sop("ceil:"+d);  
  36.         sop("floor:"+d1);  
  37.         sop("round:"+l);  
  38.   
  39.         //返回2^4。   
  40.         double d2 = Math.pow(2,4);  
  41.         sop("pow:"+d2);  
  42.     }  
  43.     public static void sop(Object obj)  
  44.     {  
  45.         System.out.println(obj);  
  46.     }  
  47. }  
运行结果:

6、Date、DateFormat类
日期对象和毫秒值间的转换:
a 毫秒值-->日期对象 new Date(); setTime();
b 日期对象-->毫秒值 getTime();
c 对日期对象进行格式化:使用DateFormat类中的format方法。
  1. import java.util.*;  
  2. import java.text.*;  
  3.   
  4. class DateDemo  
  5. {  
  6.     public static void main(String[] args)  
  7.     {  
  8.         Date d = new Date();  
  9.         sop(d);  
  10.   
  11.         sop("将日期对象转成毫秒值:"+d.getTime());  
  12.   
  13.         //将模式封装到SimpleDateFormat对象中。   
  14.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");  
  15.   
  16.         //调用format方法让模式格式化指定Date对象。   
  17.         String time = sdf.format(d);  
  18.   
  19.         sop("time="+time);  
  20.     }  
  21.     public static void sop(Object obj)  
  22.     {  
  23.         System.out.println(obj);  
  24.     }  
  25. }  
运行结果:

7、Calendar类

该类是一个抽象类,它为特定瞬间与一组诸如YREA、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换
提供了一些方法,并为操作日历字段提供了一些方法。
add(int field,int amount):依据日历规则,为指定日历字段指定添加或减去指定的时间量。
  1. /* 
  2. 1,获取任意年的二月有多少天。 
  3.     思路:根据指定年设置一个时间就是 
  4.     c.set(year,3,1)//某一年的3月1日。 
  5.     c.add(Calendar.DAY_OF_MONTH,-1);//3月1日前一天就是2月最后一天。 
  6. 2,获取昨天的现在这个时刻。 
  7.     c.add(Calendar.DAY_OF_MONTH,-1); 
  8. */  
  9. import java.util.*;  
  10. class CalendarDemo  
  11. {  
  12.     public static void main(String[] args)  
  13.     {  
  14.   
  15.         Calendar c = Calendar.getInstance();  
  16.   
  17.         c.set(2012,3,1);  
  18.   
  19.         c.add(Calendar.MONTH,-1);  
  20.   
  21.         c.add(Calendar.DAY_OF_MONTH,-1);  
  22.   
  23.         printlnCalendar(c);  
  24.     }  
  25.     public static void printlnCalendar(Calendar c)  
  26.     {  
  27.         String[] mons = {"一月","二月","三月","四月"  
  28.                 ,"五月","六月","七月","八月"  
  29.                 ,"九月","十月","十一月","十二月"};  
  30.   
  31.         String[] weeks = {"","星期日","星期一","星期二","星期三"  
  32.                     ,"星期四","星期五","星期六"};  
  33.   
  34.         int index = c.get(Calendar.MONTH);  
  35.   
  36.         int index1 = c.get(Calendar.DAY_OF_WEEK);  
  37.   
  38.   
  39.         sop(c.get(Calendar.YEAR)+"年");  
  40.   
  41.         //sop((c.get(Calendar.MONTH)+1)+"月");   
  42.         sop(mons[index]);  
  43.   
  44.         sop(c.get(Calendar.DAY_OF_MONTH)+"日");  
  45.   
  46.         //sop("星期"+c.get(Calendar.DAY_OF_WEEK));   
  47.         sop(weeks[index1]);       
  48.     }  
  49.     public static void sop(Object obj)  
  50.     {  
  51.         System.out.println(obj);  
  52.     }  
  53. }  
运行结果:

四、JDK1.5

JDK1.5版本出现的新特性。
JDK1.5版本后,Collection继承了Iterable接口。Iterable接口将iterator()方法抽取出来。
优点:提高了集合框架扩展性;提供了新功能:foreach:高级for循环。
1、foreach:高级for循环。凡是支持迭代器的集合都支持foreach。
1.1格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或数组){}
1.2特点:
优点:foreach简化了书写,可对集合进行遍历。
缺点:只能提出集合元素,不能修改。
PS:
迭代器:除了遍历,还可以进行remove集合中元素的动作;
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for区别:
高级for有一个局限性:必须有被遍历的目标。
建议:在遍历数组时,用传统for,因为其可以定义角标。
  1. //JDk1.5之后特性   
  2. import java.util.*;  
  3. class ForEachDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         ArrayList<String> al = new ArrayList<String>();  
  8.   
  9.         al.add("abc1");  
  10.         al.add("abc2");  
  11.         al.add("abc3");       
  12.       
  13.         //高级for循环   
  14.         for(String s : al)  
  15.         {  
  16.             s = "kk";         
  17.         }  
  18.         //只能打印集合内容,不能修改   
  19.         System.out.println("for循环后集合:"+al);  
  20.   
  21.         int[] arr = {3,5,6};  
  22.         for(int i : arr)  
  23.         {  
  24.             //高级for循环大大简化了书写   
  25.             System.out.println("i:"+i);  
  26.         }  
  27.   
  28.         HashMap<Integer,String> hm = new HashMap<Integer,String>();  
  29.   
  30.         hm.put(1,"a");  
  31.         hm.put(2,"b");  
  32.         hm.put(3,"c");  
  33.           
  34.         //用高级for循环取出键值对:方式一   
  35.         Set<Integer> keySet = hm.keySet();  
  36.         for(Integer i : keySet)  
  37.         {  
  38.             System.out.println(i+"::"+hm.get(i));  
  39.         }  
  40.   
  41.         //方式二   
  42.         //Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();   
  43.         //for(Map.Entry<Integer,String> me : entrySet)   
  44.         for(Map.Entry<Integer,String> me : hm.entrySet())  
  45.         {  
  46.             System.out.println(me.getKey()+":----:"+me.getValue());  
  47.         }  
  48.     }  
  49. }  
运行结果:

2、可变数组:简写了数组参数。 不用每次都手动的建立数组对象,只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成类数组。
格式:数据类型... 数组名 
注意:使用时,可变参数一定要定义在参数列表最后面。

  1. //JDK1.5版本出现的新特性:可变参数   
  2. class VariableArrayDemo  
  3. {  
  4.     public static void main(String[] args)  
  5.     {  
  6.         show("hah",2,1,2,115,3);  
  7.     }  
  8.     //使用时,可变参数一定要定义在参数列表最后面。   
  9.     public static void show(String str,int... ar)     
  10.     {  
  11.         System.out.println(ar.length);  
  12.     }  
  13. }  
运行结果:

3、静态导入(StaticImport):导入的是类的所有静态成员。
格式:
import static java.util.Arrays.*;
当类名重名时,需要指定具体的包名。

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

  1. //StaticImport 静态导入   
  2. import java.util.*;  
  3.   
  4. //导入的是Arrays这个类中的所有静态成员。   
  5. import static java.util.Arrays.*;  
  6.   
  7. //导入了System类中所有静态成员。   
  8. import static java.lang.System.*;  
  9.   
  10. class StaticImport  
  11. {  
  12.     public static void main(String[] args)  
  13.     {  
  14.         //由于静态导入,可省略类   
  15.         out.println("hah ");  
  16.   
  17.         int[] arr = {3,1,4};  
  18.   
  19.         sort(arr);//Arrays.sort(arr);   
  20.         int index = binarySearch(arr,4);//int index = Arrays.binarySearch(arr,1);   
  21.   
  22.         //这里的Arrays.不能省,因为Object有同名方法。   
  23.         out.println(Arrays.toString(arr));  
  24.         System.out.println("Index="+index);  
  25.     }  
  26. }  
运行结果:

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1661次
    • 积分:120
    • 等级:
    • 排名:千里之外
    • 原创:11篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章存档