Java-Collections总结

举报
AI浩 发表于 2022/04/13 20:03:41 2022/04/13
【摘要】 比较器package aaa;import java.util.Comparator;public class ComparatorByLength implements Comparator<String> {         public int compare(String o1, String o2) {                  String s1 = (String) o...

比较器

package aaa;

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {

         public int compare(String o1, String o2) {

                  String s1 = (String) o1;

                  String s2 = (String) o2;

                  int temp = s1.length() - s2.length();

                  return temp == 0 ? s1.compareTo(s2) : temp;

         }

}

package aaa;


import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.TreeSet;

public class ListDemo {

         public static void main(String[] args) {

                  // TODO Auto-generated method stub

                  demo_1();

                  demo_2();

                  demo_3();

                   Demo4();

         }

         public static void Demo4() {

                  List<String> list = new ArrayList<String>();

                  list.add("abcde");

                  list.add("cba");

                  list.add("zhangsan");

                  list.add("zhaoliu");

                  list.add("xiaoqiang");

                  System.out.println(list);

                  Collections.replaceAll(list, "cba", "NBA");// 原理set(indexOf("cba"),"nba");

                  System.out.println(list);

                  Collections.shuffle(list);//使用指定的随机源对指定列表进行置换。

                  System.out.println(list);

                  Collections.fill(list, "cc");//list中的所有元素替换冲cc,此方法用做集合的初始化

                  System.out.println(list);

         }

         public static void demo_3() {

                  // 通过比较器实现倒序排列

                  TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {

                          @Override

                          public int compare(String o1, String o2) {

                                   int temp = o2.compareTo(o1);

                                   return temp;

                          }

                  });

                  ts.add("abc");

                  ts.add("hahaha");

                  ts.add("zzz");

                  ts.add("aa");

                  ts.add("cba");

                  System.out.println(ts);

                  // 利用工具类中的方法实现翻转排序,排序规则按照比较器。

                  TreeSet<String> ts1 = new TreeSet<String>(

                                   Collections.reverseOrder(new ComparatorByLength()));

                  ts1.add("abc");

                  ts1.add("hahaha");

                  ts1.add("zzz");

                  ts1.add("aa");

                  ts1.add("cba");

                  System.out.println(ts1);

         }

         /**

          * 集合工具类排序

          */

         public static void demo_1() {

                  List<String> list = new ArrayList<String>();

                  list.add("abcde");

                  list.add("cba");

                  list.add("aa");

                  list.add("zzz");

                  list.add("cba");

                  list.add("nbaa");

                  System.out.println(list);

                  Collections.sort(list);

                  mySort(list);// Collections.sort(list)实现原理

                  System.out.println(list);

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

                  mySort(list, new ComparatorByLength());

                  System.out.println(list);

         }

         public static <T> void mySort(List<T> list, Comparator<? super T> comp) {

                  for (int i = 0; i < list.size() - 1; i++) {

                          for (int j = i + 1; j < list.size(); j++) {

                                   if (comp.compare(list.get(i), list.get(j)) > 0) {

                                            Collections.swap(list, i, j);

                                   }

                          }

                  }

         }

         /**

          * @param list

          *            Collections.sort(list)实现的原理, T extends Comparable<? super

          *            T>的意思是,所有实现Comparable的接口的类型或者父类实现Comparable接口的类型

          */

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

                  for (int i = 0; i < list.size() - 1; i++) {

                          for (int j = i + 1; j < list.size(); j++) {

                                   if (list.get(i).compareTo(list.get(j)) > 0) {

                                            Collections.swap(list, i, j);// 交换位置

                                   }

                          }

                  }

         }

         public static void demo_2() {

                  List<String> list = new ArrayList<String>();

                  list.add("abcde");

                  list.add("cba");

                  list.add("aa");

                  list.add("zzz");

                  list.add("cba");

                  list.add("nbaa");

                  System.out.println(list);

                  Collections.sort(list);

                  int index = Collections.binarySearch(list, "cba");

                  System.out.println("index=" + index);

                  String max = Collections.max(list, new ComparatorByLength());

                  System.out.println("max=" + max);

         }

}









