JAVA面试题总结-Java基础（6-9）

6.String 属于基础的数据类型吗？

不属于。

Java数据类型包括基本数据类型和引用数据类型。

基本数据类型有8个，可以分成4类，分别为整数型（byte，short，int，long）、浮点型（float，double）、布尔型（boolean）、字符型（char），整数类型中int最常用，浮点型中double常用，除了boolean之外的类型都可以进行类型转换。

引用数据类型有类、接口、数组，String属于引用数据类型。

拓展：

byte：

所占字节：1，数据范围： -2^7 ~ 2^7-1，默认值：0，对应包装类：Byte

short：

所占字节：2，数据范围： -2^15 ~ 2^15-1，默认值：0，对应包装类：Short

int：

所占字节：4，数据范围： -2^31 ~ 2^31-1，默认值：0，对应包装类：Integer

long：

所占字节：8，数据范围： -2^63 ~ 2^63-1，默认值：0，对应包装类：Long

float：

所占字节：4，数据范围： -3.410^38 ~ 3.410^38，默认值：0.0F，对应包装类：Float

double：

所占字节：8，数据范围： -1.810^308 ~ 1.810^308，默认值：0.0，对应包装类：Double

boolean：

所占字节：1（Java规范没有明确的规定，不同的JVM有不同的实现机制），数据范围：true和false，默认值：false，对应包装类：Boolean

char：

所占字节：2，数据范围： \u0000 ~ \uffff，默认值：'\u0000'，对应包装类：Character

7.java 中操作字符串都有哪些类？它们之间有什么区别？

String，StringBuffer，StringBuilder。

三者都是以char[]字符数组的形式保存的字符（在Java 9 之后，String采用byte[]数组来保存字符），但是String类型的字符串是不可变的，StringBuffer和StringBuilder是可变的字符串，对String修改相当于重新创建对象，而对StringBuffer和StringBuilder修改是在同一个对象上，StringBuffer中的方法有synchronized关键字修饰，因此StringBuffer是线程安全的，而StringBuilder是非线程安全的，但是StringBuilder的性能高。

在实际的开发中，如果一个字符串不是经常更改，优先选择String，在下一次调用字符串的时候直接指向字符串常量池，可以使字符串复用，效率更高。如果要创建一个内容可变的字符串，优先选择StringBuilder，因为它性能高。在多线程并发的情况下，选择StringBuffer，因为它是线程安全的。

8.String str="i"与 String str=new String("i")一样吗？

不一样。

当用String str="i"定义一个字符串时，JVM会将其分配到字符串常量池中，如果字符串常量池中有"i"，则直接将常量池中的"i"赋值给str，如果字符串常量池中没有"i"，则会创建一个放入字符串常量池中，再将其赋值给str。

当用String str=new String("i")定义一个字符串时，JVM会先使用常量池来管理"i"直接量，再调用String类的构造器来创建一个新的String对象，新创建的String对象会保存在堆内存中。

显然，采用new的方式会多创建一个对象，多占用内存，因此一般建议使用直接量的方式创建字符串。

例：

String str1 = "i";

String str2 = "i";

String str3 = new String("i");

System.out.println(str1 == str2);//true

System.out.println(str1 == str3);//false

9.如何将字符串反转？

首先最容易想到的就是StringBuffer或StringBuilder的reverse()方法实现字符串反转。

//StringBuffer的reverse()方法实现字符串反转
public class stringBufferReverse {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("周子琦");
        System.out.println(sb.reverse());//琦子周
    }
}
//StringBuilder的reverse()方法实现字符串反转
public class stringBuilderReverse {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("周子琦");
        System.out.println(sb.reverse());//琦子周
    }
}

String的charAt()方法也可以实现字符串反转,charAt()方法返回指定索引位置的char值。索引范围为0到length()-1，chartAt()中的括号只能传int类型的参数。

//String的charAt()方法实现字符串反转
public class stringCharAt {
    public static void main(String[] args) {
        String str = "周子琦";
        for (int i = str.length() - 1; i >= 0; i--) {
            System.out.print(str.charAt(i));//琦子周
        }
    }
}

将字符串转换成数组

通过toCharArray()方法转换成char[]数组

//String的toCharArray()方法实现字符串反转
//倒序打印
public class stringTOCharArray {
    public static void main(String[] args) {
        String str = "周子琦";
        char[] c = str.toCharArray();
        
        for(int i = c.length -1; i >= 0; i--) {
            System.out.print(c[i]);//琦子周
        }
    }
}
​
//用临时变量替换将左右互换位置
public class stringTOCharArray {
    public static void main(String[] args) {
        String str = "周子琦";
        char[] c = str.toCharArray();
        int right = c.length - 1;
        
        for(int left = 0; left < right; left++,right--) {
            char temp = c[left];
            c[left] = c[right];
            c[right] = temp;
        }
        
        for(int i = 0; i <= c.length-1; i++) {
            System.out.print(c[i]);//琦子周
        }
    }
}

通过getBytes()方法转换成byte[]数组

//String的getBytes()方法实现字符串反转
public class stringGetBytes {
    public static void main(String[] args) {
        String str = "zzq";
        byte[] b = str.getBytes();
        byte[] result = new byte[b.length];
        
        //b数组倒序赋值到result数组中
        for(int i = 0; i < b.length; i++) {
            result[i] = b[b.length - 1 - i];
        }
        
        System.out.print(new String(result));//qzz
    }
}
//当字符串为中文时会产生乱码

递归的方式实现字符串反转

public class Recursion {
    public static String recursion(String str) {
        int length = str.length();
        if(length <= 1) {
            return str;
        }
        String left = str.substring(0, length / 2);
        String right = str.substring(length / 2, length);
        return recursion(right) + recursion(left);
    }
    public static void main(String[] args) {
        String str = "周子琦";
        System.out.print(recursion(str));//琦子周
    }
}

最后这个思想非常好，通过栈先进后出的特性实现字符串反转

import java.util.Stack;
​
public class StringStack {
    public static void main(String[] args) {
        String str = "周子琦";
        
        Stack<Character> stack = new Stack<>();
        
        //入栈操作
        for(int i = 0; i < str.length(); i++) {
            stack.add(str.charAt(i));
        }
        
        StringBuilder sb = new StringBuilder();
        //出栈操作
        for(int i = 0; i < str.length(); i++) {
            sb.append(stack.pop());
        }
        
        System.out.print(sb);//琦子周
    }
}