Java面试集合（七）_字符串

前言：

​​Java面试集合（六）​​

的回顾，对于​​final​​可以修饰常量，方法，和类，一旦常量定义好后就不可改变，而方法，用​​final​​来修饰方法，方法不可重载，继承，重写，​​final​​用来修饰类，该类不能被继承。

抽象​​abstract​​，不能够有对象，即不能进行实例化，但又构造方法，在抽象修饰类时，这个抽象类，不一定有抽象方法，但是在类中有抽象方法，那么这个类就一定是抽象类。

在抽象类中的所有抽象方法，子类一旦继承抽象类，就要重写父类（即抽象类）中的所有抽象方法，但是连子类都是抽象类就不用，如果该子类继承了抽象的父类，子类也是抽象类，就不用。

抽象方法是没有方法体的，因为抽象方法是抽象功能的，在子类中实现，抽象方法可以被重载，即参数等不同。抽象方法不能再用​​static/final/private​​来修饰。

接口​​interface​​的抽象方法用​​public abstract​​来修饰，属性用​​public static final​​来修饰。

接口是没有实例化对象的，也没有构造方法

内部类的分类为，方法的内部类，成员的内部类，静态内部类，匿名内部类。

包的基础（​​package​​）和垃圾回收机制基础。

1. Object对象

所有类的父类​​Object​​，因为任何一个类都是直接或者间接的继承​​Object​​类，都是​​Object​​的子类，​​Object​​是类层次结构的根类，存在​​java.lang.Object​​中。

​​getClass​​可以获取对象的实际类型

​​toString​​可以返回对象的地址

​​equals​​可以判断两个对象是否相等

对象和类的关系进行判断：​​instanceof​​

class A {}
class B extends A {}
interface D{}
class C extends B implements D {}
B b = new C();
b instanceof A --- true
b instanceof B --- true
b instanceof C --- true 
b instanceof D --- true


构造方法：​​public Object()​​

  • ​​finalize()​​方法：java的垃圾回收时机
  • ​​Object的toString()​​方法：返回的是对象的字符串形式
  • ​​Object的equals()​​方法：比较两个对象是否相等

复习：

  • 二进制：​​以0b/0B作为开头​​ （0~1，满2进1）
  • 八进制：​​以0作为开头​​（0~7，满8进1）
  • 十进制：​​没有特殊标识​​（0~9，满10进1）
  • 十六进制：​​以0X/0x作为开头​​（09,af，满16进1）

进制间的转化

  • 十进制转二进制：不断除以2，然后取余数
  • 二进制转十进制：从最低位依次乘以2的位次次幂，然后求和

同理：

十进制转其他进制：除以对应的进制数，然后取余数
其他进制转十进制：从最低位依次开始，按位次乘以进制的位次次幂，然后求和


二进制转八进制，也是从低位开始，每三位二进制为一组，产生一个八进制数字，最高位不足三位，就补0，凑齐三位即可。

口诀：三变一

八进制转二进制，每一位八进制数都会产生三位二进制数字，不足三位就补0即可。

口诀：一变三

同理

二进制转十六位进制：口诀为四变一
十六位进制转二进制：口诀为一变四


Bin为二进制，Oct为八进制，Dec为十进制，Hex为十六进制

2. String类

在 ​​Java​​中的字符串属于对象，那么​​Java​​ 中提供了 ​​String​​ 类来创建和操作字符串，即是使用对象；因为​​String​​类修饰的字符一旦被创建就不可改变，所以当对字符串进行修改的时候，需要使用到​​StringBuffer​​ 和 ​​StringBuilder​​ 类。

​​String​​类是用来修饰字符串的，字符串是一种特殊的对象，一旦初始化就不可被改变，用​​String​​修饰的字符串变量是不可以被改变的。

例子：

//定义一个字符串
String str = "hello world";
String str = new String("hello world");


对于​​String​​类，存在​​java.lang.String​​中，​​String​​类代表字符串，如何实现字符串的字面值，就是用此类来实例的。

​​String​​类，代表字符串的类，如何的字符串都是​​String​​的对象。字符串是作为常量，被双引号包着的为常量，被初始化即不可被更改。那么接下来举个例子效果。

String i = "123";
System.out.println("i="+i);
//结果为
i=123

如果添加以下
String i = "123";
i = "12"
System.out.println("i="+i);
//结果为
i=12

// 看到这个效果，你会认为不是改了吗？
// 其实不是的，而是新创建了一个对象而已。


在​​String​​中，对象是不可变的，但可以共享的。那么怎么理解是共享的呢？这里引出常量池的概念，如下：

//多个引用指向同一个字符串
String str1 = "dashu"
String str2 = "dashu";
System.out.println(str1==str2);
//结果
true