java.util.Arrays类能方便地操作数组,它提供的所有方法都是静态的。具有以下功能:

  • 给数组赋值:通过fill方法。
  • 对数组排序:通过sort方法,按升序。
  • 比较数组:通过equals方法比较数组中元素值是否相等。
  • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;

public class TestArrays {

public static void output(int[] array) {

if (array!=null) {

for (int i = 0; i < array.length; i++) {

System.out.print(array[i]+" ");

}

}

System.out.println();

}

public static void main(String[] args) {

int[] array = new int[5];

//填充数组

Arrays.fill(array, 5);

System.out.println("填充数组:Arrays.fill(array, 5)");

TestArrays.output(array);

//将数组的第2和第3个元素赋值为8

Arrays.fill(array, 2, 4, 8);

System.out.println("将数组的第2和第3个元素赋值为8Arrays.fill(array, 2, 4, 8)");

TestArrays.output(array);

int[] array1 = {7,8,3,2,12,6,3,5,4};

//对数组的第2个到第6个进行排序进行排序

Arrays.sort(array1,2,7);

System.out.println("对数组的第2个到第6个元素进行排序进行排序:Arrays.sort(array,2,7)");

TestArrays.output(array1);

//对整个数组进行排序

Arrays.sort(array1);

System.out.println("对整个数组进行排序:Arrays.sort(array1)");

TestArrays.output(array1);

//比较数组元素是否相等

System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));

int[] array2 = array1.clone();

System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"\n"+Arrays.equals(array1, array2));

//使用二分搜索算法查找指定元素所在的下标(必须是排序好的,否则结果不正确)

Arrays.sort(array1);

System.out.println("元素3array1中的位置:Arrays.binarySearch(array1, 3)"+"\n"+Arrays.binarySearch(array1, 3));

//如果不存在就返回负数

System.out.println("元素9array1中的位置:Arrays.binarySearch(array1, 9)"+"\n"+Arrays.binarySearch(array1, 9));

}

}

输出结果:

填充数组:Arrays.fill(array, 5)5 5 5 5 5
将数组的第2和第3个元素赋值为8Arrays.fill(array, 2, 4, 8)5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序:Arrays.sort(array,2,7)
7 8 2 3 3 6 12 5 4
对整个数组进行排序:Arrays.sort(array1)2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):true
元素3array1中的位置:Arrays.binarySearch(array1, 3)1
元素9array1中的位置:Arrays.binarySearch(array1, 9)-9

  1. 将数组转成List集合

package aaa;

import java.util.Arrays;

import java.util.List;

public class ArraysDemo {

   public static void main(String[] args) {

           demo_1();

           demo_2();

   }

   /**

    * Arrays.asList方法将数组转化成List集合

    */

   public static void demo_1()

   {/*

            * 重点:List asList(数组)将数组转成集合。

            * 好处:其实可以使用集合的方法操作数组中的元素。

            * 注意:数组的长度是固定的,所以对于集合的增删方法是不可以使用的

            * 否则会发生UnsupportedOperationException

            */

           String[] arrStrings={"abc","haha","xixi"};

           List<String> list=Arrays.asList(arrStrings);

           boolean b1=list.contains("xixi");

           //list.add("hehe");//UnsupportedOperationException

           System.out.println("list contains="+b1);

   }

   public static void demo_2()

   {

           /*

            * 如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储。

   * 如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储。

            */

           Integer[] arrIntegers={12,32,434,55,67,87};//

           List<Integer> list=Arrays.asList(arrIntegers);

           System.out.println(list);//输出结果:[12, 32, 434, 55, 67, 87]

           int[] arr={31,11,51,61};

           List<int[]> list1=Arrays.asList(arr);

           System.out.println(list1.toString());//输出结果:[[I@154ab8e4]

   }

}

  1. 集合转成数组

