Java开发实践05-0126

最新推荐文章于 2024-07-13 13:55:40 发布

yyy001..

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量1k

点赞数 14

分类专栏： Java开发实践文章标签： java 开发语言 ide

本文链接：https://blog.csdn.net/m0_74378177/article/details/135857435

版权

Java开发实践专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、今日内容

1、常用类

（1）常用的包java.lang包-该包是java语言的核心包，并且该包中的所有内容由java虚拟机自动导入。

- 如：system类、string类、...

（2）java.uti包-该包是java语言的工具包，里面提供了大量工具类以及集合类。

- 如：Scanner类、Random类、Lis七t集合、...

（3）java.io包-该包是java语言中的输入输出包，里面提供了大量读写文件相关的类。

- 如：FileInputstream类、FileOutputstrean类、...

（4）java.net包-该包是ava语言中的网络包，里面提供了大量网络编程相关的类。

- 如：ServerSocket类、Socket类、...

2、obiect类

（1）基本概念java.ang.Object类是java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类。

（2）常用的方法（重点）

① boolean equals(Object obj)

- 用于判断调用对象是否与参数对象相等

- 该方法默认比较两个对象的地址，与 == 的效果等价

- 若希望比较两个对象的内容，则需要重写该方法

- 若该方法重写时，应该重写hashCode方法

② int hashCode()

- 用于获取调用对象的哈希码值（内存地址的编号）

- 若两个对家调用egua18方法的结果相同，则各自调用hashcode方法的数值必须相等

- 若两个对象调用egua18方法的结果不同，则各自调用hashcode方法的数值应该不相等

③ String toString()

- 用于返回调用对象的字符串形式

- 默认字符串的内容有：包名．类名@哈希码值的无符号十六进制形式

- 为了返回更有意义的数据内容需要重写该方法

- 使用print()或println()打印或＋拼接时，都会自动调用toString方法

3、包装类

（1）Person p = new Person(); 表示声明Person类型的引用指向Person类型的对象，p代表引用；

int num =10; 表示声明一个int关型的安量num初始值为10；

num不代表对象Java语言是一门纯面向对象的编程语言，万物皆对象！

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

（3）常用的包装类：

① int => java.lang.lnteger类

② char => java.lang.Character类

③ 其它类型都是将首字母改为大写即可。

如：long => java.lang.Long类

4、Integer类

（1）基本概念：java.lang.Integer类内部包装了一个int类型的变量作为成员安量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。

（2）常用的方法

Integer (int value)	- 根据参数指定的整数来构造对象
Integer (String s)	- 根据参数指定的字符串来构造对象
int intValue ()	- 获取调用对象中的整数值并返回
static Integer valueOf (int i)	- 根据参数指定整数值得到Integer类型对象
static int parseInt (String s)	- 将字符串类型转换为int类型并返回

注意：JDK 5发布之前使用包装类对象进行运算时，需要较为繁琐的"拆箱”和“装箱”操作，JDK 5增加了自动“装箱”和“拆箱”的功能。

5、数学处理类

BigDecimal类

（1）基本概念：由于float型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述。

（2）常用的方法

BigDecimal (String val)	- 根据参数指定的字符串来构造对象
BigDecimal add (BigDecimal add)	- 用实现加法运算
BigDecimal subtract (BigDecimal sub)	- 用于实现减法运算
BigDecimal multiply (BigDecimal mu1)	- 用于实现乘法运算
BigDecimal divide (BigDecimal div)	- 用于实现除法运算
static int ROUND_HALF_UP	- 向最接近的数字舍入，“四含五入”

6、string类（重点）

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

（2）常量池（原理）

String str1 = "abe";

String str2 = "123";
//比较str1 == str2

String str3 = "abc";
//比较str1 == str3

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

