java程序员面试笔试宝典-4.5 字符串与数组

灰太狼 2022-03-25 14:52 454阅读 0赞

# 4.5.1 字符串创建与存储的机制是什么？ #

字符串的声明主要有以下两种情况：  
1）String s1 = new String(“abc”);  
String s2 = new String(“abc”);  
s1和s2内容相同，但是在内存中的地址是不同的，只要用到new总会生成新的对象。  
2）String s1 = “abc”;  
String s2 = “abc”;  
在JVM中存在一个字符串池，保存很多String对象，并且可以共享使用。  
s1和s2引用的是同一个常量池中的对象。  
String s = “abc”; //把abc放到常量池中，在编译时产生  
String s1 = “ab”+“c”; //把"ab"+"c"转换位字符串常量"abc"放到常量区中  
String s2 = new String(“abc”);//在运行时把"abc"放到堆里面。

String s3 = “abc”; //在常量区里面存放了一个"abc"字符串对象  
String s4 = “abc”; //s2引用常量区中的对象，因此不会创建新的对象  
String s5 = new String(“abc”);//在堆中创建新的对象  
String s6 = new String(“abc”);//在堆中又创建一个新的对象。

## 引申： ##

### 1）对于String 类型的变量s，赋值语句s=null与s=""是否相同？ ###

s=null:其中s是一个字符串类型的引用，它不指向任何一个字符串  
s="":它指向另外一个字符串，这个字符串的值位“”，即空字符串  
因此：两者不同

### 2）new String(“abc”)创建了几个对象？ ###

一个或两个  
如果常量池中原来有abc,那么只创建了一个对象  
如果常量池中原来没有字符串“abc”,那么就会创建两个对象。

## 总结 ##

String s=new String（“abc”）创建了几个对象，有两种情况

1.如果常量池中有字符串abc，那么只会字内存中创建一个对象
    
    2.如果常量池中没有字符串abc，那么在常量池中创建一个内容为abc的对象， 但是遇到了new关键字，
    
    则还是会在内存（不是常量池）中创建一个对象，然后将对象返回给引用s， 特别注意s不是一个对象

## 这篇博客只是用来声明对象是常量池中内容为abc的对象和内存中的new出来的对象，s只是一个引用不是对象，至于什么其他原理什么的，其他博客大佬已经讲得非常清楚 ##

# 4.5.2“==” , equals 和 hashCode有什么区别？ #

## 1）== 运算符来比较两个变量的值是否相等 ##

基本数据类型：比较对应的值是否相等  
引用类型：比较两个引用是否指向同一个对象，即这两个变量所对应内存中的数值是否相等。  
若要比较两个对象的内容是否相等，用==无法实现。

## 2）equals（）方法是Object提供的方法。Object类中的equals方法是直接使用==进行比较两个对象的，所以比较的也是引用。 ##

**但是它可以被覆盖，例如String类的equals方法就是比较两个独立对象的内容是否相同，即堆中的内容是否相同。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]

