学无先后，达者为师

网站首页 编程语言 正文

常用类之包装类和String类

作者：草原灰太狼666 更新时间： 2022-07-13 编程语言

常用类

1.包装类：基本数据类型所对应的引用数据类型

       基本数据类型               包装类型     
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

  • 什么包装类

    • 包装类：基本数据类型所对应的引用数据类型
    • Object 可统一所有数据，包装类的默认值是 null

  • 类型转换中装箱和拆箱

    • 装箱：把基本类型转换为引用类型（数据：栈–>堆）
    • 拆箱：把引用类型转换为基本类型（数据：堆–>栈）
    • 基本类型存储在栈中，引用类型存储在堆中
    • 注意：为了更好的运算，JDK1.5之后，提供自动装箱和拆箱。自动装箱、拆箱，底层调用的是Integer.valueof()；

  • 基本类型和字符串转换

    • 8 种包装类提供不同类型间的转换方式：
    • Number父类中提供的6个共性方法
    • parseXXX() 静态方法。（字符串–>基本类型）
    • 包装类.toString（基本类型–>字符串）

  • Integer 缓冲区： -128 ~ 127

    • Java预先创建了256个常用的整数包装类型对象。的数值是 -128~127，当超过这个数值区间的时候，就会使用 new自己创建了
    • 在实际应用当中，对已创建对象进行复用，以节省内存

1.1 装箱与拆箱代码演示 

package classes.demo05;

public class IntegerTest {

    public static void main(String[] args) {
        int num=65;
         //类型转换：装箱，基本类型-->引用类型

        // 使用Integer类创建对象
        //第一种 构造方法
        Integer integer1=new Integer(num);
        System.out.println("装箱");
        System.out.println(integer1);

        //第二种 valueof
        Integer integer2 = Integer.valueOf(num);
        System.out.println(integer2);

        //拆箱 引用类型-->基本类型          // 拆箱，引用类型转换基本类型
        Integer integer3 = Integer.valueOf(100);
        int i = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(i);

         // JDK 1.5之后提供自动装箱和拆箱
        //自动装箱      自动装箱相当于引用了 valueOf()
        int age=77;
        Integer integer4=age;
        System.out.println("自动装箱");
        System.out.println("integer4 = " + integer4);

        //自动拆箱     自动拆箱相当于引用了 .intValue()
        int age2=integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);



    }
}

运行结果

装箱
65
65
拆箱
100
自动装箱
integer4 = 77
自动拆箱
77

1.2 基本类型和字符串转换代码演示 

package classes.demo05;

public class ParseTest {
    public static void main(String[] args) {

    // 基本类型转换字符串
    // 1. 使用 + 号
        int age=15;
        String s1=age+" ";
        System.out.println(s1);

        // 2. 使用 Integer 的 toString() 方法
        String s2=Integer.toString(age);
        System.out.println(s2);

        // 使用 Integer 的 toString() 方法的进制重载
        String s3=Integer.toString(age,16);
        System.out.println(s3);
        System.out.println("==================================");

        // 字符串转换基本类型
        // 使用 Integer 的 parseXXX() 方法
        String str="255";
        int ss = Integer.parseInt(str); // 在转换基本类型时注意不要出现非数字
        System.out.println(ss);

       // Boolean 字符串形式转换基本类型只有 "true" 转换成 true, 非 "true" 全都转换成 false
        String str1="true";
        boolean b = Boolean.parseBoolean(str1);
        System.out.println(b);

    }
}

运行结果

15 
15
f
==================================
255
true

1.3 整数缓存区代码演示 

package classes.demo05;

public class DemoCache {
    public static void main(String[] args) {

        //Java预先创建了256个常用的整数包装类型对象。便于进行复用，以节省内存

        //面试题
        //分别为false，true，false
        //第一个是通过new一个对象，等号比较的是对象的地址，所以false
        //第二和第三属于自动装箱，等价于Integer i3 = Integer.valueOf(100);
        //这个方法在数据为-128~127的值是放在缓冲区中，能直接获得同一个值，所以地址相同
        //如果超过这个区间，则会在堆中重新创造空间

        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);// false

        Integer integer3=100;  // 自动装箱 相当于引用了 valueOf()
        //Integer integer3=Integer.valueOf(100);
        Integer integer4=100;
        //Integer integer4=Integer.valueOf(100);
        System.out.println(integer3==integer4);// true  // 因为缓存区数组 [-128, 127] 在这之内地址一样

        Integer integer5=200;   // 自动装箱 相当于引用了 valueOf()
        //Integer integer5=Integer.valueOf(100);
        Integer integer6=200;
        //Integer integer6=Integer.valueOf(100);
        System.out.println(integer5==integer6);// false  //使用new 自己创建了   return new Integer(i);


    }
}

运行结果

false
true
false

