标签：java String day06 System 站千锋 println public out

java自学笔记（day06），归纳总结自：B站千锋教育

Object类

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如果没有书写extends显式继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所有定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
  • 作为参数，可接受任何对象。
  • 作为返回值，可返回任何对象。

getClass()方法

public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用：通过用于判断两个引用中实际存储对象类型是否一致。

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("yangge", 18);
        Student s2 = new Student("wangge", 20);

        Class class1 = s1.getClass();
        Class class2 = s2.getClass();

        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

hashCode()方法

public int hashCode(){}

返回该对象的哈希码值。

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

一般情况下相同对象返回相同哈希码。

System.out.println("hashCode()方法结果如下：");
System.out.println("s1.hashCode() = "+s1.hashCode());
System.out.println("s2.hashCode() = "+s2.hashCode());

Student s3 = s1;
System.out.println("s3.hashCode() = "+s3.hashCode());

hashCode()方法结果如下：
s1.hashCode() = 1163157884
s2.hashCode() = 1956725890
s3.hashCode() = 1163157884

toString()方法

public String toString(){}

返回该对象的字符串表示(表现形式)

可以根据程序需求覆盖该方法，如：展示对象各个属性值。

@Override
public String toString() {
    return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}

System.out.println(s1.toString());

equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。
  • equals()方法覆盖步骤
  • 比较两个引用是否指向同一个对象
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致
  • 强制类型转换
  • 依次比较各个属性值是否相同

@Override
public boolean equals(Object obj) {
    //1.判断两个对象是否是一个引用
    if (this == obj){
        return true;
    }
    //2.判断obj是否为null
    if (obj == null){
        return false;
    }
    //3.instanceof 判断对象是否某种类型
    if (obj instanceof Student){
        //4.强制类型转换
        Student s = (Student) obj;
        //5.比较熟悉
        if (this.name.equals(s.getName()) && this.age == s.getAge()){
            return true;
        };
    }
    return false;
}

Student s4 = new Student("zhangsan", 15);
Student s5 = new Student("zhangsan", 15);
System.out.println(s4.equals(s5));

finalize()方法

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

@Override
protected void finalize() throws Throwable {
    System.out.println(this.name+"对象被回收了");
}

new Student("aaa",18);
new Student("bbb",18);
new Student("ccc",18);
new Student("ddd",18);
new Student("eee",18);
new Student("fff",18);

System.gc();

包装类

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

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

包装类对应

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换与装箱、拆箱

JDK1.5之后有自动装箱和拆箱，可以从生成的class文件中看出<

public class Demo1 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转为引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱，引用类型转为基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
        
    }
}

基本类型和字符串转换

System.out.println("========基本类型和字符串之间的转换==========");
//基本类型和字符串之间转换
//1.基本类型转为字符串
int n1 = 15;
//1.1使用+号
String str1 = n1+"";
//1.2使用Integer的toString()方法
String str2 = Integer.toString(n1,16);
System.out.println(str1);
System.out.println(str2);

//2.字符串转为基本类型
String str3 = "12";
//使用Integer.parseXXX()方法
int n2 = Integer.parseInt(str3);
System.out.println(n2);

//3.boolean字符串形式转为基本类型；"true" ---> true， 非"true" ---> false
String str4 = "true";
boolean b1 = Boolean.parseBoolean(str4);
System.out.println(b1);

• 8种包装类提供不同类型间的转换方式：
  • Number父类中提供的6个共性方法。
  • parseXXX()静态方法。
  • valueOf()静态方法。
• 注意：需保证类型兼容，否则抛出NumberFormatException异常。

Integer缓冲区（理解）

• Java预先创建了256个常用的整数包装类型对象。
• 在实际应用当中，对已创建的对象进行复用。

重点理解Integer.valueOf()

public class Demo2 {
    public static void main(String[] args) {
        //整数缓冲区面试题

        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

        Integer integer3 = Integer.valueOf(100);//自动装箱Integer.valueOf()
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4);//true

