基础题的复习----第一章

题目：

---

1.程序：
排序： 冒泡  选择  插入 快速排序  画出：快速排序流程图 和 插入的流程图
优化冒泡排序，使其效率更高。
2.import java和javax差异
3.debug  冒泡排序
4.java中是否可以写出引用传递的例子
5.this三种用法  并说出  this 第三种用法写一个实例出来， 找源码里在哪里用过
6.单例模式  在多线程中是否线程安全， 如何保证线程安全。
7.static 是否能修饰类，属性，局部变量，方法，代码块，如果能说明其特点，及加载顺序
8.权限修饰符，protected 和默认 之间的差别  并用例子来验证。
9.数组的数据类型是引用类型还是基本类型。
10.如何理解二维数组。
11.集合类与数组的转化 写一个  demo
12.Arrays 在哪个包下

---

 1.排序：说实话，手到擒来；

1.冒泡排序：

package code711;
import java.util.Arrays;
import java.util.Scanner;

public class sort {
    //这是一个冒泡排序,优化后的冒泡排序
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int []a=new int[n];
        for (int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        boolean flag;
        for (int i=0;i<n-1;i++){
            flag=false;
            for (int j=0;j<n-1-i;j++){
                if (a[j]<a[j+1]) {
                    int b = a[j+1];
                    a[j+1] = a[j];
                    a[j] = b;
                    flag=true;
                }
            }
            if(flag==false) break;
        }
        System.out.println(Arrays.toString(a));
    }
}

运行结果：

 

选择排序：

package code711;

import java.util.Arrays;
import java.util.Scanner;

public class sort1 {
    //这是一个选择排序
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[]a=new int[n];
        for (int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        for (int i=0;i<n;i++){
            int num=i;
            for (int j=i+1;j<n;j++){
                if (a[num]<a[j]){
                    num=j;
                }
            }
            int aa=a[num];
            a[num]=a[i];
            a[i]=aa;
        }
        System.out.println(Arrays.toString(a));
    }
}

 运行结果：

插入排序：

package code711;

import java.util.Arrays;
import java.util.Scanner;

public class sort2 {
    //这是一个插入排序
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n];
        for (int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        for (int i=1;i<n;i++){
            int key=a[i];
            int j=i-1;
            while (j>=0 && a[j]>key){
                a[j+1]=a[j];
                j--;
            }
            a[j+1]=key;
        }
        System.out.println(Arrays.toString(a));
    }
}

运行结果：

快速排序：

package code711;

import java.util.Arrays;
import java.util.Scanner;

public class sort3 {
    //这是一个快速排序
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n];
        for (int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        quick(a,0,n-1);
        System.out.println(Arrays.toString(a));
    }
    public static int[] quick(int[] a,int left,int right){
        if (left<right){
            int mid=fen(left,right,a);
            fen(left,mid-1,a);
            fen(mid+1,right,a);
        }
        return a;
    }
    public static int fen(int left,int right,int[]a){
        int nmax=a[right];
        int num=left;
        for (int j=left;j<=right;j++){
            if (a[j]>nmax){
                int n=a[num];
                a[num]=a[j];
                a[j]=n;
                num++;
            }
        }
        int n=a[num];
        a[num]=nmax;
        a[right]=n;
        return num;
    }
}

运行结果：

画图：插入排序

 

快速排序：

 优化冒泡排序：没有交换元素的时候说明这时候已经是有序的了

package code711;
import java.util.Arrays;
import java.util.Scanner;

public class sort {
    //这是一个冒泡排序,优化后的冒泡排序
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int []a=new int[n];
        for (int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        boolean flag;
        for (int i=0;i<n-1;i++){
            flag=false;
            for (int j=0;j<n-1-i;j++){
                if (a[j]<a[j+1]) {
                    int b = a[j+1];
                    a[j+1] = a[j];
                    a[j] = b;
                    flag=true;
                }
            }
            if(flag==false) break;
        }
        System.out.println(Arrays.toString(a));
    }
}

2.import java和javax差异

java包
1.标准核心库：java包包含了Java标准核心类库，这是Java开发所必需的基本类库。
2.常见类库：包括基本的语言功能（如字符串操作、基本数据结构）、输入输出、网络编程、并发处理、反射、数学运算等。
eg.示例包：
1.java.lang：包含核心语言类，如String、System、Math、Thread等。不需要显式导入，默认包含。
2.java.util：包含集合框架类，如ArrayList、HashMap、Date、Random等。
3.java.io：包含输入输出类，如File、InputStream、OutputStream、Reader、Writer等。
4.java.net：包含网络编程类，如Socket、ServerSocket、URL、URLConnection等。

