JAVA学习-常用类

String类的常见方法

.equalsCase

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

.equalsIgnoreCase

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

username1.equalsIgnoreCase(username2)

这就是判断username1与username2的内容是否相等

.length

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

.indexOf

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

String username = "johnjohn";
int index = username.indexOf('j');//返回值为0

.lastIndexOf

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

String username = "johnjohn";
int index = username.lastIndexOf('j');//返回值为4

补充：也可以是子字符串在字符串对象第一次出现的索引，举例如下：

String username = "johnjohn";
int index = username.lastIndexOf("hn");//返回值为6

.substring

截取指定范围的子字符串

String username = "johnjohn";
System.out.println(username.substring(1));//从索引1开始截取后面所有内容：ohnjohn
////////////////////////////////
String username = "johnjohn";
System.out.println(username.substring(1,5));//从索引1开始截取,到索引5停止截取，不截取索引5的字符：ohnj

.toUpperCase

转换成大写

String username = "john";
System.out.println(unsername.toUpperCase())//JOHN

.toLowerCase

转换成小写

String username = "JOHN";
System.out.println(unsername.toUpperCase())//john

.concat

拼接字符串

String username = "john";
System.out.println(unsername.concat(is).concat(my).concat(name)//joheismyname

.replace

替换字符串

String s1 = "john jack jack jack";
System.out.println(s1.replace("jcak","john"))

.split

分割字符串，对于某些分割，我们需要转义

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

//在对字符串进行分割时，如果有特殊字符，需要加入转义符\。例如如果要以\\为分割，则要在每个\前加一个\，则为\\\\
String poem = "E:\\aaa\\bbb";
String split[] = poem.split("\\\\");
for(int i= 0; i < split.length; i++){
    System.out.println(split[i]);
}

.toCharArray

将字符串转成字符数组

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

.compareTo

比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，则返回0

理解：如果两个字符串，完全相等，则返回0。如果长度相等，则用第一个字符串的第一个出现字符与第二个对应位置的字符不相等的对应的码减去第二个字符串的这个位置字符的码（比如“abde”与"abee"，它们长度就是“d"对应的码减去”e"对应的码，等于-1）。如果两个字符串，长度不相等，且长的那个不是短的那个字符串的衍生，它们大小的比较同上，是比较码。但如果两个字符串长度不相等，但长的字符串是短的字符串的衍生，则直接前者的字符串的长度减去后者字符串的长度就是比较结果。

.fomat

将所有信息都拼接在一个字符串

占位符：%s , %d ,%f %c

这些占位符由后面的变量来替换

%s 表示有字符串来替换 %d是整数替换 %.2f表示用小数来替换，替换后保留小数点两位 %c表示用char来替换

%.2f会进行四舍五入

StringBuffer类

  1. StringBuffer的直接父类是AbstractStringBuilder
  2. StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
  3. 在父类中，AbstractStringBuilder有属性char[] value , 不是final 。 该value数组存放字符串内容，引出存放在堆中的
  4. StringBuffer是一个final类，不能被继承。

String VS StringBuffer

  1. String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低。 //private final char value[]；
  2. StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高 //char[] value；存放在堆中。

String与StringBuffer的相互转化

String --> StringBuffer

String str = "hello tom";
//方式一 使用构造器
StringBuffer stringbuffer = new StringBuffer(str);
//方式二 使用append方法
StringBuffer stringbuffer = new StringBuffer();
stingbuffer = stringbuffer.append(str);

StringBuffer - -> String

StringBuffer stringbuffer = new StringBuffer();
//方式一 使用StringBuffer提供的toString方法
String str = stringbuffer.toString();
//方式二 使用构造器
String str = new String(stringbuffer);

.append

增加字符串

StringBuffer stringbuffer = new StringBuffer("hello");
stringbuffer.append("tangxiaoyuan");
System.out.println(stringbuffer);//hellotangxiaoyuan

.delete

删除

StringBuffer stringbuffer = new StringBuffer("hello");
stringbuffer.delete(1,3);//删除1到3的字符[1,3)
System.out.println(stringbuffer);//hlo

.replace

替换

StringBuffer stringbuffer = new StringBuffer("hello");
stringbuffer.replace(1,3,"iou");//替换1到3的字符[1,3)为iou
System.out.println(stringbuffer);//heioulo

.indexOf

查找指定子字符串在字符串第一次出现的索引，如果找不到返回-1

StringBuffer stringbuffer = new StringBuffer("hello");
int indexOf = stringbuffer.indexOf("l");
System.out.println(indexOf);//返回2

.insert

插入

StringBuffer stringbuffer = new StringBuffer("hello");
//在索引为2的位置查入“你好”，索引为2开始就是“你好”
stringbuffer.stringbuffer.insert(2,"你好");
System.out.println(stringbuffer);//he你好llo

作业：给数字自动加逗号

package com.classLearn.stringBuffer;

import java.util.Scanner;

public class AutoAddSomething {


    //实现用户输入数字，自动用逗号隔开，例如：1,898,789,666,090,335.88
    public String Scanner(){
        String num = null ;
        System.out.println("请输入数字：");
        Scanner scanner= new Scanner(System.in);
        if (scanner.hasNextDouble()){
             num = scanner.next();
        }else {
            System.out.println("你输入的不是数字");
            return num;
        }
        return num ;
    }

    public StringBuffer AddSomething (String num){
        StringBuffer stringbuffer = new StringBuffer(num);
        int thePointHost = stringbuffer.lastIndexOf(".");
        if (thePointHost > 0 ){
            for (int i = thePointHost-3; i > 0 ; i-=3) {
                stringbuffer.insert(i ,",");
            }
        }else {
            for (int i = stringbuffer.length()-3; i > 0 ; i-=3) {
                stringbuffer.insert(i,",");
            }
        }
        return stringbuffer;
    }
}
////////////////////////////////////////
package com.classLearn;

import com.classLearn.stringBuffer.AutoAddSomething;

public class Application {
    public static void main(String[] args) {
        AutoAddSomething demo01 = new AutoAddSomething();
        String scannreNum = demo01.Scanner();
        StringBuffer endNum = demo01.AddSomething(scannreNum);
        System.out.println(endNum);
    }
}

StringBuilder类

  1. StringBulider 继承了 AbstractStringBuilder 类
  2. 实现了 Serializable , 说明StringBuilder对象是可以串行化（对象可以网络传输，可以保存到文件）
  3. StringBuilder 是final类，不能被继承
  4. StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder的char[] value 中，所以字符序列是在堆中
  5. StringBuilder 的方法，没有做互斥处理，即没有 synchronized关键字，因此推荐在单线程的情况下使用StringBuilder

StringBuilder&StringBuffer&String 的比较

  1. StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

  2. String：不可变字符序列，效率低，但是复用率高。

  3. StringBuffer：可变字符序列，效率较高（增删），线程安全

  4. StringBilder：可变字符序列，效率最高，线程不安全

  5. String使用注意说明：

    String s = "a"; //创建了一个字符串
s += "b";//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b"(也就是ab)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。结论：如果我们对String做大量修改，不要使用String

Math类

数学类，是一个静态类，不用new，直接可用

.abs

绝对值

.pow

求幂

.ceil

向上取整，返回大于等于这个参数的最小整数

.floor

向下取整，返回小于等于这个参数的最小整数

.round

四舍五入

.sqrt

求开方

.random

返回一个大于0小于1的随机数

实现在任意范围返回任意个整数

//a<x<b
for(int i = 0; i < 7; i++){
    System.out.print((int)(a+Math.random()*(b-a+1)))
}

.max .min

返回最大值最小值

Arrays类

.toString

返回数组的字符串形式

.sort

sort可以定制排序，代码如下：

import java.util.Comparator;

public class Sort {
    public void AutoChose(int[] arr , Comparator c ){
        for (int i = 0; i < arr.length-1 ; i++) {
            for (int j = 0; j < arr.length-1-i ; j++) {
                if (c.compare(arr[j],arr[j+1])>0){ //这里是交换顺序的条件
                    //下面是交换顺序
                    //但是想要交换顺序，必须要满足 c.compare(arr[j],arr[j+1])>0
                    //我们只需要改变这个结果，就可以改变排序的顺序
                    int num = 0;
                    num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                }
            }
        }
    }
}
/////////////////////////////
import com.classLearn.arrays.Sort;

import java.util.Arrays;
import java.util.Comparator;

public class Application {
    public static void main(String[] args) {
        int[] arry = {1,89,9,54,5,76,3,90};
        Sort sort = new Sort();
        sort.AutoChose(arry, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int a = (Integer)o1;
                int b = (Integer)o2;
                return a - b; //现在相当于是arr[j]-arr[j+1]>0就交换，则是从小到大
                //若改成 return b - a; 则相当于arr[j+1]-arr[j]>0交换，从大到小排序
            }
        });
        System.out.println(Arrays.toString(arry));
    }
}

