三、字符串

字符串（字符序列），表示把多个字符按照一定得顺序排列起来

字符串按照内容是否可变可以分为两类：

不可变字符串-String：当String对象创建完毕之后，该对象的内容是不可以改变的，一旦内容改变就变成了一个新的对象
可变字符串-StringBuilder/StringBuffer：是可变的，当创建完对象之后，对象的内容可以发送改变，当内容发生改变的时候，对象保持不变

3.1、String

String 类型表示字符串，Java 程序中的所有字符串字面值（如 "ABC" ）都作为此类的实例实现。String的底层是以字符数组的形式存在，String是字符数组的包装类，并提供以只读的形式操作其包装的字符数组的方法

3.1.1、String内存图

3.1.1.1、通过字面量创建

通过字面量创建的内存图 String str1 = "ABC"

网络异常，图片无法展示

通过字面量创建的字符串分配在常量池中，所以字面量字符串是常量；它们的值在创建之后不能更改，因为 String 对象是不可变的，所以可以共享

3.1.1.2、通过实例化对象创建

通过实例化对象创建的内存图

网络异常，图片无法展示

3.1.1.3、总结

String类，表示不可变的字符串，当String对象创建完毕之后，该对象的内容是不能改变的，一旦内容改变就变成了一个新的对象

String str = "hello";
str = str + "word";

网络异常，图片无法展示

3.1.2、String对象的空值问题

//表示引用为空(null)
String  str1 = null;  //没有初始化，没有分配内存空间. 
//内容为空字符串
String  str2  = "";   // 已经初始化，分配内存空间，不过没有内容

3.1.3、字符串常用方法

3.1.3.1、==

== 比较是否是同一个引用，即是否是同一个对象

3.1.3.2、equals

== 比较的是值是否相等

3.1.3.3、字符串查找

contains

// 字符串查找
    String str3 = "hello world";
    // 检测是否包含
    System.out.println(str3.contains("w"));

Java Api文档对contains方法的描述：

网络异常，图片无法展示

译文：当且仅当此字符串包含指定的char值序列时，才返回true

endsWith/startsWith

// 判断是否以xx为后缀/前缀
    String str4 = "icon20191101.png";
    System.out.println(str4.endsWith(".png"));
    System.out.println(str4.startsWith("icon"));

Java Api文档对startsWith/endsWith方法的描述：

网络异常，图片无法展示

译文：测试此字符串是否以指定的前缀开头

测试从指定索引开始的此字符串的子串是否以指定的前缀开头

网络异常，图片无法展示

译文：测试此字符串是否以指定的后缀结尾

indexOf

String str5 = "helloworld123";
    System.out.println(str5.indexOf('o'));
    System.out.println(str5.indexOf('o', 5));

Java Api文档对indexOf方法的描述：

网络异常，图片无法展示

译文：返回指定字符第一次出现的字符串中的索引

返回指定字符第一次出现的字符串中的索引，从指定索引处开始搜索

3.1.3.4、字符串的替换

replace

String str1 = "helloworld123";
  // 替换给定字符
  String newStr1 = str1.replace("h", "H");
  System.out.println(newStr1);
  // 替换给定字符串
  // String newStr2 = str1.replace("hello", "HELLO");
  String newStr2 = str1.replace("hello", "");
  System.out.println(newStr2);

网络异常，图片无法展示

译文：返回一个字符串，该字符串是用newChar替换此字符串中所有出现的oldChar的结果。

网络异常，图片无法展示

译文：用给定的替换项替换该字符串中与给定的正则表达式匹配的每个子字符串

3.1.3.5、字符串分割

// 字符串分隔
    String str1 = "186-2001-1234";
    String[] strArr = str1.split("-");
    System.out.println(Arrays.toString(strArr));
  //如果有多个分隔符可以放在[]中，多个分隔符用空格隔开
  String str = "a;b:c;d:w";
    System.out.println(Arrays.toString(str.split("[;:]")));

网络异常，图片无法展示

译文：围绕给定正则表达式的匹配项拆分此字符串

3.1.3.6、求字串

substring

