Java基础常用类深度解析（包含常见排序算法）

目录

• 一、工具类
  • 1.1、工具类的设计
    • 1.1.1、公共静态方法
  • 1.2、单例模式
• 二、包装类
  • 2.1、基本类型的包装类
    • 2.1.1、Integer
      • 2.1.1.1、Integer >> int
      • 2.1.1.2、int >> Integer
      • 2.1.1.3、Integer >>String
      • 2.1.1.4、String >> Integer
      • 2.1.1.5、String >> int
      • 2.1.1.6、int >> String
  • 2.2、拆箱和装箱
    • 2.2.1、装箱
    • 2.2.2、拆箱
    • 2.2.3、自动拆箱和装箱
  • 2.3、缓存设计
  • 2.4、BigDecimal
    • 2.4.1、基本运算
    • 2.4.2、精度控制
    • 2.4.3、无理数问题
• 三、字符串
  • 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、数组的删除
• 六、泛型
  • 6.1、泛型的概述
  • 6.2、自定义和使用泛型
  • 6.2、在集合中使用泛型

一、工具类

1.1、工具类的设计

​ 把很多完成通用功能的方法抽取分类存放到类中，这些类就叫工具类

工具类如何设计（分两种）

1. 工具方法全部使用public static修饰（常用）

   ​ 此时只需要使用工具类类名调用工具方法，且须把工具类的构造器私有化，防止创建工具类的对象来调用静态方法

2. 如果工具方法没有使用static修饰

   ​ 此时必须使用工具类的对象去调用工具类的方法，且必须把工具类设计成单例模式

1.1.1、公共静态方法

需求一：使用公共静态方法的方式，设计一个数组的工具类

ArraysUtils类

public void ArraysUtils{
    //1. 先私有化构造器，防止被实例化对象
    private ArraysUtils(){

    }

    //2.写工具方法
    public static void sort(){
        System.out.println("我是排序方法")
    }
     public static void print(){
        System.out.println("我是打印方法方法")
    }

}

TsstDemo类

public class TsstDemo{
    public static void main(String[] args){
        ArraysUtils.sort()
    }
}

调用者必须通过工具类名.工具方法名称完成调用

1.2、单例模式

设计模式（Design pattern）

​ 是一套被反复使用的代码设计经验总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性，Java常用的设计模式有23种

单例设计模式（singleton）

​ 最常用、最简单的设计模式，单例模式分为两种：懒汉式和饿汉式

目的

​ 保证在整个应用中某一个类有且只有一个实例

步骤（以饿汉式为例）

1. 私有化自身构造器，防止外界通过构造器实例化出对象
2. 在该类中，自己先创建出一个对象
3. 向外暴露一个公共的静态方法用于返回自身的对象

public class SingletonUtil{

    // 1. 先私有化构造器，防止被实例化对象
    private SingletonUtil(){

    }

    //2. 自己创建出一个对象
    private static SingletonUtil instance = new SingletonUtil();

    //3. 暴露给外界调用方法，返回创建好的对象
    public static SingletonUtil getInstance(){
        return instance;
    }

    public void sort() {
		System.out.println("排序操作");
	}
	public void binarySearch() {
		System.out.println("二分查找操作");
	}

}

调用方法：

SingletonUtil.getInstance().sort();

二、包装类

​ Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互，数值型包装类都继承至Number，而字符型和布尔型继承至Object

2.1、基本类型的包装类

基本数据类型和包装类对应关系：

基本类型	对于包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

2.1.1、Integer

​ Integer内部封装了int类型的基本数据类型value，并提供了方法对int值进行操作和String之间进行互换（开发中常用）

2.1.1.1、Integer >> int

	Integer i = new Integer();
    int intValue = i.intValue();

2.1.1.2、int >> Integer

    int i = 20;
    Integer integer = Integer.valueOf(i);

2.1.1.3、Integer >>String

	int i = 30;
	Stirng value = Integer.valueOf(i);

2.1.1.4、String >> Integer

Integer i = Integer.valueOf("3");

2.1.1.5、String >> int

	int i = Integer.parseInt("134");

2.1.1.6、int >> String

String str = Integer.toString(134);

2.2、拆箱和装箱

2.2.1、装箱

​ 把基本数据类型转为对于的包装类对象

	Integer num2 = Integer.valueOf(17);

2.2.2、拆箱

​ 把包装类对象转化为对应的基本数据类型

	int val = num3.intValue();

2.2.3、自动拆箱和装箱

​ 从JDK5之后提供了自动装箱和自动拆箱，我们再也不用频繁的去手动拆箱和装箱了

    Integer num4  =  17; //装箱操作
    int val2 = num4; //拆箱操作

2.3、缓存设计

​ 从性能上考虑，把常用数据存储到缓存区域，使用时不需要每次都创建新的对象，可以提高性能

常用包装类型的缓存范围

• Byte、Short、Integer、Long：缓存范围[-128，127]
• Character：缓存范围[0，127]

//第一种
Integer i1 = new Integer(123);
Integer i2 = new Integer(123);
System.out.println(i1 == i2);// false，因为都在堆中new了一个新的对象

//第二种
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf(123);
System.out.println(i3 == i4);// true，由于在[-128,127]之间，所以直接在缓存中取，都是同一个对象