package aaa;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class ToArray {

   public static void main(String[] args) {

           /*

            * 集合转成数组呢?

            * 使用的就是Collection接口中的toArray方法。

            * 集合转成数组:可以对集合中的元素操作的方法进行限定。不允许对其进行增删。

            */

           List<String> list = new ArrayList<String>();

           list.add("abc1");

           list.add("abc2");

           list.add("abc3");

           /*

            * toArray方法需要传入一个指定类型的数组。

            * 长度该如何定义呢?

            * 如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size的数组。

            * 如果长度大于集合的size,那么该方法就会使用指定的数组,存储集合中的元素,其他位置默认为null。

            * 所以建议,最后长度就指定为,集合的size。

            */

           String[] arrStrings=list.toArray(new String[list.size()]);

           System.out.println(Arrays.toString(arrStrings));//输出结果:[abc1, abc2, abc3]

   }

}


1、格式:

for(类型  变量   :Collection集合|数组)

         {      

         }

等同于C#中的foreach

2、传统for和高级for的区别?

  传统for可以完成对语句执行很多次,因为可以定义控制循环的增量和条件。

高级for是一种简化形式。

它必须有被遍历的目标。该目标要是数组,要么是Collection单列集合。

对数数组的遍历如果仅仅是获取数组中的元素,可以使用高级for。

如果要对数组的角标进行操作建议使用传统for。

package aaa;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

public class ForEachDemo {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        for (String s:list) {//简化书写

            System.out.println(s);

        }

        int[] arr={2,3,3,4};

        for (int i :arr) {

            System.out.println(i);

        }

        Map<Integer, String> map=new LinkedHashMap<Integer,String>();

        map.put(3, "zhangsan");

        map.put(2,"wangyi");

        map.put(7,"wangwu");

        map.put(4, "zhangsansan");

        for (Integer key:map.keySet()) {

            String valueString=map.get(key);

            System.out.println(key+"::"+valueString);

        }

        for(Map.Entry<Integer, String> me:map.entrySet())

        {

            Integer keyInteger=me.getKey();

            String valString=me.getValue();

            System.out.println(keyInteger+":"+valString);

        }

    }

}

输出结果:

abc1

abc2

abc3

2

3

3

4

3::zhangsan

2::wangyi

7::wangwu

4::zhangsansan

3:zhangsan

2:wangyi

7:wangwu

4:zhangsansan



package cn.itcast.p4.news.demo;

public class ParamterDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

             int sum = newAdd(5,1,4,7,3);

             System.out.println("sum="+sum);

             int sum1 = newAdd(5,1,2,7,3,9,8,7,6);

             System.out.println("sum1="+sum1);

    }

    /*

     * 函数的可变参数。

     * 其实就是一个数组,但是接收的是数组的元素。

     * 自动将这些元素封装成数组。简化了调用者的书写。

     * 注意:可变参数类型,必须定义在参数列表的结尾。

     */

    public static int newAdd(int a,int...  arr){

             int sum = 0;

             for (int i = 0; i < arr.length; i++) {

                      sum+=arr[i];

             }

             return sum;

    }


package cn.itcast.p4.news.demo;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import static java.util.Collections.*;//静态导入,其实到入的是类中的静态成员。

import static java.lang.System.*;

public class StaticImportDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

             List<String> list = new ArrayList<String>();

             list.add("abc3");

             list.add("abc7");

             list.add("abc1");

             out.println(list);

             sort(list);//静态导入之后,就不用写Collections

             System.out.println(list);

             String max = max(list);

             System.out.println("max="+max);

    }

}

输出结果:

[abc1, abc3, abc7]

max=abc7


package aaa;

import java.util.Properties;

import java.util.Set;

public class SystemDemo {

         private static final String LINE_SEPARATOR = System

                          .getProperty("line.separator");// 获取换行符,不同的系统,换行符是不一样的。需要根据属性来获取,要不然可能出现不兼容的现象

         public static void main(String[] args) {

                  // TODO Auto-generated method stub

                  demo_1();

                  demo_2();

         }

         private static void demo_2() {

                  /*

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

                   * 常见方法: long currentTimeMillis();获取当前时间的毫秒值。

                   */

                  long l2 = System.currentTimeMillis();

                  System.out.println(l2);// 输出的结果是当前时间的毫秒值

                  System.out.println("hello-"+LINE_SEPARATOR+" world");//换行

         }

