算法
算法(Algorithm):
就是定义良好的计算过程,他取一个或一组的值为输入,并产生出一个或一组值作为输出。
简单来说算法就是一系列的计算步骤,用来将输入数据转化成输出结果。
相关java知识
1. 泛型 Generic
2. 自动装箱 autobox 和自动拆箱 autounbox
3. Object 的 equals 方法
4. Comparable 和 Comparator 接口
时间复杂度
大O渐进表示法
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中,只保留最高阶项。
3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。
最坏情况:任意输入规模的最大运行次数(上界)
在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)
要观察代码的思路而不只是代码,有些循环达到某个条件就会跳出去所以主要是看思路
例子:
// 计算func2的时间复杂度?
void func2(int N) {
int count = 0;
for (int k = 0; k < 2 * N ; k++) {
count++;
}
int M = 10;
while ((M--) > 0) {
count++;
}
System.out.println(count);
}
O(N)
void func3(int N, int M) {
int count = 0;
for (int k = 0; k < M; k++) {
count++;
}for (int k = 0; k < N ; k++) {
count++; }
System.out.println(count);
}
O(N+M)
void func4(int N) {
int count = 0;
for (int k = 0; k < 100; k++) {
count++; }
System.out.println(count);
}
O(1)
递归的时间复杂度
递归次数当前的不算,第二次进入才算。
每次递归执行次数主要取决于递归程序有没有循环代码
空间复杂度
主要看创建(不是必须的变量)有多少
void bubbleSort(int[] array) {
for (int end = array.length; end > 0; end--) {
boolean sorted = true;
for (int i = 1; i < end; i++) {
if (array[i - 1] > array[i]) {
Swap(array, i - 1, i);
sorted = false;
}
常数个不是必须的变量直接O(1)
int[] fibonacci(int n) {
long[] fibArray = new long[n + 1]; //创建了N+1个非必须变量
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n ; i++) {
fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
}return fibArray;
}
O(N)
递归的空间复杂度和时间复杂度一样
long factorial(int N) {
return N < 2 ? N : factorial(N-1)*N; }
递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间。空间复杂度为O(N)
泛型
引用数据类型有:类、接口、数组、包装类
泛型就是传参,参数可以是类型,不是一个确定的值。传类型的作用只是动态进行了强制类型转换并不是把T换成传参类型。
擦除机制
ublic class SimpleGeneric<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public static void main(String[] args) {
SimpleGeneric<String> gs = new SimpleGeneric<>();
gs.setT("hello");
String string = gs.getT();
}
}
擦除后
public class SimpleGeneric {
private Object t;
public Object getT() {
return t;
}
public void setT(Object t) {
this.t = t;
}
public static void main(String[] args) {
SimpleGeneric gs = new SimpleGeneric();
gs.setT("hello");
String string = (String)gs.getT();
}
}
比对了一下编译前后的代码我们会发现其中所有T的部分都会被置换为了Obejct。
同时,由于我们传入的类型参数是String,所以在取值时,编译器为我们动态添加了(String)的强制转换
不管怎么样擦除后泛型T换成Object与传参类型无关
由于类型出现了参数,因此我们会发现,
在泛型类中,我们只能通过T来调用一些Object拥有的方法,
我们无法通过泛型类型去获取任何有关类型参数的信息。
我们在使用泛型时完全可以将泛型类中的泛型参数当作Object使用
class FruitContainer<T extends Fruit>{
private T t;
public void setFruit(T t){
this.t = t;
t.f();
}
public T getFruit(){
return t;
}
}
擦除后
class FruitContainer{
private Fruit t;
public void setFruit(Fruit t){
this.t = t;
t.f();
}
public Fruit getFruit(){
return t;
}
}
通过上面的编译前后的对比,我们可以这么认为,擦除就会将类型参数在编译时擦除为对应的边界
泛型作用
实现一个类,类中包含一个数组成员,使得数组中可以存放任何类型的数据,
也可以根据成员方法返回数组中某个下标的值
class MyArray {
public Object[] array = new Object[10];
public Object getPos(int pos) {
return this.array[pos];
}
public void setVal(int pos,int val) {
this.array[pos] = val;
}
}
public class TestDemo {
public static void main(String[] args) {
MyArray myArray = new MyArray();
myArray.setVal(0,10);
myArray.setVal(1,"hello");//字符串也可以存放 String ret = myArray.getPos(1);//编译报错 System.out.println(ret);
}
}
任何类型数据都可以存放
1号下标本身就是字符串,但是确编译报错。必须进行强制类型转换
虽然在这种情况下,当前数组任何数据都可以存放,但是,更多情况下,
我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。
所以,泛型的主要目的:就是指定当前的容器,要持有什么类型的对象。
让编译器去做检查。此时,就需要把类型,作为参数传递。需要什么类型,就传入什么类型。
语法
泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
在写泛型数组时尽量用这个方法
不能实例化泛型类型类数组
可能会造出编译错误,所以尽量使用上面这个方法
class MyArray<T> {
public T[] array = (T[]) new Object[10];
public T getPos(int pos) {
return this.array[pos];
}
public void setVal(int pos, T val) {
this.array[pos] = val;
}
public T[] getArray() {
return array;
}
}
public class Main {
public static void main(String[] args) {
MyArray<Integer> myArray1 = new MyArray<>();
Integer[] strings = myArray1.getArray();//错误 不安全
}
}
/*Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer; at TestDemo.main(TestDemo.java:31)
*/
数组和泛型之间的一个重要区别是它们如何强制执行类型检查。
具体来说,数组在运行时存储和检查类型信息。然而,泛型在编译时检查类型错误。
通俗讲就是:返回的Object数组里面,可能存放的是任何的数据类型,
可能是String,可能是Person,运行的时候,直接转给Intefer类型的数组,编译器认为是不安全的
泛型的上界
继承了Object类E就可以调用Object方法,继承了这个接口就能实现这个接口
我们发现在FruitContainer类中声明了<T extends Fruit>,这表示我们传入的参数类型必须继承自Fruit或者Fruit本身,
也就是说,FruitContainer<T extends Fruit>中不关持有的是什么类型,它都必然是Fruit的子类或者Fruit本身,
因此,这个类也必然可以安全的向上转型为Fruit,也就是说,我们完全可以通过T来调用属于Fruit的方法
在定义泛型类时,有时需要对传入的类型变量做一定的约束,可以通过类型边界来约束。
class 泛型类名称<类型形参 extends 类型边界> {
...
}
MyArray<Integer> l1;
// 正常,因为 Integer 是 Number 的子类型 MyArray<String> l2;
// 编译错误,因为 String 不是 Number 的子类型
<>里面的只是虚拟的,泛型编译时用来检查数组内部是不是<>里面的类型
实际上T都换成泛型的上界
接口如果有<T> 或抽象方法有T时,就把T换成你要使用的类,因为类也是引用数据类型可以存放在<>里面。
通配符
通配符可以接收任何<>里面的类型数据
通配符默认继承object
通用符的上界
通用符的下界
引用类型的==
如果数值在[-128, 127]之间,就会从缓冲池中取出对象。
毫无以为,对于对象而言,==其实比较的是地址值。
由于num1~num4都在[-128, 127]范围内,所以从缓存中取,只要值相同,对象就相同,所以两者相等。
而当数值超出[-128, 127]之外,就会new Integer(i),此时就会分别new一个对象,自然地址值不同。