String str1 = "helloworld";
  System.out.println(str1.substring(5));
  // 有两个参数，一个是开始的索引，一个是结束的索引，如果结束的索引不写，默认到最后一位，求字串的原则是含头不含尾
  System.out.println(str1.substring(0,5));

网络异常，图片无法展示

译文：返回一个字符串，该字符串是该字符串的子字符串

3.1.3.7、获取指定位置的字符

// 获取自定位置的字符
  String str1 = "hello";
  char c = str1.charAt(0);
  System.out.println(c);

网络异常，图片无法展示

译文：返回指定索引处的字符值

3.1.3.8、字符串连接

// 字符串连接
  String str2 = "abc";
  String str3 = "123";
  System.out.println(str2.concat(str3));

网络异常，图片无法展示

译文：将指定的字符串连接到该字符串的末尾

3.1.3.9、字符串长度

String str4 = "123";
  System.out.println(str4.length());

网络异常，图片无法展示

3.1.3.10、判断字符串是否为空

String str4 = "123";
  System.out.println(str4.length());

网络异常，图片无法展示

3.1.3.11、大小写转换

// 大小写转换
  String str5 = "Hello";
  System.out.println(str5.toUpperCase());//转大写
  System.out.println(str5.toLowerCase());//转小写

3.1.3.12、去除空格

String str = "  hello  ";
    System.out.println(str.length());
    String trim = str.trim();
    System.out.println(trim.length());
复制代码

网络异常，图片无法展示

返回一个值为该字符串的字符串，其中删除了所有前导和尾随空格

3.1.3.13、判断字符串非空

public static boolean hasLength(String str) {
  return str != null && !"".equals(str.trim());
}

3.2、StringBuilder/StringBuffer

在程序开发过程中，我们常常碰到字符串连接的情况，方便和直接的方式是通过"+"符号来实现，但是这种方式达到目的的效率比较低，且每执行一次都会创建一个String对象，即耗时，又浪费空间。使StringBuilder类就可以避免这种问题的发生，在使用StringBuilder过程中需创建一个StringBuilder对象

StringBuffer和StringBuilder都表示可变的字符串，功能方法相同的，区别是：

StringBuffer：StringBuffer中的方法都使用了synchronized修饰，保证线程安全但性能较低
StringBuilder：StringBuilder中的方法没有使用synchronized修饰，线程不安全但但是性能较高

开发中建议使用StringBuilder

StringBuilder stringBuilder = new StringBuilder("123");//进行初始化

3.2.1、字符串拼接

语法格式

append(String str)/append(Char c)

示范

StringBuilder stringBuilder = new StringBuilder("123");
    System.out.println(stringBuilder.append("abc").append("123"));

优势

可以链式调用，在后面无限进行拼接

3.2.2、替换

语法格式

注意

setCharAt(int i, char c)：将第 i 个代码单元设置为 字符c（可以理解为替换）

示范

StringBuilder sb = new StringBuilder("123");
  sb.setCharAt(1,'A');
  System.out.println(sb);

注意

第一个参数是需要替换的位置，第二个参数是需要替换的字符，仅仅只是char类型

3.2.3、插入

语法格式

insert(int offset, String str)/insert(int offset, Char c)：在指定位置之前插入字符(串)

示范

StringBuilder sb = new StringBuilder("123");
  sb.insert(1,"1234");
    System.out.println(sb);

注意

在添加的方法中，可以添加字符也可以添加字符串

3.2.4、删除

语法格式

delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串

示范

System.out.println(sb.delete(3, 6));

注意

delete方法也是含头不含尾

四、常用类

4.1、Math

Math 类包含用于执行数学运算的方法，如初等指数、对数、平方根和三角函数等，该类的方法都是static修饰的，在开发中会用到数学的处理可以使用这个类

public class MathDemo {
  public static void main(String[] args) {
    System.out.println(Math.max(99, 10));// 返回最大值
    System.out.println(Math.min(99, 10));// 返回最小值
    // 返回一个[0,1)之间的随机小数
    double num = Math.random();
    System.out.println(num);
    // 得到一个[0,100)之间的随机整数
    int intNum1 = (int) (num * 100);
    System.out.println(intNum1);
    //得到23~104之间的随机数等价于0~81之间随机数+23
    int intNum2 = (int)(Math.random() * 81 + 23);
    System.out.println(intNum2);
  }
}

