JAVA基础笔记

最新推荐文章于 2023-12-30 22:08:53 发布

超喜欢榴莲吖

最新推荐文章于 2023-12-30 22:08:53 发布

阅读量161

点赞数 1

分类专栏： JAVA学习 # JAVA基础内容

本文链接：https://blog.csdn.net/cherry_ff/article/details/107632526

版权

JAVA学习同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

JAVA基础内容

2 篇文章 0 订阅

订阅专栏

一个很好的专栏：清浅池塘。就其中的学习到的JAVA零碎知识点做一个记录。

1. == 和 equals 的区别

$= =$ ：当 $= =$ 两边是基本数据类型时，比较的是两边的两个值是否相等，当 $= =$ 两边是引用类型时比较的是两个内存地址，也可以看成是看这两个引用是否指向堆内存里的同一块地址（结合第三点JAVA数据类型使用）

equals：数值型判断值是否相等，字符串会依次判断其中字符是否相等，因此在判断相等时要用equals（结合第六部分equals）

2. 反编译文件

学会查看反编译文件，可以看到java真实的处理。
例如：
在这里插入图片描述
反编译文件：

3. JAVA类型

4类8种基本类型
在这里插入图片描述
除掉这四类八种基本类型，其它的都是对象，也就是引用类型，包括数组。
不同的声明方式在内存中的展现：

下面举例说明不同类型的存储情况。

基本类型数据
方法体里声明的基本数据类型在栈内存里，对于基本数据类型来说，赋值（=号）就相当于拷贝了一份值，把int1的值100，拷贝给int2。int1=500，直接修改int1的值为500。
数组
先初始化arr1，当执行到new这个关键字，会在堆内存分配内存空间，并把该内存空间的地址赋值给arr1。
arr2初始化时并没有new关键字，并不会在堆内存里新开辟一块空间，而是把arr1里存的堆内存地址直接赋值给了arr2，对于引用类型来说，赋值（=号）就相当于拷贝了一份内存地址，也就是说arr1，arr2现在指向了同一块堆内存。
对象
new表示在堆内存里开辟了一块内存空间；
Person里有一个叫name的String对象，String这个对象有点特殊，虽然没有new这个关键字，但还是在堆内存中开辟了一块空间；
String底层是数组实现的，数组也是引用类型，age为基本数据类型

整个Person对象在堆内存中的体现如下：

没有new关键字，per2不会在堆内存中新开辟空间，和数组一样，也是把per1的内存地址直接赋值给了per2。

总结：
当 $= =$ 两边是基本数据类型时， $= =$ 于比较的是两边的两个值是否相等，当 $= =$ 两边是引用类型时比较的是两个内存地址，也可以看成是看这两个引用是否指向堆内存里的同一块地址，如下图

4. Java自动装箱/拆箱

Java装箱过程：加ValueOf()函数
在JDK1.5中，给这四类八种基本类型加入了包装类，对应如下：

第一类：整型

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long

第二类：浮点型

基本类型	包装类
float	Float
double	Double

第三类：逻辑型

基本类型	包装类
boolean	Boolean

第四类：字符型

基本类型	包装类
char	Character

将int的变量转换成Integer对象，这个过程叫做装箱。
用valueOf作为装箱方法。
反之将Integer对象转换成int类型值，这个过程叫做拆箱。
拆箱方法各自表述，一般是基本数据类型加上Value做为拆箱方法，如intValue，longValue，booleanValue。

以上这些装箱拆箱的方法是在编译成class文件时自动加上的，不需要程序员手工介入，因此又叫自动装箱/拆箱。

在这里插入图片描述
自动编译后：

自动装箱拆箱优点：查看原文吧

5. 面向对象

面向对象，是对现实世界的模拟，下图我们简单模拟了一个动物世界。
在这里插入图片描述

