• JAVA学习笔记28（常用类）

    1.常用类

    1.1 包装类

    1.包装类的分类

    ​ 1.针对八中基本数据类型相应的引用类型–包装类

    ​ 2.有了类的特点，就可以调用类中的方法

    在这里插入图片描述

    2.包装类和基本数据类型的转换

    ​ *装箱：基本类型 --> 包装类型

    //手动装箱
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);

//自动装箱
//int -> Integer
int n2 = 200;
Integer integer2 = n2;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    ​ *拆箱：包装类型 --> 基本类型

    //手动拆箱
//Integer -- > int
int i = integer.intValue();

    • 1
    • 2
    • 3

    3.包装类型和String类型的相互转换

    //包装类(Integer) ->String
Integer i = 100;//自动装箱
//方式1
String str1 = i + "";

//方式2
String str2 = i.toString();

//方式3
String str3 = String.valueOf(i);

//String -> 包装类(Integer)
//方式1
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//自动装箱

//方式2
Integer integer = new Integer(str4);	//构造器
    


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    4.Integer和Character常用的方法

    System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值

System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是否为小写

System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    ​ *valueOf范围为-128 —127，否则就会new Integer(xx);

    ​ *如果xx在IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回

    1.2 String类

    ​ *String 对象用于保存字符串

    ​ *字符串常量对象是用双引号括起来的字符序列

    ​ *字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节

    ​ *String类常用构造器

    String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)

    • 1
    • 2
    • 3
    • 4

    1.创建String对象的两种方式

    1.直接赋值
    String s = "hspedu";

    • 1
    2.调用构造器
    String s2 = new String("hspedu");

    • 1

    在这里插入图片描述

    2.字符串的特性

    ​ 1.String是一个final类，代表不可变的字符序列

    ​ 2.字符串是不可变的，一个字符串对象一但被分配，其内容不可变。(如果想要改变就是直接更改指向地址)

    在这里插入图片描述

    3.String类的常见方法

    ​ *String类是保存字符串常量的，每次更新都需要重新开辟空间，效率较低，因此还提供了StringBuilder和StringBuffer来增强String的功能

    1.equals

    //区分大小写，判断内容是否相等

    直接用==号的话，判断的是地址是否相同

    str1.equals(str2);

    • 1
    2.equalsIgnoreCase

    //忽略大小写的判断内容是否相等

    str1.equalsIgnoreCase(str2);

    • 1
    3.length

    //获取字符的个数，字符串的长度

    str1.length();

    • 1
    4.indexOf

    //获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1

    str1.indexOf("@");	//@符号第一次出现的位置

    • 1
    5.lastIndexOf

    //获取字符在字符串中最后一次出现的索引，索引从0开始，如找不到，返回-1，同时查找两个字符则返回第一个字符的位置

    6.substring

    //截取指定范围的字串

    String name = "hello,wisth";
//下面name.substring(6) 从索引6开始截取后面所有的内容
System.out.println(name.substring(6));	//截取后面的字符
System.out.println(name.substring(0,5));	//表示从索引0开始截取，截取到索引 5-1=4的位置，5不包括

    • 1
    • 2
    • 3
    • 4
    7.trim

    //去前后空格

    8.charAt

    //获取某索引处的字符，注意不能使用Str[index]这种方式

    str1.charAt(0);	//获取字符串0号位置的字符

    • 1
    9.toUpperCase

    //转换成大写

    String s = "hello";
System.out.println(s.toUpperCase());

    • 1
    • 2
    10.toLowerCase

    //转换成小写

    11.concat

    //拼接字符串

    String s1 = "宝玉";
s1 = s1.concat("123").concat("456").concat("789");

    • 1
    • 2
    12.replace

    //替换字符串中的字符

    s1 = s1.replace("123","789");	//把所有的123替换成789
//s1.replace() 方法执行后，返回的结果才是替换过的
//replace对s1没有任何影响
String s11 = s1.replace("123","789");

    • 1
    • 2
    • 3
    • 4
    13.split

    //分割字符串，对于某些分割字符，我们需要转义比如 | \\等，两个斜杠表示一个斜杠

    String poem = "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
