首页 > 其他分享> > 常用类之包装类与String类

常用类之包装类与String类

2022-06-27 22:03:41 作者：互联网

常用类

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. replace(char oldChar,char newChar)方法

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.更多参考

千峰教育-常用类

标签：常用,String,包装,System,str,println,Integer,out
来源： https://www.cnblogs.com/xingchenyang/p/16412168.html