Java题集练习1

Java题集练习1

1.排序算法：冒泡 ，选择 ，插入 ，快排，优化冒泡排序使其效率更高

代码如下：

public class Test101 {
    //1 直接插入排序
    public void InsertSort(int[] a,int size){
        for (int i = 0;i < size - 1;i++){
            int end = i;
            int tmp = a[end + 1];
            while (end >= 0){
                if (tmp < a[end]){
                    a[end + 1] = a[end];
                    end--;
                }
                else{
                    break;
                }
            }
            a[end + 1] = tmp;
        }
    }
    //2 冒泡排序
    public void BubbleSort(int[] a,int size){
        for (int i = 0;i < size - 1;i++){
            for (int j = 0;j < size - i - 1;j++){
                if (a[j + 1] < a[j]){
                    int temp = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
    //3 选择排序
    public void SelectSort(int[] a,int size){
        for (int i = 0;i < size - 1;i++){
            int midIndex = i;
            for (int j = i + 1;j < size;j++){
                if (a[j] < a[midIndex]){
                    midIndex = j;
                }
            }
            int tmp = a[i];
            a[i] = a[midIndex];
            a[midIndex] = tmp;
        }
    }
    //4 快速排序
    public void RapidSort(int[] a,int left,int right){
        if (left < right){
            int mid = partition(a, left, right);
            RapidSort(a, left, mid - 1);
            RapidSort(a,mid + 1, right);
        }
    }
    public static int partition(int[] a,int left,int right){
        int mid = a[right];
        int i = left - 1;
        for (int j = left;j < right;j++){
            if (a[j] < mid){
                i++;
                swap(a, i, j);
            }
        }
        swap(a, i + 1, right);
        return i + 1;
    }
    public static void swap(int[] a,int i,int j){
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    public static void main(String[] args) {
        int[] a = {2,34,21,32,13,24,12,55};
        Test101 t = new Test101();
        t.RapidSort(a, 0, a.length - 1);
        for (int i : a){
            System.out.print(i);
        }
    }
}

2 import java 和 javax 有什么区别

JavaAPI所必需的包必须是java开头的包，javax只作为扩展包来使用，但随着时间的推移，javax逐渐的扩展成为javaAPI的组成部分，但是 将扩展从javax包移动到java包非常麻烦 会破坏现有的代码，所以，javax包也将成为标准API的一部分，所以import java 和 javax 是没有什么区别的

3 debug冒泡排序

通过debug冒泡排序，可以看出冒泡排序的原理是从1索引处的元素开始递增 每次都与他上一个元素的值进行比较 如果小于上一元素则进行交换 因此 每进行一轮比较 都可以筛选出一个最小值

4 java中是否可以写出引用传递的例子

5 this的三种用法 并说出this的第三种用法用实例写出来 找源码在哪里用过

• this的第一种用法：在一个方法内，如果成员变量被局部变量所屏蔽，即同名，可以使用this关键字防止成员变量被屏蔽；this还可以调用成员方法

• this的第二种用法：this可以调用构造方法，比如，当分别创建了无参构造方法，一个参数的构造方法和带有两个参数的构造方法，可以在无参数的构造方法内使用this关键字调用有参的构造方法，同理，也可以在两个参数的构造方法内调用含一个参数的构造方法，可以提高代码的复用性，使代码更简洁

• this的第三种用法：this可以作为实参来访问当前实例的引用，具体代码实现如下：

public class Test105 {
    private int age;
    private Test105(){
        this(80);
    }
    private Test105(int age){
        this.age = age;
    }
    public void setAge(int age){
        //使用this关键字防止成员变量被屏蔽
        this.age = age;
    }
//    使用this关键字作为实参访问当前实例的引用
    public void passAge(){
        judgeAge(this);
    }
    public void judgeAge(Test105 t){
        if (t.age < 18){
            System.out.println("未成年！");
        }else {
            System.out.println("已成年！");
        }
    }
    public static void main(String[] args) {
        Test105 t1 = new Test105();
        t1.passAge();
    }
}

此作用的使用场景为：

• 观察者模式

• 责任链模式

6 单例设计模式

 public class Single {
//    懒汉式
    private Single(){}
    private static Single single = null;
    public static Single getSingle(Single single){
        if (single == null){
            single = new Single();
        }
        return single;
    }
}
class Singlen{
//    饿汉式
    private Singlen(){}
    private static Singlen singlen = new Singlen();
    public static Singlen getSinglen(Singlen singlen){
        return singlen;
    }
}

其中，静态成员变量的权限修饰符必须是private而不能是public，因为用public修饰会使该类在另一个包创建对象时可以更改他的属性，不能达到该单例设计模式的目的

7 static是否可以修饰类 属性 局部变量 方法 代码块，如果能说明其特点，及加载顺序

1. 静态变量（静态属性）

• 特点：静态变量属于类本身，而不是类的实例。所有类的实例共享同一个静态变量。当类加载时，静态变量被初始化。
• 加载顺序：在类的初始化阶段，静态变量被初始化。静态变量的初始化在类的构造方法执行之前完成。

class Example {
    static int staticVar = 10; // 静态变量
}

2. 静态方法

• 特点：静态方法也属于类本身，可以直接通过类名调用，而不需要实例化对象。静态方法不能访问类的实例变量和实例方法（即非静态变量和方法），只能访问其他静态成员。
• 加载顺序：静态方法在类加载时被加载。调用静态方法时，不需要实例化类的对象。

class Example {
    static void staticMethod() {
        System.out.println("Static method");
    }
}

3. 静态代码块

• 特点：静态代码块用于初始化静态变量或执行类加载时需要的其他初始化任务。静态代码块在类加载时执行，并且只执行一次。
• 加载顺序：静态代码块的执行顺序是按照它们在类中的定义顺序执行的。它们在类的加载阶段被执行，确保静态变量和方法在使用之前已经被正确初始化。

class Example {
    static {
        System.out.println("Static block");
    }
}

4. 静态内部类

• 特点：静态内部类是一个嵌套在外部类中的类，它与外部类没有直接的对象关联。静态内部类只能访问外部类的静态成员，不能访问外部类的实例变量和实例方法。

• 加载顺序：静态内部类的加载与外部类的加载相关联。外部类加载时，静态内部类的定义和初始化并不会立即发生，只有在静态内部类被实际使用时才会进行加载和初始化。

• class OuterClass {
      static class StaticInnerClass {
          // 静态内部类
      }
  }
  
  

5. 静态局部变量

• 特点：Java 中不支持静态局部变量。在方法内声明的变量不能是静态的，因为局部变量的生命周期与方法的调用相关联，而静态变量的生命周期是类的整个生命周期。
• 加载顺序：由于静态局部变量在 Java 中是不允许的，所以不存在相关的加载顺序。

总结

• 静态变量：属于类共享，类加载时初始化。
• 静态方法：属于类，可以直接通过类名调用。
• 静态代码块：用于初始化静态变量，类加载时执行。
• 静态内部类：与外部类的实例无关，类加载时定义，不立即加载。