2.String类

  • 字符串是常量，创建之后不可改变。修改相当于重写开辟空间，不会修改原来的数据，原有常量失效（变成垃圾）
  • 字符串字面值存储在字符串池中 (方法区中)，可以共享
  • String s = “Hello”;产生一个对象，字符串池中存储
  • String s = new String(“Hello”); 产生两个对象，堆、池各一个
  • String 比较使用 equals ，在 String 中重写了 equals ，此时比较的不是对象的地址，而是字符串的值

2.1 String类常用方法

1.  length()方法

public int length()

  • 返回字符串的长度

2.  charAt(int index)方法

public char charAt(int index)

  • 根据下标获取字符

3.  contains(String str)方法

public boolean contains(String str)

  • 判断当前字符串中是否包含str

4. toCharArray()方法

public char[] toCharArray()

  • 将字符串转换成数组

5. indexOf(String str)方法

public int indexOf(String str)

  • 查找str首次在字符串中出现的下标，若存在，则输出下标，若不存在则返回-1

6. lastIndexOf(String str)方法

public int lastIndexOf(String str)

  • 查找字符串在当前字符串中最后一次出现的下标索引

7. trim()方法

public String trim()

  • 去掉字符串前后的空格。

8. toUpperCase()方法

public String toUpperCase()

  • 将小写转成大写

public String toLowerCase()

  • 将大写转成小写。

9. endWith(String str)方法

public boolean endWith(String str)

  • 判断字符串是否以str结尾。

10. replace(char oldChar,char newChar)方法

public int indexOf(String str)

  • 将旧字符转换成新字符

11. split(String str)方法

public String[] split(String str)

  • 根据str做拆分

12. equals() 和compare()的比较

  • equalsIgnoreCase是忽略大小写的比较是否相同；
  • equals()：比较内容是否相等；
  • compareTo()：若字符串首字符相同，则比较第二个，逐次比较相减，若前一个字符串和第二个子字符串都相同，则比较其长度，长度相减；

2.2 String常用方法代码演示： 

package classes.demo07;

import java.util.Arrays;

/**
 *
 *
 *
 *
 * */


public class Demo {
    public static void main(String[] args) {

        String name="hello";//"hello"常量存储在字符串池中
        name="张三";//张三赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2="张三";
        System.out.println(name.hashCode());
        System.out.println(name2.hashCode());
        System.out.println(name==name2);
        System.out.println("====================");

        //演示字符串的另一种创建方式，new String();
        String str = new String("java");
        String str1 = new String("java");
        System.out.println(str==str1);
        System.out.println(str.equals(str1));//String 比较使用 equals ，在 String 中重写了 equals ，此时比较的不是对象的地址，而是字符串的值


        System.out.println("****************字符串的常用方法 1********************");
        // 1. length(); 返回字符串长度
        // 2. charAt(int index); 返回某个位置的字符
        // 3. contains(String str); 判断是否包含某个字符串
        String content=" java 是世界上最好用的语言,java真香 ";
        System.out.println(content.length());
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("Python"));

        System.out.println("****************字符串的常用方法 2********************");

        // 4. toCharArray(); 返回字符串对应数组
        // 5. indexOf(); 返回子字符串首次出现的位置
        // 6. lastIndexOf(); 返回字符串最后一次出现的位置
        System.out.println(content.toCharArray());
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.lastIndexOf("java"));
        System.out.println(content.indexOf("java",6));//从下标6开始找

        System.out.println("****************字符串的常用方法 3********************");
        // 7. trim(); //去掉字符串前后空格   无法去掉中间的空格
        // 8. toUpperCase(); toLowerCase(); 转换大小写    toUpperCase();小写转大写   toLowerCase(); 大写转小写
        // 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
        String content2="  hello world ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.endsWith("java"));

        System.out.println("****************字符串的常用方法 4********************");
        // 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
        // 11. split(); 对字符串拆分

        System.out.println(content.replace("java","PHP"));
        String say=" java   is the ,best language";
        System.out.println(say.split(" "));
        System.out.println(Arrays.toString(say.toCharArray()));
        System.out.println(Arrays.toString(say.split(",")));
         //String[] strr = say.split("[ ,]}+");   //+号表示拆分多余的空格
        //String[] strr = say.split("[ ,]}");//使用空格或者，拆分  可拆分掉逗号
        String[] strr = say.split(" ");
        for (String s : strr) {
            System.out.println(s);
        }

        System.out.println("****************补充方法 4********************");
          //12. 补充两个   equals/compareTo();比较大小
        String s1="hello";
        String s2="HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));// 忽略大小写比较

        //两字符不同时比较字符字典序的ascii码
        String S3="abc";//97
        String S4="xyz";//120
        System.out.println(S3.compareTo(S4));

        // 字符相同时比较长度 返回差值
        String s5="abc";
        String s6="abcdfg";
        System.out.println(s5.compareTo(s6));




    }
}

运行结果

774889
774889
true
====================
false
true
****************字符串的常用方法 1********************
24
 
