java常用类笔记（String类））

最新推荐文章于 2024-04-05 23:04:20 发布
最新推荐文章于 2024-04-05 23:04:20 发布
阅读量106 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48080076/article/details/121245723
版权

1.String类

java.lang.String类的使用

1.1.概述

  1. String声明为final的，不可被继承
  2. String实现了Serializable接口：表示字符串是支持序列化的。
    实现了Comparable接口：表示String可以比较大小
  3. String内部定义了final char[] value用于存储字符串数据
  4. 通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中)。
  5. 字符串常量池中是不会存储相同内容(使用String类的equals()比较，返回true)的字符串的。

1.2.String的不可变性

以下情况需要重写指定内存区域赋值，不能使用原有的value进行赋值：

  1. 当对字符串重新赋值时
  2. 当对现的字符串进行连接操作时
  3. 当调用String的replace()方法修改指定字符或字符串时

举例

String s1 = "abc";//字面量的定义方式
String s2 = "abc";
s1 = "hello";
System.out.println(s1);//hello
System.out.println(s2);//abc

String s2 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);//abc

String s4 = "abc";
String s5 = s4.replace('a', 'm');
System.out.println(s4);//abc
System.out.println(s5);//mbc

1.3.String实例化的不同方式

方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式

//通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
String s3 = new String("javaEE");
String s4 = new String("javaEE");

System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false

图示：
java
问题：String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？（面试题）
两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

1.4.字符串拼接方式赋值的对比

1.4.1.说明

  • 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
  • 只要其中一个是变量，结果就在堆中。
  • 如果拼接的结果调用intern()方法，返回值就在常量池中

1.4.2.代码举例

String s1 = "javaEE";
String s2 = "hadoop";

String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1 + "hadoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;

System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s5 == s6);//false
System.out.println(s5 == s7);//false
System.out.println(s6 == s7);//false

String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
****************************
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false

final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true

1.5.常用方法

int length()：返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

1.6.String与其它结构的转换

1.6.1.与基本数据类型、包装类之间的转换

String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)

String str1 = "123";
//int num = (int)str1;//错误的
int num = Integer.parseInt(str1);
String str2 = String.valueOf(num);//"123"
String str3 = num + "";

1.6.2.与字符数组之间的转换

String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器

String str1 = "abc123";  //题目： a21cb3
char[] charArray = str1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
    System.out.println(charArray[i]);
}
char[] arr = new char[]{'h','e','l','l','o'};
String str2 = new String(arr);
System.out.println(str2);

1.6.3.与字节数组之间的转换

编码(字符串 -->字节)：String --> byte[]:调用String的getBytes()
解码(编码的逆过程)：byte[] --> String:调用String的构造器
说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

String str1 = "abc123中国";
byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
String str2 = new String(bytes);//使用默认的字符集，进行解码。
System.out.println(str2);
String str3 = new String(gbks);
System.out.println(str3);

1.6.4.与StringBuffer、StringBuilder之间的转换

String -->StringBuffer、StringBuilder:调用StringBuffer、StringBuilder构造器
StringBuffer、StringBuilder -->String:
①调用String构造器；
②StringBuffer、StringBuilder的toString()
补充：JVM中字符串常量池存放位置说明：
jdk 1.6 (jdk 6.0 ,java 6.0):字符串常量池存储在方法区（永久区）
jdk 1.7:字符串常量池存储在堆空间
jdk 1.8:字符串常量池存储在方法区（元空间）

2.String、StringBuffer、StringBuilder

2.1.对比

  • String:不可变的字符序列；底层使用char[]存储
  • StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
  • StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

2.2.常用方法

增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
*遍历：for() + charAt() / toString()

3.日期时间

3.1.获取系统当前时间

System类中的currentTimeMillis()

long time = System.currentTimeMillis();
//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//称为时间戳
System.out.println(time);

3.2.java.util.Date类与java.sql.Date类

1.两个构造器的使用
>构造器一：Date()：创建一个对应当前时间的Date对象
>构造器二：创建指定毫秒数的Date对象
2.两个方法的使用
>toString():显示当前的年、月、日、时、分、秒
>getTime():获取当前Date对象对应的毫秒数。（时间戳）
3. java.sql.Date对应着数据库中的日期类型的变量
>如何实例化
>如何将java.util.Date对象转换为java.sql.Date对象

//构造器一：Date()：创建一个对应当前时间的Date对象
Date date1 = new Date();
System.out.println(date1.toString());//Sat Feb 16 16:35:31 GMT+08:00 2019
System.out.println(date1.getTime());//1550306204104
//构造器二：创建指定毫秒数的Date对象
Date date2 = new Date(155030620410L);
System.out.println(date2.toString());
//创建java.sql.Date对象
java.sql.Date date3 = new java.sql.Date(35235325345L);
System.out.println(date3);//1971-02-13
//如何将java.util.Date对象转换为
Date date4 = new Date();
java.sql.Date date5 = new java.sql.Date(date4.getTime());