         /**

          * 获取所有的属性

          */

         private static void demo_1() {

                  // 获取系统的属性信息,并存储到了Properties集合中。

                  /*

                   * properties集合中存储都是String类型的键和值。 最好使用它自己的存储和取出的方法来完成元素的操作。

                   */

                  Properties properties = System.getProperties();

                  Set<String> namSet = properties.stringPropertyNames();

                  for (String string : namSet) {

                          String valueString = properties.getProperty(string);

                          System.out.println(string + "::" + valueString);

                  }

         }

}




在java中Runtime类表示运行时操作类,是一个封装了JVM进程的类,每一个JVM都对应着一个Runtime类的实例,此实例由JVM运行时为其实例化。所以在JDK文档中读者不会发现任何有关Runtime类中构造方法的定义,这是因为Runtime类本身的构造方法是私有化的(单例设计),如果想要得到一个Runtime实例,只有以下方法:

Runtime run=Runtime.getRuntime();

也就是说在Runtime类中提供了一个静态的getRuntime()方法,此类可以取得Runtime类的实例,然后通过Runtime就可以取得一些系统的信息。如,getRuntime(),取得Runtime实例;freeMemory()返回java虚拟机中的空闲内存量;maxMemory()返回JVM的最大内存量;gc()运行垃圾回收器,释放空间;exec(command)执行本机命令。

package aaa;

import java.io.IOException;

public class RuntimeDemo {

         public static void main(String[] args) throws IOException,

                          InterruptedException {

                  // TODO Auto-generated method stub

                  Runtime runtime = Runtime.getRuntime();

                  Process p = runtime.exec("notepad.exe");

                  Thread.sleep(5000);

                  p.destroy();// 销毁进程

                  runtime.gc();// 垃圾回收

                  runtime.exec("notepad.exe c:\\RuntimeDemo.java");//用notepad.exe打开RuntimeDemo文件

         }

}


package aaa;

import java.util.Random;

public class MathDemo {

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       /*

        * Math:提供了操作数学运算的方法。都是静态的。

        * 常用的方法:

        * ceil():返回大于参数的最小整数。

        * floor():返回小于参数的最大整数。

        * round():返回四舍五入的整数。

        * pow(a,b):a的b次方。

        */

       double d1 = Math.ceil(12.56);

       double d2 = Math.floor(12.56);

       double d3 = Math.round(12.46);

       sop("d1="+d1);

       sop("d2="+d2);

       sop("d3="+d3);

       double d = Math.pow(10, 2);

        sop("d="+d);

        //第一种  输出1到10 的随机数

        for (int i = 0; i < 10; i++) {

           double d4=(int)(Math.random()*10+1);

           System.out.println(d4);

       }

        //第二种  输出1到10 的随机数

        Random random=new Random();              

        for (int i = 0; i < 10; i++) {

       double d5=(int)(random.nextDouble()*10+1);

       System.out.println(d5);

       int d6=random.nextInt(10)+1;

       System.out.println(d6);

       }

    }

    public static void sop(String string) {

       System.out.println(string);

    }

}