4.2、Random

Random类用于生产一个伪随机数（通过相同的种子，产生的随机数是相同的），Math类的random方法底层使用的就是Random类的方式

public class RandomDemo {
  public static void main(String[] args) {
    Random r = new Random();
    int intNum1 = r.nextInt(100);// 100以内随机数
    System.out.println(intNum1);
    // 随机获取A~Z之间的5个字母组成的字符串
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 5; i++) {
      int intNum2 = 65 + r.nextInt(25);
      char ch = (char) intNum2;
      sb.append(ch);
    }
    System.out.println(sb);
  }
}

4.3、UUID

UUID表示通用唯一标识符 (Universally Unique Identifier) ，其算法通过电脑的网卡、当地时间、随机数等组合而成，优点是真实的唯一性，缺点是字符串太长了

public class UUIDDemo {
  public static void main(String[] args) {
    //UUID随机字符串
    String uuid = UUID.randomUUID().toString();
    System.out.println(uuid);
    //获取UUID前5个字母作为验证码
    String code = uuid.substring(0, 5);
    System.out.println(code);
    System.out.println(code.toUpperCase());//把验证码转为大写字母
  }
}

4.4、日期类

4.4.1、Date类

Date类，时期时间类，表示特定的瞬间，可以解释为年、月、日、小时、分钟和秒值

Date类中的大量方法都标记为已经时的，即官方不建议使用。在开发中，我们要表示日期（年月日）或时间（时分秒）类型都使用Date类来表示

public class DateDemo {
  public static void main(String[] args) {
    java.util.Date d = new java.util.Date();
    System.out.println(d);// 欧美人的时间风格
    System.out.println(d.toLocaleString());// 本地区域时间风格，已过时的方法
    long time = d.getTime();// 获取当前系统时间距离1970 年 1 月 1 日 00:00:00 以来的毫秒数
    System.out.println(time);
  }
}

网络异常，图片无法展示

4.4.2、SimpleDateFormat

打印Date对象时，默认打印的是欧美人的日期时间风格，如果需要输出自定义的时间格式，而SimpleDateFormat就时提供给我们来格式化我们的时间，其中主要是包含了两个主要的方法：

格式化（format）：Date类型转化为String类型
解析（parse）：将String类型转为Date类型

无论是格式化还是解析都需要设置日期和时间的格式

网络异常，图片无法展示

举例：

yyyy-MM-dd              如2020-12-12
HH:mm:ss              如20：12：12
yyyy-MM-dd HH:mm:ss         如2020-12-12 20：12：12
yyyy/MM/dd HH:mm:ss         如2020/12/12 20：12：12
yyyy年MM月dd日 HH时mm分ss秒 如2020年12月12日 20时12分12秒

格式化和解析的示范：

package day11_CommonUtils2.test.Math;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/11 15:21
 */
public class TestMath {
  public static void main(String[] args) throws ParseException {
    /*
    格式化
     */
    //新建一个日期类
    Date date = new Date();
    //设置一个格式
    String paaaern = "yyyy-MM-dd HH:mm:ss";
    //将设置的格式传到simpleDateFormat中
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(paaaern);
    //simpleDateFormat对传进来的日子进行格式化
    String format = simpleDateFormat.format(date);
    //输出格式化信息
    System.out.println(format);
    /*
    解析
     */
    //将字符串信息传到simpleDateFormat.parse方法中进行解析，返回一个Date对象
    Date d = simpleDateFormat.parse("2020-12-11 16:53:48");、
    //输出Date信息
    System.out.println(d);
  }
}

4.4.3、Calendar

Calendar是日历类，主要是对日期进行相加和相减，重新设置日期功能，Calendar本身是一个抽象来，必须通过getInstance方法获取对象