（3）常用的方法(练熟）

String ()	- 使用无参方式构造对象得到空字符序列
String (byte[] bytes, int offset, int length)	- 使用bytes数組中下标offset位置开始的length个字节来构造对象
String (byte[] bytes)	- 使用bytes数组中的所有内容构造对象
String (String str)	- 根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本
char charAt (int index)	- 方法charAt用于返回字符串指定位置的字符，index表示指定的位置
int length ()	- 返回字符串字符序列的长度
boolean contains (Charsequence s)	- 用判断当前字符串是否包含参数指定的内容
String toLowerCase ()	- 返回字符串的小写形式
String toUpperCase ()	- 返回字符串的大写形式
String trim ()	- 返回去掉签到和后继空白的字符串
boolean startsWith (String prefix)	- 判断字符串是否以参数字符串开头
boolean endeWith (String suffix)	- 判断字符串是否以参数字符串結尾

7、StringBuilder类和 StringBuffer类（重点）

（1）基本概念：由于String类描述的字符串内容是个常量，不可改变，当需要在java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空同的浪费。为了解决上述问题，可以使用 java.lang.StringBuilder类和 StringBuffer类来描述字符序列可以改变的字符串，如：“ab”，“abe”，“abcd”。其中 StringBuffer类是sjdk1.0开始存在，属于线程安全的类，因此效率比较低；其中 StringBuilder类是从jdk1.5开始存在，屋于非线程安全的类，因此效率比较高；

（2）常用的方法(练熟）

① StringBuilder 类

StringBuiider()	- 构造一个不带任何字符的字符串生成器，初始容量为16个字符
StringBuiider(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()	- 字符串反转
int indexOf (String str)	- 查找字符串出现的位置

② StringBuffer类上同

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

（1）Date类

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

② 常用的方法

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毫秒的时间点

（2）SimpleDateFormat类

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

② 常用的方法

SimpleDateFormat()	- 用默认的模式和默认语言环境的日期格式符号构造 SimleDateFormat
SimpIeDateFormat(String pattern)	- 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat

9、可变参数

（1）一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

（2）语法：

返回值类型方法名称(数据类型_参数名称) {

// 参数在方法内部，以数组的形式来接收

}

（3）注意：可变参数只能出现在参数列表的最后。

二、代码

1、Student 及Test

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

import java.util.Objects;

/**
 * @Author: ydh 2303
 * @description: 编程实现Student类的封装，特征：学号(id)和姓名，要求提供打印所有特征的方法；
 *               编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征。
 * @Date: 2024/1/26 8:29
 * @Version: 1.0
 */
public class Student {

    private String name;
    private int id;

    public Student() {
    }

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

//    //重写equals()方法
//    @Override
//    public boolean equals(Object o){
//        //强转
//        Student student = (Student)o;
//        return this.getId() == student.getId(); //id相同，则相等
//    }

//    @Override
//    public boolean equals(Object o) {
//        //表示两个引用指向同一个地址
//        if(this == o) {
//            return true;
//        }
//        if(null == o) {
//            return false;
//        }
//        if(o instanceof Student) {
//            Student student = (Student) o;
//            if(this.getName().equals(student.getName()) && this.getId() == student.getId()) {
//                return true;
//            }
//        }
//        return false;
//    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
    return Objects.hash(name, id);
    }


    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;
    }

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

StudentTest

编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征。

/**
 * @Author: ydh 2303
 * @description:
 * ==  和  equals()
 *        ==：基本数据可惜，比较的是数值大小
 *           引用数据类型，比较的是引用的地址
 *  equals()：默认比较两个对象的地址，若想要比较两个对象的内容时，需要重写这个方法
 * @Date: 2024/1/26 8:30
 * @Version: 1.0
 */
public class StudentTest {
    public static void main(String[] args) {
        //new出来的对象，引用地址肯定不一样
        Student s1 = new Student("张三", 1001);
        //Object中的toString方法默认打印全类名@十六进制
        System.out.println(s1);
        Student s2 = new Student("张三", 1001);
        // false
        System.out.println(s1.equals(s2));
        //true
        //在Student类中重写equals()方法
    }
}

运行结果：s1与s2姓名相同时

运行结果：s1与s2姓名不同时

2、Integer01

/**
 * @Author: ydh 2303
 * @description: Integer java.lang.Integer类内部包装了一个int类型的变量作为成员安量;
 *               主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。
 *                      Integer (int value)	       - 根据参数指定的整数来构造对象
 *                      Integer (String s)	       - 根据参数指定的字符串来构造对象
 *                       int intValue ()	       - 获取调用对象中的整数值并返回
 *               static Integer valueOf (int i)	   - 根据参数指定整数值得到Integer类型对象
 *               static int parseInt (String s)	   - 将字符串类型转换为int类型并返回
 * @Date: 2024/1/26 10:00
 * @Version: 1.0
 */
public class Integer01 {

    public static void main(String[] args) {

        //将Integer类型的数组，转变为int类型的数值，叫做手动拆箱
        Integer it1 = new Integer(10);
        System.out.println("it1 = " + it1);
        int i = it1.intValue();
        System.out.println(i);

        System.out.println("----------");
        //将int类型的数组，转变为Integer类型的对象，叫做手动装箱
        Integer integer = Integer.valueOf(i);
        System.out.println(integer);
        Integer it2 = new Integer("20");
        System.out.println("it2 = " + it2);

        System.out.println("----------");
        //JDK1.5开始提供了自动拆箱和装箱机制
        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);
    }
}

运行结果：

3、BigdecimalTest

数学处理类-BigdecimalTest类

import java.math.BigDecimal;
/**
 * @Author: ydh 2303
 * @description: 数学处理类-BigdecimalTest类
 *  常用的方法：
 *          BigDecimal (String val)                  - 根据参数指定的字符串来构造对象
 *          BigDecimal add (BigDecimal add)	         - 用实现加法运算
 *          BigDecimal subtract (BigDecimal sub)	 - 用于实现减法运算
 *          BigDecimal multiply (BigDecimal mu1)	 - 用于实现乘法运算
 *          BigDecimal divide (BigDecimal div)	     - 用于实现除法运算
 *          static int ROUND_HALF_UP	             - 向最接近的数字舍入，“四含五入”
 * @Date: 2024/1/26 10:55
 * @Version: 1.0
 */
public class BigdecimalTest {
    public static void main(String[] args) {
        double d1 = 0.1 + 0.2;
        System.out.println(d1);
        System.out.println("------------------");

        //小数的精确运算
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.2");
        //加
        System.out.println(bd1.add(bd2));
        //减
        System.out.println(bd1.subtract(bd2));
        //乘
        System.out.println(bd1.multiply(bd2));
        //除
        System.out.println(bd1.divide(bd2));
        //四舍五入（除不尽出错）修改完善
        System.out.println(bd1.divide(bd2, BigDecimal.ROUND_HALF_UP));
    }
}

运行结果：

4、String类

（1）String01

String类

package string01;

/**
 * @Author: ydh 2303
 * @description: String类
 * @Date: 2024/1/26 15:41
 * @Version: 1.0
 */
public class String01 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "123";
        System.out.println(str1 == str2); //false

        String str3 = new String("abc");
        String str4 =new String("abc");
        System.out.println(str1 == str3); //false
        System.out.println(str3 == str4); //false

        String str5 = "abc";
        System.out.println(str1 == str5); //true
    }
}

