Java学习笔记-数字与字符串

Java SE的内容我是学习过一遍的，但是很长时间不用加上内容比较繁杂，很多知识又忘记了。这里记录一下遗漏的知识点。

1. 装箱拆箱

1.1 封装类

所有的基本类型，都有对应的类类型。比如int对应的类是Integer，这种类就叫做封装类。

tips：简单类型变量无法直接获得变量类型。

数字封装类有Byte，Short，Integer，Long，Float，Double，这些类都是抽象类Number的子类。

1.2 自动装箱和拆箱

基本类型转换为封装类，称为装箱；封装类转换为基本类型，称为拆箱。

package encapsulation;

public class TestNumber {

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

        // 装箱：把一个基本类型的变量，转换为Integer对象
        Integer it = new Integer(i);
        // 拆箱：把一个Integer对象，转换为一个基本类型的int
        int it2 = it.intValue();
    }

}

不需要调用构造方法，通过“=”符号，进行装箱和拆箱，称为自动装箱和自动拆箱。

package encapsulation;

public class AutoEncapsulation {

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

int的最大值可以通过其对应的封装类Integer.MAX_VALUE获取。

自动装箱、拆箱，只能应用在对应类型下，不是对应的封装类，只能通过基本类型和封装类转换，进行装箱和拆箱。（Byte类型可以直接拆箱到int类型）。

2. 字符串转换

2.1 数字转字符串

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

package transform;

public class Number2String {

    public static void main(String[] args) {
        int i = 25977;

        // 方法1
        String s1 = String.valueOf(i);
        // 方法2
        Integer it = i;
        String s2 = it.toString();
        System.out.println(s1);
        System.out.println(s2);
    }

}

2.2 字符串转数字

调用Integer的静态方法parseInt

package transform;

public class String2Number {

    public static void main(String[] args) {
        String s = "2578";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }

}

3. 格式化字符串

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

System.out.format()方法格式化字符串。

4. 字符类型

char 对应的封装类为Character，只能放一个字符。

Character有很多静态方法可以用来判断字符类型（比如是否为数字？是否为大写字母？）

package typeChar;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Practice {

    public static void main(String[] args) {
        /* 通过Scanner从控制台读取字符串，然后把字符串转换为字符数组，再筛选出读取到的字符串中的
           字母和数字，并打印出来
         */
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        // 转换为字符数组
        char[] cs = str.toCharArray();

        List<Character> list = new ArrayList<>();
        for (char element : cs) {
            if (Character.isUpperCase(element) || Character.isDigit(element)) {
                list.add(element);
            }
        }
        System.out.println(list);
    }

}

5. 字符串

字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象。三种方法创建字符串：

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

字符串是不可改变(immutable)的。即不能改变长度、不能增删字符、不能修改字符。一旦创建好这个字符串，里面的内容永远不能改变。

length()方法返回当前字符串的长度

package string;

import java.util.Random;

public class Practice {

    public static void main(String[] args) {
        // 创建一个长度是5的随机字符串，随机字符有可能是数字，大写字母或者小写字母。
        Random r = new Random();
        int randomNumber;
        char[] is = new char[5];
        for (int i = 0; i < is.length; i++) {
            while (true) {
                randomNumber = r.nextInt(75) + 45;
                char c = (char) randomNumber;
                if (Character.isDigit(c) || Character.isUpperCase(c) || Character.isLowerCase(c)) {
                        is[i] = c;
                        break;
                }
            }
        }
        String str = new String(is);
        System.out.println(str);
    }

}

String类的toLowerCase可以把字符串全转换为小写字母

package string;

import java.util.Random;

public class Practice2 {

    public static void main(String[] args) {
        /* 创建一个长度是8的字符串数组，使用8个长度是5的随机字符串初始化这个数组，
           对这个数组进行排序，按照每个字符串的首字母排序。
         */
        String[] strings = new String[8];
        for (int i = 0; i < strings.length; i++) {
            strings[i] = getRandomString();
        }

        for (String string : strings) {
            System.out.println(string);
        }

        System.out.println("========================================");

        String str;
        for (int i = 0; i < strings.length; i++) {
            for (int j = i + 1; j < strings.length; j++) {
                char c1 = strings[i].toLowerCase().toCharArray()[0];
                char c2 = strings[j].toLowerCase().toCharArray()[0];
                if ((short) c1 > (short) c2) {
                    str = strings[i];
                    strings[i] = strings[j];
                    strings[j] = str;
                }
            }
        }

        for (String string : strings) {
            System.out.println(string);
        }
    }

