JAVA高级-常用类和常用方法

2022/3/20 22:58:52

编程Tag： string new 常用 Java int 高级 out system println

本文主要是介绍JAVA高级-常用类和常用方法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

常用类

String类

**String****类：代表字符串。**Java 程序中的所有字符串字面值（如 “abc” ）都作

为此类的实例实现。
String是一个final类，代表不可变的字符序列。
字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

https://i.loli.net/2021/06/12/Ps7AnfxNqwKQc8h.png

String对象的字符内容是存储在一个字符数组value[]中的。

implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];

以上可见，在String类里，我们实现里两个接口，Serializable：这表示字符串是可以序列化的，Comparable：表示字符串是可以比较的

字面量实例化

package com.hyb.usualClass;

import org.junit.Test;

/**
 * @program: StringTest
 * @description:常用类，String
 *
 *
 * @author: Huang Yubin
 * @create: 2021-06-08 12:35
 **/

public class StringTest {
    @Test
    public void test1(){
//        字面量赋值
        String s1="abc";
        s1+="1";
        System.out.println(s1);
        /*可见我们可以给字符串更改值，但是从内存结构来讲，abc是没有被改变的，只是将abc1这个值赋值给了s1
        * 但是abc1从哪来的呢？只是从常量池里找来的，并不是在原来的abc上加过来的*/

        /*--------------------------------*/
        String s2="abc";
        String s3=s2.replace("a","c");
        System.out.println(s3);
//      cbc
        /*在这里原理也是一样，我们将a用c代替，只是创造了一个新的常亮cbc，而不是将原来abc修改了*/

        /*在这里我们便能总结出一个道理：
        * 字符串本质上是不可变的    */

    }
}

new关键字实例化

@Test
public void test2(){
    String s1="abc";
    String s2="abc";
    String s3=new String("abc");
    String s4=new String("abc");
    System.out.println(s1==s2);//true,因为常量值是一定的，不可改变，当然，地址可能不一样
    System.out.println(s1==s3);//false,对象存储在堆中，abc存在常量池中，地址可能改变
    System.out.println(s3 == s4);//false,对象比较是地址
    System.out.println(s1 == s4);//false

    /*但是这里可说明一点，当我们用同一个类new两个对象比较两个相等的字符串时，==符号便可以比较的
    * 因为我们new了两个对象在堆空间中造了两个地址，但是这两个相等的字符串是在常量池里的，不可改变*/
    
    /*---------------*/
    
    /*面试题里，一般都会问String s3=new String("abc");创建了几个对象？
    * 可知，有两个。
    * 一个是堆空间里的，一个是常量池里的*/

}

https://i.loli.net/2021/06/12/ONm7hq2HW1I6uAY.png

https://i.loli.net/2021/06/12/jreEBhJbDmH62lC.png

https://i.loli.net/2021/06/12/VQms7Nonctwhqpv.png

区别

@Test
public void test3(){
        String s1="abc";
        String s2="abc";
        String s3=s1+s2;
        String s4="abcabc";
        String s5=s1+"abc";
        System.out.println(s1 == s2);//true常量池的常量不可变
        System.out.println(s1 == s3);//false内容都不等
        System.out.println(s3 == s4);//false s4在常量池里，而s3在堆里创建了一个对象，让s1+s2
        System.out.println(s4 == s5);//false 也一样

        String s6=(s3).intern();
        System.out.println(s6==s4);//ture,intern()返回常量池
        /*我们就此可以总结出：
        * 1.常亮与常亮的拼接是返回常亮池的，且常量池里没有相同的常亮
        * 2.只要其中有一个是变量，结果就在堆中
        * 3.如果用intern方法，结果会返回常量池*/
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMdbNMLb-1647786099625)(C:\Users\黄渝斌\Desktop\5.png)]

面试题1

package com.hyb.usualClass;

/**
 * @program: InterviewProblem
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-08 13:43
 **/

public class InterviewProblem1 {
    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };
    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b'; 
    }
    public static void main(String[] args) {
        InterviewProblem1 ex = new InterviewProblem1();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
    /*good是一个字符串，字符串是无法改变的，所以输出good，也可以这样理解，java是值传递的，改变不了str
    * ch是一个数组，数组是可变的，自然可以改变*/
}

常用方法

https://i.loli.net/2021/06/12/bS7ZalCqFNMjOnG.png

https://i.loli.net/2021/06/12/MnAPZ5Rgu3TbUla.png

https://i.loli.net/2021/06/12/AluWXjTYt7KLiI3.png

String与基本数据类型的转换

字符串 -> 基本数据类型、包装类
1. Integer包装类的public static int parseInt(String s)：可以将由“数字”字
  
  符组成的字符串转换为整型。
2. 类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应
  
  的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
基本数据类型、包装类 -> 字符串
1. 调用String类的public String **valueOf(int n)**可将int型转换为字符串
2. 相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double
  
  d)、valueOf(boolean b)可由参数的相应类型到字符串的转换
字符数组 -> 字符串
1. String 类的构造器：String(char[]) 和 String(char[]，int offset，int
  
  length) 分别用字符数组中的全部字符和部分字符创建字符串对象。
