Java 核心类库（上）1-3

小青年IT

已于 2022-02-26 22:02:45 修改

阅读量281

点赞数

分类专栏： Java 文章标签： java 开发语言后端

于 2022-02-18 18:57:16 首次发布

本文链接：https://blog.csdn.net/weixin_42200505/article/details/123003286

版权

Java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

常用类的概述和使用1-3-1

Object() 使用无参方式构造对象
boolean equals(Object obj)
方法是基类Object中的方法，是用来比较两个对象的引用是否相等，即是否指向同一个对象，对于equals方法，注意：equals方法不能作用于基本数据类型的变量，如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容
int hashCode() 用于获取调用对象的哈希码值(内存地址的编号)。若两个对象调用equals方法相等，则各自调用该方法的结果必须相同若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同，为了使得该方法与equals方法保持一致，需要重写该方法。
String toString() 用于获取调用对象的字符串形式，该方法默认返回的字符串为：包名.类名@哈希码值的十六进制，为了返回更有意义的数据，需要重写该方法，使用print或println打印引用或字符串拼接引用都会自动调用该方法
Class<?> getClass() 用于返回调用对象执行时的Class实例，反射机制使用
Integer类的使用

package com.lagou.task11;

public class IntegerTest {

    public static void main(String[] args) {

        // 1.打印Integer类中常用的常量数值
        System.out.println("最大值是：" + Integer.MAX_VALUE); // 2^31-1
        System.out.println("最小值是：" + Integer.MIN_VALUE); // -2^31
        System.out.println("所表示二进制的位数是：" + Integer.SIZE); // 32
        System.out.println("所占字节的个数是：" + Integer.BYTES); // 4
        System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // int

        System.out.println("------------------------------------------------------");
        // 2.使用构造方法来构造Integer类型的对象并打印
        //Integer it1 = new Integer(123);
        //System.out.println("it1 = " + it1); // 自动调用toString方法   123
        //Integer it2 = new Integer("456");
        //System.out.println("it2 = " + it2); // 456
        // 上述方法已过时，建议使用valueOf方法取代之，相当于从int类型到Integer类型的转换，叫做装箱
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3); // 123
        // 相当于从String类型到Integer类型的转换
        Integer it4 = Integer.valueOf("456");
        System.out.println("it4 = " + it4); // 456   自动调用toString方法得到的是String类型
        // 获取调用对象中的整数数值，相当于从Integer类型到int类型的转换，叫做拆箱
        int ia = it4.intValue();
        System.out.println("获取到的整数数据是：" + ia); // 456  得到的是int类型

        System.out.println("------------------------------------------------------");
        // 3.从Java5开始增加了自动装箱和自动拆箱的机制
        Integer it5 = 100;  // 直接通过赋值运算符实现自动装箱
        int ib = it5;       // 直接通过赋值运算符实现自动拆箱

        System.out.println("------------------------------------------------------");
        // 4.装箱和拆箱的笔试考点
        Integer it6 = 127; //128;
        Integer it7 = 127; //128;
        Integer it8 = new Integer(127); //new Integer(128);
        Integer it9 = new Integer(127); //new Integer(128);
        System.out.println(it6 == it7);      // 比较地址  false  true  地址一样
        System.out.println(it6.equals(it7)); // 比较内容  true
        System.out.println(it8 == it9);      // 比较地址  false
        System.out.println(it8.equals(it9)); // 比较内容  true

        System.out.println("------------------------------------------------------");
        // 5.实现静态方法的调用
        int ic = Integer.parseInt("200");
        //int ic = Integer.parseInt("200a"); // 编译ok,运行发生NumberFormatException数字格式异常，因为有字母
        System.out.println("字符串转换为整数的结果是：" + ic); // 200
        System.out.println("根据参数指定的整数获取对应的十进制字符串是：" + Integer.toString(200));
        System.out.println("根据参数指定的整数获取对应的二进制字符串是：" + Integer.toBinaryString(200));
        System.out.println("根据参数指定的整数获取对应的十六进制字符串是：" + Integer.toHexString(200));
        System.out.println("根据参数指定的整数获取对应的八进制字符串是：" + Integer.toOctalString(200));
    }
}

Double类的使用

package com.lagou.task11;

public class DoubleTest {

    public static void main(String[] args) {

        // 1.在Java5之前装箱和拆箱的实现
        // 实现了从double类型到Double类型的转换，装箱
        Double db1 = Double.valueOf(3.14);
        System.out.println("db1 = " + db1); // 3.14
        // 实现了从Double类型到double类型的转换，拆箱
        double d1 = db1.doubleValue();
        System.out.println("d1 = " + d1); // 3.14

        System.out.println("---------------------------------------------");
        // 2.从Java5开始实现自动装箱和自动拆箱
        Double db2 = 3.14;
        double d2 = db2;

        System.out.println("---------------------------------------------");
        // 3.实现静态方法和成员方法的调用
        double d3 = Double.parseDouble("13.14");
        System.out.println("d3 = " + d3); // 13.14

        System.out.println("db2对象的判断结果是：" + db2.isNaN()); // false 不是非数字
        Double db3 = Double.valueOf(0/0.0);
        System.out.println("db2对象的判断结果是：" + db3.isNaN()); // true  是非数字


    }
}