    public static String getRandomString() {
        Random r = new Random();
        int randomNumber;
        char[] is = new char[5];
        for (int i = 0; i < is.length; i++) {
            while (true) {
                randomNumber = r.nextInt(75) + 45;
                char c = (char) randomNumber;
                if (Character.isDigit(c) || Character.isUpperCase(c) || Character.isLowerCase(c)) {
                    is[i] = c;
                    break;
                }
            }
        }
        return new String(is);
    }

}

注意理解此处的递归方法

package string;

import java.util.Random;

public class Practice3 {

    public static void main(String[] args) {
        /* 生成一个长度是3的随机字符串，把这个字符串作为密码；
           使用穷举法生成长度是3的字符串，匹配上述生成的密码。
         */
        // 生成长度为3的随机字符串
        String password = getRandomString(3);
        System.out.println("标准密码：" + password);
        char[] passwords = new char[3];
        generatePassword(passwords, 0, password);

    }

    /**
     * 生成随机字符串
     * @param length 字符串长度
     * @return
     */
    public static String getRandomString(int length) {
        String stringPool = "";
        for (short i = 'a'; i <= 'z'; i++) {
            stringPool += (char) i;
        }
        for (short i = '0'; i <= '9'; i++) {
            stringPool += (char) i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            stringPool += (char) i;
        }

        Random r = new Random();
        char[] chars = new char[length];
        for (int i = 0; i < length; i++) {
            int randomIndex = r.nextInt(stringPool.length());
            chars[i] = stringPool.charAt(randomIndex);
        }
        return new String(chars);
    }

    /**
     * 使用递归进行穷举密码
     * @param passwords 字符数组，用来穷举密码
     * @param index 检查密码的第几位
     * @param password 标准密码
     */
    public static void generatePassword(char[] passwords, int index, String password) {
        for (short i = '0'; i <= 'z'; i++) {
            if (!Character.isLetterOrDigit((char) i)) {
                continue;
            }
            passwords[index] = (char) i;
            if (index != password.length() - 1) {
                generatePassword(passwords, index + 1, password);
            } else {
                String guess = new String(passwords);
//                System.out.println("穷举的密码：" + guess);
                if (guess.equals(password)) {
                    System.out.println("得到正确的密码：" + guess);
                    return;
                }
            }
        }
    }

}

5.1 操纵字符串

方法	简介
charAt	获取字符
toCharArray	获取对应的字符数组
subString	截取子字符串(左闭右开)
split	分割
trim	去掉首尾空格
toLowerCase toUpperCase	大小写
indexOf lastIndexOf contains	定位
replaceAll replaceFirst	替换

5.2 比较字符串

str1和str2的内容相同，但并不是同一个字符串对象。

特例：

str1 = "the light";
str2 = "the light";

一般来说，编译器每碰到一个字符串的字面值，就会创建一个新的对象，所以在str1创建一个新的字符串”the light”，但是在第7行，编译器发现已经存在现成的”the light”，那么就直接拿来使用，而没有进行重复创建。

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

是否以子字符串开始或结束—startsWith; endsWith

给字符串数组中的字符串赋值字符串时，不要使用增强for循环，否则会无法赋值。。。

5.3 StringBuffer

StringBuffer是可变长的字符串，并且不产生新的未使用对象。

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

根据String对象，使用StringBuffer的构造方法创建一个StringBuffer对象。

为什么StringBuffer可以变长？

和String内部是一个字符数组一样，StringBuffer也维护了一个字符数组。但是，这个字符数组，留有冗余长度，从而可以进行追加和插入。

5.4 StringBuilder

是StringBuffer的一个简易替换，jdk1.5版本起才有的。

与StringBuffer的不同之处：
StringBuffer是同步的，线程安全，但每次操作时都要判断锁，效率低
StringBuilder是线程不同步的，不用判断锁，效率高，线程安全性要求高时可以手动同步。
开发建议使用StringBuilder.

6. 参考

• HOW2J.CN