java学习之数字与字符串

java学习是根据how2j上提供的资料进行整理，如有雷同，很是正常。

封装类

所有的基本类型，都有对应的封装类。

数字封装类

数字封装类有Byte,Short,Integer,Long,Float,Double，这些类都是抽象类Number的字类。比如int的封装类是Integer，Integer就叫做封装类。

那基本类型如何转化为封装类。

public class TestNumber{
    public static void main(String[] args){
        int i = 1;
        //基本类型转换为封装类
        Integer it = new Integer(i);
    }
}

那封装类如何转化为基本类型

public class TestNumber{
    public static void main(String[] args){
        int i = 1;
        Integer it = new Integer(i);
        //封装类转换为基本类型
        int i2 = it.intValue();
    }
}

那啥叫自动装箱和拆箱。装箱就是说不需要像上述调用构造方法，通过=就能自动转换成Integer类型。

public class TestNumber{
    public static void main(String[] args){
        int i = 2;
        //自动装箱
        Integer it = i;
    }
}

自动拆箱就是说，不需要调用Integer的intValue方法。通过=就自动转换成int类型，就叫做拆箱。

public class TestNumber{
    public static void main(String[] args){
        Integer it = 5;
        //自动拆箱
        int i = it;
    }

还有一个比较常用的就是Int的最大值和最小值可以通过调用Integer.MAX_VALUE和Integer.MIN_VALUE；

public class TestNumber{
    public static void main(String[] args){
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

练习自动装箱和拆箱

byte a = 3;
short b = 3;
float c = 3;
double d = 3;
//byte自动装箱和拆箱
Byte az=new Byte(a); 或 Byte az = a;
byte ac=az.byteValue(); 或 byte ac = az;
//short自动装箱和拆箱
Short bz = new Short(b);或 Short bz = b;
short bc = bz.shortValue();或short bc = bz;

数字如何转字符串？有考虑过该问题吗。方法有两个。

方法1. 使用String的静态方法valueOf
方法2. 使把基本类型装箱为对象，然后调用对象的toString

public class TestNumber{
    public static void main(String[] args){
        int i = 5;

        //方法1
        String str = String.valueOf(i);
        System.out.pringln(str);
        //方法2
        Integer i2 = i;
        String str2 = Integer.toString(i2);
        System.out.println(str2);
    }
}

那字符串转数字呢？

调用Integer的parseInt方法

public class TestNumber{
    public static void main(String[] args){
        String str = '999';
        //调用Integer的parseInt方法
        Integer i = Integer.parseInt(str);
        System.out.println(i);
    }
}

那把浮点型3.14转换为 字符串"3.14"，在把字符串“3.14”转换为浮点数3.14

public class TestNumber{
    public static void main(Strign[] args){
        float f = 3.14;
        //使用方法一
        String str = String.valueOf(f);
        //使用方法二
        Float f1 = f;
        String str1 = Float.toString(f1);
        Float f2 = Float.parseFloat(str1);
    }
}

java中还提供一些数学方法，并且以静态方法形式存在，意味着可以直接调用。我举几个常见的。

public class TestNumber{
    public static void main(String[] args){
        float f1 = 5.4f;
        float f2 = 5.5f;

        //5.4四舍五入到5
        System.out.println(Math.round(f1));

        //5.5四舍五入到6
        System.out.pringln(Math.round(f2));

        //得到0-1之间的随机浮点数(取不到1)
        System.out.println(Math.random())；

        //得到0-10之间的随机数(取不到10)，这个比较常用
        System.out.println((int)(Matn.random()*10));

        //开方
        System.out.println(Math.sqrt(9));

        //次方
        System.out.println(Math.pow(2,4));

        //派
        System.out.println(Math.PI);

        //自然常数
        System.out.println(Math.E);
    }
}

那如何做到格式化输出？

%s 表示字符串
%d 表示数字
%n 表示换行

代码演示。如下

public class TestNumber{
    public static void main(String[] args){
        String name = "小明";
        int count = 3;
        String title = "一等奖";

        //直接使用+进行字符串连接
        String sentence = name + "获得"+count+"次"+title;
        System.out.println(sentence);
        //使用格式化输出
        String sentence1 = "%s获得%d次%s";
        System.out.printf(sentence1,name,count,title);
    }
}

使用format和printf能够达到一摸一样的效果

public class TestNumber{
    public static void main(String[] args){
        String name = "小明";
        int count = 3;
        String title = "一等奖";

        //直接使用+进行字符串连接
        String sentence = name + "获得"+count+"次"+title;
        System.out.println(sentence);
        //使用格式化输出
        String sentence1 = "%s获得%d次%s";
        System.out.format(sentence1,name,count,title);
    }
}

字符

字符类型的封装类Character。

public class TestChar{
    public static void main(String[] args){
        char c1 = '1';
        //装箱
        Character c = c1;
        //拆箱
        char c2 =c;
    }
}

那char的封装类Character的常见方法有以下几类。

Character.isLetter('a') //判断是否为字母
Character.isDigit('a') //判断是否数字
Character.isWhitespace(' ')//判断是否为空白
Character.isUpperCase('a') //判断是否为大写
Character.isLowerCase('a') //判断是否为小写
Character.toUpperCase('a') //转换为大写
Character.toLowerCase('A') //转换为小写 

字符类型转化为字符串。

public class TestChar{
    public static void main(String[] args){
        //下面的部分会报错,char无法转换成String
        String a = 'a';
        System.out.println(a);
        //可修改成如下
        String a = Character.toString('a');
        System.out.println(a);
    }
}

会报错，报错内容如下。

TestChar.java:4: 错误: 不兼容的类型: char无法转换为String
        String a = 'a';
                   ^

字符串

创建字符串常见方式有以下三种。

1. 每当有一个字面值出现的时候，虚拟机就会创建一个字符串
2. 调用String的构造方法创建一个字符串对象
3. 通过+加号进行字符串拼接也会创建新的字符串对象

public class TestString{
    public static void main(String[] args){
        String gareen = "盖伦";
        String temmo = new String("提莫");
        char[] cs = new char[]{'小','明'};
        String hero = new String(cs);
        String hero3 = gareen + temmo;
    }
}

String被修饰为final，所以不能被继承。字符串也是不可修改的，不可变。

String str = "张三"；
str = "李四"；
System.out.println(str); //输出李四，str="李四"，是重新引用了一个对象，而不是修改了张三这个对象

字符串常见的方法。

方法 解释
charAt(int index) 获取指定位置的字符
toCharArray() 获取对应的字符数组
subString() 截取字符串
split 根据分隔符进行分割
trim 去掉首尾空格
toLowerCase 全部变成小写
toUpperCase 全部变成大写
indexOf 判断字符串或子字符串出现的位置
contains 是否包含子字符串
replaceAll 替换所有的
replaceFirst 只替换第一个

如何判断是否为同一个对象，可通过==进行判断，看下面的代码。

public class TestString{
    public static void main(String[] args){
        String str1 = "the light";
        String str2 = new String(str1);
        String str3 = "the light";
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
    }
}

判断内容是否相同。使用equals进行字符串内容的比较，必须大小写一致。equalsIgnoreCase忽略大小写判断内容是否一致。

public class TestString{
    public static void main(String[] args){
        String str1 = "the light";
        String str2 = new String(str1);
        String str3 = "the light";
        String str4 = "THE LIGHT";
        //判断对象是否一致
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        //equals内容一样返回true
        System.out.println(str1.equals(str2));
        System.out.println(str1.equals(str4));
        //忽略大小写的比较
        System.out.println(str1.equalsIgnoreCase(str4));
    }
}

判断是否以xx字符串开头，是否以xx结束。

public class TestString1 {

    public static void main(String[] args) {
        String str1 = "the light";

        String start = "the";
        String end = "Ight";

        System.out.println(str1.startsWith(start));//以...开始,得到true
        System.out.println(str1.endsWith(end));//以...结束,得到flase

    }
}

StringBuffer是可变长的字符串。

方法 解释
append 追加
delete 删除
insert 插入
reverse 反转
length 长度
capacity 容量

来看代码。

public class TestString{
    public static void main(String[] args){
        String str1 = "let here";

        StringBuffer sb = new StringBuffer(str1);

        //在最后追加
        sb.append("be light");
        System.out.println(sb);

        //删除4到10之间的字符
        sb.delete(4,10);
        System.out.println(sb);

        //在4插入there
        sb.insert(4,"there ");
        System.out.println(sb);

        //反转
        sb.reverse();
        System.out.println(sb);
    }
}

为什么StringBuffer可以变长，和String内部是一个字符数组一样，StringBuffer也维护一个字符数组。但是，这个字符数组，留有冗余长度。

原文地址：https://www.cnblogs.com/yihang996/p/11668867.html