        Integer integer5 = Integer.valueOf(200);
        Integer integer6 = Integer.valueOf(200);
        System.out.println(integer5 == integer6);//false
    }
}

String类概述（重点）

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中，可以共享。
• String s = “Hello”; 产生一个对象，字符串池中存储。
• String s = new String(“Hello”); //产生两个对象，堆、池各存储一个。

public class Demo3 {
    public static void main(String[] args) {
        String name = "Hello"; //"Hello"常量存储在字符串池中，
        name = "zhangsan";  //"zhangsan"赋值给name变量，给字符串赋值的时候并没有修改数据，而是重新开辟空间
        String name2 = "zhangsan";

        //演示字符串的另一种创建方式，new String();
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str == str2); //false
        System.out.println(str.equals(str2)); //true

    }
}

String的常用方法

public int length()：返回字符串的长度

String str = "java是最好的编程语言！";
System.out.println(str.length()); //13

public char charAt(int index)：根据下标获取字符

System.out.println(str.charAt(str.length()-1));// !

public boolean contains(String str)：判断当前字符串中是否包含str

System.out.println(str.contains("j")); //true

public char[] toCharArray()：将字符串转为数组

String str2 = "java是最好的编程语言，java真香~";
System.out.println(Arrays.toString(str2.toCharArray())); //[j, a, v, a, 是, 最, 好, 的, 编, 程, 语, 言, ，, j, a, v, a, 真, 香, ~]

public int indexOf(String str)：查找str首次出现的下标，存在则返回该下标；不存在则返回-1

System.out.println(str2.indexOf("java"));  //0
System.out.println(str2.indexOf("java",5));//13，因为从第二位开始，后得到java的首字母j位于13号位置，所以返回。

public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引

System.out.println(str2.lastIndexOf("va")); //15

public String trim()：去掉字符串前后的空格

String str3 = "   Hello World   ";
System.out.println(str3.trim());  //Hello World

public String toUpperCase()，toLowerCase()：将小写转成大写或大写转成小写

System.out.println(str3.toUpperCase());  //   HELLO WORLD
System.out.println(str3.toLowerCase());  //   hello world

public boolean endWith(String str)，startWith(String str)：判断字符串是否以str结尾或以str开始

String str4 = "hello.java";
System.out.println(str4.endsWith(".java"));  //true
System.out.println(str4.startsWith("he"));  //true

public String replace(char oldChar, char newChar)：将旧字符串替换成新字符串

String str5 = "我爱java，一天不用IDEA写java就难受";
System.out.println(str5.replace("java","php"));  //我爱php，一天不用IDEA写php就难受

public String[] split(String str)：根据str做拆分

String str6 = "java is the best porgraming   languae in the world,java xiang";
String[] arr = str6.split("[ ,]+");//[]代表供选择的，+代表可以有多个
for (String string: arr) {
    System.out.println(string);
}
//java
//is
//the
//best
//porgraming
//languae
//in
//the
//world
//java
//xiang

补充两个方法equals()、compareTo()；比较大小

equals()

String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));  //false
System.out.println(s1.equalsIgnoreCase(s2));  //true

compareTo()两个字符串比较大小实质上是比较其在编码表的位置

String s3 = "abc";  //a的ASCII值为97
String s4 = "xyz";  //x的ASCII值为120
System.out.println(s3.compareTo(s4));  //比大小

String s5 = "abc";
String s6 = "abcd";
System.out.println(s5.compareTo(s6));  //比长度

String案列演示

package com.commonclass;

/*
* 需求：
*   已知String str = "this is a text";
*   1.将str中的单词单独取出来
*   2.将str中的text替换为practice
*   3.在text前面插入一个easy
*   4.将每个单词的首字母改为大写
* */
public class Demo5 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独取出来
        String[] arr = str.split(" ");
        for (String string: arr) {
            System.out.println(string);
        }
        //2.将str中的text替换为practice
        System.out.println(str.replace("text","practice"));
        //3.在text前面插入一个easy
        System.out.println(str.replace("text","easy text"));
        //4.将每个单词的首字母改为大写
        for(int i = 0; i < arr.length; i++){
            char first = arr[i].charAt(0);  //获取到数组元素的首字母
            char upperfirst = Character.toUpperCase(first);  //将数组元素的首字母转为大写

            String news = upperfirst+arr[i].substring(1);  //将数组元素首字母与其后续拼接在一起
            System.out.println(news);
            //This
            //Is
            //A
            //Text
        }
    }
}

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全

