目录

一、工具类

1.1、工具类的设计

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

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

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

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

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

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

1.1.1、公共静态方法

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

ArraysUtils类

  1. public void ArraysUtils{
  2.     //1. 先私有化构造器，防止被实例化对象
  3.     private ArraysUtils(){
  5.     }
  7.     //2.写工具方法
  8.     public static void sort(){
  9.         System.out.println("我是排序方法")
  10.     }
  11.      public static void print(){
  12.         System.out.println("我是打印方法方法")
  13.     }
  15. }

TsstDemo类

  1. public class TsstDemo{
  2.     public static void main(String[] args){
  3.         ArraysUtils.sort()
  4.     }
  5. }

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

1.2、单例模式

设计模式（Design pattern）

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

单例设计模式（singleton）

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

目的

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

步骤（以饿汉式为例）

  1. 私有化自身构造器，防止外界通过构造器实例化出对象
  2. 在该类中，自己先创建出一个对象
  3. 向外暴露一个公共的静态方法用于返回自身的对象
  1. public class SingletonUtil{
  3.     // 1. 先私有化构造器，防止被实例化对象
  4.     private SingletonUtil(){
  6.     }
  8.     //2. 自己创建出一个对象
  9.     private static SingletonUtil instance = new SingletonUtil();
  11.     //3. 暴露给外界调用方法，返回创建好的对象
  12.     public static SingletonUtil getInstance(){
  13.         return instance;
  14.     }
  16.     public void sort() {
  17. 		System.out.println("排序操作");
  18. 	}
  19. 	public void binarySearch() {
  20. 		System.out.println("二分查找操作");
  21. 	}
  23. }

调用方法：

  1. 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

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

2.1.1.2、int >> Integer

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

2.1.1.3、Integer >>String

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

2.1.1.4、String >> Integer

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

2.1.1.5、String >> int

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

2.1.1.6、int >> String

  1. String str = Integer.toString(134);

2.2、拆箱和装箱

2.2.1、装箱

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

  1. 	Integer num2 = Integer.valueOf(17);

2.2.2、拆箱

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

  1. 	int val = num3.intValue();

2.2.3、自动拆箱和装箱

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

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

2.3、缓存设计

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

常用包装类型的缓存范围

  • Byte、Short、Integer、Long：缓存范围[-128，127]
  • Character：缓存范围[0，127]
  1. //第一种
  2. Integer i1 = new Integer(123);
  3. Integer i2 = new Integer(123);
  4. System.out.println(i1 == i2);// false，因为都在堆中new了一个新的对象
  6. //第二种
  7. Integer i3 = Integer.valueOf(123);
  8. Integer i4 = Integer.valueOf(123);
  9. System.out.println(i3 == i4);// true，由于在[-128,127]之间，所以直接在缓存中取，都是同一个对象
  11. //第三种
  12. Integer i5 = 123; // 底层等价于第二种
  13. Integer i6 = 123;
  14. 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不能直接把赋值和运算操作，只能通过构造器传递数据，而且必须使用字符串类型的构造器

  1.     System.out.println(0.09 + 0.01);

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

![image-20201210192733401](D:\学习笔记\Java SE\Java常用类\Java常用类.assets\image-20201210192733401.png)

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

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

![image-20201210192926108](D:\学习笔记\Java SE\Java常用类\Java常用类.assets\image-20201210192926108.png)

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

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

![image-20201210193044032](D:\学习笔记\Java SE\Java常用类\Java常用类.assets\image-20201210193044032.png)

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

2.4.2、精度控制

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

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

2.4.3、无理数问题

  1.    	/*
  2.    	 java.lang.ArithmeticException
  3.   	 Non-terminating decimal expansion; no exact representable decimal result.
  4.   	 报错原因:除不尽(3.333333333...333...)
  5.    	*/
  6. 	BigDecimal num1 = new BigDecimal("10.0");
  7.     BigDecimal num2 = new BigDecimal("3.0");
  8.     BigDecimal r2 = num1.divide(num2,3,RoundingMode.HALF_UP);
  9.     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对象创建完毕之后，该对象的内容是不能改变的，一旦

内容改变就变成了一个新的对象

  1. String str = "hello";
  2. str = str + "word";

3.1.2、String对象的空值问题

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

3.1.3、字符串常用方法

3.1.3.1、==

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

3.1.3.2、equals

