寒假实训第五天（懵逼）常用类包装类数学处理类String类Data类

想学好Java的小菜鸡

已于 2024-01-26 21:22:24 修改

阅读量1.3k

点赞数 31

文章标签： java

于 2024-01-26 21:15:13 首次发布

本文链接：https://blog.csdn.net/Auroramine/article/details/135873605

版权

常用类

常用的包java.lang包-包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。
. 如: System类String类、 ...
java.uti包-包是ava语言的工具包，里面提供了大量邛具类以及集合类。
如: Scanner类、 Random类、 List集合、
java.io包-袍是ava语言中的输入输出包，里面提供了大量读写文件相关的类。
- 如: FileInputStream类、 Fileoutputstream类、 ...
java.net包-包是Java语言中的网络包，面提供了大量网络编程相关的类。
一如: ServerSocket类、 Socket类、
...
0bject类
(1)基本概念java.lang.bject类是ava语言中类层次结构的根类,也就是说任何-一个类都是该类的直接或者间接子类。
(2)常用的方法(重点)
boolean equals(Object obj)
一用于判断调用对象是否与参数对象相等。
一该方法默认比较两个对象的地址，与==的效果等价。一若希望比较两个对象的内容，则需要重写该方法。
若该方法重写时，应该重写hashCode方法。
int hashCode0
一用于获取调用对象的哈希码值(内存地址的编号)
一若两个对象调用equal s方法的结果相同，则各自调用hashCode方法的数值必须相等。一若两个对象调用equa1s方法的结果不同，则各自调用hashCode方法的数值应该不相等。
String toString0
一用于返回调用对象的字符串形式。
一默认字符串的内容有:包名.类名哈希码值的无符号十六进制形式一为了返回更有意义的数据内容需要重写该方法。
- 使用print ()或println ()打印或+拼接时，都会自动调用toString方法。

练习:编程实现Student类的封装,特征:学号(id)和姓名，要求提供打印所有特征的方法。编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征。

public class Student {
    String name;
    int id;

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

    @Override
    public boolean equals(Object o){
        Student student = (Student)o;
        return  this.getId() == student.getId();
    }
  

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public Student() {
    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student("xaiobai",2);
        Student student1 = new Student("xiaohei",2);
        System.out.println(student.equals(student1));
        System.out.println(student);
    }
}

结果

true
Student{name='xaiobai', id=2}

包装类

Person p = new Person0 -示声明Person类型的引用指向Person类型的对象，p代表引用int num= 10;

声明一-个int类型的变量num初始值为10, num不代表对象

Java语言是一门纯面向对象的编程语言，万物皆对象!

包装类的概念通常情况下基本数据类型的变不是对象，为了满足万物接对象的理念就需要对基本数据类型的变进行打包封装处理变成对象，负责将这些变量声明为成员变进行对象化处理的相关类,叫做包装类。

常用的包装类int => java.lang.Integer类 char => java.lang.Character类它类型都是将首字母改为大写即可

Integer类