.binarySearch

通过二分搜索法进行查找，要求必须有序数组

Interger a[] = {1,3,5,70,90};
int index = Arrays.binarySearch(a,1); //在a这个数组找1，如果有，会返回索引给index。如果不存在，会返回-(low+1)
//low 是它应该存在的位置。上述数组，如果我们查找60，则它如果存在的话，索引为3，low=3，则最终的index=-4 。

.copyOf

数组元素的复制

Integer a[] = {1,3,5,70,90};
Integer newA[] = Arrays.copyOf(a, a.length);
//拷贝a数组的 a.length 个数到newA数组，个数可以改变，-1则少一个元素，+1则多一个元素为null，填0则没有，填-1会抛出异常。

.fill

数组元素的填充，替换原来的所有元素

Integer a[] = {1,3,5,70,90};
Arrays.fill(a, 99);//现在a[]={99,99,99,99,99}

.equals

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

如果一样则返回true，不一样返回false

bollean equals = Arrays.equals(arr1,arr2);//比较arr1与arr2是否完全一样

.asList

asList方法会将 比如：(1,3,4,6,6,7) 数据转成一个List集合

返回的asList 编译类型 List（接口）

Arrays类作业

自定义Book类，里面包含name和price，按照price排序（从大到小，从小到大），再按照书名的长度排序，用定制排序。