public class CalendarDemo1 {
  public static void main(String[] args) throws Exception {
    Calendar c = Calendar.getInstance();
    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar.MONTH) + 1;
    int date = c.get(Calendar.DAY_OF_MONTH);
    int hour = c.get(Calendar.HOUR_OF_DAY);
    int minute = c.get(Calendar.MINUTE);
    int second = c.get(Calendar.SECOND);
    System.out.println(year);//2018
    System.out.println(month);//5
    System.out.println(date);//17
    System.out.println(hour);//15
    System.out.println(minute);//1
    System.out.println(second);//38
    c.add(Calendar.YEAR, 100);//在当前年份上增加100
    System.out.println(c.get(Calendar.YEAR));//2118
  }
}

4.5、正则表达式

正则表达式，简写为regex和RE。

正则表达式用来判断某一个字符串是不是符合某一种正确的规则，在开发中通常用于判断操作、替换操作、分割操作等。

常用的规则如下：

网络异常，图片无法展示

public class REDemo {
  public static void main(String[] args) throws Exception {
    // 判断前面的字符串是否是一个数字，"\\d"表示一个数字
    System.out.println("12345678S".matches("\\d"));// false
        // 判断前面的字符串是否是一个数字，"\\d"表示一个数字
    System.out.println("12345678".matches("\\d"));// false
        // 判断前面的字符串是否是一串数字，"\\d*"表示多个数字
    System.out.println("12345678".matches("\\d*"));// true
        // 判断前面的这串数字是否出现了5-10次（有一个英文就是false）
    System.out.println("1234".matches("\\d{5,10}"));// false
    System.out.println("12345678".matches("\\d{5,10}"));// true
    // 判断一个字符串是否是手机号码，第一位是1第二位是3/4/5/7/8，往后是0-9共出现九次
    String regex1 = "^1[3|4|5|7|8][0-9]{9}$";
    System.out.println("12712345678".matches(regex1));// false
    System.out.println("13712345678".matches(regex1));// true
    // 判断一个字符串是否是18位身份证号码，数字出现17次，最后一位是0-9或者是X
    String regex2 = "\\d{17}[[0-9]X]";
    System.out.println("511123200110101234".matches(regex2));// true
    System.out.println("51112320011010123X".matches(regex2));// true
    System.out.println("51112320011010123S".matches(regex2));// false
    // 判断一个字符串是否6到16位，且第一个字必须为字母
    String regex3 = "^[a-zA-Z]\\w{5,15}$";
    System.out.println("will".matches(regex3));// false
    System.out.println("17will".matches(regex3));// false
    System.out.println("will17willwillwill".matches(regex3));// false
    System.out.println("will17".matches(regex3));// true
  }
}

五、数组高级

5.1、冒泡排序法

对未排序的各元素从头到尾依次比较相邻两个元素的大小关系，如果前一个元素大于后一个元素则交换位置，经过第一轮比较后可以得到最大值，同理第二轮比较后出现第二大值等

第1轮比较：需要比较5次，比较完出现最大值。
第2轮比较：需要比较4次，比较完出现第二大值。
第3轮比较：需要比较3次，比较完出现第三大值。
...
可以看出如有N个元素，则需要N-1轮比较，第M轮需要N-M次比较。
i(轮数)              次数           每轮次数的规律
  0                   3            数组长度-i-1
  1                   2            数组长度-i-1
  2                   1            数组长度-i-1

网络异常，图片无法展示

package ArraysAdvanced;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/14 14:04
 */
public class Bubble {
  public static void main(String[] args) {
    int[] nums = new int[10];//创建一个数组
    for (int i = 0; i < nums.length; i++) {
     nums[i] = new Random().nextInt(100);//对数组进行随机赋值，
    }
    System.out.println(Arrays.toString(nums));//打印原始的数组（未排序之前的）
    for (int i = 0 ; i < nums.length-1 ; i++){//定义一个控制循环控制总共需要冒泡几轮：数组长度-1
      for (int j = 0 ; j < nums.length-1-i ; j++){//控制每轮比较几次
        int temp = 0;//设置临时变量，用于进行两两交换
        if (nums[j]>nums[j+1]){//如果前面的值大于后面的值，那么就进行交换，保证后面的值大于前面的
          temp = nums[j];//将大的值存储在临时变量中
          nums[j] = nums[j+1];//将小的值赋值给大的值
          nums[j+1] = temp;//将临时变量的值赋值给小的值，从而完成了两两交换
        }
      }
    }
    System.out.println(Arrays.toString(nums));//输出排序后的数组
  }
}