(1)基本概念java.lang.Integer类内部包装了一-个int类型的变作为成员疆，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。
(2)常用的方法
Integer (int value) 根据参数指定的整数来构造对象
Integer (String str）根据参数指定的字符串来构造对象
int intValue () 获取调用对象中的整数值并返回
static Integer valueOf (int i) 根据参数指定整数值得到Integer类型对象
static int parseInt (String str) 将字符串类型转换为int类型并返回
注意: JDK 5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作, JDK 5增加了自动"装箱”和“拆箱”的功能。

看一个例子

用Integer类去创建一个对象，然后去实现它的方法

public class IntegerDemo {
    public static void main(String[] args) {
        //IntegerDemo i =
        Integer it1 =new Integer(10);
        System.out.println("it1 = " + it1);
        //将integer类型的对象，转变为intd的数值，叫做手动拆箱
        int i = it1.intValue();
        System.out.println(i);
        //将int类型的数值，转变为integer类型的对象，叫做手动装箱
        System.out.println("-----------------");
        Integer integer = Integer.valueOf(i);
        System.out.println(integer);
        Integer it2 = new Integer(20);
        System.out.println("it2 = " + it2);
        System.out.println("=====================");
        Integer i1 = 12;
        int i2 = i1;
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("---------------------");
        String str = "123";
        int i3 = Integer.parseInt(str);
        System.out.println(i3);
    }

}

结果

it1 = 10
10
-----------------
10
it2 = 20
=====================
12
12
---------------------
123

数学处理类

BigDecimal类(1)基本概念由于float类型和double类型在运算时可能会有差,若希实现精确运算则借助java.math.BigDecimal类型加以描述。
(2)常用的方法
BigDecimal(String val)-根据参数指定的字符串来构造对象

BigDecimal add (BigDecimal add)用于实现加法运算
BigDecimal subtract (BigDecimal sub)用于实现减法运算
BigDecimal multiply (BigDecima1 mul) -用于实现乘法运算
BigDecimal divide (BigDecimal div)用于实现除法运算
static int ROUND_ HalF_ UP向最接近的数字舍入，"四舍五入”;

看个例子

创建一个BigDecima类对象，然后去实现它的方法

public class BigDecimalTest {
    public static void main(String[] args) {
        double d1 = 0.1 + 0.2;
        System.out.println(d1);
        BigDecimal bd = new BigDecimal("0.1");
        BigDecimal bd1 = new BigDecimal("0.2");
        System.out.println(bd.add(bd1));
        System.out.println(bd.subtract(bd1));
        System.out.println(bd.multiply(bd1));
        System.out.println(bd.divide(bd1));
        System.out.println(bd1.divide(bd1, BigDecimal.ROUND_HALF_UP));

    }
}

结果

0.30000000000000004
0.3
-0.1
0.02
0.5
1.0

String类(重点)

ja.lang.String类主要用于描述字符串内容, Java程序中所有字符串字面值都可以使用该类的实例对象)加以描述,如: "abc"等。谈由final关键字修饰表示该类不能被继承。（final修饰的类都是太监类）该类描述的字符串内容是个常不可改变,因此可以被共享。如: Stringstr1 ="abc"; -中"abc"这个字符串是个常不可改变,但str1的数值可以改变str1 ="123"; -示将"123”字符串的地址赋值给变量str1 ,覆盖str1中原来的数值
- 也就是改变str1的指向并没有改变指向的内容

常量池(原理)
String str1 = "abc";String str2 = "123";//比较str1 == str2String str3 = "abc";//比较str1 == str

由于string类型描述的字符串内容是个常量不可改变，因此Java虚拟机将首次出现的字符串放入常量中，若后续代码中出现了相同的字符串内容则直接使用池中已有的字符串对象而无需申请内存以及创建对象，从而提高了性能。

看

public class StringDemo {
    public static void main(String[] args) {
        String str1  = "abc";
        String str2 = "123";
        System.out.println(str1 == str2);
        String str3 = new String("abc");
        String str4 = new String("abc");
        System.out.println((str1 == str3));//常量和对象地址不一样
        System.out.println((str3 == str4));
        String str5 = "abc";
        System.out.println((str1 == str5));//常量池


    }
}

结果

false
false
false
true

创建出来的对象地址都是不一样的

常用的方法(练熟)
String()
使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, int 1ength)
使用bytes数组中下标从offset位置开始的length个字节来构造对象
String(byte[] bytes)使用bytes数组中的所有内容构造对象
String(String str)-根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本。
char charAt (int index) -

方法charAt用于返回字符串指定位置的字符。index表示指定的位置int length ()
返回字符串字符序列的长度
boolean contanins (Charsequence s用于判断当前字符串是否包含参数指定的内容
String toLowerCase()- 返回字符串的小写形式
String toUpperCase ()返回字符串的大写形式
String trim()返回去掉签到和后继空白的字符串
boolean startsWith (String prefix)判断字符串是否以参数字符串开头
boolean endsWith(String suffix)-判断字符串是否以参数字符串结尾

public class StringDemo01 {
    public static void main(String[] args) {
        String str = new String("  you see see me,me see see you.");
        System.out.println(str.charAt(7));//返回指定位置的字符
        System.out.println("字符串长度为：" + str.length());
        System.out.println(str.contains("me"));//是否包含参数指定的内容
        System.out.println(str.toLowerCase());//小写
        System.out.println(str.toUpperCase());//大写
        System.out.println(str.trim());//去空格
        System.out.println(str.startsWith("me"));//是否以字符串开头
        System.out.println(str.endsWith("you"));//是否以字符串结尾
        String s = new String();
        System.out.println("s = " + s);//输出是空  相当于""
        byte[] brr = {99,100,101,102,103,104};
        String str3 = new String(brr,0,5);
        System.out.println(str3);

    }
}

结果

e
字符串长度为：32
true
you see see me,me see see you.
YOU SEE SEE ME,ME SEE SEE YOU.
you see see me,me see see you.
false
false
s =
cdefg

StringBuilder类和StringBuffer类(重点)

基本概念由于String类描述的字符串内容是个常量，可改变,当需要在]ava代码中描述大类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。为解决上述问题，可以使用java.lang. StringBuilder类和StringBuffer类来描述字符序列可以改变的字符串，如: "ab", "abc", "abcd"。中StringBuffer类是从jdk1.0开始存在，于线程安全的类，因此效率比较低;中StringBuilder类是从jdk1 .5开始存在，于非线程安全的类,因此效率比较高;