== 比较的是值是否相等

3.1.3.3、字符串查找

contains

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

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

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

endsWith/startsWith

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

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

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

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

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

indexOf

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

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

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

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

3.1.3.4、字符串的替换

replace

  1.   String str1 = "helloworld123";
  2.   // 替换给定字符
  3.   String newStr1 = str1.replace("h", "H");
  4.   System.out.println(newStr1);
  5.  
  6.   // 替换给定字符串
  7.   // String newStr2 = str1.replace("hello", "HELLO");
  8.   String newStr2 = str1.replace("hello", "");
  9.   System.out.println(newStr2);

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

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

3.1.3.5、 字符串分割

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

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

3.1.3.6、求子串

substring

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

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

3.1.3.7、获取指定位置的字符

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

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

3.1.3.8、字符串连接

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

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

3.1.3.9、字符串长度

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

3.1.3.10、判断字符串是否为空

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

3.1.3.11、大小写转换

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

3.1.3.12、去除空格

  1.   	String str = "  hello  ";
  2.     System.out.println(str.length());
  3.     String trim = str.trim();
  4.     System.out.println(trim.length());

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

3.1.3.13、判断字符串非空

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

3.2、StringBuilder/StringBuffer

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

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

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

开发中建议使用StringBuilder

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

3.2.1、字符串拼接

语法格式

  1. append(String str)/append(Char c)

示范

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

优势

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

3.2.2、替换

语法格式

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

示范

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

注意

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

3.2.3、插入

语法格式

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

示范

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

注意

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

3.2.4、删除

语法格式

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

示范

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

注意

delete方法也是含头不含尾

四、常用类

4.1、Math

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

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

4.2、Random

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

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

4.3、UUID

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

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

4.4、日期类

4.4.1、Date类

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

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

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

![image-20201211164602282](D:\学习笔记\Java SE\Java常用类\Java常用类.assets\image-20201211164602282.png)

4.4.2、SimpleDateFormat

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

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

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

举例：

  1. yyyy-MM-dd							如2020-12-12
  2. HH:mm:ss							如20：12：12
  3. yyyy-MM-dd HH:mm:ss					如2020-12-12 20：12：12
  4. yyyy/MM/dd HH:mm:ss					如2020/12/12 20：12：12
  5. yyyy年MM月dd日 HH时mm分ss秒	如2020年12月12日 20时12分12秒

格式化和解析的示范：

  1. package day11_CommonUtils2.test.Math;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Random;
  7. import java.util.UUID;
  9. /**
  10.  * @author Xiao_Lin
  11.  * @version 1.0
  12.  * @date 2020/12/11 15:21
  13.  */
  14. public class TestMath {
  16.   public static void main(String[] args) throws ParseException {
  18.     /*
  19.     格式化
  20.      */
  21.     //新建一个日期类
  22.     Date date = new Date();
  23.     //设置一个格式
  24.     String paaaern = "yyyy-MM-dd HH:mm:ss";
  25.     //将设置的格式传到simpleDateFormat中
  26.     SimpleDateFormat simpleDateFormat = new SimpleDateFormat(paaaern);
  27.     //simpleDateFormat对传进来的日子进行格式化
  28.     String format = simpleDateFormat.format(date);
  29.     //输出格式化信息
  30.     System.out.println(format);
  32.     /*
  33.     解析
  34.      */
  35.     //将字符串信息传到simpleDateFormat.parse方法中进行解析，返回一个Date对象
  36.     Date d = simpleDateFormat.parse("2020-12-11 16:53:48");、
  37.     //输出Date信息
  38.     System.out.println(d);
  40.   }
  41. }

4.4.3、Calendar

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

  1. public class CalendarDemo1 {
  2. 	public static void main(String[] args) throws Exception {
  3. 		Calendar c = Calendar.getInstance();
  4. 		int year = c.get(Calendar.YEAR);
  5. 		int month = c.get(Calendar.MONTH) + 1;
  6. 		int date = c.get(Calendar.DAY_OF_MONTH);
  7. 		int hour = c.get(Calendar.HOUR_OF_DAY);
  8. 		int minute = c.get(Calendar.MINUTE);
  9. 		int second = c.get(Calendar.SECOND);
  11. 		System.out.println(year);//2018
  12. 		System.out.println(month);//5
  13. 		System.out.println(date);//17
  14. 		System.out.println(hour);//15
  15. 		System.out.println(minute);//1
  16. 		System.out.println(second);//38
  17. 		c.add(Calendar.YEAR, 100);//在当前年份上增加100
  18. 		System.out.println(c.get(Calendar.YEAR));//2118
  19. 	}
  20. }