继承，这里Primat继承了Animal，Person继承了Primat。
封装。对于这种隐藏对象属性和实现细节，仅对外公开指定方法来控制程序中属性的访问和修改，我们称之为封装。（这儿我们没有对age提供set方法，压根没法修改，提供了一个printAge()方法供外部访问）。
person对象能访问到name、sex属性，eat()、printAge()方法，但无法访问age属性，isLady()方法。因为我们在该属性和方法前面加了private关键字，隐藏了不想对客户端暴露的age属性和isLady()方法（这里的客户端是main方法）。但是我们对客户端提供了一个printAge方法来打印年龄，但在打印年龄前，我们对年龄做了一系列处理（不打印女士年龄）。
多态。在代码中，不管是动物，鸟类，人类，猴子，我们都可以抽象成类，类是对象的模板，通过new关键字，可以创建一个个对象。仔细看蓝色框里的内容，animal1和animal2，虽然都是同一个形态（Animal），由于指向的是子类对象，当调用同一个eat()方法，运行时会智能匹配到子类的实现，最后得到的结果也不一样，这种形为，我们称之为多态。
多态满足三个条件：
一、要有继承；（Person继承了Animal，Monkey也继承了Animal）
二、要有重写；（都重写了父类的eat方法）
三、父类引用指向子类对象。（红框内容）

这里提到一个面向对象的技巧：比较两个对象是否相等，不应该由客户端来决定，而是由对象本身来决定。
例如在person对象判断是否相等时，首先不能用equals直接判断相等，因为两者都是new出来的新对象。而由于age属性是私有属性，无法直接对两个对象的所有属性值判断是否相等，为了不破坏封装，应该直接在类内定义判断方法。
在这里插入图片描述
但是这只是我们自己定义了对象判等的方法，对于java内部的判等，例如HashSet去重等，则需要重写equals方法。

6. equals方法

背景：
在这里插入图片描述
结果：

原因：

String重写了equals()方法，所以这儿打印size结果是1；
Person没有重写，因此Set没法判断这两个"张三"是否是同一个人，打印size结果是2。

解决方法：

重写Person的equals方法。
在这里插入图片描述
原因：
原来我们跟本就不是重写（覆盖）了父类的equals方法，而是自己又写了一个参数为Person的equals方法，根本不是重写，只是重载了父类的方法而已。

这里给出重写和重载的区别：

重载：就是在同一个类中，方法的名字相同，但参数个数、参数的类型不同。

重写：它是指子类和父类的关系，子类重写了父类的方法，但方法名、参数类型、参数个数必须相同

正确写法：
在这里插入图片描述
实验：

运行结果：

Person这个类在重写equals()方法后，虽然已经支持List，但还不支持Set。要完美支持HashMap,HashSet,LinkedHashMap,ConcurrentHashMap等这些类，不但要重写equals方法，还需要重写hashCode()方法。
在这里插入图片描述
运行结果：

总结：

当我们在实际业务中需要重写（覆盖）equals方法时，根据规范，我们一定要重写（覆盖）hashCode方法。在实际开发过程中，不建议一上来就重写equals方法，除非你有特殊的需求。例如，在本节一开始的示例中，person1,person2并不是同一个对象，默认equals方法是继承自Object的，也就相当于==，如果没有额外的需求明确name相同就视为同一个对象处理，就没有必要去重写equals方法了。

7. JAVA泛型

本小节参考链接

1. 泛型概述

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}
//结果：D/泛型测试: 类型相同

总结：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

2. 泛型使用

1）泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类基本类型：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

举例：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

定义的泛型类，就一定要传入泛型类型实参么？并不是这样。

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。

如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

Generic generic = new Generic("111111"); 
Generic generic1 = new Generic(4444); 
Generic generic2 = new Generic(55.55); Generic
generic3 = new Generic(false);

Log.d("泛型测试","key is " + generic.getKey()); //D/泛型测试: key is 111111
Log.d("泛型测试","key is " +generic1.getKey()); //D/泛型测试: key is 4444
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());

2）泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当实现泛型接口的类，未传入泛型实参时：

与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
即：class FruitGenerator<T> implements Generator<T>
如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错：“Unknown class”

class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

当实现泛型接口的类，传入泛型实参时：

定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>，但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型，即：Generator<T>，public T next()中的的T都要替换成传入的String类型。

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3）泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；
泛型方法，是在调用方法的时候指明泛型的具体类型。

3.1 泛型方法说明：

1）public 与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

Object obj = genericMethod(Class.forName("com.test.test"));

3.2 泛型方法基本用法

仔细阅读代码中的注释

public class GenericTest {
    //这个类是个泛型类，在上面已经介绍过
    public class Generic<T>{
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        /*虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        所以在这个方法中才可以继续使用 T 这个泛型。*/
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
         public E setKey(E key){
            this.key = keu
         }
         */
    }

    /**
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这不是一个泛型方法，就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        System.out.println("泛型测试"+"key value is " + obj.getKey());
    }

    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        System.out.println("泛型测试"+"key value is " + obj.getKey());
    }

    /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
     public <T> T showKeyName(Generic<E> container){
        ...
     }
     */

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
     public void showkey(T genericObj){
        ...
     }
     */