javax包
1.扩展库：javax包最初是Java扩展类库（Java Extension）的缩写，后来一些被广泛使用的扩展库也被纳入Java标准库。
2.特定领域：主要用于某些特定领域的功能，如企业级开发、图形用户界面、Web开发等。
示例包：
javax.swing：包含图形用户界面组件，如JButton、JFrame、JPanel等。
javax.servlet：包含Servlet API，用于Web开发，如HttpServlet、ServletRequest、ServletResponse等。
javax.ejb：包含企业JavaBeans API，如SessionBean、EntityBean等。
javax.persistence：包含Java持久化API，用于对象关系映射（ORM），如EntityManager、Query、Persistence等。

总结来说，java包主要包含Java核心类库，适用于各种通用的编程需求；而javax包包含特定领域的扩展类库，适用于图形界面、企业级开发、Web开发等特定应用场景。

3.debug 就省略了。

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

不可以，在Java中，方法参数传递是通过“按值传递”实现的。

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

1. 用于引用当前对象的实例变量或方法
  在类的方法中，this关键字可以用来引用当前对象的实例变量或方法。这种用法通常用于区分实例变量和方法参数的同名情况，或者在构造方法中调用其他重载构造方法。

局部变量会屏蔽成员变量，this可以调到。

public class MyClass {
    private int number;

    public MyClass(int number) {
        this.number = number; // 使用this引用当前对象的实例变量
    }

    public void setNumber(int number) {
        this.number = number; // 使用this引用当前对象的实例变量
    }

    public void displayNumber() {
        System.out.println("Number: " + this.number); // 使用this引用当前对象的实例变量
    }
}

2. 用于在构造方法中调用其他构造方法
  在一个构造方法中，可以使用this()来调用本类的其他构造方法。这种方式可以避免代码重复，并确保在初始化对象时执行共同的初始化逻辑。

public class MyClass {
    private int number;
    private String name;

    public MyClass() {
        this(0, "Default"); // 调用另一个构造方法
    }

    public MyClass(int number, String name) {
        this.number = number;
        this.name = name;
    }
}

3. 用于传递当前对象的引用
  在某些情况下，this关键字可以用于将当前对象的引用传递给其他方法或构造方法，以便在方法内部可以操作当前对象。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        printDetails(this); // 将当前对象的引用传递给方法
    }

    private void printDetails(Person person) {
        System.out.println("Name: " + person.name);
        System.out.println("Age: " + person.age);
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
    }
}

再源码中：

只能说有很多......

      this关键字在Java源码中经常被使用，特别是在类的构造方法中调用其他构造方法，以及在实例方法中引用当前对象的实例变量。例如，在Java标准库中的很多类和框架中，都会看到这些用法的应用，比如java.lang.Object类的构造方法就用了这种方式。 

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

单例模式：

描述：确保一个类只有一个实例，并提供全局访问点。这个模式在我学Java基础的时候其实就接触过了，如今在查看tomcat源码的时候还能重新相见。

示例：在tomcat中，org.apache.catalina.startup.Catalina类使用了单例模式:

public class Catalina {
    private static Catalina instance = null;
    
    private Catalina() {
        // 私有构造函数
    }
 
    public static synchronized Catalina getInstance() {
        if (instance == null) {
            instance = new Catalina();
        }
        return instance;
    }
}

 其实，单例模式可以分为懒汉式和饿汉式：

上面的tomcat的单例模式是使用的懒汉式；

饿汉式：

public class Singlen {
    private static Singlen s = new Singlen();
 
    private Singlen() {
    }
 
    public static Singlen getSingle() {
        return s;
    }
}
/**
 *          懒汉式         饿汉式
 * 效率       低             高    懒汉式每次都要进行比较，比较浪费时间，所以效率比饿汉式低
 * 内存       少             多    懒汉式只有在需要的时候才会创建出来，而饿汉式不换、管是否
 *                                 使用，在做开始的时候就会把对象创建出来，所以占用内存
 */

在线程中不安全，要特别注意线程安全问题。

方法一：使用同步方法
    这种方法通过同步整个getInstance方法来确保线程安全，但会导致性能下降，因为每次访问实例时都需要同步。

public class SynchronizedSingleton {
    private static SynchronizedSingleton instance;

    private SynchronizedSingleton() {
        // 私有构造方法防止实例化
    }