package aaa;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo {

         public static void main(String[] args) throws ParseException {

                  // TODO Auto-generated method stub

                  demo_1();

                  demo_2();

                  demo_3();

         }

         /**

          * 将日期格式的字符串-->日期对象。

          *   使用的是DateFormat类中的parse()方法。

          * @throws ParseException

          */

         private static void demo_3() throws ParseException {

                  // TODO Auto-generated method stub

                  String str_Date = "2015年4月12日";

                  DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);

                  Date date = dateFormat.parse(str_Date);

                  System.out.println(date);

                  //自定义格式转换为日期对象

                  str_Date="2015---08--12";

                  dateFormat=new SimpleDateFormat("yyyy---MM--dd");

                  date=dateFormat.parse(str_Date);

                  System.out.println(date);

         }

         /**

          * 对日期对象进行格式化。 将日期对象-->日期格式的字符串。 使用的是DateFormat类中的format方法。

          */

         private static void demo_2() {

                  // TODO Auto-generated method stub

                  Date date = new Date();

                  DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);// 格式化日期

                  System.out.println(dateFormat.format(date));

                  dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,

                                   DateFormat.LONG);// 格式化日期和时间

                  System.out.println(dateFormat.format(date));

                  // 自定义风格

                  dateFormat = new SimpleDateFormat("yyyy--MM--dd");

                  String stringDate = dateFormat.format(date);

                  System.out.println(stringDate);

         }

         /**

          * 日期对象和毫秒值之间的转换。

          *

          * 毫秒值-->日期对象 : 1,通过Date对象的构造方法 new Date(timeMillis); 2,还可以通过setTime设置。

          * 因为可以通过Date对象的方法对该日期中的各个字段(年月日等)进行操作。 日期对象-->毫秒值: 2,getTime方法。

          * 因为可以通过具体的数值进行运算。

          */

         private static void demo_1() {

                  Date date = new Date();// 将当前日期和时间封装成Date对象。

                  System.out.println(date);// Sun Apr 29 11:48:02 CST 2012

                  long time = System.currentTimeMillis();

                  Date date1 = new Date(time);

                  System.out.println(date1);

         }

}

练习: "2012-3-17"到"2012-4-6"中间有多少天?

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

/*

 * 思路:两个日期相减就哦了。

 * 咋减呢?必须要有两个可以进行减法运算的数。

 * 能减可以是毫秒值。如何获取毫秒值?通过date对象。

 * 如何获取date对象呢?可以将字符串转成date对象。

* 1,将日期格式的字符串转成Date对象。2,将Date对象转成毫秒值。3,相减,在变成天数

*/

public class DateTest {

         public static void main(String[] args) throws ParseException {

                  String str_date1 = "2012-3-17";

                  String str_date2 = "2012-4-18";

                  test(str_date1,str_date2);

         }

         public static void test(String str_date1,String str_date2) throws ParseException {

                  DateFormat dateFormat = DateFormat.getDateInstance();//定义日期格式对象。

                  dateFormat = new SimpleDateFormat("yyyy-MM-dd");

                  Date date1 = dateFormat.parse(str_date1); //1,将日期字符串转成日期对象。

                  Date date2 = dateFormat.parse(str_date2);

                  long time1 = date1.getTime();

                  long time2 = date2.getTime();

                  long time = Math.abs(time1-time2);

                  int day = getDay(time);

                  System.out.println(day);

         }

         private static int getDay(long time) {

                  int day = (int)(time/1000/60/60/24);

                  return day;

         }

}


JDK1.1版本开始,在处理日期和时间时,系统推荐使用Calendar类进行实现。在设计上,Calendar类的功能要比Date类强大很多,而且在实现方式上也比Date类要复杂一些,下面就介绍一下Calendar类的使用。

Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可。

1、使用Calendar类代表当前时间

                   Calendar c = Calendar.getInstance();

由于Calendar类是抽象类,且Calendar类的构造方法是protected的,所以无法使用Calendar类的构造方法来创建对象,API中提供了getInstance方法用来创建对象。

使用该方法获得的Calendar对象就代表当前的系统时间,由于CalendartoString实现的没有Date类那么直观,所以直接输出Calendar类的对象意义不大。

2、使用Calendar类代表指定的时间

                   Calendar c1 = Calendar.getInstance();

                   c1.set(2009, 3 - 1, 9);

使用Calendar类代表特定的时间,需要首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。

set方法的声明为:

         public final void set(int year,int month,int date)

以上示例代码设置的时间为200939日,其参数的结构和Date类不一样。Calendar类中年份的数值直接书写,月份的值为实际的月份值减1,日期的值就是实际的日期值。

如果只设定某个字段,例如日期的值,则可以使用如下set方法:

         public void set(int field,int value)

在该方法中,参数field代表要设置的字段的类型,常见类型如下:

         Calendar.YEAR——年份

         Calendar.MONTH——月份

         Calendar.DATE——日期

         Calendar.DAY_OF_MONTH——日期,和上面的字段完全相同

         Calendar.HOUR——12小时制的小时数

         Calendar.HOUR_OF_DAY——24小时制的小时数

         Calendar.MINUTE——分钟

         Calendar.SECOND——

         Calendar.DAY_OF_WEEK——星期几