3.3.java.text.SimpleDataFormat类

SimpleDateFormat对日期Date类的格式化和解析

3.3.1.两个操作：

格式化：日期 —>字符串
解析：格式化的逆过程，字符串 —> 日期

3.3.2.SimpleDateFormat的实例化

new + 构造器

SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
String format1 = sdf1.format(date);
System.out.println(format1);//2019-02-18 11:48:27
//解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),否则，抛异常
Date date2 = sdf1.parse("2020-02-18 11:48:27");
System.out.println(date2);

3.4.Calendar类：日历类、抽象类

1.实例化
方式一：创建其子类（GregorianCalendar的对象
方式二：调用其静态方法getInstance()

2.常用方法

Calendar calendar = Calendar.getInstance();
//get()
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
//set()
//calendar可变性
calendar.set(Calendar.DAY_OF_MONTH,22);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
//add()
calendar.add(Calendar.DAY_OF_MONTH,-3);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
//getTime():日历类---> Date
Date date = calendar.getTime();
System.out.println(date);
//setTime():Date ---> 日历类
Date date1 = new Date();
calendar.setTime(date1);

3.5.LocalDate / LocalTime / LocalDateTime

本地日期、本地时间、本地日期时间的使用：LocalDate / LocalTime / LocalDateTime
1.说明
① 分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
② LocalDateTime相较于LocalDate、LocalTime，使用频率要高
③ 类似于Calendar
2.常用方法
在这里插入图片描述

3.6.日期时间格式化类：DateTimeFormatter

1.说明：
① 格式化或解析日期、时间
② 类似于SimpleDateFormat
2. 常用方法：
自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
在这里插入图片描述

//重点：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//格式化
String str4 = formatter3.format(LocalDateTime.now());
System.out.println(str4);//2019-02-18 03:52:09
//解析
TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
System.out.println(accessor);

4.Java比较器

4.1.Java比较器的使用背景

Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的
但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

4.2.自然排序：使用Comparable接口

4.2.1. 说明

  1. 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
  2. 像String、包装类重写compareTo()方法以后，进行了从小到大的排列
  3. 重写compareTo(obj)的规则：
    如果当前对象this大于形参对象obj，则返回正整数，
    如果当前对象this小于形参对象obj，则返回负整数，
    如果当前对象this等于形参对象obj，则返回零。
  4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序

4.2.2. 自定义类代码举例

public class Goods implements  Comparable{

    private String name;
    private double price;

    //指明商品比较大小的方式:照价格从低到高排序,再照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
//        System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
//                return 0;
               return -this.name.compareTo(goods.name);
            }
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
// getter、setter、toString()、构造器：省略
}

4.3. 定制排序：使用Comparator接口

4.3.1.说明

  1. 背景：
    当元素的类型没实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
  2. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
    如果方法返回正整数，则表示o1大于o2；
    如果返回0，表示相等；
    返回负整数，表示o1小于o2。

4.3.2 代码举例

Comparator com = new Comparator() {
    //指明商品比较大小的方式:照产品名称从低到高排序,再照价格从高到低排序
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Goods && o2 instanceof Goods){
            Goods g1 = (Goods)o1;
            Goods g2 = (Goods)o2;
            if(g1.getName().equals(g2.getName())){
                return -Double.compare(g1.getPrice(),g2.getPrice());
            }else{
                return g1.getName().compareTo(g2.getName());
            }
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
}

4.4. 两种排序方式对比

  • Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
  • Comparator接口属于临时性的比较。
