Java数据类型的比较（续）

12. String(字符串)之间的比较

(1)String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。

(2)java中字符串的值是不可改变的，相同的字符串在内存中只会存一份，因此使用String直接定义的两个相同字符串，使用==来比较时，会返回true. 使用equals方法比较也会返回true.

(3)使用String和new String()定义的相同字符串，使用==比较将会返回false(不同的对象), 使用equals方法比较返回true.

(4)使用new String()创建的两个相同字符串，使用==比较时返回false（不同的对象）,使用equals方法比较返回true.

(5)字符串的+操作，也会生成新的对象。

(6)final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

(7)使用final修饰的两个字符串变量做拼接操作后，与另一个相同的字符串使用==比较返回的也是true.

示例代码1：

public class TypeCompare6 {

    public static void main(String[] args) {
        String s1 = "abcdef";
        String s2 = "abcdef";
        String s3 = "abc";
        String s4 = "def";
        String s5 = new String("abcdef");
        String s6 = new String("abcdef");
        String s7 = s3 + s4;
        final String s8 = "abc";
        final String s9 = "def";
        String s10 = s8 + s9;


        System.out.println(s1 == s2);  //true
        System.out.println(s1 == s5);  //false
        System.out.println(s3 == s4);  //false
        System.out.println(s5 == s6);  //false
        System.out.println(s1 == s7);  //false  s3+s4实际上是使用StringBuilder.append来完成，会生成不同的对象
        System.out.println(s1 == s10); //true 修饰的变量为常量，是不可修改的。final变量在编译后会直接替换成对应的值，所以实际上等于s10="abc"+"def"，而这种情况下，编译器会直接合并为s10="abcdef"，所以最终s1==s10。

        System.out.println("1: " + s1.equals(s2));  //true
        System.out.println("2: " + s3.equals(s4));  //false
        System.out.println("3: " + s5.equals(s6));  //true
        System.out.println("4: " + s1.equals(s5));  //true

    }

}

13. Date之间的比较

引入jar包(joda-time-2.10.6.jar)：

<!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
<dependency>    
    <groupId>joda-time</groupId>    
    <artifactId>joda-time</artifactId>    
    <version>2.10.6</version>
</dependency>

示例代码2：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.time.DateUtils;
import org.joda.time.DateTime;
import org.joda.time.LocalDate;

public class TypeCompare7 {

    // 方法一  只比较年月日，忽略时分秒
    public static boolean sameDate(Date d1, Date d2) {
        if (null == d1 || null == d2) {
            return false;
        }

        Calendar cal1 = Calendar.getInstance();
        cal1.setTime(d1);
        cal1.set(Calendar.HOUR_OF_DAY, 0);
        cal1.set(Calendar.MINUTE, 0);
        cal1.set(Calendar.SECOND, 0);
        cal1.set(Calendar.MILLISECOND, 0);

        Calendar cal2 = Calendar.getInstance();
        cal2.setTime(d2);
        cal2.set(Calendar.HOUR_OF_DAY, 0);
        cal2.set(Calendar.MINUTE, 0);
        cal2.set(Calendar.SECOND, 0);
        cal2.set(Calendar.MILLISECOND, 0);

        return cal1.getTime().equals(cal2.getTime());
    }

    // 方法二
    public static boolean sameDate1(Date date1, Date date2) throws ParseException {
        // 1.利用Date的equals比较大小
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // sdf.setTimeZone(new TimeZone()); // 如果需要设置时间区域，可以在这里设置

        if (date1.equals(date2)) {
            // 相等
            return true;
        } else {
            return false;
        }
    }

    // 方法三   只比较年月日，忽略时分秒
    public static boolean sameDate2(Date date1, Date date2) {
        return DateUtils.isSameDay(date1, date2);
    }

    // 方法四 只比较年月日，忽略时分秒  ， 需要引入joda-time-2.10.6.jar 包
    public static Boolean sameDate3(Date dt1, Date dt2) {
        LocalDate ld1 = new LocalDate(new DateTime(dt1));
        LocalDate ld2 = new LocalDate(new DateTime(dt2));
        return ld1.equals(ld2);
    }

    // 方法五  只比较年月日，忽略时分秒
    public static boolean sameDate4(Date d1, Date d2) {
        java.time.LocalDate localDate1 = ZonedDateTime.ofInstant(d1.toInstant(), ZoneId.systemDefault()).toLocalDate();
        java.time.LocalDate localDate2 = ZonedDateTime.ofInstant(d2.toInstant(), ZoneId.systemDefault()).toLocalDate();
        return localDate1.isEqual(localDate2);
    }

    // 方法六
    public static boolean sameDate5(Date date1, Date date2) {
        Calendar time1 = Calendar.getInstance();
        Calendar time2 = Calendar.getInstance();
        time1.setTime(date1);
        time2.setTime(date2);
        if(time1.equals(time2)) {
            return true;
        }else {
            return false;
        }

    }

    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String timeStr1 = "2020-07-01 12:45:45";
        String timeStr2 = "2020-07-01 12:45:40";
        Date date1 = sdf.parse(timeStr1);
        Date date2 = sdf.parse(timeStr2);

        //Date date1 = new Date();
        //Date date2 = new Date();
        System.out.println("1 = " + sameDate(date1, date2));   //true
        System.out.println("2 = " + sameDate1(date1, date2));  //false
        System.out.println("3 = " + sameDate2(date1, date2));  //true
        System.out.println("4 = " + sameDate3(date1, date2));  //true
        System.out.println("5 = " + sameDate4(date1, date2));  //true
        System.out.println("6 = " + sameDate5(date1, date2));  //false

    }

}

14. 默认值

基本数据类型对应的封装类型都是对象，对象的默认值为null.

String默认值为null.

点击查看更多内容

来源：oschina

链接：https://my.oschina.net/u/4353713/blog/4338348

标签

Joda-Time

def

java