常用的方法(练熟)
StringBuilder类
StringBuilder()一构造一个不带任何字符的字符串生成器，初始容量为16个字符StringBuilder (String str)构造一个字符串生成器，并初始化为指定的字符串内容

int capacity()返回当前容量

int length() 一返回长度(字符数）
StringBuilder insert (int offset, String str)-插入字符串

StringBuilder append (String str）追加字符串
StringBuilder delete(int start, int end):删除字符串，前闭后开区间StringBuilder replace(int start, int end, String str) 一替换字符串

StringBuilder reverse ()字符串反转

看到这里突然想到一个有趣的事情，就是输入一个三位数，倒序输出就可以用这个来实现

来看一下

public class ThreeNumber {
    public static void main(String[] args) {
        System.out.println("请输入一个三位数");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringBuilder sb = new StringBuilder(str);
        System.out.println(sb.reverse());
    }
}

328
823

int indexOf (String str)-查找字符串出现的位置

public class StringBuilderDemo {
    public static void main(String[] args) {
    StringBuilder sb = new StringBuilder();
    StringBuilder sb1 = new StringBuilder("you see see me");
        System.out.println("初始长度为 " + sb.capacity());
        System.out.println("长度为 ：" + sb.length());
        System.out.println("初始长度为 " + sb1.capacity());
        System.out.println("长度为 ：" + sb1.length());
        System.out.println(sb1.insert(0, "haha"));//指定位置插入
        System.out.println(sb1.append("hallo"));//追加字符串
        System.out.println(sb1.delete(0, 3));//删除指定位置
        System.out.println(sb1.replace(0, 3, "yes"));//替换指定位置
        System.out.println(sb1.reverse());//倒序输出
        sb1.indexOf("m");


    }
}

结果

初始长度为 16
长度为：0
初始长度为 30
长度为：14
hahayou see see me
hahayou see see mehallo
ayou see see mehallo
yesu see see mehallo
ollahem ees ees usey

StringBuffer类同上

日期相关的类(会用即可)

Date类

(1)基本概念java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒,可以精确到毫秒。

(2)常用的方法
Date ()- 分配 Date对象并初始化此对象，以表示分配它的时间(精确到毫秒)
Date(long date) -分配Date对象并初始化此对象，以表示自从标准基准时间(称为“历元(epoch)”。即1970年1月1日00:00:00 GMT)以来的指定毫秒数
long getTime() 一返回自1970 年1月1日00:00:00 GMT以来此Date 对象表示的毫秒数。
void setTime(long time) 一设置此Date对象，以表示1970年1月1日00:00:00 GMT以后time毫秒的时间点。

来练一下

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        Date date1 = new Date(10000);
        System.out.println(date1);
        date1.setTime(1000);
        System.out.println(date1.getTime());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date1);
    }
}

结果

Fri Jan 26 21:05:20 CST 2024
Thu Jan 01 08:00:10 CST 1970
1000

SimpleDateFormat类

(1)基本概念java.text. SimpleDateFormat类主要用于实现日期类型和文本类型之间的转换。

(2)常用的方法
SimpleDateFormat()一用默认的模式和默认语言环境的日期格式符号构造SimpleDateFormat.
SimpleDateFormat (String pattern) -用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat.

可变参数
一个方法中定义完了参数，则在调用的时候必须传入与其一-对应的参数，但是在JDK 1. 5之后提供了新的功能，可以根据需要自动传入任意个数的参数。
语法:
返回值类型方法名称(数据类型.参数名称) {//参数在方法内部，以数组的形式来接收
注意:
可变参数只能出现在参数列表的最后。

public class Demo {
    public static void main(String[] args) {
        System.out.println(add(1, 3));
        System.out.println("--------------------");
        System.out.println(sum());
        System.out.println(sum(1, 2, 3, 4));
        System.out.println(sum(1));
        System.out.println(sum(1, 2));
        System.out.println(sum(1, 2,3));

    }
    public static int add(int a,int b){//不可变的参数，就是固定的两个
        return a + b;
    }public static int sum(int...args){//args是可变参数，相当于看成一个数组
        int sum = 0;
        for (int i = 0;i <args.length;i++){
            sum = sum + args[i];
        }
        return sum;
    }
}

结果

4
--------------------
0
10
1
3
6
嗯嗯呐，第五天结束了，休息两天，接着熬，加油！！！！