package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别：1.效率比String高；2.比String节省内存
* */
public class Demo6 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append();追加
        sb.append("java世界第一秀");
        System.out.println(sb.toString());  //java世界第一秀
        sb.append("java真香");
        System.out.println(sb.toString());  //java世界第一秀java真香
        sb.append("java不错");
        System.out.println(sb.toString());  //java世界第一秀java真香java不错
        //2.insert();添加
        sb.insert(0, "我在最前面");
        System.out.println(sb.toString());  //我在最前面java世界第一秀java真香java不错
        //3.replace();替换
        sb.replace(0, 4, "hello");  //遵循左包含原则，eg：[20,30);
        System.out.println(sb.toString());  // hello面java世界第一秀java真香java不错
        //4.delete();删除
        sb.delete(0, sb.length());  //输出为空
        System.out.println(sb.toString());
        System.out.println(sb.length());  //0
    }
}

StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全

package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别：1.效率比String高；2.比String节省内存
* */
public class Demo6 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        //1.append();追加
        sb.append("java世界第一秀");
        System.out.println(sb.toString());  //java世界第一秀
        sb.append("java真香");
        System.out.println(sb.toString());  //java世界第一秀java真香
        sb.append("java不错");
        System.out.println(sb.toString());  //java世界第一秀java真香java不错
        //2.insert();添加
        sb.insert(0, "我在最前面");
        System.out.println(sb.toString());  //我在最前面java世界第一秀java真香java不错
        //3.replace();替换
        sb.replace(0, 4, "hello");  //遵循左包含原则，eg：[20,30);
        System.out.println(sb.toString());  // hello面java世界第一秀java真香java不错
        //4.delete();删除
        sb.delete(0, sb.length());  //输出为空
        System.out.println(sb.toString());
        System.out.println(sb.length());  //0
    }
}

验证StringBuilder效率高于String

package com.commonclass;
/*
*    验证StringBuilder效率高于String
* */
public class Demo7 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String string = "";
        for (int i = 0; i < 99999; i++) {
            string += i;
        }
        System.out.println(string);
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));  //用时：34695

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("用时：" + (end2 - start));  //用时：31
    }
}

BigDecimal类

double、float类型存储的是近似值！此时对于精度运算有需求的，需要借助BigDecimal

public class Demo8 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1 - d2); //0.09999999999999998

        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);  //0.9999999999999999
    }
}

• 位置：java.math包中。
• 作用：精确计算浮点数。
• 创建方式：BigDecimal bd = new BigDecimal(“1.0”);
• 方法：
  • BigDecimal add(BigDecimal bd) 加
  • BigDecimal subtract(BigDecimal bd) 减
  • BigDecimal multiply(BigDecimal bd) 乘
  • BigDecimal divide(BigDecimal bd) 除
• 除法：divide (BigDecimal bd, int scal, RoundingMode mode)
• 参数scal：指定精确到小数点后几位。
• 参数mode：
  • 指定小数部分的取舍模式，通常采用四舍五入的模式。
  • 取值为BigDecimal.ROUND_HALF_UP。

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");

//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);  //0.1

//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);  //1.9

//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);  //0.90

//除法
//double result = (1.4 - 0.5) / 0.9;
BigDecimal r4 = new BigDecimal("1.4")
        .subtract(new BigDecimal("0.5"))
        .divide(new BigDecimal("0.9"));
System.out.println(r4);  //1

BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
System.out.println(r5);  //6.67

Date类

• Date类表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendat类中的方法所取代。
• 时间单位
  • 1秒 = 1000毫秒
  • 1毫秒 = 1000微秒
  • 1微秒 = 1000纳秒

package com.commonclass;

import java.util.Date;