4.5、正则表达式

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

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

​ 常用的规则如下：

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

五、数组高级

5.1、冒泡排序法

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

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

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

5.2、选择排序

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

  1. 实现思路：
  2. 	(1)、控制选择几轮：数组长度-1
  3. 	(2)、控制每轮从当前位置开始比较几次
  4. i(轮数)              次数           每轮比较几次
  5.   0                  3             数组长度-i-1
  6.   1                  2             数组长度-i-1
  7.   2                  1             数组长度-i-1
  1. package com.test;
  2. import java.util.Arrays;
  3. import java.util.Random;
  5. /**
  6.  * @author Xiao_Lin
  7.  * @date 2020/12/25 11:31
  8.  */
  9. public class SelectSort {
  10.   public static void main(String[] args) {
  11.    //定义一个数组
  12.         int[] arr = {7, 6, 5, 4, 3};
  13.         System.out.println("排序前：" + Arrays.toString(arr));
  14.   		// 定义一个控制循环几轮
  15.         for (int x = 0; x < arr.length; x++) {
  16.             // 定义一个循环控制每轮比较几次，一定是以当前位置与后面的元素进行比较，遍历后面的元素
  17.             // i=0  j=1 2 3
  18.             // i=1  j=2 3
  19.             // i=2  j=3
  20.             for (int i = x+1; i < arr.length; i++) {
  21.                 //拿当前的位置与指定的元素进行大小比较，后面的较小就交换位置
  22.                 if (arr[x] > arr[i]) {
  23.                     int temp = arr[x];
  24.                     arr[x] = arr[i];
  25.                     arr[i] = temp;
  26.                 }
  27.             }
  28.         }
  29.         System.out.println("排序后：" + Arrays.toString(arr));
  30.   }
  31. }

5.3、二分查找法

查找数组元素的语法：

  • 线性查找：从头到尾查找，性能很低
  • 二分查找法（折半查找）：前提是数组元素必须有序，性能比较好
  1. package day012_ArraysAdvanced.classing;
  3. /**
  4.  * @author Xiao_Lin
  5.  * @version 1.0
  6.  * @date 2020/12/14 18:39
  7.  */
  8. public class Find {
  10.   /**
  11.    * 二分查找的方法
  12.    * @param nums 需要查找的元素所在的数组
  13.    * @param value 需要查找的元素
  14.    * @return
  15.    */
  16.   public static int binarySearch(int[] nums , int value){//定义一个二分查找的方法
  17.     int low = 0;//定义最低的位置，默认值为0
  18.     int hight = nums.length-1;//定义最高的位置，默认值为数组的最后一位
  19.     int mid , midValue; //定义中间的变量值和序号
  20.     while (low <= hight){//如果最低位小于等于最高位，说明我们查找的元素还在数组织中，否则说明数组中没有该元素，返回-1
  21.       mid = (low+hight)/2;//计算出中间位
  22.       midValue = nums[mid];//取出中间位置的值
  23.       if (value > midValue){//如果需要寻找的变量在中间值的右边
  24.         low = mid+1;//将最低位移到中间位置后一位
  25.       }else if(value < midValue){//如果需要寻找的变量在中间值的左边
  26.         hight = mid-1;//将最高位移到中间位置的前一位
  27.       }else if(value == midValue){//如果中间的值和需要寻找的值相等，说明找到
  28.         return mid;//返回找到的序号
  29.       }
  30.     }
  31.     return -1;//返回-1说明找不到
  32.   }
  33.   public static void main(String[] args) {
  34.     int[] nums = {1,2,3,4,5,6};
  35.     System.out.println(binarySearch(nums, 30));
  37.   }
  38. }

5.3、操作数组的API-Arrays

5.3.1、打印数组元素

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

5.3.2、拷贝数组元素

​ Arrays 中提供了数组复制的方法，copyOf(int[] original, int newLength) 复制指定的数组，截取或者用0填充，他是直接创建一个新的数组，如果我们指定的数组元素长度不够就素截取，如果长度多余就是用0填充