Boolean类的概述

常用的常量
public static final Boolean FALSE 对应基值为false的对象
public static final Boolean TRUE 对应基值为true的对象
public static final Class TYPE 表示boolean类型的Class实例
常用的方法
Boolean(boolean value) 根据参数指定的布尔数值来构造对象（已过时）
Boolean(String s) 根据参数指定的字符串来构造对象（已过时）
boolean booleanValue() 获取调用对象中的布尔数值并返回
static Boolean valueOf(boolean b) 根据参数指定布尔数值得到Boolean类型对象
boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等
String toString() 返回描述调用对象数值的字符串形式
static boolean parseBoolean(String s) 将字符串类型转换为boolean类型并返回

Character类的概述

常用的常量
public static final int SIZE 表示char类型的二进制位数
public static final int BYTES 表示char类型的字节个数
public static final Class TYPE 表示char类型的Class实例
常用的方法
Character(char value) 根据参数指定的字符数据来构造对象（已过时）
char charValue() 获取调用对象中的字符数据并返回
static Character valueOf(char c) 根据参数指定字符数据得到Character类型对象
boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等
String toString() 返回描述调用对象数值的字符串形式
static boolean isUpperCase(char ch) 判断参数指定字符是否为大写字符
static boolean isLowerCase(char ch) 判断参数指定字符是否为小写字符
static boolean isDigit(char ch) 判断参数指定字符是否为数字字符
static char toUpperCase(char ch) 将参数指定的字符转换为大写字符
static char toLowerCase(char ch) 将参数指定的字符转换为小写字符

Math类的概述

常用的方法
static int max(int a, int b) 返回两个参数中的最大值
static int min(int a, int b) 返回两个参数中的最小值
static double pow(double a, double b) 返回第一个参数的幂
static int abs(int a) 返回参数指定数值的绝对值
static long round(double a) 返回参数四舍五入的结果
static double sqrt(double a) 返回参数的平方根
static double random() 返回0.0到1.0的随机数

BigDecimal类

常用的方法
BigDecimal(String val) 根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend) 用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend) 用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand) 用于实现乘法运算
BigDecimal divide(BigDecimal divisor) 用于实现除法运算

BigInteger类

常用的方法
BigInteger(String val) 根据参数指定的字符串来构造对象
BigInteger add(BigInteger val) 用于实现加法运算
BigInteger subtract(BigInteger val) 用于实现减法运算
BigInteger multiply(BigInteger val) 用于实现乘法运算
BigInteger divide(BigInteger val) 用于实现除法运算
BigInteger remainder(BigInteger val) 用于实现取余运算
BigInteger[] divideAndRemainder(BigInteger val) 用于实现取商和余数的运算

String类的概述和使用1-3-2

- 常用的构造方法

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

常用的成员方法

String toString() 返回字符串本身
byte[] getBytes() 将当前字符串内容转换为byte数组并返回
char[] toCharArray() 用于将当前字符串内容转换为char数组并返回
char charAt(int index) 方法charAt用于返回字符串指定位置的字符。
int length() 返回字符串字符序列的长度
boolean isEmpty() 判断字符串是否为空
int compareTo(String anotherString) 用于比较调用对象和参数对象的大小关系
int compareToIgnoreCase(String str) 不考虑大小写，也就是’a’和’A’是相等的关系
String concat(String str) 用于实现字符串的拼接
boolean contains(CharSequence s) 用于判断当前字符串是否包含参数指定的内容
String toLowerCase() 返回字符串的小写形式
String toUpperCase() 返回字符串的大写形式
String trim() 返回去掉前导和后继空白的字符串
boolean startsWith(String prefix) 判断字符串是否以参数字符串开头
boolean startsWith(String prefix, int toffset) 从指定位置开始是否以参数字符串开头
boolean endsWith(String suffix) 判断字符串是否以参数字符串结尾
boolean equals(Object anObject) 用于比较字符串内容是否相等并返回
int hashCode() 获取调用对象的哈希码值
boolean equalsIgnoreCase(String anotherString)用于比较字符串内容是否相等并返回，不考虑大小写，如：'A’和’a’是相等
int indexOf(int ch) 用于返回当前字符串中参数ch指定的字符第一次出现的下标
int indexOf(int ch, int fromIndex) 用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str)在字符串中检索str返回其第一次出现的位置，若找不到返回-1
int indexOf(String str, int fromIndex)表示从字符串的fromIndex位置开始检索str第一次出现的位置
int lastIndexOf(int ch) 用于返回参数ch指定的字符最后一次出现的下标
int lastIndexOf(int ch, int fromIndex)用于从fromIndex位置开始查找ch指定字符出现的下标
int lastIndexOf(String str) 返回str指定字符串最后一次出现的下标
int lastIndexOf(String str, int fromIndex)用于从fromIndex位置开始反向搜索的第一次出现的下标。
String substring(int beginIndex, int endIndex)返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串
String substring(int beginIndex)返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串