运行结果：

（2）String02

常用的方法

package string01;
/**
 * @Author: ydh 2303
 * @description: 常用的方法：
 *           String ()	                                     - 使用无参方式构造对象得到空字符序列
 *           String (byte[] bytes, int offset, int length)	 - 使用bytes数組中下标offset位置开始的length个字节来构造对象
 *           String (byte[] bytes)	                         - 使用bytes数组中的所有内容构造对象
 *           String (String str)	                         - 根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本
 *           char charAt (int index)	                     - 方法charAt用于返回字符串指定位置的字符，index表示指定的位置
 *           int length ()	                                 - 返回字符串字符序列的长度
 *           boolean contains (Charsequence s)	             - 用判断当前字符串是否包含参数指定的内容
 *           String toLowerCase ()	                         - 返回字符串的小写形式
 *           String toUpperCase ()	                         - 返回字符串的大写形式
 *           String trim ()	                                 - 返回去掉签到和后继空白的字符串
 *           boolean startsWith (String prefix)	             - 判断字符串是否以参数字符串开头
 *           boolean endeWith (String suffix)	             - 判断字符串是否以参数字符串結尾
 * @Date: 2024/1/26 16:05
 * @Version: 1.0
 */
public class String02 {
    public static void main(String[] args) {
        String str = new String("      Let me give you some color to see see!");
        System.out.println("所指位置为：" + str.charAt(8)); //t
        System.out.println("字符串的长度为：" + str.length()); //44
        System.out.println(str.contains("me"));
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
        System.out.println(str.trim());
        System.out.println(str.startsWith("Let"));
        System.out.println(str.endsWith("!"));

        System.out.println("--------------------");
        String s = new String();
        System.out.println("s = " + s); //  ""   null

        byte[] brr = {97, 98, 99, 100, 101};
        String str3 = new String(brr, 0, 5);
        System.out.println(str3);
    }
}