System类中提供了数组元素拷贝的方法，并且支持任意类型的数组拷贝，而不仅仅是int类型数组。

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

5.3.3、数组元素的排序

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

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

5.3.4、数组的二分查找

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

5.4、数组的增删改查操作

5.4.1、数组初始化操作

  1. package day012_ArraysAdvanced.classing.ArraysCRUD;
  3. /**
  4.  * @author Xiao_Lin
  5.  * @version 1.0
  6.  * @date 2020/12/14 19:17
  7.  */
  8. public class ArraysUtils {
  9.   private Integer[] nums = null;  //声明一个数组
  10.   private int size;//声明数组中元素的个数，不是数组长度
  12.   public  ArraysUtils(int capacity){//构造方法,用于初始化
  13.     if (capacity < 0){//如果传进来的容量值<0,说明这个容量值是不合法的
  14.       System.out.println("数组的容量不可以小于0");
  15.       return;
  16.     }else {
  17.       this.nums = new Integer[capacity];//将传进来的容量值进行初始化一个新的数组
  18.     }
  19.   }
  21.   public   ArraysUtils(){//无参构造器
  22.     this(10);//调用有参构造器,并且传入一个初始化的值
  23.   }
  25.   public Integer[] getNums() {
  26.     return nums;
  27.   }
  29.   public void setNums(Integer[] nums) {
  30.     this.nums = nums;
  31.   }
  33.   public int getSize() {
  34.     return size;
  35.   }
  37.   public void setSize(int size) {
  38.     this.size = size;
  39.   }
  40. }

测试类:

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

5.4.2、数组的修改

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

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

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

5.4.4、数组的打印

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

5.4.5、数组的追加

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

5.4.5、数组的扩容

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

扩容的原理是：

  1. 创建一个原数组长度两倍长的新数组
  2. 把旧数组中的所有元素拷贝到新数组中
  3. 把新数组的引用赋给旧数组变量
  1.  public ArraysUtils append(int num){
  2.   if (size == nums.length){//如果数组中的元素个数等于数组的长度,说明这个时候需要扩容
  3.     this.nums = Arrays.copyOf(nums,nums.length*2+2);//将copyOf产生的新数组赋值给原来的数组,并且将长度扩大到原来的2倍+2个元素
  4.   }
  5.   this.nums[size] = num;
  6.   size++;
  7.   return this;
  8.  }

5.4.6、数组的删除

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

六、泛型

6.1、泛型的概述

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

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

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

6.2、自定义和使用泛型

定义泛型

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

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

使用泛型

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

  1. //没有使用泛型，默认类型是Object
  2. Point p1 = new Point();
  3. Object x1 = p1.getX();
  4. //使用String作为泛型类型
  5. Point<String> p2 = new Point<String>();
  6. String x2 = p2.getX();
  7. //使用Integer作为泛型类型
  8. Point<Integer> p3 = new Point<Integer>();
  9. Integer x3 = p3.getX();

6.2、在集合中使用泛型

  1. class ArrayList<E>{
  2. 	public boolean add(E e){ }
  3. 	public E get(int index){ }
  4. }

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

  1. //只能存储String类型的集合
  2. List<String> list1 = new ArrayList<String>();
  3. list1.add("A");
  4. list1.add("B");
  5. //只能存储Integer类型的集合
  6. List<Integer> list2 = new ArrayList<Integer>();
  7. list2.add(11);
  8. list2.add(22);

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

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

注意

  1. 泛型必须是引用类型，不能是基本数据类型
  1. List<int> list = new ArrayList<int>();//编译错误
  1. 泛型不存在继承的关系
  1. List<Object> list = new ArrayList<String>(); //编译错误