//第三种
Integer i5 = 123; // 底层等价于第二种
Integer i6 = 123;
System.out.println(i5 == i6);// true

注意

1. 如果数字都不在缓存范围内，那么返回的结果都是false

2. 如果要比较两个对象的数据是否相等，必须使用equals方法来判断，==比较的是两个数据的内存空间是否是同一块，equals比较的是存储数据是否相等

3. int类型的默认值为0，Integer的默认值为null，在开发中建议使用Integer，因为Integer既可以表示0，也可以表示null

2.4、BigDecimal

​ float和double都不能表示精确的小数，使用BigDecimal类可以解决该问题，BigDecimal用于处理金钱或任意精度要求高的数据

2.4.1、基本运算

​ BigDecimal不能直接把赋值和运算操作，只能通过构造器传递数据，而且必须使用字符串类型的构造器

    System.out.println(0.09 + 0.01);

我们运行这段代码，结果是


他会生成一个无限接近0.1的值，说明这个并不适合我们运算

    BigDecimal num1 = new BigDecimal(0.09);
    BigDecimal num2 = new BigDecimal(0.01);
    System.out.println(num1.add(num2));


如果我们不用字符串类型的构造器的话，BigDecimal无法开启高精度模式

    BigDecimal num3 = new BigDecimal("0.09");
    BigDecimal num4 = new BigDecimal("0.01");
    System.out.println(num3.add(num4));


终于运行处了正确结果，需要注意一定要使用字符串的构造方法，才可以开启高精度计算模式

2.4.2、精度控制

我们在运算的时候需要进行精度控制操作

/*
  1. 保留位数和精度控制
  	 RoundingMode 舍入模式
  	 RoundingMode.HALF_UP   四舍五入
*/
BigDecimal num5 = new BigDecimal("0.987");
    BigDecimal bigDecimal = num5.setScale(2, RoundingMode.HALF_UP);
    System.out.println(bigDecimal);

2.4.3、无理数问题

   	/*
   	 java.lang.ArithmeticException
  	 Non-terminating decimal expansion; no exact representable decimal result.
  	 报错原因:除不尽(3.333333333...333...)
   	*/
	BigDecimal num1 = new BigDecimal("10.0");
    BigDecimal num2 = new BigDecimal("3.0");
    BigDecimal r2 = num1.divide(num2,3,RoundingMode.HALF_UP);
    System.out.println(r2);

三、字符串

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

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

1. 不可变字符串-String：当String对象创建完毕之后，该对象的内容是不可以改变的，一旦内容改变就变成了一个新的对象
2. 可变字符串-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就时提供给我们来格式化我们的时间，其中主要是包含了两个主要的方法：

1. 格式化（format）：Date类型转化为String类型
2. 解析（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数组只能存储初始化指定数量的元素，如果再多存储一个就报错：数组索引越界。此时就要考虑在保存操作时对数组做扩容操作。

扩容的原理是：

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

 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;//返回当前对象
 }

六、泛型

6.1、泛型的概述

​ 泛型其实就是一种数据类型，主要用于某个类或者接口中的数据类型不确定的时候，可以用一个标识符或者占位符来标书未知的数据类型，然后再使用该类或者该接口的时候可以指定该位置类型的真实类型

​ 泛型可以用到接口、类、方法中，将数据类型作为参数传递，其实更像是一种数据类型的模板。

​ 如果不使用泛型的话，从容器中获取出来的元素，由于我们不知道类型，所以需要强制类型转换

6.2、自定义和使用泛型

定义泛型

​ 我们可以使用一个标识符，比如T（Type）在类中表示一种未知的数据类型

//在类上声明使用符号T,表示未知的类型
public class Point<T> {
	private T x;
	private T y;
  //省略getter/setter
}

使用泛型

​ 一般在创建对象时，给未知的类型设置一个具体的类型，当没有指定泛型时，默认类型为Object类型。

//没有使用泛型，默认类型是Object
Point p1 = new Point();
Object x1 = p1.getX();
//使用String作为泛型类型
Point<String> p2 = new Point<String>();
String x2 = p2.getX();
//使用Integer作为泛型类型
Point<Integer> p3 = new Point<Integer>();
Integer x3 = p3.getX();

6.2、在集合中使用泛型

class ArrayList<E>{
	public boolean add(E e){ }
	public E get(int index){ }
}

此时的E也仅仅是一个占位符，我们知道这里仅仅只是一个元素，但是不知道是什么类型，E表示元素（Element）的类型，那么当使用容器时给出泛型就表示,该容器只能存储某种类型的数据。

//只能存储String类型的集合
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
//只能存储Integer类型的集合
List<Integer> list2 = new ArrayList<Integer>();
list2.add(11);
list2.add(22);

由于集合的前后两个类型必须相同，所以在JDK1.8之后就可以省略后面实例化对象的时候的泛型的书写

List<String> list1 = new ArrayList<String>();
// 可以简写为
List<String> list1 = new ArrayList<>();

注意

1. 泛型必须是引用类型，不能是基本数据类型

List<int> list = new ArrayList<int>();//编译错误

1. 泛型不存在继承的关系

List<Object> list = new ArrayList<String>(); //编译错误