为​​true​​代表它们同时指向一个字符串，即为对象。创建了一个​​str1​​对象，字符串常理为​​"dashu"​​，那么再次创建一个对象时，常理名相同，在常量池中发现有相同的​​"dashu"​​，那么就同时指向一个值。

常量池是放置常量的，如果有相同的值，就不用创建对象，第一个创建的字符串放在常量池中，如果要用的时候，就拿来用。

// 字符串在底层是以字符数组形式来存储的
String str = “ab”; 
String str = new String(“ab”);
String s = “a”;
s = s + “b”;
//内容相同，但是创建方式不同的情况
String str3 = "abc"
String str4 = new String ("abc");
System.out.println(str3==str4);//false
System.out.println(str3.equals(str4));//true
//结果
false
true
// 100个元素拼接成一个字符串，使用+进行拼接
// 整个过程产生301个
String[] arr = { /*100个元素*/ };
// 为 1
String str = “”;

for(String s : arr){
str += s; 
// 每拼接1次，要多产生3个对象。
// 一共100个元素，拼接100次，意味着要多产生300个元素
}


​​String​​代表是字符串的类，而字符串本身就是常量，字符串在底层是以字符数组形式存储的，字符串是共享的，在常量池中

StringBuffer

对于字符串是常量，它的值在创建后时不可以改变的，但字符串缓冲区支持可变的字符串。

​​StringBuffe​​r类为​​java.lang​​中，​​StringBuffer​​为字符串缓冲，​​StringBuffer​​为线程安全的可变字符序列，类似​​String​​的字符串缓冲区，缓冲区不能改，但里面可以改，通过某方法可以改变序列的长度和内容。

​​StringBuffer​​提供了主要的两种方法，一，​​append（）​​ ,二， ​​inset（）​​

​​StringBuffer​​为一个字符串缓冲区，相对于一个容器，长度是可变的，可以存储任意类型数据，是将任意数据转变为字符串进行存储，​​StringBuffer​​提供了对数据的很多的操作功能。

例子：

StringBuffer sb = new StringBuffer();
sb.append("da");
sb.append("shu");
System.out.println(sb);
//sb.append("da").append("shu");


如果要操作数据，要转换为字符串。​​StringBuffer​​所有存储的元素都被转成字符串才可使用。

String str = sb.append("da").append("shu").toString();


在指定位置插入元素

sb.insert(2,"hehe");//插入


​​StringBuilder​​的效率要远高于用“+”，需要拼接多个字符串，建议使用​​StringBuilder​​。

StringBuffer和StringBuilder的区别

​​StringBuilder​​是线程不安全的，​​StringBuffer​​是线程安全的

​​StringBuilder​​为​​java.lang​​类，是一个可变的字符序列，提供了与​​StringBuffer​​兼容的​​API​​，​​StringBuffer​​和​​StringBuilder​​方法是一模一样的。

​​StringBuilder​​不同步，不安全。如果同时​​append(),delete(),insert(),​​会导致出错，多线程访问不安全，添加修饰​​synchronized​​即可。在​​jdk1.5​​版本后，推出​​StringBuilder​​被用作一个​​StringBuffer​​的简易替换，用在字符串缓冲区被单个线程使用的时候。

3. 装箱与拆箱

封装类有：​​Byte , short , Integer , Character , long , Float , Double​​ 记住这些类就可以了，这些都是​​Number​​的子类。

包装类

byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean
void
Void


自动封箱/自动装箱

底层默认调用​​valueOf​​方法进行封箱

自动拆箱

用​​***Value()​​进行拆箱

自动封装，将基本类型的变量赋值给对应的引用类型对象
自动拆箱，将引用类型的变量赋值给对应的基本类型变量

public class Test{
 public static void main(String[] args){
  int i = 5;
  Integer integer = new Integer(i);//装箱
  //拆箱
  int i2 = integer.intValue();
 }
}
//
public class Test{
 public static void main(String[] args){
  int i = 5;
  Integer integer = new Integer(i);
  Interger i2 = i;//自动装箱
  int i3 = integer;//自动拆箱
 }
}
//
public class Test{
 public static void main(String[] args){
  char c = 'Vic';
  character c2 = c;
  c3 = c2;
  }
}


4. 类Date

​​Date​​代表日期的类

Date的构造方法

Date(): 为分配Date对象，并初始化对象

​​Date(int year, int month, int date)​​

类 Calendar日历的类

​​Calendar​​ 类是一个抽象类

public abstract class Calendar extends Object
//Calendar 提供了一个类方法 getInstance
 Calendar rightNow = Calendar.getInstance();


结语

  • 下面我将继续对​​Java​​、 ​​Android​​中的其他知识 深入讲解 ，有兴趣可以继续关注


版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！