Java基础常用类深度解析（包含常见排序算法）的更多相关文章

  1. Java基础语法(8)-数组中的常见排序算法

    title: Java基础语法(8)-数组中的常见排序算法 blog: CSDN data: Java学习路线及视频 1.基本概念 排序: 是计算机程序设计中的一项重要操作,其功能是指一个数据元素集合 ...

  2. Java 8 Optional 类深度解析

    Java 8 Optional 类深度解析 身为一名Java程序员,大家可能都有这样的经历:调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法.我们首先要判断这个返回值是否为null,只 ...

  3. java基础---常用类

    一.字符串类String String:字符串,使用一对""引起来表示,字符串常量池在方法区中 public final class String implements java. ...

  4. JAVA基础--常用类 String,StringBuffer, 基础数据类型包装类, Math类, Enum类

    字符串相关类: String, StringBuffer String类为不可变的字符序列 String s1="hello"; String s2="hello&quo ...

  5. JAVA 基础编程练习题28 【程序 28 排序算法】

    28 [程序 28 排序算法] 题目:对 10 个数进行排序 程序分析:可以利用选择法,即从后 9 个比较过程中,选择一个最小的与第一个元素交换, 下次类推,即 用第二个元素与后 8 个进行比较,并进 ...

  6. Java基础——常用类之日期时间类

    如果有机会,请尝试Java8中全新的时间日期API!(参见Java8新特性随笔) 如果还是使用Java7及之前的版本,那么你可以尝试一些工具类(参考使用工具类相关的Hutool-DateUtil) 如 ...

  7. Java基础——常用类(Date、File)以及包装类

    本文要点: 基本数据类型的包装类 字符串相关类: 不可变字符序列:String 可变字符序列:StringBuffer.StringBuilder 时间处理相关类: Date DateFormat.S ...

  8. Java基础(三) String深度解析

    String可以说是Java中使用最多最频繁.最特殊的类,因为同时也是字面常量,而字面常量包括基本类型.String类型.空类型. 一. String的使用 1. String的不可变性 /** * ...

  9. Java 8 Optional类深度解析

    身为一名Java程序员,大家可能都有这样的经历:调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法.我们首先要判断这个返回值是否为null,只有在非空的前提下才能将其作为其他方法的参数. ...

随机推荐

  1. 更改EFI分区位置

    我是win10 + arch 双系统,并且efi分区用的是win10自动创建的(大小100m),所以这些空间很快就不够用了(内核和initramfs都放在了ESP分区当中) 我原本是直接把win的ef ...

  2. ElasticSearch学习笔记（超详细）

    文章目录 初识ElasticSearch 什么是ElasticSearch ElasticSearch特点 ElasticSearch用途 ElasticSearch底层实现 ElasticSearc ...

  3. Arrays.Sort()中的那些排序算法

    本文基于JDK 1.8.0_211撰写,基于java.util.Arrays.sort()方法浅谈目前Java所用到的排序算法,仅个人见解和笔记,若有问题欢迎指证,着重介绍其中的TimSort排序,其 ...

  4. 开发过程中遇到的js知识点总结，面试题等，持续更新

     1.Object.freeze() 方法用于冻结一个对象,即将对象设置为不可扩展.将对象的所有自有的属性和方法(包括Symbol值的属性和方法)配置为不可配置,不可写. Object.freeze( ...

  5. C#连接Excel读取与写入数据库SQL （ 上 ）

    第一次写C#与sql的东西,主要任务是从Excel读取数据,再存到SQL server中. 先上读取Excel文件的code如下. public bool GetFiles(string equipN ...

  6. 使用python模块plotdigitizer抠取论文图片中的数据

    技术背景 对于各行各业的研究人员来说,经常会面临这样的一个问题:有一篇不错的文章里面有很好的数据,但是这个数据在文章中仅以图片的形式出现.而假如我们希望可以从该图片中提取出数据,这样就可以用我们自己的 ...

  7. PHP中一些常用的安全类函数

      (1) htmlspecialchars() 表单验证(验证表单中的数据是否为空以及提交的数据是否合法) htmlspecialchars() //该函数将预定义的字符转化为html实体,预定义的 ...

  8. CVE-2020-1938 -Tomcat-AJP任意文件读取/包含

    为什么这个漏洞被称作 Ghostcat(幽灵猫)? 这个漏洞影响全版本默认配置下的 Tomcat(在我们发现此漏洞的时候,确认其影响 Tomcat 9/8/7/6 全版本,而年代过于久远的更早的版本未 ...

  9. zxy的猪错误

    我觉得这篇文章还是要重构啊,如果哪道题调的久了就标上日期放上来吧. 2021/3/10 题目:玩游戏 \(\tt memset\) 不能直接清空一个指针指向的数组,因为不知道 \(\tt size\) ...

  10. java 集合 的理解

    1.对象的存储:①数组(基本数据类型 & 引用数据类型) ②集合(引用数据类型) >数组存储数据的弊端:长度一旦初始化以后,就不可变:真正给数组元素赋值的个数没有现成的方法可用. 2.集 ...