    public static synchronized SynchronizedSingleton getInstance() {
        if (instance == null) {
            instance = new SynchronizedSingleton();
        }
        return instance;
    }
}

方法二：双重检查锁定（Double-Checked Locking）
这种方法在第一次检查实例是否存在时不加锁，只有在实例不存在时才进行同步块内的第二次检查，减少了不必要的同步，提高了性能。

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {
        // 私有构造方法防止实例化
    }

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

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

static可以修饰属性，方法，代码块。同时static只能修饰内部类，成为静态内部类，不能修饰局部变量。

静态内部类
特点：静态内部类可以直接访问外部类的静态成员，但不能直接访问外部类的非静态成员。
可以独立于外部类的实例而创建。
修饰属性（静态变量）
静态变量是属于类的变量，而不是类的实例（对象）的变量。属于类。
特点：静态变量在类加载时初始化。
所有实例共享同一个静态变量。
可以通过类名直接访问（MyClass.staticVariable）。
修饰方法（静态方法）
静态方法是属于类的方法，而不是类的实例的方法。
特点：静态方法可以在没有实例化类的情况下调用。
静态方法只能访问静态变量和调用静态方法，不能访问实例变量和调用实例方法。
可以通过类名直接调用（MyClass.staticMethod()）。
修饰代码块（静态代码块）
静态代码块在类加载时执行，并且只执行一次。
特点：静态代码块用于初始化类级别的资源或执行只需要执行一次的操作。
在类加载时按照代码顺序执行。
修饰局部变量
static关键字不能修饰局部变量。局部变量是在方法中定义的变量，它们在方法调用时创建，在方法结束时销毁。静态变量的生命周期和局部变量的生命周期不同，因此不能用static来修饰局部变量。

加载顺序
静态变量和静态代码块：

按在类中定义的顺序加载。

静态变量在静态代码块之前初始化。
静态代码块在类加载时执行，并且只执行一次。
实例变量和实例代码块：在对象创建时按照它们在类中定义的顺序加载。

实例变量在构造函数之前初始化。
实例代码块在构造函数之前执行。 

package code711;

public class code04 {
    static int staticVariable = 10; // 静态变量

    static {
        System.out.println("Static block executed.");
        System.out.println("Static variable: " + staticVariable);
    }

    static void staticMethod() {
        System.out.println("This is a static method.");
    }

    static class StaticNestedClass {
        void display() {
            System.out.println("Inside static nested class.");
        }
    }

    public static void main(String[] args) {
        // 访问静态变量
        System.out.println("Static variable: " + code04.staticVariable);

        // 调用静态方法
        code04.staticMethod();

        // 创建静态内部类的实例并调用其方法
        code04.StaticNestedClass nestedInstance = new code04.StaticNestedClass();
        nestedInstance.display();
    }
}

运行结果：

8.权限修饰符，protected 和默认 之间的差别  并用例子来验证。

权限修饰符：public protected 默认 private

protected
同一个包内：protected成员可以被同一个包内的其他类访问。
不同包中的子类：protected成员可以被不同包中的子类访问。
不同包中的非子类：protected成员不能被不同包中的非子类访问。
默认（包级访问）
同一个包内：默认成员只能被同一个包内的其他类访问。
不同包中的子类和非子类：默认成员不能被不同包中的子类和非子类访问。 

同一个包中就不写了，一定都是可以的。

9.数组的数据类型是引用类型还是基本类型。

引用类型。 

10.如何理解二维数组。

二维数组其实就是一个一维数组中存储一个一维数组。感觉没有什么特别的。

package code711;

public class code02 {
    public static void main(String[] args) {
        // 声明并初始化二维数组
        int[][] array = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };

        // 访问和修改元素
        int value = array[1][2]; // 获取第二行第三列的值
        System.out.println("Value at array[1][2]: " + value);
        array[2][3] = 20; // 将第三行第四列的值设为20

        // 遍历二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

11.集合类与数组的转化 写一个  demo

使用Arrays.asList();    .toArray();如以下程序：

package code711;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class code01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        // 使用toArray()方法将集合转换为数组
        String[] array = list.toArray(new String[0]);
        // 输出数组元素
        for (String element : array) {
            System.out.println(element);
        }
        int a[]={'a','b','c'};
        // 使用Arrays.asList()方法将数组转换为集合
        List list1=Arrays.asList(a);
        for (int element : a) {
            System.out.println(element);
        }
    }
}

 

12.Arrays 在哪个包下：

当然是在Java.util包下

import java.util.Arrays;