5.2、选择排序

从当前位置开始找出后面的较小值与该位置交换

网络异常，图片无法展示

实现思路：
  (1)、控制选择几轮：数组长度-1
  (2)、控制每轮从当前位置开始比较几次
i(轮数)              次数           每轮比较几次
  0                  3             数组长度-i-1
  1                  2             数组长度-i-1
  2                  1             数组长度-i-1

package com.test;
import java.util.Arrays;
import java.util.Random;
/**
 * @author Xiao_Lin
 * @date 2020/12/25 11:31
 */
public class SelectSort {
  public static void main(String[] args) {
   //定义一个数组
        int[] arr = {7, 6, 5, 4, 3};
        System.out.println("排序前：" + Arrays.toString(arr));
      // 定义一个控制循环几轮
        for (int x = 0; x < arr.length; x++) {
            // 定义一个循环控制每轮比较几次，一定是以当前位置与后面的元素进行比较，遍历后面的元素
            // i=0  j=1 2 3
            // i=1  j=2 3
            // i=2  j=3
            for (int i = x+1; i < arr.length; i++) {
                //拿当前的位置与指定的元素进行大小比较，后面的较小就交换位置
                if (arr[x] > arr[i]) {
                    int temp = arr[x];
                    arr[x] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(arr));
  }
}

5.3、二分查找法

查找数组元素的语法：

线性查找：从头到尾查找，性能很低
二分查找法（折半查找）：前提是数组元素必须有序，性能比较好

package day012_ArraysAdvanced.classing;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/14 18:39
 */
public class Find {
  /**
   * 二分查找的方法
   * @param nums 需要查找的元素所在的数组
   * @param value 需要查找的元素
   * @return
   */
  public static int binarySearch(int[] nums , int value){//定义一个二分查找的方法
    int low = 0;//定义最低的位置，默认值为0
    int hight = nums.length-1;//定义最高的位置，默认值为数组的最后一位
    int mid , midValue; //定义中间的变量值和序号
    while (low <= hight){//如果最低位小于等于最高位，说明我们查找的元素还在数组织中，否则说明数组中没有该元素，返回-1
      mid = (low+hight)/2;//计算出中间位
      midValue = nums[mid];//取出中间位置的值
      if (value > midValue){//如果需要寻找的变量在中间值的右边
        low = mid+1;//将最低位移到中间位置后一位
      }else if(value < midValue){//如果需要寻找的变量在中间值的左边
        hight = mid-1;//将最高位移到中间位置的前一位
      }else if(value == midValue){//如果中间的值和需要寻找的值相等，说明找到
        return mid;//返回找到的序号
      }
    }
    return -1;//返回-1说明找不到
  }
  public static void main(String[] args) {
    int[] nums = {1,2,3,4,5,6};
    System.out.println(binarySearch(nums, 30));
  }
}

5.3、操作数组的API-Arrays

5.3.1、打印数组元素

public class Test01ToString {
  public static void main(String[] args) {
    int[] arr = new int[] { 10, 20, 30, 40, 50, 60, 70 };
    String str = Arrays.toString(arr);
    System.out.println(str);
 }
}

5.3.2、拷贝数组元素

Arrays 中提供了数组复制的方法，copyOf(int[] original, int newLength) 复制指定的数组，截取或者用0填充，他是直接创建一个新的数组，如果我们指定的数组元素长度不够就素截取，如果长度多余就是用0填充 System类中提供了数组元素拷贝的方法，并且支持任意类型的数组拷贝，而不仅仅是int类型数组。

package day012_ArraysAdvanced.classing;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/14 16:11
 */
public class ArraysTestDemo {
  public static void main(String[] args) {
    //Arrays的copyOf方法
    int[] nums = {21,3,4,652,2};
    int[] ints = Arrays.copyOf(nums, 10);//我们指定复制后的数组长度为10，说明有多，就是用0填充
    System.out.println(Arrays.toString(ints));
    int[] copyOf = Arrays.copyOf(nums, 3);//我们指定复制后的数组长度为3，长度比原来的数组小，直接从前往后截取
    System.out.println(Arrays.toString(copyOf));
    //System的
    int[] num = {1,3,5,7,9};
    int[] newnum = new int[10];
    //参数解释：需要复制的源数组 从源数组的什么位置开始复制 复制到哪个数组中去 从复制到的数组的哪个位置开始填充值 在原数组中填充的长度是多少
    System.arraycopy(num,0,newnum,0,num.length);
    System.out.println(Arrays.toString(newnum));
  }

5.3.3、数组元素的排序

Arrays类中已经提供了数组排序的方法sort，并且是调优之后的，性能非常优异，在开发中只需要我们直接调用该方法即可即可，sotr默认为升序，等到以后我们才可以指定sort的排序方式（降序还是升序）

import java.util.Arrays;
public class Test03Sort{
  public static void main(String[] args) {
    int[] arr = new int[] { 2, 9, 6, 7, 4, 1 };
    System.out.println(Arrays.toString(arr));//排序前
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));//排序后
      }
  }
}

