String类、static关键字、Arrays类

String类

特点

1. 字符串不变：字符串的值在创建后不能被更改。

String s1 = “abc”;
s1 += “d”;
System.out.println(s1); // “abcd”
// 内存中有"abc"，“abcd"两个对象，s1从指向"abc”，改变指向，指向了"abcd"。

2. 因为String对象是不可变的，所以它们可以被共享。

String s1 = “abc”;
String s2 = “abc”;
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3. “abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。
   String底层是靠字符数组实现的。

String str = “abc”;
相当于：
char data[] = {‘a’, ‘b’, ‘c’};
String str = new String(data);

使用步骤

// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {‘a’, ‘b’, ‘c’};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);

常用方法
判断功能的方法

public  class  String_Demo01 {
public  static  void main(String[]  args)  {
//  创建字符串对象
String  s1  = "hello";
String  s2  = "hello";
String  s3  = "HELLO";
//  boolean  equals(Object obj):比较字符串的内容是否相同
System.out.println(s1.equals(s2));  //  true
System.out.println(s1.equals(s3));  //  false
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
//boolean  equalsIgnoreCase(String  str):比较字符串的内容是否相同,忽略大小写
System.out.println(s1.equalsIgnoreCase(s2));  //  true
System.out.println(s1.equalsIgnoreCase(s3));  //  true
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
}
}

获取功能的方法

public  class  String_Demo02 {
public  static  void main(String[]  args)  {
//创建字符串对象
String  s  = "helloworld";
//  int  length():获取字符串的长度，其实也就是字符个数
System.out.println(s.length());
System.out.println("‐‐‐‐‐‐‐‐");
//  String  concat (String  str):将将指定的字符串连接到该字符串的末尾.
String  s  = "helloworld";
String  s2  = s.concat("**hello  ts");
System.out.println(s2);//  helloworld**hello  ts
//  char  charAt(int index):获取指定索引处的字符
System.out.println(s.charAt(0));
System.out.println(s.charAt(1));
System.out.println("‐‐‐‐‐‐‐‐");
//  int  indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
System.out.println(s.indexOf("l"));
System.out.println(s.indexOf("owo"));
System.out.println(s.indexOf("ak"));
System.out.println("‐‐‐‐‐‐‐‐");
//  String  substring(int start):从start开始截取字符串到字符串结尾
System.out.println(s.substring(0));
System.out.println(s.substring(5));
System.out.println("‐‐‐‐‐‐‐‐");
//  String  substring(int start,int  end):从start到end截取字符串。含start，不含end。
System.out.println(s.substring(0,  s.length()));
System.out.println(s.substring(3,8));
}
}

转换功能的方法

public  class  String_Demo03 {
public  static  void main(String[]  args)  {
//创建字符串对象
String  s  = "abcde";
//  char[]  toCharArray():把字符串转换为字符数组
char[]  chs  = s.toCharArray();
for(int  x  = 0;  x  <  chs.length;  x++)  {
System.out.println(chs[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
//  byte[]  getBytes ():把字符串转换为字节数组
byte[]  bytes  = s.getBytes();
for(int  x  = 0;  x  <  bytes.length;  x++)  {
System.out.println(bytes[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
//  替换字母it为大写IT
String  str  = "itnan  itnv";
String  replace  = str.replace("it",  "IT");
System.out.println(replace);  //  ITnan ITnv
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
}
}

分割功能的方法

public  class  String_Demo03 {
public  static  void main(String[]  args)  {
//创建字符串对象
String  s  = "aa|bb|cc";
String[]  strArray  = s.split("|");  //  ["aa","bb","cc"]
for(int  x  = 0;  x  <  strArray.length;  x++)  {
System.out.println(strArray[x]);  //  aa bb  cc
}
}
}

static关键字

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

类变量 ：
使用 static关键字修饰的成员变量。
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

定义格式：

static 数据类型 变量名；

举例：

static int numberID；

静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要
创建类的对象。调用方式非常简单。

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){
// 执行语句
}

静态方法调用的注意事项：

• 静态方法可以直接访问类变量和静态方法。
• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
• 静态方法中，不能使用this关键字。
• 静态方法只能访问静态成员。

调用格式：

// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；

静态代码块
定义在成员位置，使用static修饰的代码块{ }。

• 位置：类中方法外。
• 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

public class ClassName{
static {
// 执行语句
}
}

作用：给类变量进行初始化赋值。用法演示，代码如下：

public  class  Game {
public  static  int number;
public  static  ArrayList<String> list;
static  {
//  给类变量赋值
number  =  2;
list  =  new ArrayList<String>();
//  添加元素到集合中
list.add("张三");
list.add("李四");
}
}

Arrays类

此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

返回指定数组内容的字符串表示形式：

public static String toString(int[] a)

public  static  void main(String[]  args)  {
//  定义int  数组
int[]  arr
=
{2,34,35,4,657,8,69,9};
//  打印数组,输出地址值
System.out.println(arr);  //  [I@2ac1fdc4
//  数组内容转为字符串
String  s  = Arrays.toString(arr);
//  打印字符串,输出内容
System.out.println(s);  //  [2, 34,  35,  4,  657,  8,  69, 9]
}

对指定的 int 型数组按数字升序进行排序：

public  static  void main(String[]  args)  {
//  定义int  数组
int[]  arr
=
{24,  7,  5, 48,  4,  46,  35,  11,  6, 2};
System.out.println("排序前:"+  Arrays.toString(arr));  // 排序前:[24,  7,  5,  48,  4,  46, 35,  11,  6,
2]
//  升序排序
Arrays.sort(arr);
System.out.println("排序后:"+  Arrays.toString(arr));//  排序后:[2, 4,  5,  6,  7,  11,  24, 35,  46,
48]
}