String[] split = poem.split("，");	//以，为标准对poem进行分割，返回一个数组
for(int i =0;i<split.length;i++)
{
	System.out.println(split[i]);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    14.toCharArray

    转成字符数组

    s = "happy";
char[] chs = s.toCharArray();
for(int i =0;i < chs.length;i++)
{
	System.out.println(chs[i]);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    15.compareTo

    比较两个字符串的大小

    //如果前者大，则返回正数，后者大，则返回负数，如果相等，则返回0

    ​ 1.如果长度相同，并且每个字符也相同，返回0

    ​ 2.如果长度相同或者不相同，但是比较时，可以区分大小

    ​ 就返回 if ( c1 != c2) {

    ​ return c1 - c2;

    ​ }

    ​ 3.如果前面的部分都相同，就返回 str1.len - str2.len

    String a = "jcck";
String b = "jack";
System.out.println(a.compareTo(b));		//返回值是'c'-'a' = 2的值

    • 1
    • 2
    • 3
    16.format

    格式字符串，用占位符填充

    1.占位符%d,%s,%.2f,%c

    2.这些变量由后面的变量来替换

    3.%d 用整数替换

    4.%s 表示由后面的字符串替换

    5.%.2f 用小数来替换，替换后，保留两位小数，并进行四舍五入的处理

    6.%c 用char类型数据替换

    String str2 = String.format("我的姓名是%s 年龄是 %d，成绩是%.2f 性别是 %c，希望大家喜欢我", name,age,score,gender);

//或者
String formatStr = "我的姓名是%s 年龄是 %d，成绩是%.2f 性别是 %c，希望大家喜欢我";
    
String info2 = String.format(formatStr,name,age,score,gender)    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    1.3 StringBuffer类

    ​ *StringBuffer代表可变字符序列，可以对字符串内容进行增删

    ​ *很多方法与String相同

    ​ *StringBuffer是一个容器

    StringBuffer stringBuffer = new StringBuffer(“hello”);

    1.StringBuffer构造器

    //1.创建一个大小为16的char[]，用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();

StringBuffer stringBuffer1 = new StringBuffer("123");

//2.通过构造器指定char[]大小
StringBuffer stringBuffer2 = new StringBuffer(100);

//3.通过给一个String创建一个StringBuffer，此时char[]大小就是hello.length()+16
StringBuffer hello = new StringBuffer("hello");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2.StringBuffer和String的转换

    1.String —> StringBuffer

    String str = "hello tom";
//1.使用构造器
//返回的才是StringBuffer对象,对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);

//2.使用append方法
StringBuffer stringBuffer1 = new StringBuffer();
StringBuffer1 = stringBuffer1.append(str);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2.StringBuffer —> String

    StringBuffer stringBuffer3 = new StringBuffer("小吴");
//1.使用toString方法
String s= stringBuffer3.toString();

//2.使用构造器来搞定
Stirng s1 = new String(stringBuffer3);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    3.常用方法

    1.append //增加

    2.delete //删除

    s.delete(11,14);
//删除11~14的字符 [11,14)，不包括14号位置的字符

    • 1
    • 2

    3.replace //替换

    s.replace(9,11,"小树苗");
//使用小树苗替换索引9-11的字符，不包括11，如果9-10为两个字符，则用小树苗替换这两个字符

    • 1
    • 2

    4.indexOf //查找

    5.insert //插入

    s.insert(9,"赵明");
//在索引为9的位置插入“赵明”，原来索引为9的位置内容自动后移

    • 1
    • 2

    1.4 StringBuilder类

    ​ *一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步(StringBuilder不是线程安全)，该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候，如果可能，建议优先采用该类，因为大多数实现中，它比StringBuffer快

    ​ *在StringBuilder上主要操作是appends和insert方法，可重载这些方法，以接受任意类型的数据

    ​ *String,StringBuffer,StringBuilder比较

    在这里插入图片描述
    在这里插入图片描述

    1.5 Math类

    ​ *Math类包含用于执行基本数学运算的方法，如初等指数，对数，平方根和三角函数

    1.abs

    //绝对值

    int a = Math.abs(-9);

    • 1

    2.pow

    //求幂

    double pow = Math.pow(2,4);//2的四次方

    • 1

    3.ceil

    //向上取整(转成double)

    double pow = Math.ceil(-3.0001);//返回-3

    • 1

    4.floor

    //向下取整(转成double)

    double pow = Math.floor(3.0001);//返回3

    • 1

    5.round

    //四舍五入

    long round = Math.round(-5.001);

    • 1

    6.sqrt

    //求开方

    double sqrt = Math.sqrt(9.0);

    • 1

    7.random

    //求随机数

    

    • 1

    8.max

    //求两个数的最大值

    max(1,14);

    • 1

    9.min

    //求两个数的最小值

    

    • 1

    1.6 Arrays类

    1.toString

    //1.toString 返回数组的字符串形式
Arrays.toString(arr);

Integer[] integers = {1,20,90};
System.out.println(Arrays.toString(integers));

    • 1
    • 2
    • 3
    • 4
    • 5

    2.sort

    //排序

    Integer arr[] = {1,-1,7,0};
//进行排序
Arrays.sort(arr,new Comparator());	//comparator返回的值大于0则升序(冒泡排序)，小于0则降序

    • 1
    • 2
    • 3

    //sort排序代码
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    3.binarySearch

    //通过二分搜索法进行查找，要求必须排好序

    Integer[] arr = {1,2,90,123,567}

//数组为有序的才可以使用
//如果数组中不存在该元素，就返回-1
int index = Arrays.binarySearch(arr, 3);

    • 1
    • 2
    • 3
    • 4
    • 5

    ​ *key not found 返回 - (应该在的位置+1)

    4.copyOf

    ​ *从arr数组中，拷贝arr.length个元素到newArr数组中

    ​ *如果拷贝的长度 > arr.length就在新数组的后面增加null

    //数组元素的复制

    Integer[] newArr = Arrays.copyOf(arr, arr.length);

    • 1

    5.fill

    //数组元素的填充

    //用99替换原来的元素

    Integer[] num = new Integer[]{9,3,2};
Arrays.fill(num, 99);

    • 1
    • 2

    6.equals

    //比较两个数组元素内容是否完全一致

    boolean equals = Arrays.equals(arr,arr2);

    • 1

    7.asList

    //将一组值，转换成list

    List<Integer> asList = Arrays.asList(2,3,4,5,6,1);

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

    • 1
    • 2
    • 3

    1.7 System类

    1.exit

    //退出当前程序

    System.exit(0);
//0表示一个状态，正常状态

    • 1
    • 2

    2.arrays.copy

    //复制数组元素，适合底层调用，一般使用Arrays.copyOf完成复制数组

    int[] src = {1,2,3};
int[] dest = new int[3];
System.arraycopy(src,0,dest,0,3);//src.length()

    • 1
    • 2
    • 3

    3.currentTimeMillens

    //返回当前时间距离1970-1-1的毫秒数

    System.out.println(System.currentTimeMillens());

    • 1

    4.gc

    //运行垃圾回收机制

    1.8 BigInteger和BigDecimal类

    BigInteger bigInteger = new BigInteger("2379999999999999999999999");//转成字符串
BigInteger bigInteger = new BigInteger("100");

//1.在对BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
BigInteger add = bigInteger.add(bigInteger2);

    • 1
    • 2
    • 3
    • 4
    • 5

    ​ *BigInteger 大整数(整型)

    ​ *BigDecimal 大精度(小数)

    1.add

    //加

    2.subtract

    //减

    3.multiply

    //乘

    4.divide

    //除

    BigDecimal bigDecimal = new BigDecimal("19999.111111111111999999999");
BigDecimal bigDecimal2 = new BigDecimal("2");
//在调用divide方法时，指定精度即可，BigDecimal.ROUND_CEILING
//如果有无限循环小数，就会保留分子的精度
System.out.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING)

    • 1
    • 2
    • 3
    • 4
    • 5

    1.9 Date类

    *java.util.Date包下

    1.第一代日期类

    1.Date：精确到毫秒，代表特定的瞬间

    2.SimpleDateFormat：格式和解析日期的类

    ​ SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化

    Date d1 = new Date();	//获取当前系统时间
System.println("当前系统时间为："+ d1);
//默认输出的日期格式是国外的方式，因此通常需要对格式进行转换

Date d2 = new Dae(9234567);	//通过指定毫秒数得到时间
System.out.println(d1.getTime());	//获取某个时间对应的毫秒数

//1.创建SimpleDateFormat对象，可以指定对应的格式
//2.这里的格式使用的字母是规定的，如下表
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1);