作业中遇到的问题：

用对象类new的数组，用toString输出不对，这个时候，我们要在对象里面添加一个toString的方法

public class Book {
     String name = null;
     Double price = 0.0;

    public Book() {
    }

    public Book(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {  //这个方法定义了Book类的数组应该怎么输出
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
///////////////////////////////////
import com.classLearn.arrays.Book;

import java.util.Arrays;

public class Application {
    public static void main(String[] args) {
        Book[] books = new Book[4];//创建一个Book类型的数组，长度为4
        books[0] = new Book("红楼梦",50.0);
        books[1] = new Book("西游记新",60.0);
        books[2] = new Book("青年文摘20",70.0);
        books[3] = new Book("java从入门到放弃",500.0);
        System.out.println(Arrays.toString(books));

System类

.exit

退出当前程序

System.exit(0);//就推出了，0表示一个状态，正常的状态

.arraycopy

五个参数：

src : 源数组

srcPos : 从源数组的哪个索引位置开始拷贝

dest : 目标数组，即把源数组的数据拷贝到哪个数组

destPos : 把源数组的数据拷贝到目标数组的哪个索引

length : 从源数组拷贝多少个数据到目标数组

.currentTimeMillis

至今到1970年1月1日的时间差，以毫秒为单位

BigInteger BigDecimal

用于非常的的数据，不能用简单的加减乘除，要用方法去加减乘除。

Date

精确到毫秒。代表特定的瞬间

LocalDateTime

第三代日期

LocalDate 只有年月日

LocalTime 只有是时分秒

LocalDateTime 年月日时分秒

.now

获取现在的时间

LocalDateTime now = LocalDateTime.now();

使用DateTimeFormatter

DateTimeFormatter 可以实现格式化

LocalDateTime now = LocalDateTime.now();
//创建DateTimeFormatter对象
DateTimeFormatter dateTimeForematter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分ss秒")；
String format = dateTimeFormatter.format(now);
System.out.println("格式化的日期："+format);

Instant

时间戳

通过now()方法获取表示当前时间戳的对象

Instan now = Instant.now();

通过from可以把Instant转成Date

Date date = Date.from(now);

通过date的toInstant()可以把date转成Instant

Instant instant = date.toInstant

.plus 和 .minus

对当前时间进行加或则减

LocalDateTime now = LocalDateTime.now();
DateTimeFormatter dateTimeForematter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分ss秒")；
//看看900天后
LocalDateTime localDateTime = now.plusDays(900);
System.out.println("900天后" + dateTimeFormatter.format(localDateTime))
posted @   老哥不老  阅读(51)  评论(0)  编辑  收藏  举报
相关博文：
·  JAVA学习-变量、常量与运算
·  JAVA学习-对象
·  JAVA 常用类总结
·  常用类的学习
·  人生苦短我学Java-11-常用类及方法
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
点击右上角即可分享
微信分享提示
AI IDE Trae