5.3.4、数组的二分查找

import java.util.Arrays;
public class Test04Search{
  public static void main(String[] args) {
    int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int index = Arrays.binarySearch(arr, 8);
    System.out.println(index);
  }
}

5.4、数组的增删改查操作

5.4.1、数组初始化操作

package day012_ArraysAdvanced.classing.ArraysCRUD;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/14 19:17
 */
public class ArraysUtils {
  private Integer[] nums = null;  //声明一个数组
  private int size;//声明数组中元素的个数，不是数组长度
  public  ArraysUtils(int capacity){//构造方法,用于初始化
    if (capacity < 0){//如果传进来的容量值<0,说明这个容量值是不合法的
      System.out.println("数组的容量不可以小于0");
      return;
    }else {
      this.nums = new Integer[capacity];//将传进来的容量值进行初始化一个新的数组
    }
  }
  public   ArraysUtils(){//无参构造器
    this(10);//调用有参构造器,并且传入一个初始化的值
  }
  public Integer[] getNums() {
    return nums;
  }
  public void setNums(Integer[] nums) {
    this.nums = nums;
  }
  public int getSize() {
    return size;
  }
  public void setSize(int size) {
    this.size = size;
  }
}

测试类:

package day012_ArraysAdvanced.classing.ArraysCRUD;
/**
 * @author Xiao_Lin
 * @version 1.0
 * @date 2020/12/14 19:24
 */
public class TestArraysUtils {
  public static void main(String[] args) {
    ArraysUtils arraysUtils = new ArraysUtils(13);
    System.out.println(arraysUtils.getNums().length);
  }
}

5.4.2、数组的修改

public ArraysUtils set(int num,int index){//定义一个进行修改指定位置元素的方法,返回值为ArraysUtils方便写链式调用
   if (index < 0){
     System.out.println("索引不能小于0");
     return null;
   }if (index >= size){
     System.out.println("索引越界");
     return null;
   }
    nums[index] = num;//将需要修改的值赋给指定元素下表原来的值
    return this;//返回当前对象,方便可以进行链式调用
 }

5.4.3、数组的指定索引的查找

public Integer get(int index){//定义一个根据指定序列查询的方法
    if (index < 0){
      System.out.println("索引不能小于0");
      return null;
    }if (index >= size){
     System.out.println("索引越界");
     return null;
   }
    return this.nums[index];//返回指定序列的值
 }

5.4.4、数组的打印