public class Demo9 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());  //2021-2-27 14:35:51

        //昨天
        Date date2 = new Date(date1.getTime() - (24 * 60 * 60 * 1000));
        System.out.println(date2.toLocaleString());  //2021-2-26 14:35:51

        //2.方法 after、before
        boolean b1 = date1.after(date2);
        System.out.println(b1);  //true
        boolean b2 = date1.before(date2);
        System.out.println(b2);  //false

        //比较compareTo();
        int d = date2.compareTo(date1);
        System.out.println(d);  //-1
        //比较是否相等equals();
        boolean b3 = date1.equals(date2);
        System.out.println(b3);  //false
    }
}

Calendar类

• 所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。

  该类还提供了用于在包外部实现具体日历系统的其他字段和方法。 这些字段和方法定义为protected 。

  与其他区域设置敏感的类一样， Calendar提供了一种类方法getInstance ，用于获取此类型的一般有用的对象。 Calendar的getInstance方法返回一个Calendar对象，其日历字段已使用当前日期和时间进行初始化：

  • Calendar rightNow = Calendar.getInstance();

• Calendat提供了获取或设置各种日历字段的方法。

• 构造方法

  • protected Calendar(); 由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如：年、月、日等
void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

package com.commonclass;

import java.util.Calendar;

public class Demo10 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月，月份从0-11
        int month = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH); //Date
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  //HOUR12小时制，HOUR_OF_DAY24小时制
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);

        System.out.println(year+"年" +(month+1)+"月" +day+"日 "+hour+":"+minute+":"+second);

        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 6);   //改变此月份的某一日子
        //calendar2.set(Calendar.DAY_OF_MONTH, 30);  此时月份改为3月2日，因为2021年的2月只有28天
        System.out.println(calendar2.getTime().toLocaleString());

        //4.add方法修改时间
        calendar2.add(Calendar.HOUR, -1);  //减去一个小时
        System.out.println(calendar2.getTime().toLocaleString());

        //5.补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
• 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
• 常用的时间模式字母

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	367

package com.commonclass;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo11 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象 y年 M月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date = new Date();
        //3.格式化date (把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //4.解析 (把字符串转成日期)
        Date date2 = sdf.parse("1998/09/01");
        System.out.println(date2);
    }
}

System类

• System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit (int status);	推出JVM，如果参数是0表示正常推出JVM，非0表示异常推出JVM

package com.commonclass;

import java.util.Arrays;

public class Demo12 {
    public static void main(String[] args) {
        //1.arraycopy：数组的复制
        //src：源数组
        //srcPos：从那个位置开始复制0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int arr[] = {13, 15, 18, 25, 36, 78, 92, 100};
        int[] dest = new int[8];
        System.arraycopy(arr, 0, dest, 0, arr.length);
        for (int i = 0; i < dest.length; i++){
            System.out.println(dest[i]);
        }
        //Arrays.copyOf(original, newLength)

        //2.System.currentTimeMillis()可用于计时
        long start = System.currentTimeMillis();
        for (int i = -999999; i < 999999; i++){
            for (int j = -999999; j < 999999; j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end - start));

        //3.static void gc();
        Student s1 = new Student("wangge", 25);
        Student s2 = new Student("sange", 25);

        new Student("haiyan", 25);
        new Student("haiwa", 25);
        new Student("haiwang", 25);

        System.gc();  //告诉垃圾回收器回收

        //4.退出JVM
        System.exit(0);
        System.out.println("程序结束了.......");
    }
}

总结

• 内部类：
  • 在一个类的内部再定义一个完整的类。
  • 成员内部类、静态内部类、局部内部类、匿名内部类。
• Object类
  • 所有类的直接或间接父类，可以存储任何对象。
• 包装类：
  • 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
• String类
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal：
  • 可精确计算浮点数
• Date
  • 特定时间
• Calendar
  • 日历
• SimpleDateFormat
  • 格式化时间
• System
  • 系统类

标签：java,String,day06,System,站千锋,println,public,out
来源： https://blog.csdn.net/weixin_46083893/article/details/114198098

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。