java_day11

Java基础

Java常用类

Object类

• 超类、基类，是所有类的直接或间接的父类，位置继承树的顶端
• 任何类，都默认直接或者间接继承Object类
• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可以接受任何对象
  • 作为返回值，可以返回任何对象

getClass()方法

public class GetClass {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();

        Class c1 = stu1.getClass();
        Class c2 = stu2.getClass();
        //判断s1和s2是不是同一个类型
        if (c1 == c2){
            System.out.println("是同一类型");

        }else {
            System.out.println("没有关系");
        }


    }
}

hashCode()方法

• 放回对象的哈希码值

• 哈希码值是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

• 一般相同对象返回相同哈希码值

  public class HashCode {
      public static void main(String[] args) {
          Student stu1 = new Student();
          Student stu2 = new Student();
          Student stu3 = stu1;
          
          System.out.println(stu1.hashCode()); //460141958
          System.out.println(stu2.hashCode());//1163157884
          System.out.println(stu3.hashCode()); //460141958
      }
  }
  

toString()方法

• 返回该对象的字符串表示值

• 可以根据程序需求重写该方法

  public class Student {
      private String name;
      private int age;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  
      @Override
      public String toString() {
          return "Student{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  '}';
      }
  }
  
  public class Application {
      public static void main(String[] args) {
          Student stu1 = new Student();
          System.out.println(stu1.toString());
      }
  }
  
  

equals()方法

• 默认实现为this==obj 比较两个对象地址是否相等

  public class Application {
      public static void main(String[] args) {
          Student stu1 = new Student();
          Student stu2 = new Student();
          Student stu3 = stu1;
  
          //equals是判断二个对象的地址是否相等
          System.out.println(stu1.equals(stu2)); //false
          System.out.println(stu1.equals(stu3));//true
      }
  
  }
  

finalize()方法

• 当对象被判定为垃圾对象时，JVM自动调用此方法，以标记垃圾对象，进入回收队列
• 垃圾对象：没有有效引用指向此对象
• 垃圾回收：有GC销毁垃圾对象，释放资源
• 自动回收机制：JVM的内存耗尽，一次性回收所有的垃圾对象
• 手动回收机制：使用System.gc();通知JVM执行垃圾回收

包装类

• 基本数据类型所对应的引用数据类型

• Object可统一所有数据，包装类的默认值时null

类型转换与装箱、拆箱

将基本类型转为对应包装类叫装箱

而包装类转为基本类型叫拆箱

public class Demo1 {
    public static void main(String[] args) {

//-----------------JDK1.5以前--------------------------
        int num = 18;
        //创建Integer类对象 装箱
        Integer inte = new Integer(num);
        Integer inte2 = Integer.valueOf(num);

        //拆箱：包装类转基本类型
        Integer inte3 = new Integer(233);
        int num2 = inte3.intValue();

//        --------JDK1.5以后自动装箱----------------------
        int num3 = 15;
        //自动装箱
        Integer inte4 = num3;
        //自动拆箱
        int num4 = inte4;

    }
}

/*
        基本类型与字符串之间的转换
     */
    //基本类型转字符串
    int n1 = 34;
    //1.使用字符串+基本类型
    String str = n1+"";
    //2.使用包装类方法toString
    String str2 = Integer.toString(n1);
    String str3 = Integer.toString(n1,2);//后面一个参数是进制

    //字符串转基本类型
    String str4 = "3434";
    //使用包装类方法parseXXX
    int n2 = Integer.parseInt(str4);//字符串中不能包含数字外的字符
    System.out.println(n2);

    //boolean 字符串转基本类型，“true”>true 如果字符串不是true直接转为false
    String str5 = "df";
    boolean flag = Boolean.parseBoolean(str5);
    System.out.println(flag);//false

}

整数缓冲区

• Java预先创建256个常用的整数包装类对象

public class Demo2 {
    public static void main(String[] args) {
        //
        Integer int1 = new Integer(100);
        Integer int2 = new Integer(100);
        //对于包装类对象类型==比较的是地址
        System.out.println(int1==int2); //false

        Integer int3 = 101;//这里隐藏了valuOf方法
        Integer int4 = 101;
        System.out.println(int3==int4); //true

        Integer int5 = 128;
        Integer int6 = 128;
        System.out.println(int5==int6); //false


    }
}