true
false
****************字符串的常用方法 2********************
 java 是世界上最好用的语言,java真香 
[ , j, a, v, a,  , 是, 世, 界, 上, 最, 好, 用, 的, 语, 言, ,, j, a, v, a, 真, 香,  ]
1
17
17
****************字符串的常用方法 3********************
hello world
  HELLO WORLD 
false
****************字符串的常用方法 4********************
 PHP 是世界上最好用的语言,PHP真香 
[Ljava.lang.String;@1b6d3586
[ , j, a, v, a,  ,  ,  , i, s,  , t, h, e,  , ,, b, e, s, t,  , l, a, n, g, u, a, g, e]
[ java   is the , best language]

java


is
the
,best
language
****************补充方法 4********************
true
-23
-3

2.4 实践案例代码演示： 

package classes.demo07;

public class Demo01 {
    public static void main(String[] args) {
        /*  案例测试
        已知String str = "this is a text";
        将str中的单词单独获取
        将str中的text替换成practice
        在text前面插入一个easy
        将每个单词的首字母改为大写

       */
        String str = "this is a text";
        //1.将str中的单词单独获取
        System.out.println("---------1. 将str中的单词单独获取出来-------");
        String[] chars = str.split(" ");
        for (String aChar : chars) {
            System.out.println(aChar);
        }
        //2.将str中的text替换成practice
        System.out.println("---------2. 将str中的text替换为practice-------");
        System.out.println(str.replace("text","practice"));
        //3.在text前面插入一个easy
        System.out.println("---------3. 在text前面插入easy-------");
        System.out.println(str.replace("text","easy text"));


        //4.将每个单词的首字母改为大写
        System.out.println("---------4. 将每个单词的首字母改为大写------");
        for (int i = 0; i <chars.length ; i++) {
            //先用charAt()方法选取第一个字符
            char c = chars[i].charAt(0);

            //把第一个字符转成大写，用Character.toUpperCase()方法
            char upperfirst = Character.toUpperCase(c);//Character类中的toUpperCase() 方法

            //把字符拼回字符串,substring()方法是截取用的
            String s = upperfirst + chars[i].substring(1);//substring()  截取方法
            System.out.println(s);

        }

    }
}

运行结果

---------1. 将str中的单词单独获取出来-------
this
is
a
text
---------2. 将str中的text替换为practice-------
this is a practice
---------3. 在text前面插入easy-------
this is a easy text
---------4. 将每个单词的首字母改为大写------
This
Is
A
Text

2.5 可变字符串：StringBuffer 和 StringBuilder

  • StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。

  • StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。

  • 可变字符串和String的区别：

    • 运行效率比String要高
    • 比String要节省内存

2.6 StringBuffer方法代码演示： 

package classes.demo07;

public class Demo02 {
    public static void main(String[] args) {
        // StringBuffer 和 StringBuilder 用法一致
        //StringBuilder stringBuffer = new StringBuilder();

        StringBuffer stringBuffer = new StringBuffer();
        // 1. append(); 追加
        stringBuffer.append("java是世界第一");
        System.out.println(stringBuffer);
        System.out.println(stringBuffer.append("java真香"));

          // 2. insert(); 添加、插入
        stringBuffer.insert(0,"我在最前面");
        System.out.println(stringBuffer.toString());

        // 3.replace(); 替换
        //这里的下标含头不含尾，如下面只替换下标为0-4的内容
        stringBuffer.replace(0,5,"hello");// 包头不包尾
        System.out.println(stringBuffer.toString());

        // 4. delete(); 删除
        stringBuffer.delete(0,5);
        System.out.println(stringBuffer.toString());

        //5.反转reverse()
        stringBuffer.reverse();
        System.out.println(stringBuffer.toString());

        // 6. 清空
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer.toString());



    }
}

运行结果

java是世界第一
java是世界第一java真香
我在最前面java是世界第一java真香
hellojava是世界第一java真香
java是世界第一java真香
香真avaj一第界世是avaj

2.7 String和stringBuffer运行效率比较代码演示： 

package classes.demo07;
//验证StringBuilder效率高于StringBuffer
public class Demo03 {

    public static void main(String[] args) {
        //开始时间
        long star = System.currentTimeMillis();

        /*String ss=" ";
        for (int i = 0; i < 9999; i++) {
            ss+=i;

        }*/



        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            stringBuffer.append(i);
        }


        System.out.println(stringBuffer.toString());
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-star));


    }

}

运行结果

用时：37

————————————————————————————————————————————————————————————————————————————

3.更多参考

千峰教育-常用类

原文链接：https://blog.csdn.net/qq_60501861/article/details/125492680

相关推荐

栏目分类
最近更新
Copyright © 2025   AB教程网    免责声明
本站部分资源收集于互联网、用户投稿，其版权归原作者所有，内容以共享、参考、学习为主，不存在任何商业目的。如有侵权请与本站联系，情况属实将予以删除!
本站由    提供CDN加速