public String toString(){//定义一个打印方法
   StringBuilder sb = new StringBuilder();//定义一个 StringBuilder 对象
    if (nums == null){//如果当前数组为空
      return null;//直接返回null
    }if (size == 0){//如果当前数组的长度为0
      return "[]";//返回一个空的字符数组
   }else {
      sb.append("[");//先在StringBuilder后追加一个"["
     for (int i = 0; i < size; i++) {//遍历nums数组,切记这里的i要小于数组的元素个数,而不是长度
       if (i == size-1){//如果需要遍历的元素是数组的最后一个元素
         sb.append(nums[i]).append("]");//在最后面追加一个"]"
       }else {
         sb.append(nums[i]).append(",");//否则就只是追加元素和,
       }
     }
   }
    return sb.toString();
 }

5.4.5、数组的追加

public ArraysUtils append(int num){
  this.nums[size] = num;//将传进来的值追加到数组的后一位
  size++;//数组的元素加一个
  return this;//返回当前对象,方便链式调用
 }

5.4.5、数组的扩容

因为数组的长度是固定的，此时的nums数组只能存储初始化指定数量的元素，如果再多存储一个就报错：数组索引越界。此时就要考虑在保存操作时对数组做扩容操作。扩容的原理是：

创建一个原数组长度两倍长的新数组
把旧数组中的所有元素拷贝到新数组中
把新数组的引用赋给旧数组变量

public ArraysUtils append(int num){
  if (size == nums.length){//如果数组中的元素个数等于数组的长度,说明这个时候需要扩容
    this.nums = Arrays.copyOf(nums,nums.length*2+2);//将copyOf产生的新数组赋值给原来的数组,并且将长度扩大到原来的2倍+2个元素
  }
  this.nums[size] = num;
  size++;
  return this;
 }

5.4.6、数组的删除

public ArraysUtils delete(int index){//定义删除的方法
   if (index < 0){//如果下标小于0
     System.out.println("索引不能小于0");
     return null;//返回空
   }if (index >= size){//如果下标的值比数组中的元素还大的时候
     System.out.println("索引越界");//返回数组越界
     return null;
   }
   for (int i = index ; i < size-1 ;i++){//遍历数组中的元素
     nums[i] = nums[i+1];//将需要删除的索引的后面的值赋值给前面
   }
   nums[size-1] = null;//将数组的最后一位置空
   size--;//数组的元素个数减一
   return this;//返回当前对象
 }

作者：XiaoLin_Java

链接：https://juejin.cn/post/6983686380119392264

来源：稀土掘金

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Java中的常用类保姆级教程(中)

三、字符串

3.1、String

3.1.1、String内存图

3.1.1.1、通过字面量创建

3.1.1.2、通过实例化对象创建

3.1.1.3、总结

3.1.2、String对象的空值问题

3.1.3、字符串常用方法

3.1.3.1、==

3.1.3.2、equals

3.1.3.3、字符串查找

3.1.3.4、字符串的替换

3.1.3.5、 字符串分割

3.1.3.6、求字串

3.1.3.7、获取指定位置的字符

3.1.3.8、字符串连接

3.1.3.9、字符串长度

3.1.3.10、判断字符串是否为空

3.1.3.11、大小写转换

3.1.3.12、去除空格

3.1.3.13、判断字符串非空

3.2、StringBuilder/StringBuffer

3.2.1、字符串拼接

3.2.2、替换

3.2.3、插入

3.2.4、删除

四、常用类

4.1、Math

4.2、Random

4.3、UUID

4.4、日期类

4.4.1、Date类

4.4.2、SimpleDateFormat

4.4.3、Calendar

4.5、正则表达式

五、数组高级

5.1、冒泡排序法

5.2、选择排序

5.3、二分查找法

5.3、操作数组的API-Arrays

5.3.1、打印数组元素

5.3.2、拷贝数组元素

5.3.3、数组元素的排序

5.3.4、数组的二分查找

5.4、数组的增删改查操作

5.4.1、数组初始化操作

5.4.2、数组的修改

5.4.3、数组的指定索引的查找

5.4.4、数组的打印

5.4.5、数组的追加

5.4.5、数组的扩容

5.4.6、数组的删除

商业转载请注明出处。

热门文章

最新文章

相关课程

相关电子书

相关实验场景

3.1.3.5、字符串分割