后续的参数value代表,设置成的值。例如:

         c1.set(Calendar.DATE,10);

该代码的作用是将c1对象代表的时间中日期设置为10号,其它所有的数值会被重新计算,例如星期几以及对应的相对时间数值等。

3、获得Calendar类中的信息

                   Calendar c2 = Calendar.getInstance();

                   int year = c2.get(Calendar.YEAR); //年份

                   int month = c2.get(Calendar.MONTH) + 1; //月份

                   int date = c2.get(Calendar.DATE); //日期

                   int hour = c2.get(Calendar.HOUR_OF_DAY); //小时

                   int minute = c2.get(Calendar.MINUTE); //分钟

                   int second = c2.get(Calendar.SECOND);   //

                   int day = c2.get(Calendar.DAY_OF_WEEK); //星期几

                   System.out.println("年份:" + year);

                   System.out.println("月份:" + month);

                   System.out.println("日期:" + date);

                   System.out.println("小时:" + hour);

                   System.out.println("分钟:" + minute);

                   System.out.println("秒:" + second);

                   System.out.println("星期:" + day);

使用Calendar类中的get方法可以获得Calendar对象中对应的信息,get方法的声明如下:public int get(int field)

其中参数field代表需要获得的字段的值,字段说明和上面的set方法保持一致。需要说明的是,获得的月份为实际的月份值减1,获得的星期的值和Date类不一样。在Calendar类中,周日是1,周一是2,周二是3,依次类推。

4、其它方法说明

其实Calendar类中还提供了很多其它有用的方法,下面简单的介绍几个常见方法的使用。

aadd方法:public abstract void add(int field,int amount)

该方法的作用是在Calendar对象中的某个字段上增加或减少一定的数值,增加是amount的值为正,减少时amount的值为负。

         例如在计算一下当前时间100天以后的日期,代码如下:

                   Calendar c3 = Calendar.getInstance();

                   c3.add(Calendar.DATE, 100);

                   int year1 = c3.get(Calendar.YEAR);

                   int month1 = c3.get(Calendar.MONTH) + 1; //月份

                   int date1 = c3.get(Calendar.DATE); //日期

                   System.out.println(year1 + "" + month1 + "" + date1 + "");

这里add方法是指在c3对象的Calendar.DATE,也就是日期字段上增加100,类内部会重新计算该日期对象中其它各字段的值,从而获得100天以后的日期,例如程序的输出结果可能为: 2009617

bafter方法:public boolean after(Object when)

该方法的作用是判断当前日期对象是否在when对象的后面,如果在when对象的后面则返回true,否则返回false。例如:

                   Calendar c4 = Calendar.getInstance();

                   c4.set(2009, 10 - 1, 10);

                   Calendar c5 = Calendar.getInstance();

                   c5.set(2010, 10 - 1, 10);

                   boolean b = c5.after(c4);

                   System.out.println(b);

在该示例代码中对象c4代表的时间是20091010号,对象c5代表的时间是20101010号,则对象c5代表的日期在c4代表的日期之后,所以after方法的返回值是true。另外一个类似的方法是before,该方法是判断当前日期对象是否位于另外一个日期对象之前。

                   cgetTime方法:public final Date getTime()

该方法的作用是将Calendar类型的对象转换为对应的Date类对象,两者代表相同的时间点。

类似的方法是setTime,该方法的作用是将Date对象转换为对应的Calendar对象,该方法的声明如下:public final void setTime(Date date)

转换的示例代码如下:

                  Date d = new Date();

                   Calendar c6 = Calendar.getInstance();

                    Date d1 = c6.getTime();     //Calendar类型的对象转换为Date对象

                     Calendar c7 = Calendar.getInstance();

                   c7.setTime(d); //Date类型的对象转换为Calendar对象

         5Calendar对象和相对时间之间的互转

                            Calendar c8 = Calendar.getInstance();

                            long t = 1252785271098L;

                               long t1 = c8.getTimeInMillis();    //Calendar对象转换为相对时间

                             Calendar c9 = Calendar.getInstance();

                            c9.setTimeInMillis(t1); //将相对时间转换为Calendar对象