    public static void main(String[] args) {
        
    }
}

3.3 类中的泛型方法

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

3.4 泛型方法与可变参数

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}

printMsg("111",222,"aaaa","2323.4",55.55);

3.5 静态方法与泛型

静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

3.6 泛型方法总结

泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：

无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。

3. 泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
泛型的上下边界添加，必须与泛型的声明在一起。

例一：泛型类

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型。

public void showKeyValue1(Generic<? extends Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

若修改泛型类：

public class Generic<T extends Number>{
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}

//这一行代码也会报错，因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

例二：泛型方法

在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下边界，即在泛型声明的时候添加。

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

8. JAVA线性表

在这里插入图片描述
红框里的内容就是线性表的大家族了，其中黄色部分是要重点了解的，线性表里的元素是按线性排列的（这里的线性指逻辑上的）线性表分为两大类，分别是顺序表和链表。

1. 顺序表

在这里插入图片描述
ArrayList底层是数组实现的，底层元素在内存中是按顺序排列的，ArrayList是Java中顺序表的体现。

2. 链表

单向链表
双向链表
循环链表

LinkedList实现原理是双向链表。

3. 栈和队列

栈
队列

Queue是基于链表来体现的。注意，Queue是一个接口，直接写如下代码是会报错的：
Queue queue = new Queue();//会报错，Queue是接口，不允许实例化
队列的链表实现是通过子类LinkedList来实现的，Queue接口收窄了LinkedList的访问权限，只提供从队尾，队头等的操作。
Queue queue = new LinkedList();// 正确的用法，基于链表来实现

9. ArrayList

1. ArrayList初始化

链接

在这里插入图片描述
构造函数：

最终内存表示：

2. ArrayList扩容

对于1中情况，则需要对原先长度为10的数组扩容。
在这里插入图片描述

如果直接初始化时指定ArrayList长度：

3. ArrayList删除

在这里插入图片描述

通过指定index删除的方式：

通过指定对象删除的方式：

因此，在上面给出的示例中，无法删除“孙7”这个元素，因为是直接new出来的，采用equals判等时，是不同的引用。

解决方法：
重写equals方法：
在这里插入图片描述
删除后结果：

图中的“孙七”，“周八”已经没有引用指向它们，JVM虚拟机会在适当的时候进行回收。

4. ArrayList总结

时间复杂度分析
在ArrayList中，底层数组存/取元素效率非常的高(get/set)，时间复杂度是O(1)，而查找，插入和删除元素效率似乎不太高，时间复杂度为O(n)。

当我们ArrayLIst里有大量数据时，这时候去频繁插入/删除元素会触发底层数组频繁拷贝，效率不高，还会造成内存空间的浪费，这个问题在另一个类：LinkedList里有解决方案。查找元素效率不高，在HashMap里有解决方案。

5. ArrayList和vector区别

Vector是线程安全的，ArrayList不是线程安全的。以add方法为例：

vector只要是关键性的操作，方法前面都加了synchronized关键字，来保证线程的安全性。当执行synchronized修饰的方法前，系统会对该方法加一把锁，方法执行完成后释放锁，加锁和释放锁的这个过程，在系统中是有开销的，因此，在单线程的环境中，Vector效率要差很多。（多线程环境不允许用ArrayList，需要做处理）。
和ArrayList和Vector一样，同样的类似关系的类还有HashMap和HashTable，StringBuilder和StringBuffer，后者是前者线程安全版本的实现。
ArrayList在底层数组不够用时在原来的基础上扩展0.5倍，Vector是扩展1倍。

10. LinkedList

源码探索：直接查看大佬原文吧
LinkedList初探
 LinkedList元素的删除原理

超喜欢榴莲吖

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础笔记

一个很好的专栏：清浅池塘。就其中的学习到的JAVA零碎知识点做一个记录。1. == 和 equals 的区别======：当======两边是基本数据类型时，比较的是两边的两个值是否相等，当======两边是引用类型时比较的是两个内存地址，也可以看成是看这两个引用是否指向堆内存里的同一块地址（结合第三点JAVA数据类型使用）equals：数值型判断值是否相等，字符串会依次判断其中字符是否相等，因此在判断相等时要用equals（结合第六部分equals）2. 反编译文件学会查看反编译文件，可以看到j
复制链接

扫一扫

专栏目录