package cn.itcast.demo5;
    
    public class Test2 {
    	public static void main(String[] args) {
    		String s1 = new String("Hello");
    		String s2 = new String("Hello");
    		System.out.println(s1 == s2);
    		System.out.println(s1.equals(s2));
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

## 3）hashCode方法是从Object类中继承过来的，用来鉴定两个对象是否相等。 ##

Object类中的hashCode方法返回对象在内存地址转化成的一个int值，  
所以如果没有重写hashCode方法，任何对象的hashCode方法都是不相等的。  
**一般在覆盖equals方法的同时也会覆盖hashCode方法，否则会违反Object-hashCode的通用约定**，导致该类无法与所有基于散列值（hash）的集合类（HashMap,HashSet,HashTable）结合在一起正常使用。

## hashCode与equals的关系： ##

## 如果x.equals(y)为true:那么调用 两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。   如果x.equals(y)为false:那么两个对象的hashCode方法可能相等，也可能不相等   反之:   hashCode的返回值不相等：推出equals方法的返回值不相等   hashCodde的返回值相等：equals方法的返回值可能相等，可能不相等。   String类型中的equals方法是用于比较两个独立对象的内容是否相同,即堆中的内容是否相同 ##

package cn.itcast.demo5;
    
    public class Test2 {
    	public static void main(String[] args) {
    		String s = "Hello";
    		String t = "Hello";
    		char c[] = {'H','e','l','l','o'};
    		System.out.println("A" + "\t" + s.equals(t));
    		System.out.println("B" + "\t" + t.equals(c));
    		System.out.println("C" + "\t" + (s == t));
    		System.out.println("D" + "\t" + t.equals(new String("Hello")));
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
说明：t和c分别为字符串类型和数组类型，因此返回值为false

## 可查看String类的equals方法是用于比较两个独立对象的内容是否相同的源码： ##

public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String) anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                                return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
说明：“ab”+“c"在编译器就被转换为"abc”，存放在常量区。

## Set里的元素是不能重复的，使用equals方法来区分是否重复 ##

# 4.5.3 String , StringBuffer , StringBuilder和StringTokenizer有什么区别？ #

java语言有四个类可以堆字符或字符串进行操作，分别是Character,String,StringBuffer和StringTokenizer.  
其中Character用于单个字符操作  
**String字符串操作，属于不可变类**  
StringBuffer字符串操作，可变类

## 1）String和StringBuffer的区别： ##

当实例化String时，可以通过构造函数：String s1 = new String(“World”);也可以通过赋值的方式String s2 = “World”;  
而StringBuffer只能使用构造函数（StringBuffer s = new StringBuffer(“Hello”)）来初始化。

## String字符串修改的原理： ##

首先创建一个StringBuffer,调用StringBuffer的append（）方法，最后调用StringBuffer的toString()方法把结果返回。

String s = "Hello";
            s+=" World";

等价于：

StringBuffer sb = new StringBuffer(s);
            sb.append(" World");
            s = sb.toString();

![在这里插入图片描述][20190121155257876.png]

package cn.itcast.demo5;
    
    public class Test3 {
    	public static void testString(){
    		String  s = "Hello";
    		String  s1 = "world";
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 1000; i++) {
    			s += s1;
    		}
    		long end = System.currentTimeMillis();
    		long runTime = end - start;
    		System.out.println("testString:" + runTime);
    	}
    	
    	public static void testStringBuffer(){
    		StringBuffer  s = new StringBuffer("Hello");
    		String  s1 = "world";
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 1000; i++) {
    			s.append(s1);
    		}
    		long end = System.currentTimeMillis();
    		long runTime = end - start;
    		System.out.println("testStringBuffer:" + runTime);
    	}
    	public static void main(String[] args) {
    		testString();
    		testStringBuffer();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]

## 2）StringBuilder和StringBuffer的区别： ##

StringBuilder不是线程安全的，只有在单线程访问时可以使用StringBuilder  
执行效率方面StringBuilder>StringBuffer>String  
结论：  
如果要操作的数据量比较小用String  
单线程下操作大量数据用StringBuilder  
多线程下操作大量数据StringBuffer

## 3)StringTokenizer是用来分割字符串的工具类 ##

package cn.itcast.demo6;
    
    import java.util.StringTokenizer;
    
    public class Test {
    	public static void main(String[] args) {
    		StringTokenizer st = new StringTokenizer("Welcome to our country");
    		while(st.hasMoreTokens()){
    			System.out.println(st.nextToken());
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]

# 4.5.4 Java中数组是不是对象？ #

数组是指具有相同类型的数据的集合，它们一般具有固定的长度，并且在内存中占据连续的空间。  
在java中，数组不仅有自己的属性（length），也有方法（clone）。  
对象的特点是封装了一些数据，同时提供了属性和方法。所以数组是对象。  
可以通过instanceof来判断数据的类型。

package cn.itcast.demo6;
    //数组是对象
    public class SubClass {
    	public static void main(String[] args) {
    		int[] a = {1,2};
    		int[][] b = new int[2][4];
    		String[] s = {"a","b"};
    		if(a instanceof int[]){
    			System.out.println("the type for a is int[]");
    		}
    		if(b instanceof int[][]){
    			System.out.println("the type for b is int[][]");
    		}
    		if(s instanceof String[]){
    			System.out.println("the type for s is String[]");
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]

# 4.5.5 数组的初始化方式有哪几种？ #

在java语言中，一维数组的声明方式为：type arrayName[] 或者 type[] arrayName

数组被创建后会根据数组存放的数据类型初始化成对应的初始值。  
java数组在定义时，并不会给数组分配内存空间，因此\[\]中不需要指定数组的长度。但是在使用时必须为之分配空间。

分配方法为：arrayName = new type[arraySize]

## 在完成数组的声明后，需要对其进行初始化，以下两种初始化方式： ##

1）int[] a = new int[5];
    动态创建了一个包含5个整形值的数组，默认初始化为0
    2）int[] a = {1,2,3,4,5}；

声明一个数组类型变量并初始化。  
当然也可以分开来写：

1)int[] a;
    a = new int[5];
    2)int[] a;
    a = new int[]{1,2,3,4,5};

## 二维数组的声明与初始化方式 ##

3种声明方式

1）type arrayName[][]
    2) type[][] arrayName
    3) type[] arrayName[]

## 注意：在声明二维数组时，\[\]必须为空。 ##

## 初始化： ##

type arrayName\[\]\[\] = \{ \{c11,c12,c13\},\{c21,c22,c23\},\{c31,c32,c33\}\};  
type arrayName\[\]\[\] = new type\[行数\]\[列数\]；

## 注意：在java语言中，二维数组的第二维的长度可以不同，如下第一行2列，第二行3列。 ##

1）int[][] arr = {
       {1,2},{3,4,5}};
    2) int[][] a = new int[2][];
    a[0] = new int[]{1,2} 
    a[1] = new int[]{3,4,5}

package cn.itcast.demo6;
    
    
    public class SubClass1 {
    	public static void main(String[] args) {
    		int a[][] = new int[2][];
    		a[0] = new int[]{1,2};
    		a[1] = new int[]{3,4,5};
    		for(int i = 0;i < a.length;i++){
    			for(int j = 0;j < a[i].length;j++){
    				System.out.print(a[i][j] + "\t");
    			}
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]

## 引申： ##

1）数组是一种原生类（x）  
原生类指未被实例化的类，数组一般指实例化，被分配空间的内  
2）数组的大小可以任意改变（x）不可以，数组是指具有相同类型的数据的集合,他们一般具有固定的长度  
3）public\[\] int a;(x)原因是在java语言中,一维数组的声明方式为：

type arrayName[] 或者 type[] arrayName

type-即可以是基本的数据类型,也可以是类，而public公有的访问修饰符  
arrayName-表示数组的名字  
\[\] -表示这个变量的类型为一维数组,\[\]必须为空  
4）C好像是这样的：char\[\] ca = \{‘S’,‘o’,‘m’,‘e’,‘S’,‘t’,‘r’,‘i’,‘n’,‘g’\};才对  
右边是String对象,左边是一个字符数组,类型不匹配  
![在这里插入图片描述][20190122174624230.png]

# 4.5.6 length属性和length(）方法有什么区别？ #

在java语言中，String提供了length()方法来计算字符串的长度  
引申：除了length属性与length（）方法外，Java中还有一个计算对象大小的方法size(),该方法是针对泛型集合而言的。

package cn.itcast.demo6;
    
    public class Testlength {
    	public static void testArray(int[] arr){
    		System.out.println("数组的长度为：" + arr.length);
    	}
    	public static void testString(String s){
    		System.out.println("字符串的长度：" + s.length());
    	}
    	public static void main(String[] args) {
    		int[] arr = {1,3,5,7,9};
    		String s = "1357";
    		testArray(arr);
    		testString(s);		
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220325/ffa73f0542cc4f04bd6f9c31d97659c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220325/84226af703ad462ca3e303103f4e70ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220325/bbd5c88dae9143b79d520d0e1e353758.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220325/38ac3f317e9141f98a472959da9d59b4.png
[20190121155257876.png]: /images/20220325/0d4b015670204d65b477202d53eb8597.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220325/cac81755868f4af4a6a44d0c69dd53bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220325/850c901c47d646d89087aa19c6f4f53d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220325/d9b18d86d9db4efb8b5d8bae6f6d9b11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220325/9214264b76cc4dccb68dc6d0bffffa82.png
[20190122174624230.png]: /images/20220325/a67456e43b104fb6b9ca2ef84b78ccf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220325/5148c79691534d27b717d335a144bda2.png