在转换时,使用Calendar类中的getTimeInMillis方法可以将Calendar对象转换为相对时间。在将相对时间转换为Calendar对象时,首先创建一个Calendar对象,然后再使用Calendar类的setTimeInMillis方法设置时间即可。

应用示例

         下面以两个简单的示例介绍时间和日期处理的基本使用。

         1、计算两个日期之间相差的天数

例如计算201041号和2009311号之间相差的天数,则可以使用时间和日期处理进行计算。

该程序实现的原理为:首先代表两个特定的时间点,这里使用Calendar的对象进行代表,然后将两个时间点转换为对应的相对时间,求两个时间点相对时间的差值,然后除以1天的毫秒数(24小时X60分钟X60X1000毫秒)即可获得对应的天数。实现该示例的完整代码如下:

         import java.util.*;

/**

 * 计算两个日期之间相差的天数

 */

public class DateExample1 {

         public static void main(String[] args) {

                   //设置两个日期

                       Calendar c1 = Calendar.getInstance();

                    c1.set(2009, 3 - 1, 11); //日期:2009311

                      Calendar c2 = Calendar.getInstance();

                   c2.set(2010, 4 - 1, 1);    //日期:201041

                   //转换为相对时间

                   long t1 = c1.getTimeInMillis();

                   long t2 = c2.getTimeInMillis();

                    long days = (t2 - t1)/(24 * 60 * 60 * 1000); //计算天数

                   System.out.println(days);

         }

}

         2、输出当前月的月历

该示例的功能是输出当前系统时间所在月的日历,例如当前系统时间是2009310日,则输出20093月的日历。

该程序实现的原理为:首先获得该月1号是星期几,然后获得该月的天数,最后使用流程控制实现按照日历的格式进行输出即可。即如果1号是星期一,则打印一个单位的空格,如果1号是星期二,则打印两个单位的空格,依次类推。打印完星期六的日期以后,进行换行。实现该示例的完整代码如下:

public class DateExample2{

         public static void main(String[] args){

                   //获得当前时间

                   Calendar c = Calendar.getInstance();

                   c.set(Calendar.DATE,1);   //设置代表的日期为1

                   int start = c.get(Calendar.DAY_OF_WEEK); //获得1号是星期几

       int maxDay = c.getActualMaximum(Calendar.DATE); //获得当前月的最大日期数

                   //输出标题

            System.out.println("星期日 星期一 星期二 星期三 星期四 星期五   星期六");

                   //输出开始的空格

                   for(int i = 1;i < start;i++){

                            System.out.print("      "); 

                   }

                   //输出该月中的所有日期

                   for(int i = 1;i <= maxDay;i++){

                              System.out.print(" " + i);    //输出日期数字

                              System.out.print("     "); //输出分隔空格

                            if(i < 10){System.out.print(' ');}

                            //判断是否换行

                            if((start + i - 1) % 7 == 0){  System.out.println();   }

                   }

                    System.out.println();       //换行

         }       

}

package cn.itcast.p1.otherapi;

import java.util.Calendar;

public class CalendarDemo {

         public static void main(String[] args) {

                  Calendar c = Calendar.getInstance();

                  int year = 2012;

                  showDays(year);

         }

//求二月份有多少天,思路:三月份第一天减一得到二月最后一天的天数

         public static void showDays(int year) {

                  Calendar c = Calendar.getInstance();

                  c.set(year, 2, 1);

                  c.add(Calendar.DAY_OF_MONTH, -1);

                  showDate(c);

         }

//获取Calendar对象的时间属性

         public static void showDate(Calendar c) {

                  int year = c.get(Calendar.YEAR);

                  int month = c.get(Calendar.MONTH)+1;

                  int day = c.get(Calendar.DAY_OF_MONTH);

                  int week = c.get(Calendar.DAY_OF_WEEK);

                  System.out.println(year+""+month+""+day+""+getWeek(week));

         }

         public static String getWeek(int i) {

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

                  return weeks[i];

         }

}

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200