1. public static void main(String[] args) {
  2.         Object o = new Object();
  3.         System.out.println(o);//java.lang.Object@1540e19d
  4.         System.out.println(o.toString());//java.lang.Object@1540e19d
  5.     }

两者结果完全一致，分析：System类

   out为System的静态变量

  1. System：
  1. public final static PrintStream out = null;

  1. public     void println(Object x) {
  2.         String s = String.valueOf(x);
  3.         synchronized (this) {
  4.             print(s);
  5.             newLine();
  6.         }
  7.     }

    String：
  1. public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }
  1.  

实际上printLn方法内部调用了String的valueOf()方法，valueOf()内部又掉了Object的toString()方法，所以这两者实质是一样的效果

  1. public static void main(String[] args) {
  2.         Object o1 = new Object();
  3.         Object o2 = new Object();
  4.         System.out.println(o1==o2);//false
  5.         System.out.println(o1.equals(o2));//false
  6.     }

Object类的equals方法和==没有区别，都是比较引用对象对应内存空间的地址值，故没有实际意义，真正意义在于其子类可以重写Object的equals方法来实现想要的效果

，举个例子：

  1. public class TestOne {
        public static void main(String[] args) {
            Person p1 = new Person("liuyan", '女');
            Person p2 = new Person("yangmi", '女');
            Person p3 = new Person("成龙", '男');
            System.out.println(p1.equals(p2));//true
            System.out.println(p1==p2);//false
            System.out.println(p1.equals(p3));//false
        }
    }
    class Person{
        private String name;
        private char gender;
        public Person(String name,char gender){
            this.name = name;
            this.gender = gender;
        }

        //比较Person对象重写后的的性别
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Person)) return false;
            Person person = (Person) o;
            if (gender != person.gender) {
                return false;
            }else {
                return true;
            }
        }

    }
    实际意义也就是如果有多个对象，地址值肯定不同，但只要属性值相同，用重写后的equals方法比较后就应该相等。
  1.  public static void main(String[] args) {
  2.         /**
  3.          * Calendar是一个抽象类，不能创建实例
  4.          * Calendar.getInstance()得到的是Calendar的子类对象
  5.          * 这个方法可以根据本地信息（时区/语言）来获取相应版本的日历
  6.          * 如果在日本，获取的就是JapaneseImperialCalendar 日本日历
  7.          * 如果在中国，获取的就是GregorianCalendar ,格里高利历 俗称‘公历’
  8.          */
  9.         Calendar ca = Calendar.getInstance();//2019-08-16
  10.         System.out.println("ca = " + ca);
  11.         //给月份向后平移两个月
  12.         ca.add(Calendar.MARCH,2);
  13.         int year = ca.get(Calendar.YEAR);
  14.         //国外时间是（0-11）所以需要加1
  15.         int month = ca.get(Calendar.MARCH) + 1;
  16.         int day = ca.get(Calendar.DAY_OF_MONTH);
  17.         System.out.println(year+"-"+month+"-"+day);//2019-10-16
  18.     }

 在格里高利历中，月份是从0-11依次对应中国的1-12，所以在取月份的时候要加1，set月份时候要减1，但如果set和get同时用到，就不需要加1和减1

例如：

  1.  
  1. Calendar ca2 = Calendar.getInstance();//2019-08-25
    ca2.set(Calendar.MARCH, 4-1);
    System.out.println(ca2.get(Calendar.MARCH)+1);
    System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(ca2.getTime()));
    Calendar ca3 = Calendar.getInstance();//2019-08-25
    ca3.set(Calendar.MARCH, 4);
    System.out.println(ca3.get(Calendar.MARCH));
    System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(ca3.getTime()));

    //结果

4
2019-04-25
4
2019-05-25

 

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将 数组中指定的数据拷贝到另一个数组中。

  1.     private static void arrayCopy() {
  2.         /**
  3.          * 前提是目标数组要又对应的值，不能造成数组越界异常
  4.          */
  5.         Integer[] arr1 = {1, 2, 3, 4, 5};
  6.         Integer[] arr2 = {6,7,8,9};
  7.         System.arraycopy(arr1,2,arr2,0,3);
  8.         System.out.println(Arrays.toString(arr2));
  9.     }
  • 由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改
  • 而StringBuffer刚好对此进行了优化，它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动 维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
  • 两个常用方法 append（）和toString
版权声明：本文为chenglei0718原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/chenglei0718/p/11361450.html