一些小理解，

冒泡：

public  static   void  paixu(int [] array){

        int n=array.length;
        for (int i=0;i<n-1;i++){
            for (int j=0;j<n-1-i;j++){
                if (array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int [] b={5,9,8,5,36,7,2};
        paixu(b);

        for (int c:b ){
            System.out.print(c+" ");
        }
    }

插入：

public static void main(String[] args){

        int b[]={8,95,2,3,5,61,561,532,16,320};
        paixu(b);
        for (int c:b){
            System.out.print(c+" ");
        }

    }


    public static void paixu(int [] array){

        int n= array.length;
        for (int i=1;i<n;i++;){
            int m=array[i];
            int j=i-1;
            while (j>=0;&& array[j]>m){
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=m;
        }
    }

选择：

public static void main(String[] args) {
        int []b={8,9,5,6,21,5,6,31,5,1,5,65};
        paixu(b);
        for (int c:b){

            System.out.print(c+" ");

        }

    }

    public static  void paixu(int [] array){
        int n=array.length;
        for (int i=0;i<n-1;i++){
            int min=i;
            for (int j=i+1;j<n;j++){
                if (array[j]<array[min]){
                    min=j;
                }
            }
            int temp=array[min];
            array[min]=array[i];
            array[i]=temp;
        }
    }

快速：

    public static void main(String[] args) {
        int b[]={9,84,8,45,6,49,49,15,1};
        int n=b.length;

       quickSort(b,0,n-1);
        for (int c:b){
            System.out.print(c+" ");
        }

    }

    public static  void quickSort(int [] array,int left,int right){
        if (left<right){
            int index=partition(array,left,right);
            quickSort(array,left,index-1);
            quickSort(array,index+1,right);
        }
    }


    public static  int partition(int [] array,int left,int right){

        int p=array[right];
        int i=(left-1);
        for (int j=left;j<right;j++){
            if (array[j]<=p){
                i++;
                int temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }

        }
        int temp=array[i+1];
        array[i+1]=array[right];
        array[right]=temp;
        return i+1;
    }

插入流程图 

快速排序流程

 

2.import java和javax差异 

`java` 和 `javax` 是 Java 中用于组织类和接口的包前缀。它们之间的主要差异在于它们的历史背景和用途。

`java`包

核心包：`java` 包中的类和接口是 Java 语言核心的一部分。这些包在 JDK 中从一开始就存在，并且包含了 Java 标准库的基本组件。
- 稳定性：`java` 包中的类和接口一般不会轻易发生变化，因为它们是 Java 平台的基础。
- 示例：`java.lang`, `java.util`, `java.io`, `java.net`, `java.sql` 等。
  
  java
  import java.util.ArrayList;
  import java.io.File;
  ```

 `javax` 包

- 扩展包：`javax` 包中的类和接口最初是作为扩展包提供的，即使它们后来成为了标准 Java 平台的一部分。`javax` 包用于包含核心功能之外的扩展库。
- **示例**：`javax.swing`, `javax.servlet`, `javax.xml`, `javax.annotation` 等。

  java
  import javax.swing.JFrame;
  import javax.servlet.http.HttpServlet;
  ```

总结

- `java` 包用于核心和基础的 Java 库，通常不会轻易变化。
- `javax` 包用于扩展和附加功能，最初作为扩展提供，后来有些成为了标准的一部分。

这种命名区分帮助开发者理解某个类或接口是核心库的一部分还是扩展库的一部分，以及这些库的稳定性和发展方向。

3，this的三种用法：

一，第一种：this用来区分局部变量和成员变量；

当形参名称与该方法内部的成员名称冲突时，使用this可以对其进行区分

public class Student {

    private String name;

    public Student(String name){
        this.name=name;//this.name代表的是该方法的成员变量

    }

二，第二种：this用来指代对象本身，（类里面的方法要通过对象来调用，即：对象.方法()。此时this就代表调用方法的对象）

public class This2 {
    public void jump(){

        System.out.println("正在跳");
        System.out.println("----------------------");
    }

    public void  walk(){

        this.jump();
        System.out.println("正在行走");
    }

    public static void main(String[] args) {
        This2 t=new This2();
        t.walk();

    }

三，作为当前对象的引用传递

在需要将当前对象的引用传递给另一个方法、构造方法或返回当前对象时，可以使用this关键字。

public class User {

    private String name;


    public User(){
        this("张");
    }

    public User(String name){
        this.name=name;
    }
    private void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        User user=new User();
        user.print();

    }

4.单例模式  在多线程中是否线程安全， 如何保证线程安全.

首先有两种单例模式分别为饿汉单例模式和懒汉单例设计模式，其中饿汉为线程安全，懒汉为线程不安全。

饿汉： 

public class Eager {


//在创建的时候直接初始化
    private static final Eager instance=new Eager();
//防止外部new
    private Eager(){

    }
//让外部成功访问创建的对象
    public static Eager getInstance(){
        return instance;

    }
}

懒汉：为了线程安全可以进行双重锁定，和静态内部类。

public class Lazy {
    //线程不安全

//延迟初始化实例
    private static Lazy instance;

    //防止new

    private Lazy(){

    }

    //

    private static Lazy getInstance(){
        if (instance==null){

                    instance=new Lazy();
                }

        return instance;
    }

    /** 双重锁定
     * private static Lazy getInstance(){
     *         if (instance==null){
     *         synchronized (Lazy.class){
     *                 if (instance == null){
     *                     instance=new Lazy();
     *                 }
     *             }
     *
     *
     *         return instance;
     *     }
     */
    /**静态内部类
     * private Lazy() {}
     *
     *     // 静态内部类持有单例实例
     *     private static class SingletonHolder {
     *         private static final Lazy instance = new Lazy();
     *     }
     *
     *     // 提供一个公有的静态方法，返回实例
     *     public static Lazy getInstance() {
     *         return SingletonHolder.instance;
     *     }
     */