```
String s2=new String(Arry);
System.out.println(s2);//abc
```
字符串->转为为字符数组
1. **public char[] toCharArray()**将字符串中的全部字符存放在一个字符数组
  
  中的方法。
2. public void getChars(int srcBegin, int srcEnd, char[] dst,
  
  **int dstBegin)**提供了将指定索引范围内的字符串存放到数组中的方法。
```
String s1="abc";
char[] Arry=s1.toCharArray();
for (int i = 0; i < s1.length(); i++) {
    System.out.println(Arry[i]);
}
```
字符串->字符数组
1. public byte[] getBytes() **：**使用平台的默认字符集将此 String 编码为
  
  byte 序列，并将结果存储到一个新的 byte 数组中。
2. public byte[] getBytes(String charsetName) **：**使用指定的字符集将
  
  此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
```
String s1="abc中国";
byte[] s2=s1.getBytes();
```
字节数组 -> 字符串
1. String(byte[]，int offset，**int length) **用指定的字节数组的一部分，
  
  即从数组起始位置offset开始取length个字节构造一个字符串对象。
2. String(byte[],int offset，int length) 用指定的字节数组的一部分，
  
  即从数组起始位置offset开始取length个字节构造一个字符串对象。
```
String s = new String(s2);
```

@Test
public void test5() throws UnsupportedEncodingException {

//        编码
        String s1="abc中国";
        byte[] s2=s1.getBytes();
        System.out.println(Arrays.toString(s2));
//        [97, 98, 99, -28, -72, -83, -27, -101, -67]UTF_8

        byte[] s3=s1.getBytes("gbk");
        System.out.println(Arrays.toString(s3));
//        [97, 98, 99, -42, -48, -71, -6]jbk

//        解码

        String s = new String(s2);
        System.out.println(s);
//      abc中国

        String gbk = new String(s3, "gbk");
        System.out.println(gbk);
//        abc中国


    }
}

StringBuffer类

可变的字符序列

//API
public final class StringBuffer
   extends AbstractStringBuilder
   implements java.io.Serializable, CharSequence

String s = new String("我喜欢学习"); 
StringBuffer buffer = new StringBuffer("我喜欢学习"); 
buffer.append("数学");
//我喜欢学习数学

请点击图片链接

https://i.loli.net/2021/06/12/mT6SBo4LcyHfCFN.png

JDK1.0中声明，可以对字符

串内容进行增删，此时不会产生新的对象。
很多方法与String相同。
作为参数传递时，方法内部可以改变值。
StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public String substring(int start,int end)：把[start,end)位置替换为str
public void setCharAt(int n ,char ch)：将指定位置字符改变
public char charAt(int n )：获取某一个位置字符
增：append(xxx)
删： delete(int start,int end)
改： replace(int start, int end, String str)：把[start,end)位置替换为str。

substring(int start,int end)：把[start,end)位置替换为str

setCharAt(int n ,char ch)：将指定位置字符改变
查：charAt(int n )：获取某一个位置字符
插： insert(int offset, xxx)：在指定位置插入xxx
长度：length()
遍历：for+查

StringBuilder类

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且

提供相关功能的方法也一样

面试题2

对比String、StringBuffer、StringBuilder

String(JDK1.0)：不可变字符序列
StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全
StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全
作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder

会改变其值。

底层都使用char数组存储。

String S1=new String();//value =new char[0]
String s1=new String("abc")//value new char[]{'a','b','c'}
    
StringBuffer s1=new StringBuffer();//value =new char[16]底层创建了一个长度为16的数组
s1.append('a');//value[0]='a';

StringBuffer s1=new StringBuffer("abc")//value =new char["abc".length()+16]扩容

输出三者的长度时：

String：就是当前length

StringBuffer：也是当前length，虽然底层创建了16长度的数组，但是返回的length是根据当前length返回的

StingBuffer都一样。
扩容问题：

如果添加的数据底层装不下，那么需要将底层的数组扩容，默认下，每次扩容两倍，将原来的数组赋值到新的数组里

**StringBuffer（int）**可指定底层数组容量

关于三者执行时间的比较：StringBuilder<StringBuffer<String

long startTime = 0L;
long endTime = 0L;
String text = "";
StringBuffer buffer = new StringBuffer("");
StringBuilder builder = new StringBuilder("");
//开始对比
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
text = text + i; }
endTime = System.currentTimeMillis();
System.out.println("String的执行时间：" + (endTime - startTime));

JDK8之前日期时间API

点击图片链接：https://i.loli.net/2021/06/12/7kdIqz4jSFRX325.png

java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时

间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，俗称时间戳。
计算世界时间的主要标准有：
1. UTC(Coordinated Universal Time)
2. GMT(Greenwich Mean Time)
3. CST(Central Standard Time)

java.util.Date类

表示特定的瞬间，精确到毫秒
**Date()**使用无参构造器创建的对象可以获取本地当前时间。
Date(long date)
**getTime()

这篇关于JAVA高级-常用类和常用方法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！