正则表达式 （熟悉）

可变字符串类和日期相关类1-3-3

可变字符串类（重点）

StringBuilder类常用的构造方法

StringBuilder() 使用无参方式构造对象，容量为16
StringBuilder(int capacity) 根据参数指定的容量来构造对象，容量为参数指定大小
StringBuilder(String str) 根据参数指定的字符串来构造对象，容量为：16+字符串长度

StringBuilder类常用的成员方法

int capacity() 用于返回调用对象的容量
int length() 用于返回字符串的长度，也就是字符的个数
StringBuilder insert(int offset, String str) 插入字符串并返回调用对象的引用，就是自己。
StringBuilder append(String str) 追加字符串
StringBuilder deleteCharAt(int index)将当前字符串中下标为index位置的单个字符删除
StringBuilder delete(int start，int end) 删除字符串
StringBuilder replace(int start，int end，String str)替换字符串
StringBuilder reverse() 字符串反转

集合类库（上）1-3-4

集合的概述（重点）
集合的由来

当需要在Java程序中记录单个数据内容时，则声明一个变量。
当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。
当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

Collection集合（重点）

boolean add(E e); 向集合中添加对象
boolean addAll(Collection<? extends E>
c)
用于将参数指定集合c中的所有元素添加到当前集合
中
boolean contains(Object o); 判断是否包含指定对象
boolean containsAll(Collection<?> c) 判断是否包含参数指定的所有对象
boolean retainAll(Collection<?> c) 保留当前集合中存在且参数集合中存在的所有对象
boolean remove(Object o); 从集合中删除对象
boolean removeAll(Collection<?> c) 从集合中删除参数指定的所有对象
void clear(); 清空集合
int size(); 返回包含对象的个数
boolean isEmpty(); 判断是否为空
boolean equals(Object o) 判断是否相等
int hashCode() 获取当前集合的哈希码值
Object[] toArray() 将集合转换为数组
Iterator iterator() 获取当前集合的迭代器

Iterator接口（重点）

boolean hasNext() 判断集合中是否有可以迭代/访问的元素
E next() 用于取出一个元素并指向下一个元素
void remove() 用于删除访问到的最后一个元素

** List集合（重中之重）**

void add(int index, E element) 向集合中指定位置添加元素
boolean addAll(int index, Collection<? extends E> c) 向集合中添加所有元素
E get(int index) 从集合中获取指定位置元素
int indexOf(Object o) 查找参数指定的对象
int lastIndexOf(Object o) 反向查找参数指定的对象
E set(int index, E element) 修改指定位置的元素
E remove(int index) 删除指定位置的元素
List subList(int fromIndex, int toIndex) 用于获取子List
Queue集合（重点）
boolean offer(E e) 将一个对象添加至队尾，若添加成功则返回true
E poll() 从队首删除并返回一个元素
E peek() 返回队首的元素（但并不删除）

集合类库（下）1-3-5

Map集合（重点）

V put(K key, V value) 将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对应的Value，返回值为该Key原来所对应的Value，若没有则返回null
V get(Object key) 返回与参数Key所对应的Value对象，如果不存在则返回null
boolean containsKey(Object key);判断集合中是否包含指定的Key
boolean containsValue (Object value);判断集合中是否包含指定的Value
V remove(Object key) 根据参数指定的key进行删除
Set keySet() 返回此映射中包含的键的Set视图
Collection values() 返回此映射中包含的值的Set视图
Set<Map.Entry<K,V>>entrySet()返回此映射中包含的映射的Set视图

Collections类

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)根据元素的自然顺序返回给定集
合的最大元素
static T max(Collection<? extends T> coll, Comparator<?
super T> comp)根据指定比较器引发的顺序返回给定集合的最大元素
static <T extends Object & Comparable<?super T>> T
min(Collection<? extends T> coll)根据元素的自然顺序返回给定集合的最小元素
static T min(Collection<? extends T> coll, Comparator<?
super T> comp)根据指定比较器引发的顺序返回给定集合的最小元素
static void copy(List<? super T> dest, List<? extends T> src)将一个列表中的所有元素复制到另一个列表中
static void reverse(List<?> list) 反转指定列表中元素的顺序
static void shuffle(List<?> list) 使用默认的随机源随机置换指定的列表
static <T extends Comparable<? super T>> void sort(List list)根据其元素的自然顺序将指定列表按升序排序
static void sort(List list, Comparator<? super T> c)根据指定比较器指定的顺序对指定列表进行排序
static void swap(List<?> list, int i, int j) 交换指定列表中指定位置的元素

小青年IT

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 核心类库（上）1-3

标题API的使用和常用包的概述常用类的概述和使用equals() 方法是基类Object中的方法，是用来比较两个对象的引用是否相等，即是否指向同一个对象，对于equals方法，注意：equals方法不能作用于基本数据类型的变量，如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容String类的概述和使用可变字符串类和日期相关类集合类库（上）集合类库（下）模块作业总结：
复制链接

扫一扫