//1.把一个格式化的String转成对应的Date
//2.在把String -> Date使用的sdf格式需要和你给的String格式一样，否则会抛出转换异常

String s = "1996年01月01日 10:20:30 星期一";
Date parse = sdf.parse(s);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述

    2.第二代日期类

    ​ *Calender(日历)

    ​ *Calender类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

    //1.Calender是一个抽象类，并且构造器是private
//2.可以通过getInstance()	来获取实例
//3.提供大量的方法和字段提供给程序员
Calender c = Calender.getInstance();

//2.获取日历对象的某个日历字段
System.out.println("年："+c.get(Calendar.YEAR));

//月要+1，因为Calendar返回月时，是按照0开始编号
System.out.println("月："+(c.get(Calendar.MONTH) + 1));
System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时："+c.get(Calendar.HOUR));//HOUR_OF_DAY	改为24小时制
System.out.println("分钟:"+c.get(Calendar.MINUTE));
System.out.println("秒："c.get(Calendar.SECOND));

//Calendar没有专门的格式化方法，所以需要自己来组合显示

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    3.第三代日期类

    ​ *可变性：像日期和时间这样的类应该是不可变的

    ​ *偏移性：Date中的年份是从1900开始的，而月份都从0开始

    ​ *格式化：格式化只对Date有用，Calender不行

    ​ *不是线程安全的；不能处理润秒(每隔2天，多出1s)

    1.常见方法

    1.LocalDate(日期、年月日)、LocalTime(时间、时分秒)、LocalDateTime(日期时间、年月日、时分秒)

    //1.使用Now返回当前日期时间的对象
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);

