Java-Collections总结（java中Collections）-伙伴云

Java-Collections 总结（java中Collections）

网友投稿 994 2022-05-30

比较器

package aaa;

import java.util.Comparator;

public class ComparatorByLength implements Comparator {

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 list = new ArrayList();

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 ts = new TreeSet(new Comparator() {

@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 ts1 = new TreeSet(

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 list = new ArrayList();

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 void mySort(List list, Comparator 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

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

public static > void mySort(List 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 list = new ArrayList();

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个元素赋值为8：Arrays.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("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"\n"+Arrays.binarySearch(array1, 3));

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

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

}

输出结果：

填充数组：Arrays.fill(array, 5)：5 5 5 5 5

将数组的第2和第3个元素赋值为8：Arrays.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

元素3在array1中的位置：Arrays.binarySearch(array1, 3)：1

元素9在array1中的位置：Arrays.binarySearch(array1, 9)：-9

将数组转成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 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 list=Arrays.asList(arrIntegers);

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

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

List list1=Arrays.asList(arr);

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

}

集合转成数组

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 list = new ArrayList();

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 list = new ArrayList();

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 map=new LinkedHashMap();

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 me:map.entrySet())

{

Integer keyInteger=me.getKey();

String valString=me.getValue();

Java-Collections总结（java中Collections）

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

}

输出结果：

abc1

abc2

abc3

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 list = new ArrayList();

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 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对象就代表当前的系统时间，由于Calendar类toString实现的没有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)

以上示例代码设置的时间为2009年3月9日，其参数的结构和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类中还提供了很多其它有用的方法，下面简单的介绍几个常见方法的使用。

a、add方法：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天以后的日期，例如程序的输出结果可能为： 2009年6月17日

b、after方法：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代表的时间是2009年10月10号，对象c5代表的时间是2010年10月10号，则对象c5代表的日期在c4代表的日期之后，所以after方法的返回值是true。另外一个类似的方法是before，该方法是判断当前日期对象是否位于另外一个日期对象之前。

c、getTime方法：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对象

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

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、计算两个日期之间相差的天数

例如计算2010年4月1号和2009年3月11号之间相差的天数，则可以使用时间和日期处理进行计算。

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

import java.util.*;

/**

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

public class DateExample1 {

public static void main(String[] args) {

//设置两个日期

Calendar c1 = Calendar.getInstance();

c1.set(2009, 3 - 1, 11); //日期：2009年3月11号

Calendar c2 = Calendar.getInstance();

c2.set(2010, 4 - 1, 1); //日期：2010年4月1号

//转换为相对时间

long t1 = c1.getTimeInMillis();

long t2 = c2.getTimeInMillis();

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

System.out.println(days);

}

2、输出当前月的月历

该示例的功能是输出当前系统时间所在月的日历，例如当前系统时间是2009年3月10日，则输出2009年3月的日历。

该程序实现的原理为：首先获得该月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];

}

Java 数据结构

总结助手在哪里开启？（助手在哪里打开）

994 2022-05-30

Java-Collections 总结（java中Collections）

总结助手？

总结助手在哪里开启？（助手在哪里打开）

总结助手怎么用（助手的助手怎么写）

推荐文章

企业生产管理是什么，企业生产管理软件

进盘点进销存软件排行榜前十名

进销存系统哪个简单好用？进销存系统优点

工厂生产管理（工厂生产管理流程及制度）

生产管理软件，机械制造业生产管理，制造业生产过程管理软件

进销存软件和ERP有什么区别？进销存与erp软件理解

进销存如何进行库存管理

如何利用excel制作销售订单管理系统？

数据库订单管理系统有哪些功能？数据库订单管理系统怎么设计？

什么是数据库管理系统？

最近发表

热评文章

零代码开发是什么？2022低代码平台排行榜

智能进销存库存管理系统（智慧进销存）

在线文档哪家强？8款在线文档编辑软件推荐

WPS2016怎么绘制简单的价格表?

定制订单管理系统（为特定需求定制的订单管理系统）

连锁餐饮管理系统的功能有哪些？餐饮服务系统的构成及工

友情链接