weixin_48080076
关注
专栏目录
java常见类
sjtu_chenchen的专栏
04-28 979
package pack;import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.Properties; import java.util.Random;public class Main { public static void main(St
Java学习笔记 --- String类
乌云的博客
10-24 566
1、String 对象用于保存字符串，也就是一组字符序列2、字符串常量对象是用双引号括起的字符序列。3、字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节4、String类比较常用的构造方法（其他查询手册）
【Object类、常用API】
09-09 1034
day01【Object类、常用API】 主要内容 Object类 Date类 DateFormat类 Calendar类 System类 StringBuilder类 包装类 教学目标 -[ ] 能够说出Object类的特点-[ ] 能够重写Object类的toString...
Java高级篇-常用类
cV展示的学习园
04-29 363
常用类 String 概述 String:字符串，使用一对""引起来表示。 String声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。 实现了Comparable接口：表示String可以比较大小 String内部定义了final char[] value用于存储字符串数据 通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中)。 字符串常量池中是不会存储相同内容(使用String类的equals()比较，返回tru
Java中常见常用的类
热门推荐
Superme
02-28 3万+
1、Object Object类是所有类的父类，也就是说任何一个类在定义时如果没有明确地继承一个父类，那它就是Object类的子类，也就是说以下两种类定义的最终效果是完全相同的。 class Book{ class Book extends Object{ } ...
【Java基础笔记】String类以及StringBuffer Builder.docx
10-25
本文主要关注Java中的三个字符串相关类：`String`、`StringBuilder`和`StringBuffer`。理解它们的特性和使用方法对于编写高效、线程安全的代码至关重要。 一、`String`类 `String`类在Java中是一个不可变类，意味着...
Java学习笔记，常用类
02-06
总之，Java的包装类提供了一种将基本数据类型与对象世界连接的方式，而`String`类的不可变性则保证了字符串数据的稳定性和安全性。这两个概念在Java编程中都是非常基础且重要的知识点，理解并熟练运用它们能够提升...
【狂神说笔记—— Java基础07-常用类】
weixin_46055348的博客
07-07 821
【狂神说笔记—— Java基础07-常用类】
java中常见的类（一）
weixin_42419715的博客
07-25 206
方法重写（补充） 发生重写的情况： 有继承关系 方法名同名 参数列表要一模一样（顺序，个数，类型） 返回值类型为引用型时，子类的返回值类型小于等于父类的返回值类型基本类型时，要一模一样 子类的修饰符权限要大于等于父类的修饰符权限（父类的修饰符不能是private） 子类抛出的异常小于等于父类抛出的异常（任何一个方法都会对外抛出运行时异常） public class Test01 { ...
Java中的常用类
yzl1293346757的博客
07-24 1132
javaSE入门基础知识,常用类涵盖基本包装类,Array类,Object类,String类,StringBuffer类,StringBuilder类,Math类,Random类,Date类,Calender类,SimpleDateFormat类,BigInteger类,BigDecimal类等
java中的常用类
最新发布
2301_77681226的博客
04-05 1057
●Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都继承实现这个类的方法。●如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类●toString方法输出一个对象，但是对象在内存中存储，是不能输出的，只能把对象信息以字符串形式输出当输出一个对象时，会默认调用此对象的toString(),如果类中没有定义toString()，会调用Object类中toString(),
Java中的常用类（一）
仰望与追逐的博客
04-27 1687
Java中的常用类一、字符串相关的类二、JDK8之前日期时间API 一、字符串相关的类 String对象的创建: String str = "hello"; //本质上this.value = new char[0]; String s1 = new String(); //this.value = original.value; String s2 = new String(String ...
Java中常见的几个类
qq_37867421的博客
05-03 780
常用类 第一节：Object 所有类的父类，他的所有方法是被子类默认继承的。 1.getClass 返回的是实际对象的类型 2.toString 返回的是该对象的地址的文本格式 public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode());...
java常见类的使用
渣渣的成长之路
02-14 200
Object类 1.equals:比较的是值；==比较的是内存地址 2.toString()方法：将任何东西都可以转为字符串 3.相同的俩个对象，他们的hashCode值一样；但俩对象的hashCode相同，他们并不一定相同。 String类 1.String的length()是方法,需要带（）；数组的length是属性，不需要（） 2.compareTo(): “x”compare...
java中常用的类1
java_5666666的博客
09-18 336
Integer整数类 final类 继承Number 不能被继承
java150个常用类_Java基础之常用类
weixin_36080842的博客
02-26 844
一、字符串相关类1、String类：构造字符串对象常量对象：字符串常量对象是用双引号括起的字符序列。 例如：String s = "你好"、String s = "12.97"、String s = "boy"等。字符串的字符使用Unicode字符编码，一个字符占两个字节。使用构造方法创建并初始化：String();//初始化一个对象，表示空字符序列String(value);//利用已存在的字符...
Java中必须了解的常用类
05-25 704
Java 中基本类型和包装类之间的转换在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。那什么是装箱和拆箱呢？我们分别来看下装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱//装箱 int i = 10; Integer x = new Integer(i);//手动装箱 Integer y = i;//自动装箱 拆箱：和装箱相反，
Java李兴华笔记：常用类库详解与实践
本学习笔记主要涵盖了Java常用类库的相关内容，由Java专家李兴华讲解，适合用于复习和初学者入门。课程分为两部分，首先是回顾上次课程的重点，包括Eclipse的JDT（Java Development Tools）、JUnit单元测试框架以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值