注意

​ 这里在堆中有一个对于整数类型的数组缓冲区 向上述int3和int4返回true原因是二者的地址相同

而int5和int6的地址不相同。因为这里有一个自动装箱隐藏的valueof方法 规定在-128和127内的整数会方法堆中的数组即缓冲区中；若超过范围数字在堆中无法找到会new一个对象 地址也就不同了

String类

• 字符串是常量，创建后不可改变
• 字符串的值存储在字符串池中，可以共享

public class Demo3 {
    public static void main(String[] args) {
        String str = "zhangsan";//"zhangsan"存在字符串池中
        str = "lisi";//这里"zhangsan"依旧在字符串池中，只不过是新创建了"lisi"。是str的地址指向"lisi"

        String s = new String("lisi");
        String s2 = new String("lisi");


        System.out.println(s.equals(s2)); //true
        System.out.println(s2==s);//false
        
    }
}

String方法

length() 返回字符串长度

charAt() 返回某个位置的字符

contains() 判断是否包含某个字符串

toCharArray() 将字符串转成数组

indexOf() 返回某一个字符串首次出现的位置

lastIndexOf() 返回某一个字符串最后出现的位置

trim() 去除字符串前后的空格

toUpperCase() 小写字母转大写

toLoewerCase() 大写字母转小写

endwith() 判断是否以某字符串结尾

startwith() 判断是否以某字符串开头

replace(old,new) 用新的字符串替换旧的

split() 拆分字符串

compareTo() 比较大小

public class PracticeStr {
    /*
        1、将字符串中的单词单独获取出来
        2、将字符串中的text替换为protice
        3、在text前插入一个easy
        4、将每个单词的首字母改为大写
     */

    public static void main(String[] args) {

        String str = "this is a text";
        String[] strs = str.split(" ");

        for (String s : strs) {
            System.out.print(s+" ");
        }

        System.out.println("\n"+"====================");

        String str2 = str.replace("text","practice");
        System.out.println(str2);

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

        String str3 = str.replace("text","easy text");
        System.out.println(str3);

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

        for (int i = 0; i < strs.length; i++) {
            char s = Character.toUpperCase(strs[i].charAt(0));
            String str4 = s+strs[i].substring(1);
            System.out.print(str4+" ");

        }

    }
}

可变字符串

• StringBuffer:可变长字符串，运行效率慢、线程安全 多线程适合
• StringBuilder:可变长字符串，运行效率快、线程不安全 单线程适合
• 都比String类运行快

public static void main(String[] args) {
    //开始时间
    long start = System.currentTimeMillis();
    String str="";
    for (int i = 0; i < 99999; i++) {
        str += i;
    }
    System.out.println(str);
    long end = System.currentTimeMillis();
    System.out.println(end-start);//16s左右

    long start1 = System.currentTimeMillis();
    StringBuilder str1 = new StringBuilder("");
    for (int i = 0; i < 99999; i++) {
        str1.append(i);
    }
    System.out.println(str1.toString());
    long end1 = System.currentTimeMillis();
    System.out.println(end1-start1);//0.1s   
}

其他类

public class Demo7 {
    public static void main(String[] args) throws ParseException {
        Calendar cal = Calendar.getInstance();
        //年
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(""+year+month+day);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Date dt = new Date();
        String str = sdf.format(dt);
        System.out.println(str);

        Date dt2 = sdf.parse("2022/03/14");
        System.out.println(sdf.format(dt2));
    }
}

public class Demo8 {
    //System类
    public static void main(String[] args) {
        /**
         * arraycopy 复制数字
         * src 源数组
         * srcPos 从哪个位置开始
         * dest 目标数组
         * destPos 目标数组的位置
         * length 复制的长度
         */
        int[] src = {213,234,35,454,6546,345};
        int[] dest = new int[8];
        System.arraycopy(src,1,dest,0,4);
        for (int i : dest) {
            System.out.println(i);
        }

        System.out.println(System.currentTimeMillis());//从19700101到现在的毫秒

//        System.gc();提醒jvm可以回收垃圾了
        System.exit(0);//停止jvm


    }
}