Java 进阶
Java进阶
1. 数组
1.1 数组的创建
注意：new是在堆中创建一个数组或者在堆中分配一块连续的存储空间，把这块空间的引用赋值给数组名
还有需要注意的是，数组定义了之后，系统会给数组默认初始化
类型[] 标识符 = new 类型[容量];
// 数组是引用数据类型，引用数据类型还有：接口，类，枚举，注解
1.2 数组的访问
注意的是：下标索引都是从0开始，且没有-1，需要注意
1.2.1 for遍历
可以通过for循环遍历得到下标获取数组内的所有值
for (int i = 0;i < 数组.length;i++){
System.out.println(数组[i]);
}
1.2.2 foreach遍历
可以使用这种遍历方法，来之前获取数组的元素，不通过下标
for (类型 元素:数组) {
System.out.println(元素);
}
1.3 数组扩容
数组的扩容，其本质是将创建一个新的数组，扩大其容量，在将所有值copy到新数组后，在重新使用新数组引用旧数组，以此来扩大旧数组容量
int old = {1};
int new = new int[old.length * 100];
System.arraycopy(old,0,new,0,old.length)
old = new;
/*
1. 优点
通过索引值可以计算出每个数组元素的地址，通过地址直接访问效率高
2. 缺点
向数组中插入/插入元素时，可以需要扩容,复制/移动大量的元素,效率低
*/
// 因此数组一般用于存储基础数据，以访问为主，很少做插入/删除操作
1.4 对象数组
如果数组存放的引用数据类型的对象，就叫对象数组
1.5 随机
Math.random() // 随机0-1的随机小数
以此得到：
1. 随机任意范围double Math.random()*系数
2. 随机任意范围int (int)(Math.random()*系数)
3. 随机字母 (char)(Math.random*26)+97 // 注97位码值，65为大写，97为小写
1.6 可变参数
在参数中编写 数据类型 ... 标识符，就是可变参数，类似未知参数，可以传递任意个(这里主要用...表示可变)
2. 算法
2.1 冒泡算法
即：从前到后里俩俩比较，如果前面的数大于后面的数就交换，也就是把大的数交换到后面
package classdemo.classdemo02;
import java.util.Scanner;
/**
* @Author Q9.Gnilu0
* @Date 2022/9/27
* @Time 11:51
*/
public class Class205 {
public static void main(String[] args) {
int[] ints = {10, 20, 30, 66, 5, 15, 15, 10, 15};
Scanner input = new Scanner(System.in);
int idx = input.nextInt();
int s1 = 0;
for (int i = 0; i < idx; i++) {
s1 += ints[i];
}
int s2 = 0;
for (int i = idx + 1; i < ints.length; i++) {
s2 += ints[i];
}
if (s1 != s2) {
System.out.println(-1);
}else{
System.out.println(1);
}
}
}
2.2 选择算法
从当前元素中选择最小的交换到前面，在剩余的元素中选择最小的交换到前面
package classdemo.classdemo02;
/**
* @Author Q9.Gnilu0
* @Date 2022/9/27
* @Time 14:12
*/
public class Class206 {
public static void main(String[] args) {
int[] ints = {1, 435, 123, 87, 12, 45};
for (int x = 0; x < ints.length - 1; x++) {
int min = x;
for (int i = min + 1; i < ints.length; i++) {
if (ints[i] < ints[min]) {
min = i;
}
}
if (x != min) {
int t = ints[x];
ints[x] = ints[min];
ints[min] = t;
}
}
for (int num : ints) {
System.out.println(num);
}
}
}
2.3 二分查找
对半查找，通过中间元素比较，缩小范围，但是前提是已经实现了从小到大的排序
package classdemo.classdemo02;
import java.util.Scanner;
/**
* @Author Q9.Gnilu0
* @Date 2022/9/27
* @Time 14:34
*/
public class Class207 {
public static void main(String[] args) {
int[] ints = {11,22,33,44,55,66,77,88,99};
// System.out.println(binarySearch(ints, 55));
// System.out.println(binarySearch(ints, 66));
// System.out.println(binarySearch(ints, 77));
// System.out.println(binarySearch(ints, 88));
System.out.println(binarySearch(ints, 99));
}
private static int binarySearch(int[] ints, int num) {
int begin = 0;
int end = ints.length -1;
int mid = (begin + end) / 2;
while (begin <= end) {
if (num == ints[mid]) {return mid;}
if (num < ints[mid]){
end = mid-1;
}else{
begin = mid + 1;
}
mid = (begin + end) / 2;
}
return -1;
}
}
3.Arrays类
3.1 toString方法
使用这个类的toString方法，可以直接打印出数组的内容
3.2 copyOf
复制指定索引范围内数组内容
3.3 sort
从小到大排序，底层会根据数据大小的容量，自动调用不同算法
4. Comparable接口
大于返回1，小于返回-1，等于返回0 (升序)
大于返回-1，小于返回1，等于返回0 (降序)
// 这里解释一下，这个接口是对对象数组排序功能的一个封装，通过重写这个接口，得到返回值，可以使用sort对对象数组进行排序
package classdemo.classdemo02;
import java.util.Arrays;
/**
* @Author Q9.Gnilu0
* @Date 2022/9/26
* @Time 15:22
*/
public class Class209 {
public static void main(String[] args) {
Person[] data = new Person[50];
int size = 0;
data[size++] = new Person("simaer", 2123);
data[size++] = new Person("zhangsan", 56);
data[size++] = new Person("lisi", 123);
data[size++] = new Person("wangwu", 879);
data[size++] = new Person("gonsuiliu", 123);
data[size++] = new Person("caoba", 67);
data[size++] = new Person("zhuchongjiu", 23);
// for (Person datum : data) {
// System.out.println(datum);
// }
// for (Person datum : data) {
// System.out.println(datum.name);
// }
// for (int i = 0; i < size; i++) {
// System.out.println(data[i].name);
// }
// Arrays.sort(data);
// Modify the collation rules and call sort to sort objects automatically
Arrays.sort(data, 0, size);
for (int i = 0; i < size; i++) {
System.out.println(data[i]);
}
// for (int i = 0; i < size; i++) {
// if (data[i].name.equals("wangwu")) {
// System.out.println(data[i].name);
// }
// }
}
static class Person implements Comparable<Person> {
String name;
int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if (this.age > o.age) {
return 1;
} else if (this.age < o.age) {
return -1;
}
return 0;
}
}
}
5. 二维数组
顾名思义，就是嵌套的数组而已
// 语法格式：数据类型[] [] 数组名 = new 数据类型[二维长度][一维长度];
package classdemo.classdemo02;
/**
* @Author Q9.Gnilu0
* @Date 2022/9/27
* @Time 17:16
*/
public class Class210 {
public static void main(String[] args) {
// int[] nums = new int[110];
int[] nums = {1,2,3};
int[] nums1 = {4,5,6};
int[][] a = {nums, nums1};
for (int[] ints : a) {
for (int anInt : ints) {
System.out.println(anInt);
}
}
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j]);
}
}
}
}
6. String类
6.1 charAt
返回字符串中inden位置的字符
6.2 compareTo
比较当前字符串与参数字符串的大小
6.3 concat
在当前字符串后面连接str
6.4 getBytes
返回当前字符串在默认编码下对应的字节数组
6.5 indexOf
返回str在当前字符串中第一次出现的索引值
6.6 split
使用regex对当前字符串拆分，拆分后的字符串组成一个数组
6.7 toCharArray
把字符串转换为字符数组
6.8 toLowerCase
小写
6.9 toUpperCase
大写
6.10 trim
去掉字符串左右俩侧的空白符
6.11 valueOf
把其他类型的数据转换为字符串
7. StringBuilder类
7.1 增删改查
append
delete
insert
replace // 替换
8. 数学相关类
8.1 Math
random // 随机
8.2 Random
// 和上面不同，是专门生成随机数的
Random rd = new Random();
rd.nextInt(); // 随机整数
8.3 DecimalFormat
// 对数字格式化
DecimalFormat df = new DecimalFormat("###,###.000");
String s = df.format(1234.56); // 数字转为字符串
8.4 java.math
BigInteger // 大的整数
BigDecimal // 大的小数
浙公网安备 33010602011771号