运行结果：

5、StringBuilder类

package string01;
import com.sun.xml.internal.ws.addressing.WsaActionUtil;
/**
 * @Author: ydh 2303
 * @description: StringBuilder类
 *        StringBuiider()	                                        - 构造一个不带任何字符的字符串生成器，初始容量为16个字符
 *        StringBuiider(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()	                                - 字符串反转
 *        int indexOf (String str)	                                - 查找字符串出现的位置
 * @Date: 2024/1/26 17:07
 * @Version: 1.0
 */
public class StringBuilder01 {
    public static void main(String[] args) {

        StringBuilder sb1 = new StringBuilder();
        System.out.println("初始容量为：" + sb1.capacity());
        System.out.println("长度为：" + sb1.length());
        System.out.println("----------------------");
        StringBuilder sb2 = new StringBuilder("heihei");
        System.out.println("初始容量为：" + sb2.capacity());
        System.out.println("长度为：" + sb2.length());

        //添加
        System.out.println(sb2.insert(0, "zhangsan"));
        //追加
        System.out.println(sb2.append("666"));
        //删除
        System.out.println(sb2.delete(0, 8));
        //替换
        System.out.println(sb2.replace(0, 5, "haha"));
        //反转
        System.out.println(sb2.reverse());
        //h出现的位置
        System.out.println(sb2.indexOf("h"));
    }
}

运行结果：

6、dates-DateTest

日期相关的类

package dates;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * @Author: ydh 2303
 * @description: 日期相关的类
 *               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毫秒的时间点
 * @Date: 2024/1/26 17:48
 * @Version: 1.0
 */
public class DateTest {
    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());
        System.out.println("-----------------------");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println(format);
    }
}

运行结果：

7、Changeable

可变参数

/**
 * @Author: ydh 2303
 * @description: 可变参数
 * @Date: 2024/1/26 18:03
 * @Version: 1.0
 */
public class Changeable {
    public static void main(String[] args) {
        System.out.println(add());
        System.out.println(add(1));
        System.out.println(add(1, 2));
        System.out.println(add(1, 2, 3));
    }

    public static int add(int...args){
        int sum = 0;
        for(int i = 0; i < args.length; i++){
            sum += args[i];
        }
        return sum;
    }
}

运行结果：

三、总结

今日学习了常用类、obiect类、包装类、Integer类、数学处理类、string类（重点）、StringBuilder类和 StringBuffer类（重点）、日期相关的类(会用即可)、可变参数等内容，同学们分享了所查询的实训知识，很受教育！

yyy001..

关注

14
点赞
踩
26

收藏

觉得还不错? 一键收藏
1
评论
Java开发实践05-0126

今日学习了常用类、obiect类、包装类、Integer类、数学处理类、string类（重点）、StringBuilder类和 StringBuffer类（重点）、日期相关的类(会用即可)、可变参数等内容，同学们分享了所查询的实训知识，很受教育！
复制链接

扫一扫