ldt.getYear();
ldt.getMonthValue();	//数字的Month
ldt.getMonth();	//英文的Month
ldt.getDayOfMonth();
ldt.getHour();
ldt.getMinute();
ldt.getSecond();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2.DateTimeFormatter格式日期类

    类似于SimpleDateFormat

    DateTimeFormat dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
String str = dtf.format(日期对象);

    • 1
    • 2

    3.Instant //时间戳

    //提供了一系列和Date类转换的方式
//Instant--->Date
Date date = Date.from(instant);

//Date--->Instant
Instant instant = date.toInstant();

//1.通过静态方法Now()获取表示当前时间戳的对象
Instant now = Instant.now();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    ​ *其它方法可以自己上网查

  • 相关阅读:
    智慧环卫解决方案-最新全套文件
    redis篇
    2023-11-22 LeetCode每日一题（网格中的最小路径代价）
    岩土工程监测中振弦采集仪数据处理与解读的挑战与方法
    计算机辅助药物设计- - 从蛋白质结构到药物候选物的全方位实战
    自制操作系统日志——第十七天
    【无标题】
    数据可视化（一）
    史上最全面试题版！看完吊打面试官！七夕来袭！是时候展现专属于程序员的浪漫了 10万字+
    Bika LIMS 开源LIMS集——ERD实体关系定义（数据库设计）
  • 原文地址：https://blog.csdn.net/qwsadsdga/article/details/138030166